eval.c

/*	eval.c
 *
 *	Expression evaluation functions
 *
 *	written 1986 by Daniel Lawrence
 *	modified by Petri Kutvonen
 */

#include <stdio.h>

#include "estruct.h"
#include "edef.h"
#include "efunc.h"
#include "evar.h"
#include "line.h"
#include "util.h"
#include "version.h"

#define    MAXVARS    255

/* User variables */
static struct user_variable uv[MAXVARS + 1];

/* Initialize the user variable list. */
void varinit(void) {
  int i;
  for (i = 0; i < MAXVARS; i++)
    uv[i].u_name[0] = 0;
}

/*
 * Evaluate a function.
 *
 * @fname: name of function to evaluate.
 */
char *gtfun(char *fname) {
  int fnum;    /* index to function to eval */
  int status;    /* return status */
  char *tsp;    /* temporary string pointer */
  char arg1[NSTRING];    /* value of first argument */
  char arg2[NSTRING];    /* value of second argument */
  char arg3[NSTRING];    /* value of third argument */
  static char result[2 * NSTRING];    /* string result */

  /* look the function up in the function table */
  fname[3] = 0;        /* only first 3 chars significant */
  mklower(fname);        /* and let it be upper or lower case */
  for (fnum = 0; fnum < ARRAY_SIZE(funcs); fnum++)
    if (strcmp(fname, funcs[fnum].f_name) == 0)
      break;

  /* return errorm on a bad reference */
  if (fnum == ARRAY_SIZE(funcs))
    return errorm;

  /* if needed, retrieve the first argument */
  if (funcs[fnum].f_type >= MONAMIC) {
    if ((status = macarg(arg1)) != TRUE)
      return errorm;

    /* if needed, retrieve the second argument */
    if (funcs[fnum].f_type >= DYNAMIC) {
      if ((status = macarg(arg2)) != TRUE)
        return errorm;

      /* if needed, retrieve the third argument */
      if (funcs[fnum].f_type >= TRINAMIC)
        if ((status = macarg(arg3)) != TRUE)
          return errorm;
    }
  }


  /* and now evaluate it! */
  switch (fnum) {
    case UFADD: return ue_itoa(atoi(arg1) + atoi(arg2));
    case UFSUB: return ue_itoa(atoi(arg1) - atoi(arg2));
    case UFTIMES: return ue_itoa(atoi(arg1) * atoi(arg2));
    case UFDIV: return ue_itoa(atoi(arg1) / atoi(arg2));
    case UFMOD: return ue_itoa(atoi(arg1) % atoi(arg2));
    case UFNEG: return ue_itoa(-atoi(arg1));
    case UFCAT: strcpy(result, arg1);
      return strcat(result, arg2);
    case UFLEFT: return strncpy(result, arg1, atoi(arg2));
    case UFRIGHT:
      return (strcpy(result,
                     &arg1[(strlen(arg1) - atoi(arg2))]));
    case UFMID:
      return (strncpy(result, &arg1[atoi(arg2) - 1],
                      atoi(arg3)));
    case UFNOT: return ltos(stol(arg1) == FALSE);
    case UFEQUAL: return ltos(atoi(arg1) == atoi(arg2));
    case UFLESS: return ltos(atoi(arg1) < atoi(arg2));
    case UFGREATER: return ltos(atoi(arg1) > atoi(arg2));
    case UFSEQUAL: return ltos(strcmp(arg1, arg2) == 0);
    case UFSLESS: return ltos(strcmp(arg1, arg2) < 0);
    case UFSGREAT: return ltos(strcmp(arg1, arg2) > 0);
    case UFIND: return strcpy(result, getval(arg1));
    case UFAND: return ltos(stol(arg1) && stol(arg2));
    case UFOR: return ltos(stol(arg1) || stol(arg2));
    case UFLENGTH: return ue_itoa(strlen(arg1));
    case UFUPPER: return mkupper(arg1);
    case UFLOWER: return mklower(arg1);
    case UFTRUTH: return ltos(atoi(arg1) == 42);
    case UFASCII: return ue_itoa((int) arg1[0]);
    case UFCHR: result[0] = atoi(arg1);
      result[1] = 0;
      return result;
    case UFGTKEY: result[0] = tgetc();
      result[1] = 0;
      return result;
    case UFRND: return ue_itoa((ernd() % abs(atoi(arg1))) + 1);
    case UFABS: return ue_itoa(abs(atoi(arg1)));
    case UFSINDEX: return ue_itoa(sindex(arg1, arg2));
    case UFENV:
#if    ENVFUNC
      tsp = getenv(arg1);
      return tsp == NULL ? "" : tsp;
#else
      return "";
#endif
    case UFBIND: return transbind(arg1);
    case UFEXIST: return ltos(fexist(arg1));
    case UFFIND: tsp = flook(arg1, TRUE);
      return tsp == NULL ? "" : tsp;
    case UFBAND: return ue_itoa(atoi(arg1) & atoi(arg2));
    case UFBOR: return ue_itoa(atoi(arg1) | atoi(arg2));
    case UFBXOR: return ue_itoa(atoi(arg1) ^ atoi(arg2));
    case UFBNOT: return ue_itoa(~atoi(arg1));
    case UFXLATE: return xlat(arg1, arg2, arg3);
  }

  exit(-11);        /* never should get here */
}

/*
 * look up a user var's value
 *
 * char *vname;			name of user variable to fetch
 */
char *gtusr(char *vname) {

  int vnum;    /* ordinal number of user var */

  /* scan the list looking for the user var name */
  for (vnum = 0; vnum < MAXVARS; vnum++) {
    if (uv[vnum].u_name[0] == 0)
      return errorm;
    if (strcmp(vname, uv[vnum].u_name) == 0)
      return uv[vnum].u_value;
  }

  /* return errorm if we run off the end */
  return errorm;
}

extern char *getkill(void);

/*
 * gtenv()
 *
 * char *vname;			name of environment variable to retrieve
 */
char *gtenv(char *vname) {
  int vnum;    /* ordinal number of var refrenced */

  /* scan the list, looking for the referenced name */
  for (vnum = 0; vnum < ARRAY_SIZE(envars); vnum++)
    if (strcmp(vname, envars[vnum]) == 0)
      break;

  /* return errorm on a bad reference */
  if (vnum == ARRAY_SIZE(envars))
#if    ENVFUNC
    {
        char *ename = getenv(vname);

        if (ename != NULL)
            return ename;
        else
            return errorm;
    }
#else
    return errorm;
#endif

  /* otherwise, fetch the appropriate value */
  switch (vnum) {
    case EVFILLCOL: return ue_itoa(fillcol);
    case EVPAGELEN: return ue_itoa(term.t_nrow + 1);
    case EVCURCOL: return ue_itoa(getccol(FALSE));
    case EVCURLINE: return ue_itoa(getcline());
    case EVRAM: return ue_itoa((int) (envram / 1024l));
    case EVFLICKER: return ltos(flickcode);
    case EVCURWIDTH: return ue_itoa(term.t_ncol);
    case EVCBUFNAME: return curbp->b_bname;
    case EVCFNAME: return curbp->b_fname;
    case EVSRES: return sres;
    case EVDEBUG: return ltos(macbug);
    case EVSTATUS: return ltos(cmdstatus);
    case EVPALETTE: return palstr;
    case EVASAVE: return ue_itoa(gasave);
    case EVACOUNT: return ue_itoa(gacount);
    case EVLASTKEY: return ue_itoa(lastkey);
    case EVCURCHAR:
      return (curwp->w_dotp->l_used ==
          curwp->w_doto ? ue_itoa('\n') :
              ue_itoa(lgetc(curwp->w_dotp, curwp->w_doto)));
    case EVDISCMD: return ltos(discmd);
    case EVVERSION: return VERSION;
    case EVPROGNAME: return PROGRAM_NAME_LONG;
    case EVSEED: return ue_itoa(seed);
    case EVDISINP: return ltos(disinp);
    case EVWLINE: return ue_itoa(curwp->w_ntrows);
    case EVCWLINE: return ue_itoa(getwpos());
    case EVTARGET: saveflag = lastflag;
      return ue_itoa(curgoal);
    case EVSEARCH: return pat;
    case EVREPLACE: return rpat;
    case EVMATCH: return (patmatch == NULL) ? "" : patmatch;
    case EVKILL: return getkill();
    case EVCMODE: return ue_itoa(curbp->b_mode);
    case EVGMODE: return ue_itoa(gmode);
    case EVTPAUSE: return ue_itoa(term.t_pause);
    case EVPENDING:
#if    TYPEAH
      return ltos(typahead());
#else
      return falsem;
#endif
    case EVLWIDTH: return ue_itoa(llength(curwp->w_dotp));
    case EVLINE: return getctext();
    case EVGFLAGS: return ue_itoa(gflags);
    case EVRVAL: return ue_itoa(rval);
    case EVTAB: return ue_itoa(tabmask + 1);
    case EVOVERLAP: return ue_itoa(overlap);
    case EVSCROLLCOUNT: return ue_itoa(scrollcount);
#if SCROLLCODE
    case EVSCROLL: return ltos(term.t_scroll != NULL);
#else
      case EVSCROLL:
          return ltos(0);
#endif
  }
  exit(-12);        /* again, we should never get here */
}

/*
 * return some of the contents of the kill buffer
 */
char *getkill(void) {
  int size;    /* max number of chars to return */
  static char value[NSTRING];    /* temp buffer for value */

  if (kbufh == NULL)
    /* no kill buffer....just a null string */
    value[0] = 0;
  else {
    /* copy in the contents... */
    if (kused < NSTRING)
      size = kused;
    else
      size = NSTRING - 1;
    strncpy(value, kbufh->d_chunk, size);
  }

  /* and return the constructed value */
  return value;
}

/*
 * set a variable
 *
 * int f;		default flag
 * int n;		numeric arg (can overide prompted value)
 */
int setvar(int f, int n) {
  int status;    /* status return */
#if    DEBUGM
  char *sp;    /* temp string pointer */
  char *ep;    /* ptr to end of outline */
#endif
  struct variable_description vd;        /* variable num/type */
  char var[NVSIZE + 1];    /* name of variable to fetch */
  char value[NSTRING];    /* value to set variable to */

  /* first get the variable to set.. */
  if (clexec == FALSE) {
    status = mlreply("Variable to set: ", &var[0], NVSIZE);
    if (status != TRUE)
      return status;
  } else {        /* macro line argument */
    /* grab token and skip it */
    execstr = token(execstr, var, NVSIZE + 1);
  }

  /* check the legality and find the var */
  findvar(var, &vd, NVSIZE + 1);

  /* if its not legal....bitch */
  if (vd.v_type == -1) {
    mlwrite("%%No such variable as '%s'", var);
    return FALSE;
  }

  /* get the value for that variable */
  if (f == TRUE)
    strcpy(value, ue_itoa(n));
  else {
    status = mlreply("Value: ", &value[0], NSTRING);
    if (status != TRUE)
      return status;
  }

  /* and set the appropriate value */
  status = svar(&vd, value);

#if    DEBUGM
  /* if $debug == TRUE, every assignment will echo a statment to
     that effect here. */

  if (macbug) {
    strcpy(outline, "(((");

    /* assignment status */
    strcat(outline, ltos(status));
    strcat(outline, ":");

    /* variable name */
    strcat(outline, var);
    strcat(outline, ":");

    /* and lastly the value we tried to assign */
    strcat(outline, value);
    strcat(outline, ")))");

    /* expand '%' to "%%" so mlwrite wont bitch */
    sp = outline;
    while (*sp)
      if (*sp++ == '%') {
        /* advance to the end */
        ep = --sp;
        while (*ep++);
        /* null terminate the string one out */
        *(ep + 1) = 0;
        /* copy backwards */
        while (ep-- > sp)
          *(ep + 1) = *ep;

        /* and advance sp past the new % */
        sp += 2;
      }

    /* write out the debug line */
    mlforce(outline);
    update(TRUE);

    /* and get the keystroke to hold the output */
    if (get1key() == abortc) {
      mlforce("(Macro aborted)");
      status = FALSE;
    }
  }
#endif

  /* and return it */
  return status;
}

/*
 * Find a variables type and name.
 *
 * @var: name of variable to get.
 * @vd: structure to hold type and pointer.
 * @size: size of variable array.
 */
void findvar(char *var, struct variable_description *vd, int size) {
  int vnum;    /* subscript in variable arrays */
  int vtype;    /* type to return */

  vnum = -1;
  fvar:
  vtype = -1;
  switch (var[0]) {

    case '$':        /* check for legal enviromnent var */
      for (vnum = 0; vnum < ARRAY_SIZE(envars); vnum++)
        if (strcmp(&var[1], envars[vnum]) == 0) {
          vtype = TKENV;
          break;
        }
      break;

    case '%':        /* check for existing legal user variable */
      for (vnum = 0; vnum < MAXVARS; vnum++)
        if (strcmp(&var[1], uv[vnum].u_name) == 0) {
          vtype = TKVAR;
          break;
        }
      if (vnum < MAXVARS)
        break;

      /* create a new one??? */
      for (vnum = 0; vnum < MAXVARS; vnum++)
        if (uv[vnum].u_name[0] == 0) {
          vtype = TKVAR;
          strcpy(uv[vnum].u_name, &var[1]);
          break;
        }
      break;

    case '&':        /* indirect operator? */
      var[4] = 0;
      if (strcmp(&var[1], "ind") == 0) {
        /* grab token, and eval it */
        execstr = token(execstr, var, size);
        strcpy(var, getval(var));
        goto fvar;
      }
  }

  /* return the results */
  vd->v_num = vnum;
  vd->v_type = vtype;
  return;
}

/*
 * Set a variable.
 *
 * @var: variable to set.
 * @value: value to set to.
 */
int svar(struct variable_description *var, char *value) {
  int vnum;    /* ordinal number of var refrenced */
  int vtype;    /* type of variable to set */
  int status;    /* status return */
  int c;        /* translated character */
  char *sp;    /* scratch string pointer */

  /* simplify the vd structure (we are gonna look at it a lot) */
  vnum = var->v_num;
  vtype = var->v_type;

  /* and set the appropriate value */
  status = TRUE;
  switch (vtype) {
    case TKVAR:        /* set a user variable */
      if (uv[vnum].u_value != NULL)
        free(uv[vnum].u_value);
      sp = malloc(strlen(value) + 1);
      if (sp == NULL)
        return FALSE;
      strcpy(sp, value);
      uv[vnum].u_value = sp;
      break;

    case TKENV:        /* set an environment variable */
      status = TRUE;    /* by default */
      switch (vnum) {
        case EVFILLCOL: fillcol = atoi(value);
          break;
        case EVPAGELEN: status = newsize(TRUE, atoi(value));
          break;
        case EVCURCOL: status = setccol(atoi(value));
          break;
        case EVCURLINE: status = gotoline(TRUE, atoi(value));
          break;
        case EVRAM: break;
        case EVFLICKER: flickcode = stol(value);
          break;
        case EVCURWIDTH: status = newwidth(TRUE, atoi(value));
          break;
        case EVCBUFNAME: strcpy(curbp->b_bname, value);
          curwp->w_flag |= WFMODE;
          break;
        case EVCFNAME: strcpy(curbp->b_fname, value);
          curwp->w_flag |= WFMODE;
          break;
        case EVSRES: status = TTrez(value);
          break;
        case EVDEBUG: macbug = stol(value);
          break;
        case EVSTATUS: cmdstatus = stol(value);
          break;
        case EVASAVE: gasave = atoi(value);
          break;
        case EVACOUNT: gacount = atoi(value);
          break;
        case EVLASTKEY: lastkey = atoi(value);
          break;
        case EVCURCHAR: ldelchar(1, FALSE);    /* delete 1 char */
          c = atoi(value);
          if (c == '\n')
            lnewline();
          else
            linsert(1, c);
          backchar(FALSE, 1);
          break;
        case EVDISCMD: discmd = stol(value);
          break;
        case EVVERSION: break;
        case EVPROGNAME: break;
        case EVSEED: seed = atoi(value);
          break;
        case EVDISINP: disinp = stol(value);
          break;
        case EVWLINE: status = resize(TRUE, atoi(value));
          break;
        case EVCWLINE: status = forwline(TRUE, atoi(value) - getwpos());
          break;
        case EVTARGET: curgoal = atoi(value);
          thisflag = saveflag;
          break;
        case EVSEARCH: strcpy(pat, value);
          rvstrcpy(tap, pat);
#if    MAGIC
          mcclear();
#endif
          break;
        case EVREPLACE: strcpy(rpat, value);
          break;
        case EVMATCH: break;
        case EVKILL: break;
        case EVCMODE: curbp->b_mode = atoi(value);
          curwp->w_flag |= WFMODE;
          break;
        case EVGMODE: gmode = atoi(value);
          break;
        case EVTPAUSE: term.t_pause = atoi(value);
          break;
        case EVPENDING: break;
        case EVLWIDTH: break;
        case EVLINE: putctext(value);
        case EVGFLAGS: gflags = atoi(value);
          break;
        case EVRVAL: break;
        case EVTAB: tabmask = atoi(value) - 1;
          if (tabmask != 0x07 && tabmask != 0x03)
            tabmask = 0x07;
          curwp->w_flag |= WFHARD;
          break;
        case EVOVERLAP: overlap = atoi(value);
          break;
        case EVSCROLLCOUNT: scrollcount = atoi(value);
          break;
        case EVSCROLL:
#if SCROLLCODE
          if (!stol(value))
            term.t_scroll = NULL;
#endif
          break;
      }
      break;
  }
  return status;
}

/*
 * itoa:
 *	integer to ascii string.......... This is too
 *	inconsistant to use the system's
 *
 * int i;		integer to translate to a string
 */
char *ue_itoa(int i) {
  int digit;    /* current digit being used */
  char *sp;    /* pointer into result */
  int sign;    /* sign of resulting number */
  static char result[INTWIDTH + 1];    /* resulting string */

  /* record the sign... */
  sign = 1;
  if (i < 0) {
    sign = -1;
    i = -i;
  }

  /* and build the string (backwards!) */
  sp = result + INTWIDTH;
  *sp = 0;
  do {
    digit = i % 10;
    *(--sp) = '0' + digit;    /* and install the new digit */
    i = i / 10;
  } while (i);

  /* and fix the sign */
  if (sign == -1) {
    *(--sp) = '-';    /* and install the minus sign */
  }

  return sp;
}

/*
 * find the type of a passed token
 *
 * char *token;		token to analyze
 */
int gettyp(char *token) {
  char c;    /* first char in token */

  /* grab the first char (this is all we need) */
  c = *token;

  /* no blanks!!! */
  if (c == 0)
    return TKNUL;

  /* a numeric literal? */
  if (c >= '0' && c <= '9')
    return TKLIT;

  switch (c) {
    case '"': return TKSTR;

    case '!': return TKDIR;
    case '@': return TKARG;
    case '#': return TKBUF;
    case '$': return TKENV;
    case '%': return TKVAR;
    case '&': return TKFUN;
    case '*': return TKLBL;

    default: return TKCMD;
  }
}

/*
 * find the value of a token
 *
 * char *token;		token to evaluate
 */
char *getval(char *token) {
  int status;    /* error return */
  struct buffer *bp;    /* temp buffer pointer */
  int blen;    /* length of buffer argument */
  int distmp;    /* temporary discmd flag */
  static char buf[NSTRING];    /* string buffer for some returns */

  switch (gettyp(token)) {
    case TKNUL: return "";

    case TKARG:        /* interactive argument */
      strcpy(token, getval(&token[1]));
      distmp = discmd;    /* echo it always! */
      discmd = TRUE;
      status = getstring(token, buf, NSTRING, ctoec('\n'));
      discmd = distmp;
      if (status == ABORT)
        return errorm;
      return buf;

    case TKBUF:        /* buffer contents fetch */

      /* grab the right buffer */
      strcpy(token, getval(&token[1]));
      bp = bfind(token, FALSE, 0);
      if (bp == NULL)
        return errorm;

      /* if the buffer is displayed, get the window
         vars instead of the buffer vars */
      if (bp->b_nwnd > 0) {
        curbp->b_dotp = curwp->w_dotp;
        curbp->b_doto = curwp->w_doto;
      }

      /* make sure we are not at the end */
      if (bp->b_linep == bp->b_dotp)
        return errorm;

      /* grab the line as an argument */
      blen = bp->b_dotp->l_used - bp->b_doto;
      if (blen >= NSTRING)
        blen = NSTRING-1;
      strncpy(buf, bp->b_dotp->l_text + bp->b_doto, blen);
      buf[blen] = 0;

      /* and step the buffer's line ptr ahead a line */
      bp->b_dotp = bp->b_dotp->l_fp;
      bp->b_doto = 0;

      /* if displayed buffer, reset window ptr vars */
      if (bp->b_nwnd > 0) {
        curwp->w_dotp = curbp->b_dotp;
        curwp->w_doto = 0;
        curwp->w_flag |= WFMOVE;
      }

      /* and return the spoils */
      return buf;

    case TKVAR: return gtusr(token + 1);
    case TKENV: return gtenv(token + 1);
    case TKFUN: return gtfun(token + 1);
    case TKDIR: return errorm;
    case TKLBL: return errorm;
    case TKLIT: return token;
    case TKSTR: return token + 1;
    case TKCMD: return token;
  }
  return errorm;
}

/*
 * convert a string to a numeric logical
 *
 * char *val;		value to check for stol
 */
int stol(char *val) {
  /* check for logical values */
  if (val[0] == 'F')
    return FALSE;
  if (val[0] == 'T')
    return TRUE;

  /* check for numeric truth (!= 0) */
  return (atoi(val) != 0);
}

/*
 * numeric logical to string logical
 *
 * int val;		value to translate
 */
char *ltos(int val) {
  if (val)
    return truem;
  else
    return falsem;
}

/*
 * make a string upper case
 *
 * char *str;		string to upper case
 */
char *mkupper(char *str) {
  char *sp;

  sp = str;
  while (*sp) {
    if ('a' <= *sp && *sp <= 'z')
      *sp += 'A' - 'a';
    ++sp;
  }
  return str;
}

/*
 * make a string lower case
 *
 * char *str;		string to lower case
 */
char *mklower(char *str) {
  char *sp;

  sp = str;
  while (*sp) {
    if ('A' <= *sp && *sp <= 'Z')
      *sp += 'a' - 'A';
    ++sp;
  }
  return str;
}

#if __GNUC__ <= 3
/*
 * take the absolute value of an integer
 */
int abs(int x)
{
    return x < 0 ? -x : x;
}
#endif

/*
 * returns a random integer
 */
int ernd(void) {
  seed = abs(seed * 1721 + 10007);
  return seed;
}

/*
 * find pattern within source
 *
 * char *source;	source string to search
 * char *pattern;	string to look for
 */
int sindex(char *source, char *pattern) {
  char *sp;        /* ptr to current position to scan */
  char *csp;        /* ptr to source string during comparison */
  char *cp;        /* ptr to place to check for equality */

  /* scanning through the source string */
  sp = source;
  while (*sp) {
    /* scan through the pattern */
    cp = pattern;
    csp = sp;
    while (*cp) {
      if (!eq(*cp, *csp))
        break;
      ++cp;
      ++csp;
    }

    /* was it a match? */
    if (*cp == 0)
      return (int) (sp - source) + 1;
    ++sp;
  }

  /* no match at all.. */
  return 0;
}

/*
 * Filter a string through a translation table
 *
 * char *source;	string to filter
 * char *lookup;	characters to translate
 * char *trans;		resulting translated characters
 */
char *xlat(char *source, char *lookup, char *trans) {
  char *sp;    /* pointer into source table */
  char *lp;    /* pointer into lookup table */
  char *rp;    /* pointer into result */
  static char result[NSTRING];    /* temporary result */

  /* scan source string */
  sp = source;
  rp = result;
  while (*sp) {
    /* scan lookup table for a match */
    lp = lookup;
    while (*lp) {
      if (*sp == *lp) {
        *rp++ = trans[lp - lookup];
        goto xnext;
      }
      ++lp;
    }

    /* no match, copy in the source char untranslated */
    *rp++ = *sp;

    xnext:
    ++sp;
  }

  /* terminate and return the result */
  *rp = 0;
  return result;
}