Digital-Research-Source-Code/CPM OPERATING SYSTEMS/CPM 68K/cpm68k_pgms/sdbas/INT.C

/* SDB - boolean expression evaluator */ /* -*-c,save-*- */



#include "sdbio.h"



/* #define DEBUG	1	/* debug hackery */

#ifdef DEBUG

#define LOCAL

#else

#define LOCAL static

#endif





LOCAL struct operand *stack[STACKMAX],**sptr;

LOCAL union codecell *cptr;



/* db_interpret - interpret a boolean expression */

int db_interpret(slptr)

  register struct sel *slptr;

{

    register struct operand *result;

    register int r;

    register union codecell *tcptr;



    /* check for empty where clause */

    if ((cptr = slptr->sl_where) == NULL)

        return (TRUE);



    /* setup stack */

    sptr = stack;



    /* execute the code */

    do {

	tcptr = cptr;

	cptr++;

	} while ((*(*tcptr).c_operator)());



    /* get the result from the top of stack */

    result = *--sptr;

    r = result->o_value.ov_boolean;

    if (result->o_type == TEMP)

        free(result);



    /* make sure the stack is empty */

    while (sptr != stack) {

        if ((*sptr)->o_type == TEMP)

            free(*sptr);

        sptr -= 1;

    }



    /* return result */

    return (r);

}



int db_xstop()

{

#ifdef DEBUG

    printf("*** xstop()\n");

#endif

    return (FALSE);

}



int db_xpush()

{

#ifdef DEBUG

    printf("*** xpush(): sptr = %08X, cptr = %08X\n", sptr, cptr);

#endif

    *sptr++ = (*cptr++).c_operand;

    return(TRUE);

}



int db_xand()

{

    return (boolean('&'));

}



int db_xor()

{

    return (boolean('|'));

}



LOCAL int boolean(opr)

{

    register struct operand *lval,*rval,*result;

    register int lv,rv,r;



    rval = *--sptr; lval = *--sptr;

    lv = lval->o_value.ov_boolean;

    rv = rval->o_value.ov_boolean;

#ifdef DEBUG

    printf("*** boolean(%c): lval = %08X, rval = %08X, lv = %d, rv = %d\n",

	   opr, lval, rval, lv, rv);

#endif



    if ((result = malloc(sizeof(struct operand))) == NULL)

        return (db_ferror(INSMEM));

    result->o_type = TEMP;

    switch (opr) {

    case '&':   r = (lv && rv);

                break;

    case '|':   r = (lv || rv);

                break;

    }

    result->o_value.ov_boolean = r;

    *sptr++ = result;

    if (lval->o_type == TEMP)

        free(lval);

    if (rval->o_type == TEMP)

        free(rval);

    return (TRUE);

}



int db_xnot()

{

    struct operand *val,*result;



    val = *--sptr;

#ifdef DEBUG

    printf("*** db_xnot(): vval = %08X\n", val);

#endif

    if ((result = malloc(sizeof(struct operand))) == NULL)

        return (db_ferror(INSMEM));

    result->o_type = TEMP;

    result->o_value.ov_boolean = !val->o_value.ov_boolean;

    *sptr++ = result;

    if (val->o_type == TEMP)

        free(val);

    return (TRUE);

}



int db_xlss()

{

    return (compare(LSS));

}



int db_xleq()

{

    return (compare(LEQ));

}



int db_xeql()

{

    return (compare(EQL));

}



int db_xgeq()

{

    return (compare(GEQ));

}



int db_xgtr()

{

    return (compare(GTR));

}



int db_xneq()

{

    return (compare(NEQ));

}



LOCAL int compare(cmp)

{

    struct operand *lval,*rval,*result;

    int i;



    rval = *--sptr; lval = *--sptr;

#ifdef DEBUG

    printf("*** compare(%d): lval = %08X, rval = %08X\n",

	   cmp, lval, rval);

    printf("***            : lval->o_value.ov_char.ovc_type = %d\n",

	   lval->o_value.ov_char.ovc_type);

#endif

    if ((result = malloc(sizeof(struct operand))) == NULL)

        return (db_ferror(INSMEM));

    result->o_type = TEMP;



    if (lval->o_value.ov_char.ovc_type == TCHAR)

        i = comp(lval,rval);

    else

        i = ncomp(lval,rval);



    switch (cmp) {

    case LSS:   i = (i < 0);

                break;

    case LEQ:   i = (i <= 0);

                break;

    case EQL:   i = (i == 0);

                break;

    case GEQ:   i = (i >= 0);

                break;

    case GTR:   i = (i > 0);

                break;

    case NEQ:   i = (i != 0);

                break;

    }

    result->o_value.ov_boolean = i;

    *sptr++ = result;

    if (lval->o_type == TEMP)

        free(lval);

    if (rval->o_type == TEMP)

        free(rval);

    return (TRUE);

}



LOCAL int comp(lval,rval)

  struct operand *lval,*rval;

{

    register char *lptr,*rptr; register int lctr,rctr;

    register int len;



    lptr = lval->o_value.ov_char.ovc_string;

    lctr = lval->o_value.ov_char.ovc_length;

    rptr = rval->o_value.ov_char.ovc_string;

    rctr = rval->o_value.ov_char.ovc_length;



#ifdef DEBUG

    printf("*** comp(): lptr = %s, lctr = %d, rptr = %s, rctr = %d\n",

	   lptr, lctr, rptr, rctr);

#endif

    while (lctr > 0 && (lptr[lctr-1] == 0 || lptr[lctr-1] == ' '))

        lctr--;

    while (rctr > 0 && (rptr[rctr-1] == 0 || rptr[rctr-1] == ' '))

        rctr--;



    if (lctr < rctr)

        len = lctr;

    else

        len = rctr;



    while ((len--) > 0) {

        if (*lptr++ != *rptr++)

            if (*--lptr < *--rptr)

                return (-1);

            else

                return (1);

    }



    if (lctr == rctr)

        return (0);

    else if (lctr < rctr)

        return (-1);

    else

        return (1);

}



LOCAL int ncomp(lval,rval)

  struct operand *lval,*rval;

{

    char lstr[NUMBERMAX+1],rstr[NUMBERMAX+1];

    int len;



    strncpy(lstr,lval->o_value.ov_char.ovc_string,

          (len = lval->o_value.ov_char.ovc_length)); lstr[len] = EOS;

    strncpy(rstr,rval->o_value.ov_char.ovc_string,

          (len = rval->o_value.ov_char.ovc_length)); rstr[len] = EOS;



#ifdef DEBUG

    printf("*** ncomp(): lstr = %s, rstr = %s\n", lstr, rstr);

#endif

    return (db_cmp(lstr,rstr));

}