generic/compiler/exprs.c

/*  ASCEND modelling environment
    Copyright (C) 2006 Carnegie Mellon University
    Copyright (C) 1990, 1993, 1994 Thomas Guthrie Epperly

    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, 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., 59 Temple Place - Suite 330,
    Boston, MA 02111-1307, USA.
*//**
    @file
    Expression Module

    Requires:
    #include "utilities/ascConfig.h"
    #include "fractions.h"
    #include "compiler.h"
    #include "dimen.h"
    #include "expr_types.h"
*//*
    by Tom Epperly
    Last in CVS: $Revision: 1.13 $ $Date: 1998/02/05 16:35:58 $ $Author: ballan $
*/

#include <stdio.h>
#include <assert.h>

#include <utilities/ascConfig.h>
#include <utilities/ascPanic.h>
#include "compiler.h"
#include <utilities/ascMalloc.h>
#include <general/list.h>
#include <general/pool.h>
#include "symtab.h"
#include "fractions.h"
#include "dimen.h"
#include "functype.h"
#include "expr_types.h"
#include "func.h"
#include "name.h"
#include "sets.h"
#include "instance_enum.h"
#include "cmpfunc.h"
#include "exprs.h"


#ifndef lint
static CONST char ExpressionID[] = "$Id: exprs.c,v 1.13 1998/02/05 16:35:58 ballan Exp $";
#endif

/*------------------------------------------------------------------------------
  MEMORY USAGE

  Using 'pool' or else regular malloc...
*/

#ifdef ASC_NO_POOL
#define EXPRSUSESPOOL FALSE
#else
#define EXPRSUSESPOOL TRUE
#endif

#if EXPRSUSESPOOL /* using 'g_exprs_pool' for memory management */
/** global for our memory manager */
static pool_store_t g_exprs_pool = NULL;
    /* aim for 4096 chunks including malloc overhead */
# define EMP_LEN 10
# if (SIZEOF_VOID_P == 8)
#  define EMP_WID 63
# else
#  define EMP_WID 127
# endif
    /* retune rpwid if the size of struct name changes */
# define EMP_ELT_SIZE (sizeof(struct Expr))
# define EMP_MORE_ELTS 10
/**< Number of slots filled if more elements needed.
    So if the pool grows, it grows by EMP_MORE_ELTS*EMP_WID elements at a time. */
# define EMP_MORE_BARS 500
/**< This is the number of pool bar slots to add during expansion.
   not all the slots will be filled immediately. */

/**
    This function is called at compiler startup time and destroy at shutdown.
*/
void exprs_init_pool(void) {
  if (g_exprs_pool != NULL ) {
    Asc_Panic(2, NULL, "ERROR: exprs_init_pool called twice.\n");
  }
  g_exprs_pool = pool_create_store(EMP_LEN, EMP_WID, EMP_ELT_SIZE,
    EMP_MORE_ELTS, EMP_MORE_BARS);
  if (g_exprs_pool == NULL) {
    Asc_Panic(2, NULL, "ERROR: exprs_init_pool unable to allocate pool.\n");
  }
}

void exprs_destroy_pool(void) {
  if (g_exprs_pool==NULL) return;
  pool_clear_store(g_exprs_pool);
  pool_destroy_store(g_exprs_pool);
  g_exprs_pool = NULL;
}

void exprs_report_pool()
{
  if (g_exprs_pool==NULL) {
    FPRINTF(ASCERR,"ExprsPool is empty\n");
  }
  FPRINTF(ASCERR,"ExprsPool ");
  pool_print_store(ASCERR,g_exprs_pool,0);
}

# define EPMALLOC \
    ((struct Expr *)(pool_get_element(g_exprs_pool)))
/**< get a token. Token is the size of the struct struct Expr */

# define EPFREE(p) \
    (pool_free_element(g_exprs_pool,((void *)p)))
/**< return a struct Expr */

# define EXPR_CHECK_MEMORY(VAR) \
    AssertMemory(VAR)

#else /* not using 'g_exprs_pool'... */

void exprs_init_pool(void) {}
void exprs_destroy_pool(void) {}
void exprs_report_pool(void){
    FPRINTF(ASCERR,"ExprsPool not used at all\n");
}

# define EPFREE(p) \
    ASC_FREE(p)

# define EPMALLOC \
    ASC_NEW(struct Expr)

# define EXPR_CHECK_MEMORY(VAR) \
    AssertAllocatedMemory(result,sizeof(struct Expr))

#endif


# define EXPR_NEW(VAR,TYPE) \
    VAR = EPMALLOC; \
    VAR->t = TYPE; \
    VAR->next = NULL

/*------------------------------------------------------------------------------
  CREATION ROUTINES
*/

struct Expr *CreateVarExpr(struct Name *n)
{
  register struct Expr *result;
  assert(n!=NULL);
  AssertMemory(n);
  EXPR_NEW(result,e_var);
  result->v.nptr = n;
  EXPR_CHECK_MEMORY(result);

  return result;
}

/*
    As with var, store pointer to the name, but give it a special type 'e_diff'.
*/
struct Expr *CreateDiffExpr(struct Name *n){
  register struct Expr *result;
  ERROR_REPORTER_HERE(ASC_PROG_ERR,"not yet implemented");
  EXPR_NEW(result,e_diff);
  result->v.nptr = n;
  EXPR_CHECK_MEMORY(result);
  return result;
}

void InitVarExpr(struct Expr *result,CONST struct Name *n)
{
  assert(n!=NULL);
  AssertMemory(n);
  result->t = e_var;
  result->v.nptr = (struct Name *)n;
  result->next = NULL;
}

struct Expr *CreateOpExpr(enum Expr_enum t)
{
  register struct Expr *result;
  assert((t!=e_var)&&(t!=e_func)&&(t!=e_int)&&(t!=e_real)&&(t!=e_zero));
  EXPR_NEW(result,t);
#if EXPRSUSESPOOL
  AssertMemory(result);
#else
  AssertAllocatedMemory(result,sizeof(enum Expr_enum)+sizeof(struct Expr *));
#endif
  return result;
}

struct Expr *CreateSatisfiedExpr(struct Name *n, double tol,
                                 CONST dim_type *dims)
{
  register struct Expr *result;
  EXPR_NEW(result,e_satisfied);
  result->v.se.sen =  n;
  result->v.se.ser.rvalue = tol;
  result->v.se.ser.dimensions = dims;
  EXPR_CHECK_MEMORY(result);
  return result;
}

struct Expr *CreateFuncExpr(CONST struct Func *f)
{
  register struct Expr *result;
  EXPR_NEW(result,e_func);
  result->v.fptr = f;
  EXPR_CHECK_MEMORY(result);
  return result;
}

struct Expr *CreateIntExpr(long int i)
{
  register struct Expr *result;
  EXPR_NEW(result,e_int);
  result->v.ivalue = i;
  EXPR_CHECK_MEMORY(result);
  return result;
}

struct Expr *CreateRealExpr(double r, CONST dim_type *dims)
{
  register struct Expr *result;
  EXPR_NEW(result,e_real);
  result->v.r.rvalue = r;
  result->v.r.dimensions = dims;
  EXPR_CHECK_MEMORY(result);
  return result;
}

struct Expr *CreateTrueExpr(void)
{
  register struct Expr *result;
  EXPR_NEW(result,e_boolean);
  result->v.bvalue = 1;
  EXPR_CHECK_MEMORY(result);
  return result;
}

struct Expr *CreateFalseExpr(void)
{
  register struct Expr *result;
  EXPR_NEW(result,e_boolean);
  result->v.bvalue = 0;
  EXPR_CHECK_MEMORY(result);
  return result;
}

struct Expr *CreateAnyExpr(void)
{
  register struct Expr *result;
  EXPR_NEW(result,e_boolean);
  result->v.bvalue = 2;
  EXPR_CHECK_MEMORY(result);
  return result;
}

struct Expr *CreateSetExpr(struct Set *set)
{
  register struct Expr *result;
  EXPR_NEW(result,e_set);
  result->v.s = set;
  EXPR_CHECK_MEMORY(result);
  return result;
}


struct Expr *CreateSymbolExpr(symchar *sym)
{
  register struct Expr *result;
  assert(AscFindSymbol(sym)!=NULL);
  EXPR_NEW(result,e_symbol);
  result->v.sym_ptr = sym;
  EXPR_CHECK_MEMORY(result);
  return result;
}

struct Expr *CreateQStringExpr(CONST char *qstr)
{
  register struct Expr *result;
  EXPR_NEW(result,e_qstring);
  result->v.sym_ptr = (symchar *)qstr; /* qstr really not symbol */
  EXPR_CHECK_MEMORY(result);
  return result;
}

struct Expr *CreateBuiltin(enum Expr_enum t, struct Set *set)
{
  register struct Expr *result;
  EXPR_NEW(result,t);
  result->v.s = set;
  EXPR_CHECK_MEMORY(result);
  return result;
}

/*------------------------------------------------------------------------------
  MANIPULATION ROUTINES
*/

void LinkExprs(struct Expr *cur, struct Expr *next)
{
  assert(cur!=NULL);
  AssertMemory(cur);
  cur->next = next;
}

struct Expr *NextExprF(CONST struct Expr *e)
{
  assert(e!=NULL);
  AssertMemory(e);
  return e->next;
}

enum Expr_enum ExprTypeF(CONST struct Expr *e)
{
  assert(e!=NULL);
  AssertMemory(e);
  return e->t;
}

CONST struct Name *ExprNameF(CONST struct Expr *e)
{
  assert(e!=NULL);
  AssertMemory(e);
  return e->v.nptr;
}

CONST struct Func *ExprFuncF(CONST struct Expr *e)
{
  assert(e!=NULL);
  AssertMemory(e);
  return e->v.fptr;
}

long ExprIValueF(CONST struct Expr *e)
{
  assert(e!=NULL);
  AssertMemory(e);
  return e->v.ivalue;
}

double ExprRValueF(CONST struct Expr *e)
{
  assert(e!=NULL);
  AssertMemory(e);
  return e->v.r.rvalue;
}

CONST dim_type *ExprRDimensionsF(CONST struct Expr *e)
{
  assert(e!=NULL);
  AssertMemory(e);
  return e->v.r.dimensions;
}

CONST struct Name *SatisfiedExprNameF(CONST struct Expr *e)
{
  assert(e!=NULL);
  AssertMemory(e);
  return e->v.se.sen ;
}

double SatisfiedExprRValueF(CONST struct Expr *e)
{
  assert(e!=NULL);
  AssertMemory(e);
  return e->v.se.ser.rvalue;
}

CONST dim_type *SatisfiedExprRDimensionsF(CONST struct Expr *e)
{
  assert(e!=NULL);
  AssertMemory(e);
  return e->v.se.ser.dimensions;
}

/* This function can be made HALF as long by being a little
 * smarter about how we return the head of the list.
 */
struct Expr *CopyExprList(CONST struct Expr *e)
{
  register struct Expr *result, *p;
  register CONST struct Expr *ep;
  if (e==NULL) return NULL;
  AssertMemory(e);
  ep = e;
  switch(ep->t){
  case e_func:
    result = EPMALLOC;
    result->v.fptr = ep->v.fptr;
    break;
  case e_var:
    result = EPMALLOC;
    result->v.nptr = CopyName(ep->v.nptr);
    break;
  case e_int:
    result = EPMALLOC;
    result->v.ivalue = ep->v.ivalue;
    break;
  case e_zero:
  case e_real:
    result = EPMALLOC;
    result->v.r.rvalue = ep->v.r.rvalue;
    result->v.r.dimensions = ep->v.r.dimensions;
    break;
  case e_boolean:
    result = EPMALLOC;
    result->v.bvalue = ep->v.bvalue;
    break;
  case e_set:
    result = EPMALLOC;
    result->v.s = CopySetList(ep->v.s);
    break;
  case e_symbol:
    result = EPMALLOC;
    result->v.sym_ptr = ep->v.sym_ptr;
    break;
  case e_card:
  case e_choice:
  case e_sum:
  case e_prod:
  case e_union:
  case e_inter:
    result = EPMALLOC;
    result->v.s = CopySetList(ep->v.s);
    break;
  default:
    result = EPMALLOC;
    break;
  }
  result->t = ep->t;
  AssertMemory(result);
  p = result;
  while (ep->next != NULL) {
    ep = ep->next;
    AssertMemory(ep);
    switch(ep->t) {
    case e_func:
      p->next = EPMALLOC;
      p = p->next;
      p->v.fptr = ep->v.fptr;
      break;
    case e_var:
      p->next = EPMALLOC;
      p = p->next;
      p->v.nptr = CopyName(ep->v.nptr);
      break;
    case e_int:
      p->next = EPMALLOC;
      p = p->next;
      p->v.ivalue = ep->v.ivalue;
      break;
    case e_real:
    case e_zero:
      p->next = EPMALLOC;
      p = p->next;
      p->v.r.rvalue = ep->v.r.rvalue;
      p->v.r.dimensions = ep->v.r.dimensions;
      break;
    case e_boolean:
      p->next = EPMALLOC;
      p = p->next;
      p->v.bvalue = ep->v.bvalue;
      break;
    case e_set:
      p->next = EPMALLOC;
      p = p->next;
      p->v.s = CopySetList(ep->v.s);
      break;
    case e_symbol:
      p->next = EPMALLOC;
      p = p->next;
      p->v.sym_ptr = ep->v.sym_ptr;
      break;
    case e_card:
    case e_choice:
    case e_sum:
    case e_prod:
    case e_union:
    case e_inter:
      p->next = EPMALLOC;
      p = p->next;
      p->v.s = CopySetList(ep->v.s);
      break;
    default:
      p->next = EPMALLOC;
      p = p->next;
      break;
    }
    p->t = ep->t;
    AssertMemory(p);
  }
  p->next = NULL;
  AssertMemory(result);
  return result;
}

void DestroyExprList(struct Expr *e)
{
  register struct Expr *next,*ep;
  ep = e;
  while(ep!=NULL) {
    AssertMemory(ep);
    next = ep->next;
    switch(ep->t) {
        case e_var: 
            DestroyName(ep->v.nptr);
            break;
        case e_set:
        case e_card:
        case e_choice:
        case e_sum:
        case e_prod:
        case e_union:
        case e_inter:
            DestroySetList(ep->v.s);
            break;
        default:
            break;
    }
    EPFREE((char *)ep);
    ep = next;
  }
}

struct Expr *JoinExprLists(struct Expr *e1, struct Expr *e2)
{
  register struct Expr *e;
  if (e1 == NULL) return e2;
  AssertMemory(e1);
  e = e1;
  /* find end of expr list */
  while(e->next) e = e->next;
  /* link to e2 */
  e->next = e2;
  AssertMemory(e1);
  return e1;
}

unsigned long ExprListLength(CONST struct Expr *e)
{
  register CONST struct Expr *ptr;
  unsigned long len = 0L;

  AssertMemory(e);
  ptr = e;
  while (ptr) {
    ptr = ptr->next;
    len++;
  }
  return len;
}


int ExprBValueF(CONST struct Expr *e)
{
  assert(e&&(e->t==e_boolean));
  AssertMemory(e);
  return e->v.bvalue;
}

struct Set *ExprSValueF(CONST struct Expr *e)
{
  assert(e&&(e->t==e_set));
  AssertMemory(e);
  return e->v.s;
}

symchar *ExprSymValueF(CONST struct Expr *e)
{
  assert(e&&(e->t==e_symbol));
  AssertMemory(e);
  return e->v.sym_ptr;
}

CONST char *ExprQStrValueF(CONST struct Expr *e)
{
  assert(e&&(e->t==e_qstring));
  AssertMemory(e);
  return (CONST char *)(e->v.sym_ptr); /* remember not a symbol */
}

CONST struct Set *ExprBuiltinSetF(CONST struct Expr *e)
{
  assert(e!=NULL);
  AssertMemory(e);
  return e->v.s;
}

int ExprsEqual(CONST struct Expr *e1, CONST struct Expr *e2)
{
  if (e1==e2) return 1;
  while ((e1!=NULL)&&(e2!=NULL)){
    AssertMemory(e1);
    AssertMemory(e2);
    if (ExprType(e1)!=ExprType(e2)) return 0;
    switch(ExprType(e1)){
    case e_var:
      if (!NamesEqual(ExprName(e1),ExprName(e2))) return 0;
      break;
    case e_func:
      if (ExprFunc(e1)!=ExprFunc(e2)) return 0;
      break;
    case e_int:
      if (ExprIValue(e1)!=ExprIValue(e2)) return 0;
      break;
    case e_real:
      if ((ExprRValue(e1)!=ExprRValue(e2))||
      (!SameDimen(ExprRDimensions(e1),ExprRDimensions(e2)))) return 0;
      break;
    case e_boolean:
      if (ExprBValue(e1)!=ExprBValue(e2)) return 0;
      break;
    case e_set:
      if (!SetStructuresEqual(ExprSValue(e1),ExprSValue(e2))) return 0;
      break;
    case e_symbol:
      if (CmpSymchar(ExprSymValue(e1),ExprSymValue(e2))!=0) return 0;
      break;
    default: break;
    }
    e1 = NextExpr(e1);
    e2 = NextExpr(e2);
  }
  return ((e1==NULL)&&(e2==NULL));
}

int CompareExprs(CONST struct Expr *e1, CONST struct Expr *e2)
{
  int ctmp;
  long int ltmp;
  double rtmp;
  if (e1==e2) return 0;
  if (e1==NULL) return 1;
  if (e2==NULL) return -1;
  while ((e1!=NULL)&&(e2!=NULL)){
    AssertMemory(e1);
    AssertMemory(e2);
    ctmp = ExprType(e1) - ExprType(e2);
    if (ctmp != 0) {
      if (ctmp >0) {
        return 1;
      } else {
        return -1;
      }
    }
    switch(ExprType(e1)){
    case e_var:
      ctmp = CompareNames(ExprName(e1),ExprName(e2));
      if (ctmp != 0) return ctmp;
      break;
    case e_func:
      ctmp = strcmp(FuncName(ExprFunc(e1)),FuncName(ExprFunc(e2)));
      if (ctmp != 0) return ctmp;
      break;
    case e_int:
      ltmp = ExprIValue(e1) - ExprIValue(e2);
      if (ltmp != 0L) {
        if (ltmp > 0L) {
          return 1;
        } else {
          return -1;
        }
      }
      break;
    case e_real:
      rtmp = ExprRValue(e1) - ExprRValue(e2);
      if (rtmp != 0.0) {
        if (rtmp > 0.0) {
          return 1;
        } else {
          return -1;
        }
      }
      ctmp = CmpDimen(ExprRDimensions(e1),ExprRDimensions(e2));
      if (ctmp != 0) return ctmp;
      break;
    case e_boolean:
      if (ExprBValue(e1)!=ExprBValue(e2)) {
        if (ExprBValue(e1) >0) {
          return 1;
        } else {
          return -1;
        }
      }
      break;
    case e_set:
      ctmp = CompareSetStructures(ExprSValue(e1),ExprSValue(e2));
      if (ctmp != 0) return ctmp;
      break;
    case e_symbol:
      ctmp = CmpSymchar(ExprSymValue(e1),ExprSymValue(e2));
      if (ctmp != 0) return ctmp;
      break;

    case e_nop:     /* fallthru */
    case e_undefined:       /* fallthru */
    case e_glassbox:        /* fallthru */
    case e_blackbox:        /* fallthru */
    case e_opcode:      /* fallthru */
    case e_token:       /* fallthru */
    case e_zero:        /* fallthru */
    case e_uminus:      /* fallthru */
    case e_plus:        /* fallthru */
    case e_minus:       /* fallthru */
    case e_times:       /* fallthru */
    case e_divide:      /* fallthru */
    case e_power:       /* fallthru */
    case e_ipower:      /* fallthru */
    case e_bol_token:       /* fallthru */
    case e_notequal:        /* fallthru */
    case e_equal:       /* fallthru */
    case e_less:        /* fallthru */
    case e_greater:     /* fallthru */
    case e_lesseq:      /* fallthru */
    case e_greatereq:       /* fallthru */
    case e_maximize:        /* fallthru */
    case e_minimize:        /* fallthru */
    case e_boolean_eq:      /* fallthru */
    case e_boolean_neq:     /* fallthru */
    case e_or:      /* fallthru */
    case e_and:     /* fallthru */
    case e_not:
      break;
    case e_satisfied:
      ctmp = CompareNames(SatisfiedExprName(e1),SatisfiedExprName(e2));
      if (ctmp != 0) return ctmp;
      rtmp = SatisfiedExprRValue(e1) - SatisfiedExprRValue(e2);
      if (rtmp != 0.0) {
        if (rtmp > 0.0) {
          return 1;
        } else {
          return -1;
        }
      }
      ctmp = CmpDimen(SatisfiedExprRDimensions(e1),
                      SatisfiedExprRDimensions(e2));
      if (ctmp != 0) return ctmp;
      break;
    case e_subexpr:
    case e_const:
    case e_par:
    case e_in:
    case e_st:
      break;
    case e_qstring:
      ctmp = strcmp(ExprQStrValue(e1),ExprQStrValue(e2));
      if (ctmp != 0) return ctmp;
      break;
    case e_sum: /* fall thru */
    case e_prod: /* fall thru */
    case e_card: /* fall thru */
    case e_choice: /* fall thru */
    case e_union: /* fall thru */
    case e_inter:
      ctmp = CompareSetStructures(ExprBuiltinSet(e1),ExprBuiltinSet(e2));
      if (ctmp != 0) return ctmp;
      break;
    }
    e1 = NextExpr(e1);
    e2 = NextExpr(e2);
  }
  /* shorter is < longer */
  if (e2!=NULL) return 1;
  if (e1!=NULL) return -1;
  return 0;
}
1	johnpye	669	/* ASCEND modelling environment
2			Copyright (C) 2006 Carnegie Mellon University
3			Copyright (C) 1990, 1993, 1994 Thomas Guthrie Epperly
4	aw0a	1
5	johnpye	669	This program is free software; you can redistribute it and/or modify
6			it under the terms of the GNU General Public License as published by
7			the Free Software Foundation; either version 2, or (at your option)
8			any later version.
9
10			This program is distributed in the hope that it will be useful,
11			but WITHOUT ANY WARRANTY; without even the implied warranty of
12			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13			GNU General Public License for more details.
14
15			You should have received a copy of the GNU General Public License
16			along with this program; if not, write to the Free Software
17			Foundation, Inc., 59 Temple Place - Suite 330,
18			Boston, MA 02111-1307, USA.
19			//*
20			@file
21			Expression Module
22
23			Requires:
24			#include "utilities/ascConfig.h"
25			#include "fractions.h"
26			#include "compiler.h"
27			#include "dimen.h"
28			#include "expr_types.h"
29			//
30			by Tom Epperly
31			Last in CVS: $Revision: 1.13 $ $Date: 1998/02/05 16:35:58 $ $Author: ballan $
32			*/
33
34			#include <stdio.h>
35			#include <assert.h>
36
37	johnpye	399	#include <utilities/ascConfig.h>
38			#include <utilities/ascPanic.h>
39			#include "compiler.h"
40			#include <utilities/ascMalloc.h>
41			#include <general/list.h>
42			#include <general/pool.h>
43			#include "symtab.h"
44			#include "fractions.h"
45			#include "dimen.h"
46			#include "functype.h"
47	johnpye	669	#include "expr_types.h"
48	johnpye	399	#include "func.h"
49			#include "name.h"
50			#include "sets.h"
51			#include "instance_enum.h"
52			#include "cmpfunc.h"
53			#include "exprs.h"
54	aw0a	1
55
56			#ifndef lint
57			static CONST char ExpressionID[] = "$Id: exprs.c,v 1.13 1998/02/05 16:35:58 ballan Exp $";
58			#endif
59
60	johnpye	669	/*------------------------------------------------------------------------------
61			MEMORY USAGE
62
63			Using 'pool' or else regular malloc...
64			*/
65
66	ben.allan	14	#ifdef ASC_NO_POOL
67			#define EXPRSUSESPOOL FALSE
68			#else
69	aw0a	1	#define EXPRSUSESPOOL TRUE
70	ben.allan	14	#endif
71	aw0a	1
72	johnpye	669	#if EXPRSUSESPOOL /* using 'g_exprs_pool' for memory management */
73			/** global for our memory manager */
74	aw0a	1	static pool_store_t g_exprs_pool = NULL;
75	johnpye	669	/* aim for 4096 chunks including malloc overhead */
76			# define EMP_LEN 10
77			# if (SIZEOF_VOID_P == 8)
78			# define EMP_WID 63
79			# else
80			# define EMP_WID 127
81			# endif
82			/* retune rpwid if the size of struct name changes */
83			# define EMP_ELT_SIZE (sizeof(struct Expr))
84			# define EMP_MORE_ELTS 10
85			/**< Number of slots filled if more elements needed.
86			So if the pool grows, it grows by EMP_MORE_ELTSEMP_WID elements at a time. /
87			# define EMP_MORE_BARS 500
88			/**< This is the number of pool bar slots to add during expansion.
89	aw0a	1	not all the slots will be filled immediately. */
90
91	johnpye	669	/**
92			This function is called at compiler startup time and destroy at shutdown.
93			*/
94	aw0a	1	void exprs_init_pool(void) {
95			if (g_exprs_pool != NULL ) {
96			Asc_Panic(2, NULL, "ERROR: exprs_init_pool called twice.\n");
97			}
98			g_exprs_pool = pool_create_store(EMP_LEN, EMP_WID, EMP_ELT_SIZE,
99			EMP_MORE_ELTS, EMP_MORE_BARS);
100			if (g_exprs_pool == NULL) {
101			Asc_Panic(2, NULL, "ERROR: exprs_init_pool unable to allocate pool.\n");
102			}
103			}
104
105			void exprs_destroy_pool(void) {
106			if (g_exprs_pool==NULL) return;
107			pool_clear_store(g_exprs_pool);
108			pool_destroy_store(g_exprs_pool);
109			g_exprs_pool = NULL;
110			}
111
112			void exprs_report_pool()
113			{
114			if (g_exprs_pool==NULL) {
115			FPRINTF(ASCERR,"ExprsPool is empty\n");
116			}
117			FPRINTF(ASCERR,"ExprsPool ");
118			pool_print_store(ASCERR,g_exprs_pool,0);
119			}
120
121	johnpye	669	# define EPMALLOC \
122			((struct Expr *)(pool_get_element(g_exprs_pool)))
123			/*< get a token. Token is the size of the struct struct Expr /
124	aw0a	1
125	johnpye	669	# define EPFREE(p) \
126			(pool_free_element(g_exprs_pool,((void *)p)))
127			/*< return a struct Expr /
128	aw0a	1
129	johnpye	669	# define EXPR_CHECK_MEMORY(VAR) \
130			AssertMemory(VAR)
131
132			#else /* not using 'g_exprs_pool'... */
133
134	ben.allan	14	void exprs_init_pool(void) {}
135			void exprs_destroy_pool(void) {}
136	johnpye	669	void exprs_report_pool(void){
137			FPRINTF(ASCERR,"ExprsPool not used at all\n");
138	ben.allan	14	}
139	aw0a	1
140	johnpye	669	# define EPFREE(p) \
141			ASC_FREE(p)
142	ben.allan	14
143	johnpye	669	# define EPMALLOC \
144			ASC_NEW(struct Expr)
145
146			# define EXPR_CHECK_MEMORY(VAR) \
147			AssertAllocatedMemory(result,sizeof(struct Expr))
148
149	aw0a	1	#endif
150
151	johnpye	669
152			# define EXPR_NEW(VAR,TYPE) \
153			VAR = EPMALLOC; \
154			VAR->t = TYPE; \
155			VAR->next = NULL
156
157			/*------------------------------------------------------------------------------
158			CREATION ROUTINES
159			*/
160
161	aw0a	1	struct Expr CreateVarExpr(struct Name n)
162			{
163			register struct Expr *result;
164			assert(n!=NULL);
165			AssertMemory(n);
166	johnpye	669	EXPR_NEW(result,e_var);
167	aw0a	1	result->v.nptr = n;
168	johnpye	669	EXPR_CHECK_MEMORY(result);
169
170	aw0a	1	return result;
171			}
172
173	johnpye	669	/*
174			As with var, store pointer to the name, but give it a special type 'e_diff'.
175			*/
176			struct Expr CreateDiffExpr(struct Name n){
177			register struct Expr *result;
178			ERROR_REPORTER_HERE(ASC_PROG_ERR,"not yet implemented");
179			EXPR_NEW(result,e_diff);
180			result->v.nptr = n;
181			EXPR_CHECK_MEMORY(result);
182			return result;
183			}
184
185	aw0a	1	void InitVarExpr(struct Expr result,CONST struct Name n)
186			{
187			assert(n!=NULL);
188			AssertMemory(n);
189			result->t = e_var;
190			result->v.nptr = (struct Name *)n;
191			result->next = NULL;
192			}
193
194			struct Expr *CreateOpExpr(enum Expr_enum t)
195			{
196			register struct Expr *result;
197			assert((t!=e_var)&&(t!=e_func)&&(t!=e_int)&&(t!=e_real)&&(t!=e_zero));
198	johnpye	669	EXPR_NEW(result,t);
199	jds	114	#if EXPRSUSESPOOL
200			AssertMemory(result);
201			#else
202	aw0a	1	AssertAllocatedMemory(result,sizeof(enum Expr_enum)+sizeof(struct Expr *));
203	jds	114	#endif
204	aw0a	1	return result;
205			}
206
207			struct Expr CreateSatisfiedExpr(struct Name n, double tol,
208			CONST dim_type *dims)
209			{
210			register struct Expr *result;
211	johnpye	669	EXPR_NEW(result,e_satisfied);
212	aw0a	1	result->v.se.sen = n;
213			result->v.se.ser.rvalue = tol;
214			result->v.se.ser.dimensions = dims;
215	johnpye	669	EXPR_CHECK_MEMORY(result);
216	aw0a	1	return result;
217			}
218
219			struct Expr CreateFuncExpr(CONST struct Func f)
220			{
221			register struct Expr *result;
222	johnpye	669	EXPR_NEW(result,e_func);
223	aw0a	1	result->v.fptr = f;
224	johnpye	669	EXPR_CHECK_MEMORY(result);
225	aw0a	1	return result;
226			}
227
228			struct Expr *CreateIntExpr(long int i)
229			{
230			register struct Expr *result;
231	johnpye	669	EXPR_NEW(result,e_int);
232	aw0a	1	result->v.ivalue = i;
233	johnpye	669	EXPR_CHECK_MEMORY(result);
234	aw0a	1	return result;
235			}
236
237			struct Expr CreateRealExpr(double r, CONST dim_type dims)
238			{
239			register struct Expr *result;
240	johnpye	669	EXPR_NEW(result,e_real);
241	aw0a	1	result->v.r.rvalue = r;
242			result->v.r.dimensions = dims;
243	johnpye	669	EXPR_CHECK_MEMORY(result);
244	aw0a	1	return result;
245			}
246
247			struct Expr *CreateTrueExpr(void)
248			{
249			register struct Expr *result;
250	johnpye	669	EXPR_NEW(result,e_boolean);
251	aw0a	1	result->v.bvalue = 1;
252	johnpye	669	EXPR_CHECK_MEMORY(result);
253	aw0a	1	return result;
254			}
255
256			struct Expr *CreateFalseExpr(void)
257			{
258			register struct Expr *result;
259	johnpye	669	EXPR_NEW(result,e_boolean);
260	aw0a	1	result->v.bvalue = 0;
261	johnpye	669	EXPR_CHECK_MEMORY(result);
262	aw0a	1	return result;
263			}
264
265			struct Expr *CreateAnyExpr(void)
266			{
267			register struct Expr *result;
268	johnpye	669	EXPR_NEW(result,e_boolean);
269	aw0a	1	result->v.bvalue = 2;
270	johnpye	669	EXPR_CHECK_MEMORY(result);
271	aw0a	1	return result;
272			}
273
274			struct Expr CreateSetExpr(struct Set set)
275			{
276			register struct Expr *result;
277	johnpye	669	EXPR_NEW(result,e_set);
278	aw0a	1	result->v.s = set;
279	johnpye	669	EXPR_CHECK_MEMORY(result);
280	aw0a	1	return result;
281			}
282
283
284			struct Expr CreateSymbolExpr(symchar sym)
285			{
286			register struct Expr *result;
287			assert(AscFindSymbol(sym)!=NULL);
288	johnpye	669	EXPR_NEW(result,e_symbol);
289	aw0a	1	result->v.sym_ptr = sym;
290	johnpye	669	EXPR_CHECK_MEMORY(result);
291	aw0a	1	return result;
292			}
293
294			struct Expr CreateQStringExpr(CONST char qstr)
295			{
296			register struct Expr *result;
297	johnpye	669	EXPR_NEW(result,e_qstring);
298	aw0a	1	result->v.sym_ptr = (symchar )qstr; / qstr really not symbol */
299	johnpye	669	EXPR_CHECK_MEMORY(result);
300	aw0a	1	return result;
301			}
302
303			struct Expr CreateBuiltin(enum Expr_enum t, struct Set set)
304			{
305			register struct Expr *result;
306	johnpye	669	EXPR_NEW(result,t);
307	aw0a	1	result->v.s = set;
308	johnpye	669	EXPR_CHECK_MEMORY(result);
309	aw0a	1	return result;
310			}
311
312	johnpye	669	/*------------------------------------------------------------------------------
313			MANIPULATION ROUTINES
314			*/
315	aw0a	1
316			void LinkExprs(struct Expr cur, struct Expr next)
317			{
318			assert(cur!=NULL);
319			AssertMemory(cur);
320			cur->next = next;
321			}
322
323			struct Expr NextExprF(CONST struct Expr e)
324			{
325			assert(e!=NULL);
326			AssertMemory(e);
327			return e->next;
328			}
329
330			enum Expr_enum ExprTypeF(CONST struct Expr *e)
331			{
332			assert(e!=NULL);
333			AssertMemory(e);
334			return e->t;
335			}
336
337			CONST struct Name ExprNameF(CONST struct Expr e)
338			{
339			assert(e!=NULL);
340			AssertMemory(e);
341			return e->v.nptr;
342			}
343
344			CONST struct Func ExprFuncF(CONST struct Expr e)
345			{
346			assert(e!=NULL);
347			AssertMemory(e);
348			return e->v.fptr;
349			}
350
351			long ExprIValueF(CONST struct Expr *e)
352			{
353			assert(e!=NULL);
354			AssertMemory(e);
355			return e->v.ivalue;
356			}
357
358			double ExprRValueF(CONST struct Expr *e)
359			{
360			assert(e!=NULL);
361			AssertMemory(e);
362			return e->v.r.rvalue;
363			}
364
365			CONST dim_type ExprRDimensionsF(CONST struct Expr e)
366			{
367			assert(e!=NULL);
368			AssertMemory(e);
369			return e->v.r.dimensions;
370			}
371
372			CONST struct Name SatisfiedExprNameF(CONST struct Expr e)
373			{
374			assert(e!=NULL);
375			AssertMemory(e);
376			return e->v.se.sen ;
377			}
378
379			double SatisfiedExprRValueF(CONST struct Expr *e)
380			{
381			assert(e!=NULL);
382			AssertMemory(e);
383			return e->v.se.ser.rvalue;
384			}
385
386			CONST dim_type SatisfiedExprRDimensionsF(CONST struct Expr e)
387			{
388			assert(e!=NULL);
389			AssertMemory(e);
390			return e->v.se.ser.dimensions;
391			}
392
393			/* This function can be made HALF as long by being a little
394			* smarter about how we return the head of the list.
395			*/
396			struct Expr CopyExprList(CONST struct Expr e)
397			{
398			register struct Expr result, p;
399			register CONST struct Expr *ep;
400			if (e==NULL) return NULL;
401			AssertMemory(e);
402			ep = e;
403			switch(ep->t){
404			case e_func:
405			result = EPMALLOC;
406			result->v.fptr = ep->v.fptr;
407			break;
408			case e_var:
409			result = EPMALLOC;
410			result->v.nptr = CopyName(ep->v.nptr);
411			break;
412			case e_int:
413			result = EPMALLOC;
414			result->v.ivalue = ep->v.ivalue;
415			break;
416			case e_zero:
417			case e_real:
418			result = EPMALLOC;
419			result->v.r.rvalue = ep->v.r.rvalue;
420			result->v.r.dimensions = ep->v.r.dimensions;
421			break;
422			case e_boolean:
423			result = EPMALLOC;
424			result->v.bvalue = ep->v.bvalue;
425			break;
426			case e_set:
427			result = EPMALLOC;
428			result->v.s = CopySetList(ep->v.s);
429			break;
430			case e_symbol:
431			result = EPMALLOC;
432			result->v.sym_ptr = ep->v.sym_ptr;
433			break;
434			case e_card:
435			case e_choice:
436			case e_sum:
437			case e_prod:
438			case e_union:
439			case e_inter:
440			result = EPMALLOC;
441			result->v.s = CopySetList(ep->v.s);
442			break;
443			default:
444			result = EPMALLOC;
445			break;
446			}
447			result->t = ep->t;
448			AssertMemory(result);
449			p = result;
450			while (ep->next != NULL) {
451			ep = ep->next;
452			AssertMemory(ep);
453			switch(ep->t) {
454			case e_func:
455			p->next = EPMALLOC;
456			p = p->next;
457			p->v.fptr = ep->v.fptr;
458			break;
459			case e_var:
460			p->next = EPMALLOC;
461			p = p->next;
462			p->v.nptr = CopyName(ep->v.nptr);
463			break;
464			case e_int:
465			p->next = EPMALLOC;
466			p = p->next;
467			p->v.ivalue = ep->v.ivalue;
468			break;
469			case e_real:
470			case e_zero:
471			p->next = EPMALLOC;
472			p = p->next;
473			p->v.r.rvalue = ep->v.r.rvalue;
474			p->v.r.dimensions = ep->v.r.dimensions;
475			break;
476			case e_boolean:
477			p->next = EPMALLOC;
478			p = p->next;
479			p->v.bvalue = ep->v.bvalue;
480			break;
481			case e_set:
482			p->next = EPMALLOC;
483			p = p->next;
484			p->v.s = CopySetList(ep->v.s);
485			break;
486			case e_symbol:
487			p->next = EPMALLOC;
488			p = p->next;
489			p->v.sym_ptr = ep->v.sym_ptr;
490			break;
491			case e_card:
492			case e_choice:
493			case e_sum:
494			case e_prod:
495			case e_union:
496			case e_inter:
497			p->next = EPMALLOC;
498			p = p->next;
499			p->v.s = CopySetList(ep->v.s);
500			break;
501			default:
502			p->next = EPMALLOC;
503			p = p->next;
504			break;
505			}
506			p->t = ep->t;
507			AssertMemory(p);
508			}
509			p->next = NULL;
510			AssertMemory(result);
511			return result;
512			}
513
514			void DestroyExprList(struct Expr *e)
515			{
516			register struct Expr next,ep;
517			ep = e;
518			while(ep!=NULL) {
519			AssertMemory(ep);
520			next = ep->next;
521			switch(ep->t) {
522	johnpye	669	case e_var:
523			DestroyName(ep->v.nptr);
524			break;
525			case e_set:
526			case e_card:
527			case e_choice:
528			case e_sum:
529			case e_prod:
530			case e_union:
531			case e_inter:
532			DestroySetList(ep->v.s);
533			break;
534			default:
535			break;
536	aw0a	1	}
537			EPFREE((char *)ep);
538			ep = next;
539			}
540			}
541
542			struct Expr JoinExprLists(struct Expr e1, struct Expr *e2)
543			{
544			register struct Expr *e;
545			if (e1 == NULL) return e2;
546			AssertMemory(e1);
547			e = e1;
548			/* find end of expr list */
549			while(e->next) e = e->next;
550			/* link to e2 */
551			e->next = e2;
552			AssertMemory(e1);
553			return e1;
554			}
555
556			unsigned long ExprListLength(CONST struct Expr *e)
557			{
558			register CONST struct Expr *ptr;
559			unsigned long len = 0L;
560
561			AssertMemory(e);
562			ptr = e;
563			while (ptr) {
564			ptr = ptr->next;
565			len++;
566			}
567			return len;
568			}
569
570
571			int ExprBValueF(CONST struct Expr *e)
572			{
573			assert(e&&(e->t==e_boolean));
574			AssertMemory(e);
575			return e->v.bvalue;
576			}
577
578			struct Set ExprSValueF(CONST struct Expr e)
579			{
580			assert(e&&(e->t==e_set));
581			AssertMemory(e);
582			return e->v.s;
583			}
584
585			symchar ExprSymValueF(CONST struct Expr e)
586			{
587			assert(e&&(e->t==e_symbol));
588			AssertMemory(e);
589			return e->v.sym_ptr;
590			}
591
592			CONST char ExprQStrValueF(CONST struct Expr e)
593			{
594			assert(e&&(e->t==e_qstring));
595			AssertMemory(e);
596			return (CONST char )(e->v.sym_ptr); / remember not a symbol */
597			}
598
599			CONST struct Set ExprBuiltinSetF(CONST struct Expr e)
600			{
601			assert(e!=NULL);
602			AssertMemory(e);
603			return e->v.s;
604			}
605
606			int ExprsEqual(CONST struct Expr e1, CONST struct Expr e2)
607			{
608			if (e1==e2) return 1;
609			while ((e1!=NULL)&&(e2!=NULL)){
610			AssertMemory(e1);
611			AssertMemory(e2);
612			if (ExprType(e1)!=ExprType(e2)) return 0;
613			switch(ExprType(e1)){
614			case e_var:
615			if (!NamesEqual(ExprName(e1),ExprName(e2))) return 0;
616			break;
617			case e_func:
618			if (ExprFunc(e1)!=ExprFunc(e2)) return 0;
619			break;
620			case e_int:
621			if (ExprIValue(e1)!=ExprIValue(e2)) return 0;
622			break;
623			case e_real:
624			if ((ExprRValue(e1)!=ExprRValue(e2))\|\|
625			(!SameDimen(ExprRDimensions(e1),ExprRDimensions(e2)))) return 0;
626			break;
627			case e_boolean:
628			if (ExprBValue(e1)!=ExprBValue(e2)) return 0;
629			break;
630			case e_set:
631			if (!SetStructuresEqual(ExprSValue(e1),ExprSValue(e2))) return 0;
632			break;
633			case e_symbol:
634			if (CmpSymchar(ExprSymValue(e1),ExprSymValue(e2))!=0) return 0;
635			break;
636			default: break;
637			}
638			e1 = NextExpr(e1);
639			e2 = NextExpr(e2);
640			}
641			return ((e1==NULL)&&(e2==NULL));
642			}
643
644			int CompareExprs(CONST struct Expr e1, CONST struct Expr e2)
645			{
646			int ctmp;
647			long int ltmp;
648			double rtmp;
649			if (e1==e2) return 0;
650			if (e1==NULL) return 1;
651			if (e2==NULL) return -1;
652			while ((e1!=NULL)&&(e2!=NULL)){
653			AssertMemory(e1);
654			AssertMemory(e2);
655			ctmp = ExprType(e1) - ExprType(e2);
656			if (ctmp != 0) {
657			if (ctmp >0) {
658			return 1;
659			} else {
660			return -1;
661			}
662			}
663			switch(ExprType(e1)){
664			case e_var:
665			ctmp = CompareNames(ExprName(e1),ExprName(e2));
666			if (ctmp != 0) return ctmp;
667			break;
668			case e_func:
669			ctmp = strcmp(FuncName(ExprFunc(e1)),FuncName(ExprFunc(e2)));
670			if (ctmp != 0) return ctmp;
671			break;
672			case e_int:
673			ltmp = ExprIValue(e1) - ExprIValue(e2);
674			if (ltmp != 0L) {
675			if (ltmp > 0L) {
676			return 1;
677			} else {
678			return -1;
679			}
680			}
681			break;
682			case e_real:
683			rtmp = ExprRValue(e1) - ExprRValue(e2);
684			if (rtmp != 0.0) {
685			if (rtmp > 0.0) {
686			return 1;
687			} else {
688			return -1;
689			}
690			}
691			ctmp = CmpDimen(ExprRDimensions(e1),ExprRDimensions(e2));
692			if (ctmp != 0) return ctmp;
693			break;
694			case e_boolean:
695			if (ExprBValue(e1)!=ExprBValue(e2)) {
696			if (ExprBValue(e1) >0) {
697			return 1;
698			} else {
699			return -1;
700			}
701			}
702			break;
703			case e_set:
704			ctmp = CompareSetStructures(ExprSValue(e1),ExprSValue(e2));
705			if (ctmp != 0) return ctmp;
706			break;
707			case e_symbol:
708			ctmp = CmpSymchar(ExprSymValue(e1),ExprSymValue(e2));
709			if (ctmp != 0) return ctmp;
710			break;
711
712			case e_nop: /* fallthru */
713			case e_undefined: /* fallthru */
714			case e_glassbox: /* fallthru */
715			case e_blackbox: /* fallthru */
716			case e_opcode: /* fallthru */
717			case e_token: /* fallthru */
718			case e_zero: /* fallthru */
719			case e_uminus: /* fallthru */
720			case e_plus: /* fallthru */
721			case e_minus: /* fallthru */
722			case e_times: /* fallthru */
723			case e_divide: /* fallthru */
724			case e_power: /* fallthru */
725			case e_ipower: /* fallthru */
726			case e_bol_token: /* fallthru */
727			case e_notequal: /* fallthru */
728			case e_equal: /* fallthru */
729			case e_less: /* fallthru */
730			case e_greater: /* fallthru */
731			case e_lesseq: /* fallthru */
732			case e_greatereq: /* fallthru */
733			case e_maximize: /* fallthru */
734			case e_minimize: /* fallthru */
735			case e_boolean_eq: /* fallthru */
736			case e_boolean_neq: /* fallthru */
737			case e_or: /* fallthru */
738			case e_and: /* fallthru */
739			case e_not:
740			break;
741			case e_satisfied:
742			ctmp = CompareNames(SatisfiedExprName(e1),SatisfiedExprName(e2));
743			if (ctmp != 0) return ctmp;
744			rtmp = SatisfiedExprRValue(e1) - SatisfiedExprRValue(e2);
745			if (rtmp != 0.0) {
746			if (rtmp > 0.0) {
747			return 1;
748			} else {
749			return -1;
750			}
751			}
752			ctmp = CmpDimen(SatisfiedExprRDimensions(e1),
753			SatisfiedExprRDimensions(e2));
754			if (ctmp != 0) return ctmp;
755			break;
756			case e_subexpr:
757			case e_const:
758			case e_par:
759			case e_in:
760			case e_st:
761			break;
762			case e_qstring:
763			ctmp = strcmp(ExprQStrValue(e1),ExprQStrValue(e2));
764			if (ctmp != 0) return ctmp;
765			break;
766			case e_sum: /* fall thru */
767			case e_prod: /* fall thru */
768			case e_card: /* fall thru */
769			case e_choice: /* fall thru */
770			case e_union: /* fall thru */
771			case e_inter:
772			ctmp = CompareSetStructures(ExprBuiltinSet(e1),ExprBuiltinSet(e2));
773			if (ctmp != 0) return ctmp;
774			break;
775			}
776			e1 = NextExpr(e1);
777			e2 = NextExpr(e2);
778			}
779			/* shorter is < longer */
780			if (e2!=NULL) return 1;
781			if (e1!=NULL) return -1;
782			return 0;
783			}