/*****
 * exp.cc
 * andy hammerlindl 2002/8/19
 *
 * represents the abstract syntax tree for the expressions in the
 * language.  this is translated into virtual machine code using trans()
 * and with the aid of the environment class.
 *****/

#include "exp.h"
#include "errormsg.h"
#include "runtime.h"
#include "runmath.h"
#include "runpicture.h"
#include "runarray.h"
#include "runpair.h"
#include "runtriple.h"
#include "runpath.h"
#include "coenv.h"
#include "application.h"
#include "dec.h"
#include "stm.h"
#include "inst.h"
#include "opsymbols.h"
#include "asyprocess.h"

//void runCode(absyntax::block *code);

namespace absyntax {

using namespace types;
using namespace trans;
using vm::inst;
using mem::vector;
using mem::stdString;
using vm::getPos;

#if 0
void exp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "exp",indent, getPos());
}
#endif

void exp::transAsType(coenv &e, types::ty *target) {
  trans(e);
//  types::ty *t=trans(e);
//  assert(t->kind==ty_error || equivalent(t,target));
}

void exp::transToType(coenv &e, types::ty *target)
{
  types::ty *ct=cgetType(e);

  if (equivalent(target, ct)) {
    transAsType(e, target);
    return;
  }

  // See if the cast can be handled by the fastLookupCast method, which does
  // less memory allocation.
  if (ct->kind != ty_overloaded &&
      ct->kind != ty_error &&
      target->kind != ty_error) {
    access *a = e.e.fastLookupCast(target, ct);
    if (a) {
      transAsType(e, ct);
      a->encode(trans::CALL, getPos(), e.c);
      return;
    }
  }

  types::ty *source = e.e.castSource(target, ct, symbol::castsym);
  if (source==0) {
    if (target->kind != ty_error) {
      types::ty *sources=cgetType(e);
      em.error(getPos());

      em << "cannot cast ";
      if (sources->kind==ty_overloaded)
        em << "expression";
      else
        em << "'" << *sources << "'";
      em << " to '" << *target << "'";
    }
  }
  else if (source->kind==ty_overloaded) {
    if (target->kind != ty_error) {
      em.error(getPos());
      em << "expression is ambiguous in cast to '" << *target << "'";
    }
  }
  else {
    transAsType(e, source);
    e.implicitCast(getPos(), target, source);
  }
}

void exp::testCachedType(coenv &e) {
  if (ct != 0) {
    types::ty *t = getType(e);
    if (!equivalent(t, ct)) {
      em.compiler(getPos());
      em << "cached type '" << *ct
         << "' doesn't match actual type '" << *t << "'";
      em.sync(true);
    }
  }
}

void exp::transCall(coenv &e, types::ty *target)
{
  transAsType(e, target);
  e.c.encode(inst::popcall);
}

void exp::transConditionalJump(coenv &e, bool cond, label dest) {
  transToType(e, primBoolean());
  e.c.useLabel(cond ? inst::cjmp : inst::njmp, dest);
}

exp *exp::evaluate(coenv &e, types::ty *target) {
  return new tempExp(e, this, target);
}


tempExp::tempExp(coenv &e, varinit *v, types::ty *t)
  : exp(v->getPos()), a(e.c.allocLocal()), t(t)
{
  v->transToType(e, t);
  a->encode(WRITE, getPos(), e.c);
  e.c.encodePop();
}

void tempExp::prettyprint(ostream &out, Int indent) {
  prettyname(out, "tempExp", indent, getPos());
}

types::ty *tempExp::trans(coenv &e) {
  a->encode(READ, getPos(), e.c);
  return t;
}


varEntryExp::varEntryExp(position pos, types::ty *t, access *a)
  : exp(pos), v(new trans::varEntry(t, a, 0, nullPos)) {}
varEntryExp::varEntryExp(position pos, types::ty *t, vm::bltin f)
  : exp(pos), v(new trans::varEntry(t, new bltinAccess(f), 0, nullPos)) {}

void varEntryExp::prettyprint(ostream &out, Int indent) {
  prettyname(out, "varEntryExp", indent, getPos());
}

types::ty *varEntryExp::getType(coenv &) {
  return v->getType();
}

types::ty *varEntryExp::trans(coenv &e) {
  v->encode(READ, getPos(), e.c);
  return getType(e);
}

trans::varEntry *varEntryExp::getCallee(coenv &e, types::signature *sig) {
  return equivalent(sig, v->getType()->getSignature()) ? v : 0;
}

void varEntryExp::transAct(action act, coenv &e, types::ty *target) {
  assert(equivalent(getType(e),target));
  v->encode(act, getPos(), e.c);
}
void varEntryExp::transAsType(coenv &e, types::ty *target) {
  transAct(READ, e, target);
}
void varEntryExp::transWrite(coenv &e, types::ty *target, exp *value) {
  value->transToType(e, target);
  transAct(WRITE, e, target);
}
void varEntryExp::transCall(coenv &e, types::ty *target) {
  transAct(trans::CALL, e, target);
}


void nameExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "nameExp",indent, getPos());

  value->prettyprint(out, indent+1);
}

void fieldExp::pseudoName::prettyprint(ostream &out, Int indent)
{
  // This should never be called.
  prettyindent(out, indent);
  out << "pseudoName" << "\n";

  object->prettyprint(out, indent+1);
}

void fieldExp::prettyprint(ostream &out, Int indent)
{
  prettyindent(out, indent);
  out << "fieldExp '" << field << "'\n";

  object->prettyprint(out, indent+1);
}

types::ty *fieldExp::getObject(coenv& e)
{
  types::ty *t = object->cgetType(e);
  if (t->kind == ty_overloaded) {
    t=((overloaded *)t)->signatureless();
    if(!t) return primError();
  }
  return t;
}


array *arrayExp::getArrayType(coenv &e)
{
  types::ty *a = set->cgetType(e);
  if (a->kind == ty_overloaded) {
    a = ((overloaded *)a)->signatureless();
    if (!a)
      return 0;
  }

  switch (a->kind) {
    case ty_array:
      return (array *)a;
    case ty_error:
      return 0;
    default:
      return 0;
  }
}

array *arrayExp::transArray(coenv &e)
{
  types::ty *a = set->cgetType(e);
  if (a->kind == ty_overloaded) {
    a = ((overloaded *)a)->signatureless();
    if (!a) {
      em.error(set->getPos());
      em << "expression is not an array";
      return 0;
    }
  }

  set->transAsType(e, a);

  switch (a->kind) {
    case ty_array:
      return (array *)a;
    case ty_error:
      return 0;
    default:
      em.error(set->getPos());
      em << "expression is not an array";
      return 0;
  }
}

// Checks if the expression can be translated as an array.
bool isAnArray(coenv &e, exp *x)
{
  types::ty *t=x->cgetType(e);
  if (t->kind == ty_overloaded)
    t=dynamic_cast<overloaded *>(t)->signatureless();
  return t && t->kind==ty_array;
}


void subscriptExp::prettyprint(ostream &out, Int indent)
{
  prettyindent(out, indent);
  out << "subscriptExp\n";

  set->prettyprint(out, indent+1);
  index->prettyprint(out, indent+1);
}

types::ty *subscriptExp::trans(coenv &e)
{
  array *a = transArray(e);
  if (!a)
    return primError();

  if (isAnArray(e, index)) {
    index->transToType(e, types::IntArray());
    e.c.encode(inst::builtin, run::arrayIntArray);
    return getArrayType(e);
  }
  else {
    index->transToType(e, types::primInt());
    e.c.encode(inst::builtin,
               a->celltype->kind==ty_array ? run::arrayArrayRead :
               run::arrayRead);
    return a->celltype;
  }
}

types::ty *subscriptExp::getType(coenv &e)
{
  array *a = getArrayType(e);
  return a ? (isAnArray(e, index) ? a : a->celltype) :
    primError();
}

void subscriptExp::transWrite(coenv &e, types::ty *t, exp *value)
{
  // Put array, index, and value on the stack in that order, then call
  // arrayWrite.
  array *a = transArray(e);
  if (!a)
    return;

  if (!equivalent(a->celltype, t))
    {
      em.error(getPos());
      em << "array expression cannot be used as an address";

      // Translate the value for errors.
      value->transToType(e, t);
      return;
    }

  index->transToType(e, types::primInt());

  value->transToType(e, t);

  e.c.encode(inst::builtin, run::arrayWrite);
}


void slice::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "slice", indent, getPos());
  if (left)
    left->prettyprint(out, indent+1);
  else
    prettyname(out, "left omitted", indent+1, getPos());
  if (right)
    right->prettyprint(out, indent+1);
  else
    prettyname(out, "right omitted", indent+1, getPos());
}

void slice::trans(coenv &e)
{
  if (left)
    left->transToType(e, types::primInt());
  else
    // If the left index is omitted it can be assumed to be zero.
    e.c.encode(inst::intpush, (Int)0);

  if (right)
    right->transToType(e, types::primInt());
}


void sliceExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "sliceExp", indent, getPos());
  set->prettyprint(out, indent+1);
  index->prettyprint(out, indent+1);
}

types::ty *sliceExp::trans(coenv &e)
{
  array *a = transArray(e);
  if (!a)
    return primError();

  index->trans(e);

  e.c.encode(inst::builtin, index->getRight() ? run::arraySliceRead :
             run::arraySliceReadToEnd);

  return a;
}

types::ty *sliceExp::getType(coenv &e)
{
  array *a = getArrayType(e);
  return a ? a : primError();
}

void sliceExp::transWrite(coenv &e, types::ty *t, exp *value)
{
  array *a = transArray(e);
  if (!a)
    return;
  assert(equivalent(a, t));

  index->trans(e);

  value->transToType(e, t);

  e.c.encode(inst::builtin, index->getRight() ? run::arraySliceWrite :
             run::arraySliceWriteToEnd);
}

void thisExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "thisExp", indent, getPos());
}

types::ty *thisExp::trans(coenv &e)
{
  if (!e.c.encodeThis()) {
    em.error(getPos());
    em << "static use of 'this' expression";
  }
  return cgetType(e);
}

types::ty *thisExp::getType(coenv &e)
{
  return e.c.thisType();
}

void equalityExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "equalityExp", indent, getPos());
  callExp::prettyprint(out, indent+1);
}

types::ty *equalityExp::getType(coenv &e) {
  // Try to the resolve the expression as a function call first.
  types::ty *t = callExp::getType(e);
  assert(t);
  if (t->kind != ty_error)
    return t;
  else
    // Either an error or handled by the function equality methods.  In the
    // first case, we may return whatever we like, and the second case always
    // returns bool.  In either case, it is safe to return bool.
    return primBoolean();
}

// From a possibly overloaded type, if there is a unique function type, return
// it, otherwise 0.
types::ty *uniqueFunction(types::ty *t) {
  if (t->kind == types::ty_function)
    return t;

  if (t->isOverloaded()) {
    types::ty *ft = 0;
    for (ty_iterator i = t->begin(); i != t->end(); ++i)
      {
        if ((*i)->kind != types::ty_function)
          continue;

        if (ft) {
          // Multiple function types.
          return 0;
        }

        ft = *i;
      }

    return ft;
  }

  // Not a function.
  return 0;
}

// From two possibly overloaded types, if there is a unique function type
// common to both, return it, otherwise 0.
types::ty *uniqueFunction(types::ty *t1, types::ty *t2) {
  if (t1->kind == types::ty_function)
    return equivalent(t1, t2) ? t1 : 0;

  if (t1->isOverloaded()) {
    types::ty *ft = 0;
    for (ty_iterator i = t1->begin(); i != t1->end(); ++i)
      {
        if ((*i)->kind != types::ty_function)
          continue;

        if (!equivalent(*i, t2))
          continue;

        if (ft) {
          // Multiple function types.
          return 0;
        }

        ft = *i;
      }

    return ft;
  }

  // Not a function.
  return 0;
}

bltin bltinFromName(symbol name) {
  if (name == SYM_EQ)
    return run::boolFuncEq;
  assert(name == SYM_NEQ);
  return run::boolFuncNeq;
}

types::ty *equalityExp::trans(coenv &e) {
  // First, try to handle by normal function resolution.
  types::ty *t = callExp::getType(e);
  assert(t);
  if (t->kind != ty_error)
    return callExp::trans(e);

  // Then, check for the function equality case.
  exp *left = (*this->args)[0].val;
  exp *right = (*this->args)[1].val;

  types::ty *lt = left->getType(e);
  types::ty *rt = right->getType(e);

  // TODO: decide what null == null should do.

  // Check for function == null and null == function
  types::ty *ft = 0;
  if (rt->kind == types::ty_null)
    ft = uniqueFunction(lt);
  else if (lt->kind == types::ty_null)
    ft = uniqueFunction(rt);
  else
    ft = uniqueFunction(lt, rt);


  if (ft) {
    assert(ft->kind == ty_function);

    left->transToType(e, ft);
    right->transToType(e, ft);
    e.c.encode(inst::builtin, bltinFromName(callee->getName()));

    return primBoolean();
  } else {
    // Let callExp report a "no such function" error.
    types::ty *t = callExp::trans(e);
    assert(t->kind == ty_error);
    return t;
  }
}

void scaleExp::prettyprint(ostream &out, Int indent)
{
  exp *left=getLeft(); exp *right=getRight();

  prettyname(out, "scaleExp",indent, getPos());
  left->prettyprint(out, indent+1);
  right->prettyprint(out, indent+1);
}

types::ty *scaleExp::trans(coenv &e)
{
  exp *left=getLeft(); exp *right=getRight();

  types::ty *lt = left->cgetType(e);
  if (lt->kind != types::ty_Int && lt->kind != types::ty_real) {
    if (lt->kind != types::ty_error) {
      em.error(left->getPos());
      em << "only numeric constants can do implicit scaling";
    }
    right->trans(e);
    return types::primError();
  }

  if (!right->scalable()) {
    em.warning(right->getPos());
    em << "implicit scaling may be unintentional";
  }

  // Defer to the binaryExp for multiplication.
  return binaryExp::trans(e);
}


void intExp::prettyprint(ostream &out, Int indent)
{
  prettyindent(out,indent);
  out << "intExp: " << value << "\n";
}

types::ty *intExp::trans(coenv &e)
{
  e.c.encode(inst::intpush,value);

  return types::primInt();
}


void realExp::prettyprint(ostream &out, Int indent)
{
  prettyindent(out, indent);
  out << "realExp: " << value << "\n";
}

types::ty *realExp::trans(coenv &e)
{
  e.c.encode(inst::constpush,(item)value);

  return types::primReal();
}

void stringExp::prettyprint(ostream &out, Int indent)
{
  prettyindent(out, indent);
  out << "stringExp '" << str << "'\n";
}

types::ty *stringExp::trans(coenv &e)
{
  e.c.encode(inst::constpush,(item) string(str));

  return types::primString();
}


void booleanExp::prettyprint(ostream &out, Int indent)
{
  prettyindent(out, indent);
  out << "booleanExp: " << value << "\n";
}

types::ty *booleanExp::trans(coenv &e)
{
  e.c.encode(inst::constpush,(item)value);

  return types::primBoolean();
}

void newPictureExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "newPictureExp",indent, getPos());
}

types::ty *newPictureExp::trans(coenv &e)
{
  e.c.encode(inst::builtin, run::newPicture);

  return types::primPicture();
}

void cycleExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "cycleExp",indent, getPos());
}

types::ty *cycleExp::trans(coenv &e)
{
  e.c.encode(inst::builtin, run::newCycleToken);

  return types::primCycleToken();
}

void nullPathExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "nullPathExp",indent, getPos());
}

types::ty *nullPathExp::trans(coenv &e)
{
  e.c.encode(inst::builtin, run::nullPath);

  return types::primPath();
}

void nullExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "nullExp",indent, getPos());
}

types::ty *nullExp::trans(coenv &)
{
  // Things get put on the stack when ty_null
  // is cast to an appropriate type
  return types::primNull();
}


void quoteExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "quoteExp", indent, getPos());
  value->prettyprint(out, indent+1);
}

types::ty *quoteExp::trans(coenv &e)
{
  e.c.encode(inst::constpush,(item)value);

  return types::primCode();
}

void explist::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "explist",indent, getPos());
  for (expvector::iterator p = exps.begin();
       p != exps.end(); ++p)
    (*p)->prettyprint(out, indent+1);
}


void argument::prettyprint(ostream &out, Int indent)
{
  prettyindent(out, indent);
  out << "explist";
  if (name)
    out << " '" << name << "'";
  out << '\n';

  val->prettyprint(out, indent+1);
}



void arglist::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "arglist",indent, getPos());
  for (argvector::iterator p = args.begin();
       p != args.end(); ++p)
    p->prettyprint(out, indent+1);
}



void callExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "callExp",indent, getPos());

  callee->prettyprint(out, indent+1);
  args->prettyprint(out, indent+1);
}

signature *callExp::argTypes(coenv &e, bool *searchable)
{
  signature *source=new signature;

  // The signature is searchable unless one of the arguments is overloaded or
  // named.
  *searchable = true;

  size_t n = args->size();

  for (size_t i = 0; i < n; i++) {
    if(string(args->args[i].name) == "KEY") {
      stringExp *s=dynamic_cast<stringExp*>(args->args[i].val);
      if(s) {
        if(getPos().filename() == processData().fileName) {
          processDataStruct *P=&processData();
          P->xkey[getPos().shift(P->xmapCount).LineColumn()]=
            Strdup(s->getString());
        }
        args->args.erase(args->args.begin()+i);
        --n;
        if(i == n) break;
      }
    }

    argument a=(*args)[i];
    types::ty *t = a.val->cgetType(e);
    if (t->kind == types::ty_error)
      return 0;
    if (t->kind == types::ty_overloaded || a.name)
      *searchable = false;
    source->add(types::formal(t,a.name));
  }

  if (args->rest.val) {
    argument a=args->rest;
    types::ty *t = a.val->cgetType(e);
    if (t->kind == types::ty_error)
      return 0;
    if (t->kind == types::ty_overloaded || a.name)
      *searchable = false;
    source->addRest(types::formal(t,a.name));
  }

  return source;
}

application *callExp::resolve(coenv &e, overloaded *o, signature *source,
                              bool tacit) {
  app_list l=multimatch(e.e, o, source, *args);

  if (l.empty()) {
    //cerr << "l is empty\n";
    if (!tacit) {
      em.error(getPos());

      symbol s = callee->getName();
      if (s)
        em << "no matching function \'" << s;
      else
        em << "no matching function for signature \'";
      em << *source << "\'";
    }

    return 0;
  }
  else if (l.size() > 1) { // This may take O(n) time.
    //cerr << "l is full\n";
    if (!tacit) {
      em.error(getPos());

      symbol s = callee->getName();
      if(s)
        em << "call of function \'" << s;
      else
        em << "call with signature \'";
      em << *source << "\' is ambiguous:\n\n";
      for(app_list::iterator p=l.begin(); p != l.end(); ++p)
        em << *(*p)->getType() << "\n";
    }

    return 0;
  }
  else {
    //cerr << "l is singleton\n";
    return l.front();
  }
}

bool hasNamedParameters(signature *sig) {
  for (size_t i=0; i < sig->getNumFormals(); ++i)
    if (sig->getFormal(i).name)
      return true;
  return false;
}

void callExp::reportMismatch(function *ft, signature *source)
{
  symbol s = callee->getName();
  const char *separator=ft->getSignature()->getNumFormals() > 1 ? "\n" : " ";

  em.error(getPos());
  em << "cannot call" << separator << "'" << *ft->getResult() << " ";
  if(s)
    em << s;
  em << *ft->getSignature() << "'" << separator;

  if (ft->getSignature()->isOpen && hasNamedParameters(source))
    em << "with named parameters";
  else
    switch(source->getNumFormals()) {
      case 0:
        em << "without parameters";
        break;
      case 1:
        em << "with parameter '" << toString(*source) << "'";
        break;
      default:
        em << "with parameters\n'" << toString(*source) << "'";
    }
}

void callExp::reportArgErrors(coenv &e)
{
  // Cycle through the parameters to report all errors.
  // NOTE: This may report inappropriate ambiguity errors.
  for (size_t i = 0; i < args->size(); i++) {
    (*args)[i].val->trans(e);
  }
  if (args->rest.val)
    args->rest.val->trans(e);
}

void callExp::reportNonFunction() {
  em.error(getPos());
  symbol s = callee->getName();
  if (s)
    em << "\'" << s << "\' is not a function";
  else
    em << "called expression is not a function";
}

types::ty *callExp::cacheAppOrVarEntry(coenv &e, bool tacit)
{
  assert(cachedVarEntry == 0 && cachedApp == 0);

  // First figure out the signature of what we want to call.
  bool searchable;
  signature *source=argTypes(e, &searchable);

#ifdef DEBUG_GETAPP /* {{{ */
  cout << "getApp for ";
  if (callee->getName())
    cout << *callee->getName();
  else
    cout << "unnamed";
  cout << " at " << getPos() << endl;
  cout << "searchable: " << searchable << endl;
#endif /* }}} */

  if (!source) {
    return primError();
  }

  // An attempt at speeding up compilation:  See if the source arguments match
  // the (possibly overloaded) function exactly.
  if (searchable) {
    varEntry *ve = callee->getCallee(e, source);

#ifdef DEBUG_GETAPP
    cout << "guessed: " << (ve!=0) << endl;
#endif

    if (ve) {
      cachedVarEntry = ve;
#ifndef DEBUG_CACHE
      // Normally DEBUG_CACHE is not defined and we return here for efficiency
      // reasons.  If DEBUG_CACHE is defined, we instead proceed to resolve
      // the function by the normal techniques and make sure we get the same
      // result.
      return ((function *)ve->getType())->getResult();
#endif
    }
  }

  // Figure out what function types we can call.
  types::ty *ft = callee->cgetType(e);

#ifdef DEBUG_GETAPP
  string name = callee->getName() ? string(*callee->getName()) :
    string("unnamed");
  if (!callee->getName())
    cout << getPos() << endl;
#endif

  switch (ft->kind) {
    case ty_error:
      if (!tacit)
        // Report callee errors.
        callee->trans(e);
      break;

    case ty_function:
      //cout << "name " << name << endl;
      cachedApp = application::match(e.e, (function *)ft, source, *args);
      if (!cachedApp && !tacit)
        reportMismatch((function *)ft, source);
      break;

    case ty_overloaded: {
#ifdef DEBUG_GETAPP
      int size = ((overloaded *)ft)->sub.size();
      for (int i = 0; i < size; ++i) cout << "name " << name << endl;
#endif
      cachedApp = resolve(e, (overloaded *)ft, source, tacit);
      break;
    }

    default:
      if (!tacit)
        reportNonFunction();
      break;
  }

#ifdef DEBUG_GETAPP
  cout << name << " " << *source << " --> "
       << *cachedApp->getType()->getSignature() << endl;
#endif

#if DEBUG_CACHE
  // Make sure cachedVarEntry is giving us the right function.
  if (cachedVarEntry)
    assert(equivalent(cachedVarEntry->getType(), cachedApp->getType()));
#endif

  // getType relies on this method for the type.
  return cachedApp ? cachedApp->getType()->getResult() : primError();
}

types::ty *callExp::transPerfectMatch(coenv &e) {
  // The varEntry of the callee.  (No longer needed after translation.)
  varEntry *ve = cachedVarEntry;
  cachedVarEntry = 0;
  assert(ve);

  // Translate the arguments in turn.
  for (size_t i = 0; i < args->size(); ++i)
    (*args)[i].val->trans(e);
  if (args->rest.val)
    args->rest.val->trans(e);

  // Call the function.
  ve->encode(trans::CALL, getPos(), e.c);

  // That's it.  Return the return type of the function.
  return ct ? ct : dynamic_cast<function *>(ve->getType())->getResult();
}

types::ty *callExp::trans(coenv &e)
{
  if (cachedVarEntry == 0 && cachedApp == 0)
    cacheAppOrVarEntry(e, false);

  if (cachedVarEntry)
    return transPerfectMatch(e);

  // The cached data is no longer needed after translation, so let it be
  // garbage collected.
  application *a = cachedApp;
  cachedApp=0;

  if (!a) {
    reportArgErrors(e);
    return primError();
  }

  // To simulate left-to-right order of evaluation, produce the
  // side-effects for the callee.
  assert(a);
  function *t=a->getType();
  assert(t);
  exp *temp=callee->evaluate(e, t);

  // Let the application handle the argument translation.
  a->transArgs(e);

  // Translate the call.
  temp->transCall(e, t);

  return t->result;
}

types::ty *callExp::getType(coenv &e)
{
  if (cachedApp)
    return cachedApp->getType()->getResult();
  if (cachedVarEntry) {
    function *ft = dynamic_cast<function *>(cachedVarEntry->getType());
    assert(ft);
    return ft->getResult();
  }
  return cacheAppOrVarEntry(e, true);
}

bool callExp::resolved(coenv &e) {
  if (cachedApp == 0 && cachedVarEntry == 0)
    cacheAppOrVarEntry(e, true);
  return cachedApp || cachedVarEntry;
}

void pairExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "pairExp",indent, getPos());

  x->prettyprint(out, indent+1);
  y->prettyprint(out, indent+1);
}

types::ty *pairExp::trans(coenv &e)
{
  x->transToType(e, types::primReal());
  y->transToType(e, types::primReal());

  e.c.encode(inst::builtin, run::realRealToPair);

  return types::primPair();
}

void tripleExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "tripleExp",indent, getPos());

  x->prettyprint(out, indent+1);
  y->prettyprint(out, indent+1);
  z->prettyprint(out, indent+1);
}

types::ty *tripleExp::trans(coenv &e)
{
  x->transToType(e, types::primReal());
  y->transToType(e, types::primReal());
  z->transToType(e, types::primReal());

  e.c.encode(inst::builtin, run::realRealRealToTriple);

  return types::primTriple();
}

void transformExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "transformExp",indent, getPos());

  x->prettyprint(out, indent+1);
  y->prettyprint(out, indent+1);
  xx->prettyprint(out, indent+1);
  xy->prettyprint(out, indent+1);
  yx->prettyprint(out, indent+1);
  yy->prettyprint(out, indent+1);
}

types::ty *transformExp::trans(coenv &e)
{
  x->transToType(e, types::primReal());
  y->transToType(e, types::primReal());
  xx->transToType(e, types::primReal());
  xy->transToType(e, types::primReal());
  yx->transToType(e, types::primReal());
  yy->transToType(e, types::primReal());

  e.c.encode(inst::builtin, run::real6ToTransform);

  return types::primTransform();
}

void castExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "castExp",indent, getPos());

  target->prettyprint(out, indent+1);
  castee->prettyprint(out, indent+1);
}

types::ty *castExp::tryCast(coenv &e, types::ty *t, types::ty *s,
                            symbol csym)
{
  types::ty *ss=e.e.castSource(t, s, csym);
  if (ss == 0) {
    return 0;
  }
  if (ss->kind == ty_overloaded) {
    em.error(getPos());
    em << "cast is ambiguous";
    return primError();
  }
  else {
    castee->transAsType(e, ss);

    access *a=e.e.lookupCast(t, ss, csym);
    assert(a);
    a->encode(trans::CALL, getPos(), e.c);
    return ss;
  }
}

types::ty *castExp::trans(coenv &e)
{
  target->addOps(e, (record *)0);
  types::ty *t=target->trans(e);

  types::ty *s=castee->cgetType(e);

  if (!tryCast(e, t, s, symbol::ecastsym))
    if (!tryCast(e, t, s, symbol::castsym)) {
      em.error(getPos());
      em << "cannot cast '" << *s << "' to '" << *t << "'";
    }

  return t;
}

types::ty *castExp::getType(coenv &e)
{
  return target->trans(e, true);
}



void conditionalExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "conditionalExp",indent, getPos());

  test->prettyprint(out, indent+1);
  onTrue->prettyprint(out, indent+1);
  onFalse->prettyprint(out, indent+1);
}

void conditionalExp::baseTransToType(coenv &e, types::ty *target) {
  test->transToType(e, types::primBoolean());

  label tlabel = e.c.fwdLabel();
  e.c.useLabel(inst::cjmp,tlabel);

  onFalse->transToType(e, target);

  label end = e.c.fwdLabel();
  e.c.useLabel(inst::jmp,end);

  e.c.defLabel(tlabel);
  onTrue->transToType(e, target);

  e.c.defLabel(end);
}

void conditionalExp::transToType(coenv &e, types::ty *target)
{
  if (isAnArray(e, test)) {
    if (target->kind != ty_array) {
      em.error(getPos());
      em << "cannot cast vectorized conditional to '" << *target << "'";
    }
    test->transToType(e, types::booleanArray());
    onTrue->transToType(e, target);
    onFalse->transToType(e, target);
    e.c.encode(inst::builtin, run::arrayConditional);
  }
  else {
    baseTransToType(e, target);
  }
}

types::ty *promote(coenv &e, types::ty *x, types::ty *y)
{
  struct promoter : public collector {
    env &e;

    promoter(env &e)
      : e(e) {}

    types::ty *both (types::ty *x, types::ty *y) {
      overloaded *o=new overloaded;
      o->add(x); o->add(y);
      return o;
    }

    types::ty *base (types::ty *x, types::ty *y) {
      if (equivalent(x,y))
        return x;
      else {
        bool castToFirst=e.castable(x, y, symbol::castsym);
        bool castToSecond=e.castable(y, x, symbol::castsym);

        return (castToFirst && castToSecond) ? both(x,y) :
          castToFirst ? x :
          castToSecond ? y :
          0;
      }
    }
  };

  promoter p(e.e);
  return p.collect(x,y);
}

types::ty *conditionalExp::trans(coenv &e)
{
  types::ty *tt=onTrue->cgetType(e);
  types::ty *ft=onFalse->cgetType(e);

  if (tt->kind==ty_error)
    return onTrue->trans(e);
  if (ft->kind==ty_error)
    return onFalse->trans(e);

  types::ty *t=promote(e, tt, ft);
  if (!t) {
    em.error(getPos());
    em << "types in conditional expression do not match";
    return primError();
  }
  else if (t->kind == ty_overloaded) {
    em.error(getPos());
    em << "type of conditional expression is ambiguous";
    return primError();
  }

  transToType(e,t);
  return t;
}

types::ty *conditionalExp::getType(coenv &e)
{
  types::ty *tt=onTrue->cgetType(e);
  types::ty *ft=onFalse->cgetType(e);
  if (tt->kind==ty_error || ft->kind==ty_error)
    return primError();

  types::ty *t = promote(e, tt, ft);
  return t ? t : primError();
}


void orExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "orExp", indent, getPos());

  left->prettyprint(out, indent+1);
  right->prettyprint(out, indent+1);
}

types::ty *orExp::trans(coenv &e)
{
  //     a || b
  // translates into
  //     a ? true : b
  booleanExp be(pos, true);
  conditionalExp ce(pos, left, &be, right);
  ce.baseTransToType(e, primBoolean());

  return getType(e);
}

void orExp::transConditionalJump(coenv &e, bool cond, label dest)
{
  if (cond == true) {
    left->transConditionalJump(e, true, dest);
    right->transConditionalJump(e, true, dest);
  } else { /* cond == false */
    label end = e.c.fwdLabel();

    left->transConditionalJump(e, true, end);
    right->transConditionalJump(e, false, dest);

    e.c.defLabel(end);
  }
}


void andExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "andExp", indent, getPos());

  left->prettyprint(out, indent+1);
  right->prettyprint(out, indent+1);
}

types::ty *andExp::trans(coenv &e)
{
  //     a && b
  // translates into
  //     a ? b : false
  booleanExp be(pos, false);
  conditionalExp ce(pos, left, right, &be);
  ce.baseTransToType(e, primBoolean());

  return getType(e);
}

void andExp::transConditionalJump(coenv &e, bool cond, label dest)
{
  if (cond == true) {
    label end = e.c.fwdLabel();

    left->transConditionalJump(e, false, end);
    right->transConditionalJump(e, true, dest);

    e.c.defLabel(end);
  } else { /* cond == false */
    left->transConditionalJump(e, false, dest);
    right->transConditionalJump(e, false, dest);
  }
}

void joinExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "joinExp",indent, getPos());

  callee->prettyprint(out, indent+1);
  args->prettyprint(out, indent+1);
}


void specExp::prettyprint(ostream &out, Int indent)
{
  prettyindent(out,indent);
  out << "specExp '" << op << "' "
      << (s==camp::OUT ? "out" :
          s==camp::IN  ? "in" :
          "invalid side") << '\n';

  arg->prettyprint(out, indent+1);
}

types::ty *specExp::trans(coenv &e)
{
  intExp ie(getPos(), (Int)s);
  binaryExp be(getPos(), arg, op, &ie);
  return be.trans(e);
}

types::ty *specExp::getType(coenv &e)
{
  intExp ie(getPos(), (Int)s);
  binaryExp be(getPos(), arg, op, &ie);
  return be.cgetType(e);
}

void assignExp::prettyprint(ostream &out, Int indent)
{
  prettyname(out, "assignExp",indent, getPos());

  dest->prettyprint(out, indent+1);
  value->prettyprint(out, indent+1);
}

void assignExp::transAsType(coenv &e, types::ty *target)
{
#if 0
  // For left-to-right order, we have to evaluate the side-effects of the
  // destination first.
  exp *temp=dest->evaluate(e, target);
  ultimateValue(temp)->transToType(e, target);
  temp->transWrite(e, target);
#endif

  // All of the heavy work is handled by transWrite.
  dest->transWrite(e, target, value);
}

types::ty *assignExp::trans(coenv &e)
{
  exp *uvalue=ultimateValue(dest);
  types::ty *lt = dest->cgetType(e), *rt = uvalue->cgetType(e);

  if (lt->kind == ty_error)
    return dest->trans(e);
  if (rt->kind == ty_error)
    return uvalue->trans(e);

  types::ty *t = e.e.castTarget(lt, rt, symbol::castsym);
  if (!t) {
    em.error(getPos());
    em << "cannot convert '" << *rt << "' to '" << *lt << "' in assignment";
    return primError();
  }
  else if (t->kind == ty_overloaded) {
    em.error(getPos());
    em << "assignment is ambiguous";
    return primError();
  }
  else {
    transAsType(e, t);
    return t;
  }
}

types::ty *assignExp::getType(coenv &e)
{
  types::ty *lt = dest->cgetType(e), *rt = ultimateValue(dest)->cgetType(e);
  if (lt->kind==ty_error || rt->kind==ty_error)
    return primError();
  types::ty *t = e.e.castTarget(lt, rt, symbol::castsym);

  return t ? t : primError();
}


void selfExp::prettyprint(ostream &out, Int indent)
{
  prettyindent(out, indent);
  out << "selfExp '" << op << "'\n";

  dest->prettyprint(out, indent+1);
  value->prettyprint(out, indent+1);
}

void selfExp::transAsType(coenv &e, types::ty *target)
{
  // Create a temp expression for the destination, so it is not evaluated
  // twice.
  exp *temp=dest->evaluate(e, target);
  temp->transWrite(e, target, ultimateValue(temp));
}

void prefixExp::prettyprint(ostream &out, Int indent)
{
  prettyindent(out, indent);
  out << "prefixExp '" << op << "'\n";

  dest->prettyprint(out, indent+1);
}

types::ty *prefixExp::trans(coenv &e)
{
  // Convert into the operation and the assign.
  // NOTE: This can cause multiple evaluations.
  intExp ie(getPos(), 1);
  selfExp se(getPos(), dest, op, &ie);

  return se.trans(e);
}

types::ty *prefixExp::getType(coenv &e)
{
  // Convert into the operation and the assign.
  intExp ie(getPos(), 1);
  selfExp se(getPos(), dest, op, &ie);

  return se.getType(e);
}

void postfixExp::prettyprint(ostream &out, Int indent)
{
  prettyindent(out, indent);
  out << "postfixExp <illegal> '" << op << "'\n";

  dest->prettyprint(out, indent+1);
}

types::ty *postfixExp::trans(coenv &)
{
  em.error(getPos());
  em << "postfix expressions are not allowed";
  return primError();
}


} // namespace absyntax
