/*
 * This source code is part of hsc, a html-preprocessor,
 * Copyright (C) 1995-1998  Thomas Aglassinger
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 *
 */
/*
 * hsclib/eval.c
 *
 * attribute value evaluation functions
 *
 * updated: 16-Dec-1997
 * created: 11-Oct-1995
 */

#define NOEXTERN_HSCLIB_EVAL_H

#include <ctype.h>
#include <time.h>

#include "hsclib/inc_base.h"

#include "hsclib/eval.h"
#include "hsclib/input.h"
#include "hsclib/skip.h"
#include "hsclib/uri.h"

/* maximul length of an operator identifer */
#define MAX_OP_LEN 8

/* unknown operator */
#define OP_NONE 0

/* step-size for temp. string */
#define TMP_STEPSIZE 128

/*
 * equation operators
 */
#define OP_EQ_STR  "="
#define OP_NEQ_STR "<>"
#define OP_GT_STR  ">"
#define OP_LT_STR  "<"
#define OP_GTE_STR ">="
#define OP_LTE_STR "<="
#define OP_CEQ_STR "=="         /* TODO: case sensitive string comparison */
#define OP_INSIDE_STR "IN"
#define OP_CL_BRACKET_STR ")"   /* closing bracket */

#define OP_EQ   1
#define OP_NEQ  2
#define OP_GT   3
#define OP_LT   4
#define OP_GTE  5
#define OP_LTE  6
#define OP_CEQ  7
#define OP_INSIDE 8
#define OP_CL_BRACKET  10

/*
 * boolean operators
 */
#define OP_AND_STR "AND"
#define OP_NOT_STR "NOT"
#define OP_OR_STR  "OR"
#define OP_XOR_STR "XOR"

#define OP_AND 11
#define OP_NOT 12
#define OP_OR  13
#define OP_XOR 14

/*
 * string/arithmetik operators
 */
#define OP_CAT_STR "+"
#define OP_SUB_STR "-"
#define OP_MUL_STR "*"
#define OP_DIV_STR "/"
#define OP_MOD_STR "MOD"        /* modulo */

#define OP_CAT      15
#define OP_SUB      16
#define OP_MUL      17
#define OP_DIV      18
#define OP_MOD      19

typedef BYTE op_t;

/*
 * forward references
 */
STRPTR eval_expression(HSCPRC * hp, HSCATTR * dest, STRPTR endstr);

/*
 * 
 * global funcs
 *
 */

/*
 * err_op: unknown binary operator
 */
static VOID err_op(HSCPRC * hp, STRPTR opstr)
{
    hsc_message(hp, MSG_UNKN_BINOP, "unknown binary operator %q", opstr);
}

/*
 * eval_boolstr
 */
static BOOL eval_boolstr(STRPTR s)
{
    if (s[0])
        return (TRUE);
    else
        return (FALSE);
}

/* check for empty brakets (after GetTime/GetGmTime) */
static VOID check_brakets(HSCPRC * hp)
{
    if (parse_wd(hp, "("))
        parse_wd(hp, ")");
}

/*
 * gettimestr
 */
static EXPSTR *gettimestr(HSCPRC * hp, struct tm *time)
{
#define TIMEBUF_INC 20
    STRPTR timefmt = get_vartext_byname(hp->defattr, TIMEFORMAT_ATTR);
    EXPSTR *timebuf = init_estr(TIMEBUF_INC);
    BOOL strftrc = 0;           /* result of strftime() */
    size_t i;                   /* loop var */

    /* set default time format */
    if (!timefmt)
    {
        timefmt = "%d-%b-%Y, %H:%M";
    }

    while (!(hp->fatal) && !strftrc)
    {
        /* expand timebuffer */
        for (i = 0; i < TIMEBUF_INC; i++)
            app_estrch(timebuf, '.');

        D(fprintf(stderr, DHL "    timebuf: inc+%d\n", TIMEBUF_INC));

        /* output time */
        strftrc = strftime(estr2str(timebuf), estrlen(timebuf),
                           timefmt, time);
    }

    if (!strftrc)
    {
        del_estr(timebuf);
        timebuf = NULL;
    }

    return (timebuf);
}

/*
 * getfilesize
 *
 * get size of a specific file
 *
 * templates for HSC.FORMAT.FILESIZE:
 * %b   size in byte
 * %k   size in Kbyte
 * %m   size in MByte
 * %g   size in Gbyte
 * %a   size, unit computed automatically
 * %u   unit for %A (none, "K", "M" or "G")
 */
static STRPTR getfilesize(HSCPRC * hp, EXPSTR * dest, STRPTR uri)
{
    STRPTR filesizestr = NULL;
    FILE *file = NULL;
    LONG filesize = 0;          /* filesize in byte */
    LONG filesize_k = 0;        /* filesize in Kbyte */
    LONG filesize_m = 0;        /* filesize in Mbyte */
    LONG filesize_g = 0;        /* filesize in Gbyte */
    LONG filesize_auto = 0;     /* filesize in auto-units (%A) */
    EXPSTR *efilename = init_estr(32);
    STRPTR filename = NULL;
    STRPTR sizeunit = "";
    STRPTR s = get_vartext_byname(hp->defattr,
                                  FILESIZEFORMAT_ATTR);

    conv_hscuri2file(hp, efilename, uri);
    filename = estr2str(efilename);

    D(fprintf(stderr, DHL "  GETFILESIZE(`%s')\n", filename));
    errno = 0;
    file = fopen(filename, "rb");
    if (file)
    {
        /* retrieve size */
        fseek(file, 0L, SEEK_END);
        filesize = ftell(file);
        fclose(file);

        /* compute size in units, */
        filesize_k = (filesize + 512) >> 10;
        filesize_m = (filesize_k + 512) >> 10;
        filesize_g = (filesize_m + 512) >> 10;

        /* compute auto-size */
        if (filesize_g > 10)
        {
            filesize_auto = filesize_g;
            sizeunit = "G";
        }
        else if (filesize_m > 10)
        {
            filesize_auto = filesize_m;
            sizeunit = "M";
        }
        else if (filesize_k > 10)
        {
            filesize_auto = filesize_k;
            sizeunit = "K";
        }
        else
        {
            filesize_auto = filesize;
            sizeunit = "";
        }
    }
    else
    {
        /* file not found */
        filesize = 0;
        filesize_k = 0;
        filesize_m = 0;
        filesize_g = 0;
        filesize_auto = 0;
        sizeunit = "";
        hsc_msg_nouri(hp, filename, uri, "get filesize");
    }

    /* parse template */
    clr_estr(dest);
    if (s)
    {
        while (s[0])
        {
            if (s[0] == '%')
            {
                if (s[1])
                    s++;
                switch (s[0])
                {
                case 'b':
                    app_estr(dest, long2str(filesize));
                    break;

                case 'k':
                    app_estr(dest, long2str(filesize_k));
                    break;

                case 'm':
                    app_estr(dest, long2str(filesize_m));
                    break;

                case 'g':
                    app_estr(dest, long2str(filesize_g));
                    break;

                case 'a':
                    app_estr(dest, long2str(filesize_auto));
                    break;

                case 'u':
                    app_estr(dest, sizeunit);
                    break;

                default:
                    app_estrch(dest, '%');
                    app_estrch(dest, s[0]);
                    break;
                }
            }
            else
                app_estrch(dest, s[0]);
            s++;
        }
    }
    else
    {
        D(panic("no template for filesize-format"));
    }

    /* set filesize-str */
    filesizestr = estr2str(dest);
    D(fprintf(stderr, DHL "  =`%s'\n", filesizestr));

    del_estr(efilename);

    return (filesizestr);
}

/*
 * check_attrname
 *
 * check string for legal attribute name
 */
BOOL check_attrname(HSCPRC * hp, STRPTR name)
{
    BOOL ok = FALSE;

    if (hsc_normch(name[0]))
    {
        ok = TRUE;
    }
    else
    {
        hsc_message(hp, MSG_ILLG_ATTRNAME,
                    "illegal attribute identifier %q", name);
    }

    return (ok);
}

/*
 * eval_attrname
 *
 * read next word and check it for a legal
 * attribute identifier
 */
static STRPTR eval_attrname(HSCPRC * hp)
{
    STRPTR result = NULL;
    STRPTR nw = infgetw(hp->inpf);

    if (nw)
    {
        if (check_attrname(hp, nw))
        {
            result = nw;
        }
    }
    else
    {
        hsc_msg_eof(hp, "attribute identifier expected");
    }

    return (result);
}

/*
 * quotestr
 *
 * return readable string for quote-kind
 */
STRPTR quotestr(int quote)
{
    STRPTR s = "UNKNOWN";

    if (quote == DOUBLE_QUOTE)
    {
        s = "[double]";
    }
    else if (quote == SINGLE_QUOTE)
    {
        s = "[single]";
    }
    else if (quote == BACK_QUOTE)
    {
        s = "[back]";
    }
    else if (quote == VQ_NO_QUOTE)
    {
        s = "[none]";
    }
    else
    {
        STRARR tmp[60];
        sprintf(tmp, "unknown quote-kind: $%02x #%03d", quote, quote);
        panic(tmp);
    }

    return (s);
}

/*
 * choose_quote
 *
 * choose quote to be used for attr, depending on
 * hp->quotemode and quotes used inside the value
 */
VOID choose_quote(HSCPRC * hp, HSCATTR * attr)
{
    int quote = attr->quote;
    LONG qm = hp->quotemode;    /* lazy.. */
    BOOL single_quote = FALSE;
    BOOL double_quote = FALSE;
    BOOL nasty_char = FALSE;

    STRPTR value = get_vartext(attr);

    D(fprintf(stderr, DHL "  choosing quote\n"));

    if (attr->vartype == VT_BOOL)
    {
        D(fprintf(stderr, DHL "    forget it, it's just a boolean attrib\n"));
    }
    else if (value[0])
    {
        /* scan attribute value for quotes */
        while (value[0])
        {
            if (value[0] == SINGLE_QUOTE)
            {
                D(fprintf(stderr, DHL "    single quote detected\n"));
                single_quote = TRUE;
                nasty_char = TRUE;
            }
            else if (value[0] == DOUBLE_QUOTE)
            {
                D(fprintf(stderr, DHL "    double quote detected\n"));
                double_quote = TRUE;
                nasty_char = TRUE;
            }
            else if ((!hsc_normch(value[0]) || (value[0] == '_'))
                     && !nasty_char)
            {
                D(fprintf(stderr, DHL "    nasty-char #%d detected\n", value[0]));
                nasty_char = TRUE;
            }

            value++;
        }
    }
    else
    {
        /* empty value */
        nasty_char = TRUE;
    }

    if (qm == QMODE_KEEP)
    {
        /* check, if quote is missing */
        if ((attr->quote == VQ_NO_QUOTE)
            && nasty_char)
        {
            hsc_message(hp, MSG_REQU_QUOTE,
                        "value for %A requires quotes", attr);
        }
    }
    else
    {
        /* choose quote */
        if (single_quote && double_quote)
        {
            /* both kind of quotes appeared in value:
             * replace double-quotes by "&quot;" */
            EXPSTR *newval = init_estr(32);     /* new attribute value */

            /* scan old value for `\"', replace them by `&quot'
             * and store new value in newval */
            value = get_vartext(attr);
            while (value[0])
            {
                if (value[0] == DOUBLE_QUOTE)
                {
                    D(fprintf(stderr, DHL "    replace by `&quot;' in value\n"));
                    /* TODO: message */
                    app_estr(newval, "&quot;");
                }
                else
                    app_estrch(newval, value[0]);
                value++;
            }

            /* update attribute value */
            set_vartext(attr, estr2str(newval));

            quote = DOUBLE_QUOTE;

            del_estr(newval);
        }
        else
        {
            if (single_quote)
            {
                D(fprintf(stderr, DHL "    double quote forced\n"));
                quote = DOUBLE_QUOTE;
            }
            else if (double_quote)
            {
                D(fprintf(stderr, DHL "    single quote forced\n"));
                quote = SINGLE_QUOTE;
            }
            else
            {
                /* no quote in value: choose quote user prefers */
                if (qm == QMODE_SINGLE)
                {
                    D(fprintf(stderr, DHL "    single quote preferd\n"));
                    quote = SINGLE_QUOTE;
                }
                else if (qm == QMODE_DOUBLE)
                {
                    D(fprintf(stderr, DHL "    double quote prefered\n"));
                    quote = DOUBLE_QUOTE;
                }
                else if (qm == QMODE_NONE)
                {
                    if (nasty_char)
                    {
                        D(fprintf(stderr, DHL "    quote needed (nasty char)\n"));
                        quote = DOUBLE_QUOTE;
                    }
                    else
                    {
                        D(fprintf(stderr, DHL "    no quote needed\n"));
                        quote = VQ_NO_QUOTE;
                    }
                }
                else
                {
                    panic("illegal quote-mode");
                }
            }
        }
        /* check, if quote has changed */
        if (attr->quote != quote)
        {
            hsc_message(hp, MSG_CHANGED_QUOTE,
                        "changed quotes for %A from %s to %s",
                        attr, quotestr(attr->quote), quotestr(quote));
        }
    }

    attr->quote = quote;
}

/*
 * try_eval_unary_op
 *
 * reads next word and tries to interpret it as an unary
 * operator; if no fitting operator exists, return NULL,
 * else immediatly process the operator and return its
 * result
 */
static STRPTR try_eval_unary_op(HSCPRC * hp, HSCATTR * dest, BOOL * err)
{
    STRPTR eval_result = NULL;
    INFILE *inpf = hp->inpf;
    STRPTR nw = eval_attrname(hp);
    HSCATTR *tmpdest = new_hscattr(PREFIX_TMPATTR "unary.operator");

    tmpdest->vartype = VT_STRING;

    *err = FALSE;
    if (nw)
    {
        if (!upstrcmp(nw, "NOT"))
        {
            /* TODO: this part looks a bit stupid... */
            STRPTR nw = infgetw(inpf);

            if (nw)
            {
                BOOL err_rec = FALSE;   /* error var for recursive call */
                STRPTR endstr = NULL;

                if (strcmp(nw, "("))
                {
                    /* try to process another unary operator */
                    inungetcw(inpf);
                    eval_result = try_eval_unary_op(hp, dest, &err_rec);
                }
                else
                    endstr = ")";

                /* if not, process another expression */
                if (!eval_result && !err_rec)
                    eval_result = eval_expression(hp, dest, endstr);
            }
            else
                hsc_msg_eof(hp, "after NOT");

            /* set result or return error */
            if (eval_result)
            {
                set_varbool(dest, !get_varbool(dest));
                eval_result = get_vartext(dest);
            }
            else
                *err = TRUE;
        }
        else if (!upstrcmp(nw, "DEFINED"))
        {
            nw = eval_attrname(hp);
            if (nw)
            {
                HSCATTR *attr = find_varname(hp->defattr, nw);

                if (attr)
                    set_varbool(dest, TRUE);
                else
                    set_varbool(dest, FALSE);
                eval_result = get_vartext(dest);
            }
        }
        else if (!upstrcmp(nw, "EXISTS"))
        {
            /* check existence of file (relative to destination dir) */
            eval_result = eval_expression(hp, tmpdest, NULL);
            if (eval_result)
            {
                FILE *file = NULL;
                EXPSTR *dest_fname = init_estr(64);

                D(fprintf(stderr, DHL "  EXISTS(`%s')\n", eval_result));

                conv_hscuri2file(hp, dest_fname, eval_result);
                file = fopen(estr2str(dest_fname), "r");
                if (file)
                {
                    fclose(file);
                    set_varbool(dest, TRUE);
                }
                else
                    set_varbool(dest, FALSE);

                del_estr(dest_fname);
                eval_result = get_vartext(dest);
            }
        }
        else if (!upstrcmp(nw, "FEXISTS"))
        {
            /* check existence of file */
            eval_result = eval_expression(hp, tmpdest, NULL);
            if (eval_result)
            {
                FILE *file = NULL;
                EXPSTR *dest_fname = init_estr(64);

                D(fprintf(stderr, DHL "  EXISTS(`%s')\n", eval_result));

                file = fopen(eval_result, "r");
                if (file)
                {
                    fclose(file);
                    set_varbool(dest, TRUE);
                }
                else
                    set_varbool(dest, FALSE);

                del_estr(dest_fname);
                eval_result = get_vartext(dest);
            }
        }
        else if (!upstrcmp(nw, "GETENV"))
        {
            /* get environment variable */
            eval_result = eval_expression(hp, dest, NULL);
            if (eval_result)
            {
                STRPTR env_value = getenv(get_vartext(dest));

                D(fprintf(stderr, DHL "  GETENV(`%s')\n", eval_result));
                if (!env_value)
                {
                    hsc_message(hp, MSG_UNKN_ENVVAR,
                                "unknown environment variable %q",
                                get_vartext(dest));

                    env_value = "";
                }
                set_vartext(dest, env_value);
                eval_result = get_vartext(dest);
                D(fprintf(stderr, DHL "  =`%s'\n", eval_result));
            }
        }
        else if (!upstrcmp(nw, "GETFILESIZE"))
        {
            /* retrieve size of a file */
            EXPSTR *filesizestr = init_estr(0);
            HSCATTR *filedestattr = new_hscattr(PREFIX_TMPATTR "get.filesize");
            STRPTR filename = NULL;

            eval_result = NULL;
            filedestattr->vartype = VT_STRING;
            filename = eval_expression(hp, filedestattr, NULL);
            if (filename)
            {
                eval_result = getfilesize(hp, filesizestr, filename);
            }
            if (eval_result)
            {
                set_vartext(dest, eval_result);
                eval_result = get_vartext(dest);
            }
            del_hscattr(filedestattr);
            del_estr(filesizestr);
        }
        else if (!upstrcmp(nw, "GETTIME"))
        {
            /* get local time */
            EXPSTR *timestr = gettimestr(hp, localtime(&(hp->start_time)));

            D(fprintf(stderr, DHL "  GETTIME\n"));
            if (timestr)
            {
                set_vartext(dest, estr2str(timestr));
                del_estr(timestr);
                eval_result = get_vartext(dest);
            }
            check_brakets(hp);
        }
        else if (!upstrcmp(nw, "GETGMTIME"))
        {
            /* get greenwich mean time */
            EXPSTR *timestr = gettimestr(hp, gmtime(&(hp->start_time)));

            D(fprintf(stderr, DHL "  GETGMTIME\n"));
            if (timestr)
            {
                set_vartext(dest, estr2str(timestr));
                del_estr(timestr);
                eval_result = get_vartext(dest);
            }
            check_brakets(hp);
        }
        else if (!upstrcmp(nw, "SET"))
        {

            nw = eval_attrname(hp);
            if (nw)
            {
                HSCATTR *attr = find_varname(hp->defattr, nw);

                if (attr)
                {
                    if (attr->vartype == VT_BOOL)
                    {
                        set_varbool(dest, get_varbool(attr));
                    }
                    else if (get_vartext(attr))
                        set_varbool(dest, TRUE);
                    else
                        set_varbool(dest, FALSE);
                    eval_result = get_vartext(dest);
                }
                else
                {
                    hsc_msg_unkn_attr_ref(hp, nw);
                    *err = TRUE;
                }
            }
        }
        else
            inungetcw(inpf);
    }

    del_hscattr(tmpdest);

    if (!nw)
        *err = TRUE;

    return (eval_result);
}

/*
 * eval_op
 *
 * evaluate binary operator string
 */
static BYTE eval_op(HSCPRC * hp)
{
    BYTE op = OP_NONE;
    BOOL op_eof = FALSE;        /* flag: end of file reached */
    INFILE *inpf = hp->inpf;
    STRPTR nw = infgetw(inpf);

    D(fprintf(stderr, DHL "  operator \"%s", nw));

    if (nw)
    {
        /* boolean operators */
        if (!upstrcmp(nw, OP_AND_STR))
        {
            op = OP_AND;
        }
        else if (!upstrcmp(nw, OP_OR_STR))
        {
            op = OP_OR;
        }
        else if (!upstrcmp(nw, OP_XOR_STR))
        {
            op = OP_XOR;
        }
        else if (!strcmp(nw, OP_CAT_STR))
        {
            /* concatenation operator */
            op = OP_CAT;
        }
        else if (!strcmp(nw, OP_SUB_STR))
        {
            /* subtraction operator */
            op = OP_SUB;
        }
        else if (!strcmp(nw, OP_MUL_STR))
        {
            /* multiplication operator */
            op = OP_MUL;
        }
        else if (!strcmp(nw, OP_DIV_STR))
        {
            /* division operator */
            op = OP_DIV;
        }
        else if (!strcmp(nw, OP_MOD_STR))
        {
            /* modulo operator */
            op = OP_MOD;
        }
        else if (!strcmp(nw, OP_INSIDE_STR))
        {
            /* substring search */
            op = OP_INSIDE;
        }
        /* closing braket */
        else if (!strcmp(nw, OP_CL_BRACKET_STR))
        {
            op = OP_CL_BRACKET;
        }
        else if (strenum(nw, "<|=|>", '|', STEN_CASE))
        {
            /* comparison operators */
            STRARR opstr[3];
            int ch;

            /* determine whole comparison operator:
             * take first word, and check for next
             * single character, if it is one of
             * "<", "=" or ">", too. if so, append
             * it to the string that tells the
             * operator.
             */
            strcpy(opstr, nw);
            ch = infgetc(inpf);
            if (ch != EOF)
            {
                D(fprintf(stderr, "%c", (char) ch));

                if (strchr("<=>", ch))
                {
                    opstr[1] = ch;
                    opstr[2] = 0;
                }
                else
                    inungetc(ch, inpf);
            }
            else
                op_eof = TRUE;

            /* find out comparison operator */
            if (!strcmp(nw, OP_EQ_STR))
                op = OP_EQ;
            else if (!strcmp(nw, OP_NEQ_STR))
                op = OP_EQ;
            else if (!strcmp(nw, OP_GT_STR))
                op = OP_GT;
            else if (!strcmp(nw, OP_LT_STR))
                op = OP_LT;
            else if (!strcmp(nw, OP_LTE_STR))
                op = OP_LTE;
            else if (!strcmp(nw, OP_GTE_STR))
                op = OP_GTE;
            else if (!strcmp(nw, OP_CEQ_STR))
                op = OP_CEQ;
            else
                err_op(hp, opstr);
        }
        else
        {
            err_op(hp, nw);
        }
    }
    else
    {
        op_eof = TRUE;
    }

    D(fprintf(stderr, "\"\n"));

    if (op_eof)
    {
        hsc_msg_eof(hp, "operator expected");
    }

    return (op);
}

/*
 * stroptol
 *
 * convert string operand to long int; treat "" as 0,
 * any non-numeric values as 1
 *
 * this enables to use boolean vars in numeric expressions
 *
 * result: TRUE
 */
static BOOL stroptol(HSCPRC * hp, LONG * dest, STRPTR str)
{
    BOOL ok = TRUE;

    *dest = 0;

    if (str[0])
    {
        STRPTR last_char = NULL;
        *dest = strtol(str, &last_char, 0);
        if (!last_char || (last_char[0]))
        {
            *dest = 1;
        }
    }
    else
    {
        /* empty string "" counts as 0, too */
    }

    return ok;
}

/*
 * process_arithmetic_op
 */
static BOOL process_arithmetic_op(HSCPRC * hp, EXPSTR * result, BYTE op, STRPTR str1, STRPTR str2)
{
    BOOL result_set = TRUE;
    LONG int1 = 0;              /* integer value of string operands */
    LONG int2 = 0;
    LONG intr = 0;              /* integer result */

    /* convert both string operands to integers */
    result_set = stroptol(hp, &int1, str1);
    result_set &= stroptol(hp, &int2, str2);

    switch (op)
    {
    case OP_CAT:
        intr = int1 + int2;
        break;
    case OP_SUB:
        intr = int1 - int2;
        break;
    case OP_MUL:
        intr = int1 * int2;
        break;
    case OP_DIV:
        intr = int1 / int2;
        break;
    case OP_MOD:
        intr = int1 % int2;
        break;
    default:
        panic("unknown arithmetic operator");
        break;
    }

    /* set result */
    if (result_set)
    {
        STRARR buf[20];
        sprintf(buf, "%ld", intr);
        set_estr(result, buf);
    }

    return result_set;
}

static BOOL process_boolean_op(HSCPRC * hp, HSCATTR * dest, BYTE op, STRPTR str1, STRPTR str2)
{
    BOOL bool_val1 = eval_boolstr(str1);
    BOOL bool_val2 = eval_boolstr(str2);
    BOOL bool_valr = FALSE;

    switch (op)
    {
    case OP_AND:
        if (bool_val1 && bool_val2)
        {
            bool_valr = TRUE;
        }
        break;

    case OP_OR:
        if (bool_val1 || bool_val2)
        {
            bool_valr = TRUE;
        }
        break;

    case OP_XOR:
        if ((bool_val1 || bool_val2)
            && !(bool_val1 && bool_val2)
            )
        {
            bool_valr = TRUE;
        }
        break;
    default:
        panic("unknown boolean operator");
        break;
    }

    set_varbool(dest, bool_valr);

    return FALSE;
}

/*
 * process_op
 */
static VOID process_op(HSCPRC * hp, HSCATTR * dest, BYTE op, STRPTR str1, STRPTR str2)
{
    EXPSTR *result = init_estr(40);
    BOOL result_set = FALSE;

    D(fprintf(stderr, DHL "  \"%s\", \"%s\"\n", str1, str2));
    if (str2 && (op != OP_NONE))
    {
        switch (op)
        {
        case OP_CAT:

            if (dest->vartype != VT_NUM)
            {
                /* concat two expressions */
                set_estr(result, str1);
                app_estr(result, str2);
                result_set = TRUE;
            }
            else
            {
                result_set = process_arithmetic_op(hp, result, op, str1, str2);
            }

            break;

        case OP_INSIDE:

            /* sub-string search, ignore case */
            if (upstrstr(str2, str1))
            {
                set_varbool(dest, TRUE);
            }
            else
            {
                set_varbool(dest, FALSE);
            }
            break;

        case OP_AND:
        case OP_OR:
        case OP_XOR:
            result_set = process_boolean_op(hp, dest, op, str1, str2);
            break;

        case OP_SUB:
        case OP_MUL:
        case OP_DIV:
        case OP_MOD:
            result_set = process_arithmetic_op(hp, result, op, str1, str2);
            break;

        case OP_EQ:

            /* string comparison, ignore case */
            if (!upstrcmp(str1, str2))
            {
                set_varbool(dest, TRUE);
            }
            else
            {
                set_varbool(dest, FALSE);
            }
            break;

        case OP_NEQ:

            /* string comparison "<>" */
            if (upstrcmp(str1, str2))
            {
                set_varbool(dest, TRUE);
            }
            else
            {
                set_varbool(dest, FALSE);
            }
            break;

        case OP_GT:

            /* string comparison ">" */
            if (upstrcmp(str1, str2) > 0)
            {
                set_varbool(dest, TRUE);
            }
            else
            {
                set_varbool(dest, FALSE);
            }
            break;

        case OP_LT:

            /* string comparison "<" */
            if (upstrcmp(str1, str2) < 0)
            {
                set_varbool(dest, TRUE);
            }
            else
            {
                set_varbool(dest, FALSE);
            }
            break;

        case OP_GTE:

            /* string comparison ">=" */
            if (upstrcmp(str1, str2) >= 0)
            {
                set_varbool(dest, TRUE);
            }
            else
            {
                set_varbool(dest, FALSE);
            }
            break;

        case OP_LTE:

            /* string comparison "<=" */
            if (upstrcmp(str1, str2) <= 0)
            {
                set_varbool(dest, TRUE);
            }
            else
            {
                set_varbool(dest, FALSE);
            }
            break;

        case OP_CEQ:

            /* string comparison, case sensitive */
            if (!strcmp(str1, str2))
            {
                set_varbool(dest, TRUE);
            }
            else
            {
                set_varbool(dest, FALSE);
            }
            break;
        default:
            panic("empty operator");
            break;
        }
    }
    /* store result in destination attribute,
     * if this has not happened yet
     */
    if (result_set)
    {
        set_vartext(dest, estr2str(result));
    }

    /* remove temp. string for result */
    del_estr(result);
}

/*
 *-------------------------------------
 * eval_expression: evaluate expression
 *-------------------------------------
 */

/*
 * eval_string_expr
 *
 * evaluate string expression WITH enclosing quotes
 */
static STRPTR eval_string_expr(HSCPRC * hp, HSCATTR * dest)
{
    INFILE *inpf = hp->inpf;
    STRPTR eval_result = NULL;
    EXPSTR *tmpstr = init_estr(TMP_STEPSIZE);
    int quote;

    /* get quote char */
    quote = infgetc(inpf);
    if (quote != EOF)
    {
        BOOL end = FALSE;

        while (!end)
        {
            int ch = infgetc(inpf);
            if (ch == EOF)
            {
                hsc_msg_eof(hp, "reading string constant");
                eval_result = NULL;
                end = TRUE;
            }
            else if (ch != quote)
            {
                /* check for LF inside string */
                if (ch == '\n')
                    hsc_message(hp, MSG_STR_LF,
                                "linefeed found inside string");

                /* append next char to string */
                app_estrch(tmpstr, ch);
            }
            else
            {
                /* closing quote reached */
                eval_result = estr2str(tmpstr);
                end = TRUE;
            }
        }
    }
    else
        hsc_msg_eof(hp, "reading string constant");

    /* set new attribute value */
    if (eval_result)
    {
        /* set new quotes */
        dest->quote = quote;
        /* set new value */
        set_vartext(dest, eval_result);
        eval_result = get_vartext(dest);
    }
    /* remove temp. string */
    del_estr(tmpstr);

    return (eval_result);
}

/*
 * eval_string_expr_noquote
 *
 * evaluate string expression WITHOUT enclosing quotes
 */
STRPTR eval_string_expr_noquote(HSCPRC * hp, HSCATTR * dest)
{
    INFILE *inpf = hp->inpf;
    STRPTR eval_result = NULL;
    EXPSTR *tmpstr = init_estr(TMP_STEPSIZE);
    BOOL end = FALSE;

    /*
     * read next char from input file until a
     * closing quote if found.
     * if the arg had no quote, a white space
     * or a '>' is used to detect end of arg.
     * if a LF is found, view error message
     */
    while (!end)
    {

        int ch = infgetc(inpf);
        if (ch == EOF)
        {
            hsc_msg_eof(hp, "reading attribute");

            end = TRUE;
        }
        else if ((ch == '\n')
                 || (inf_isws(ch, inpf) || (ch == '>')))
        {
            /* end of arg reached */
            inungetc(ch, inpf);
            eval_result = estr2str(tmpstr);
            end = TRUE;
        }
        else
        {
            /* append next char to tmpstr */
            app_estrch(tmpstr, ch);
        }
    }

    /* set new attribute value */
    if (eval_result)
    {
        set_vartext(dest, eval_result);
        eval_result = get_vartext(dest);
    }
    /* remove temp. string */
    del_estr(tmpstr);

    return (eval_result);
}

/*
 * eval_attrref
 *
 * evaluate reference to attribute
 *
 */
static STRPTR eval_attrref(HSCPRC * hp, HSCATTR * destattr)
{
    STRPTR eval_result = NULL;
    STRPTR nw = eval_attrname(hp);

    if (nw)
    {
        HSCATTR *refvar = find_varname(hp->defattr, nw);

        if (refvar)
        {
            destattr->quote = refvar->quote;
            eval_result = refvar->text;

            /* check empty/circular reference */
            if (!eval_result)
                hsc_message(hp, MSG_EMPTY_SYMB_REF,
                            "empty reference to %A", destattr);

            /* debugging message */
            DDA(fprintf(stderr, DHL "   %s refers to (%s)\n",
                        destattr->name, refvar->name));
        }
        else
        {
            /* reference to unknown destattr */
            hsc_msg_unkn_attr_ref(hp, nw);
        }

        /* set empty value for reference to NULL */
        if ((!refvar) || (!eval_result))
        {
            /* return empty destattr */
            destattr->quote = '"';
            eval_result = "";
        }
    }

    /* set value of destination attribute */
    if (eval_result)
        set_vartext(destattr, eval_result);

    return (eval_result);
}

/*
 * check_color - check if a color constant is legal
 */
static VOID check_color(HSCPRC * hp, HSCATTR * dest, STRPTR value)
{
    BOOL ok = FALSE;
    size_t color_len = strlen("#rrggbb");

    if (value[0] == '#')
    {
        /* check RGB-value */
        if (strlen(value) == color_len)
        {
            size_t i = 1;

            ok = TRUE;
            for (; i < color_len; i++)
            {
                if (!isxdigit(value[i]))
                {
                    ok = FALSE;
                }
            }
        }
    }
    else
    {
        /* check color name */
        if (hp->color_names)
        {
            if (strenum(value, hp->color_names, '|', STEN_NOCASE))
                ok = TRUE;
        }
        else
            ok = TRUE;
    }

    if (!ok)
    {
        /* illegal color value */
        hsc_message(hp, MSG_ILLG_COLOR,
                    "illegal color value %q for %A",
                    value, dest);
    }
}

/*
 * check_integer - check if a integer constant is legal
 */
static VOID check_integer(HSCPRC * hp, HSCATTR * dest, STRPTR value)
{
    BOOL ok = FALSE;
    int i = 0;

    if ((value[0] == '+')
        || (value[0] == '-'))
    {
        i = 1;
    }

    if (strlen(value) - i)
    {
        ok = TRUE;
        while (value[i] && ok)
        {
            if (!isdigit(value[i]))
                ok = FALSE;
            else
                i++;
        }
    }

    if (!ok)
    {
        /* illegal integer value */
        hsc_message(hp, MSG_ILLG_NUM,
                    "illegal numeric value %q for %A",
                    value, dest);
    }
}

/*
 * new_cloned_attr
 *
 * create a new attribute and clone the type and flags
 * of another attribute.
 *
 * Normally the cloned attribute has the same name as the
 * initial target attribute, but in debug mode a more
 * informative name is used
 */
static HSCATTR *new_cloned_attr(STRPTR debug_name, HSCATTR *attr)
{
#if DEBUG
    STRPTR cloned_name = debug_name;
#else
    STRPTR cloned_name = attr->name;
#endif
    BYTE new_type = attr->vartype;
    HSCATTR *cloned_attr = new_hscattr(cloned_name);

    /* init cloned attribute */
    cloned_attr->vartype = attr->vartype;
    cloned_attr->varflag = attr->varflag;
    cloned_attr->quote = attr->quote;



    return cloned_attr;
}

/*
 * eval_expression
 *
 * params: dest....attribute where to store result in
 *         inpf....input file
 *         err.....flag that is set to TRUE if an error occured
 *         endstr..word that is expected at end of expession;
 *                 NULL for no special ending word
 * result: result of evaluation (IF_TRUE or FALSE)
 *
 * NOTE: if endstr==NULL, that means that eval_expression() is called
 *   immediatly after the "=" of an attribute. In this case, if no
 *   quotes are found as next char, all chars are read until the next
 *   white-space or LF occures.
 *
 */
STRPTR eval_expression(HSCPRC * hp, HSCATTR * dest, STRPTR endstr)
{
    INFILE *inpf = hp->inpf;

    /* used as destination by eval_string_exprXX() */
    EXPSTR *vararg = init_estr(TMP_STEPSIZE);

    /* create cloned attribute to hold result */
    HSCATTR *dest1 = new_cloned_attr(PREFIX_TMPATTR "1st.operand", dest);

    STRPTR exprstr = NULL;      /* return value */
    int ch;                     /* char read from input */

    /* skip white spaces */
    infskip_ws(inpf);

    /* read dest->quote char */
    ch = infgetc(inpf);
    if (!strchr(VQ_STR_QUOTE, ch))
    {
        if (ch != EOF)
        {
            dest1->quote = VQ_NO_QUOTE;
        }
        else
        {
            hsc_msg_eof(hp, "reading attribute");
        }
    }
    else
    {
        dest1->quote = ch;
    }

    if (ch == '(')
    {
        /* process braket */
        exprstr = eval_expression(hp, dest1, ")");

        /* set generic double quote */
        if (!endstr)
        {
            dest1->quote = '\"';
        }
    }
    else if (ch != EOF)
    {
        /* write current char read back to input buffer */
        inungetc(ch, inpf);

        if (dest1->quote != VQ_NO_QUOTE)
        {
            /* process string expression with quotes */
            exprstr = eval_string_expr(hp, dest1);
        }
        else if (endstr)
        {
            BOOL err = FALSE;

            /* try to process unary operator */
            exprstr = try_eval_unary_op(hp, dest1, &err);

            /* process attribute reference */
            if (!exprstr && !err)
            {
                exprstr = eval_attrref(hp, dest1);
            }
        }
        else
        {
            /* process string expression without quotes */
            exprstr = eval_string_expr_noquote(hp, dest1);
        }
    }

    if (exprstr && endstr)
    {
        BYTE op;

        /* evaluate operator */
        op = eval_op(hp);

        if (op == OP_CL_BRACKET)
        {
            DMSG("  END mark operator reached");
        }
        else if (op != OP_NONE)
        {
            /* read second operator */
            if (op != OP_NONE)
            {
                HSCATTR *dest2 = new_cloned_attr(PREFIX_TMPATTR "2nd.operand",
                                                 dest1);
                STRPTR str1 = get_vartext(dest1);
                STRPTR str2 = NULL;

                /* compute second operand */
                str2 = eval_expression(hp, dest2, endstr);

                if (str2)
                {
                    process_op(hp, dest1, op, str1, str2);
                }
                else
                {
                    exprstr = NULL;
                }

                /* remove temporary resources */
                del_hscattr((APTR) dest2);
            }
            else
            {
                exprstr = NULL;
            }

            if (exprstr)
            {
                /* store result */
                exprstr = get_vartext(dest1);
            }
        }
        else
        {
            DMSG("  NO operator");
        }
    }

    if (!endstr)
    {
        if (exprstr && !endstr)
        {
            /* choose quote (only for tag attributes) */
            if ((dest1->vartype != VT_BOOL)
                && !(dest1->varflag & (VF_MACRO | VF_KEEP_QUOTES)))
            {
                choose_quote(hp, dest1);
            }

            /* check enum type */
            if (dest1->vartype == VT_ENUM)
            {
                if (!strenum(exprstr, dest1->enumstr, '|', STEN_NOCASE))
                {
                    /* unknown enum value */
                    hsc_message(hp, MSG_ENUM_UNKN,
                                "unknown value %q for enumerator %A",
                                exprstr, dest1);
                }
            }
            else if (dest1->vartype == VT_COLOR)
            {
                /* check color value */
                check_color(hp, dest1, exprstr);
            }
            else if (dest1->vartype == VT_NUM)
            {
                /* check numeric value */
                check_integer(hp, dest1, exprstr);
            }
            else if (dest1->vartype == VT_BOOL)
            {
                /*
                 * for boolean attributes, set the name
                 * of the attribute if TRUE, or set an
                 * empty string, if FALSE
                 */
                if (eval_boolstr(exprstr))
                {
                    set_vartext(dest1, dest1->name);
                }
                else
                {
                    set_vartext(dest1, "");
                }
            }

            /*
             * checks performed only for tags,
             * but are skipped for macros
             */
            if (!(dest1->varflag & VF_MACRO))
            {
                /*
                 * parse uri (convert abs.uris, check existence)
                 */
                if (dest1->vartype == VT_URI)
                {
                    EXPSTR *dest_uri = init_estr(32);

                    parse_uri(hp, dest_uri, exprstr);
                    set_vartext(dest1, estr2str(dest_uri));

                    del_estr(dest_uri);
                }
            }
            exprstr = get_vartext(dest1);
        }
        else
        {
            /* if error occured,
             * skip until ">", unread ">"
             */
            skip_until_eot(hp, NULL);
            if (!hp->fatal)
            {
                inungetcw(inpf);
            }
        }
    }

    /* assign result to destination attribute */
    if (exprstr)
    {
        set_vartext(dest, exprstr);
        dest->quote = dest1->quote;
        exprstr = get_vartext(dest);
    }

    /* remove temporary resources */
    del_hscattr((APTR) dest1);
    del_estr(vararg);

    return (exprstr);
}

/*
 * assign_conditional_attr
 *
 * validate and find name of source attrib, if set, copy value
 * to destination attribute
 *
 * params: hp...........hsc-process
 *         dest.........detination attribute where to store value
 *         source_attr..name of source attribute
 * result: value of attribute, if it has been set, or NULL
 *         if attribute is empty or unknown or other error
 *         has occured.
 */
static STRPTR assign_conditional_attr(HSCPRC * hp, HSCATTR * dest, STRPTR source_name)
{
    STRPTR attrval = NULL;

    if (source_name)
    {
        if (check_attrname(hp, source_name))
        {
            HSCATTR *attr = find_varname(hp->defattr, source_name);

            if (attr)
            {
                attrval = get_vartext(attr);
                dest->quote = attr->quote;
            }
            else
            {
                hsc_msg_unkn_attr_ref(hp, source_name);
            }
        }
    }
    else
    {
        panic("no source attribute");
    }

    /* update attribute value and quotes */
    if (attrval)
    {
        set_vartext(dest, attrval);
        attrval = get_vartext(dest);
        choose_quote(hp, dest);
    }

    return (attrval);
}

/*
 * eval_conditional_expression
 *
 * evaluate a conditional expression like
 *   SEPP?=HUGO or SEPP?=("hu"+"go")
 * and modify destination attribute only if the source
 * attribute really exists
 *
 * params: hp...hsc-process
 *         dest..target attribute to update
 * result: new value or NULL in case of no update or error
 */
STRPTR eval_conditional_assignment(HSCPRC * hp, HSCATTR * dest)
{
    STRPTR nw = infgetw(hp->inpf);
    STRPTR attr_val = NULL;

    D(fprintf(stderr, DHL "  conditional assignment\n"));

    if (nw)
    {
        /* temp. attribute to store name of source attribute if it
         * is specified with an expression */
        HSCATTR *tmp_attr = NULL;
        STRPTR source_name = NULL;      /* name of source attribute */

        if (!strcmp(nw, "("))
        {
            /* get attribute name from expression */
            tmp_attr = new_hscattr(PREFIX_TMPATTR "conditional.assignment");
            source_name = eval_expression(hp, tmp_attr, ")");
        }
        else
        {
            /* attribute name was simply specified */
            source_name = nw;
        }

        if (source_name)
        {
            D(fprintf(stderr, DHL "    assign from %s\n", source_name));
            attr_val = assign_conditional_attr(hp, dest, source_name);
        }

        /* free resources */
        if (tmp_attr)
        {
            del_hscattr(tmp_attr);
        }

    }
    else
    {
        hsc_msg_eof(hp, "conditional attribute identifier expected");
    }

    return (attr_val);
}