#include <cstring>

#include "stack.h"
#include "env.h"
#include "exp.h"
#include "stm.h"
#include "refaccess.h"

using std::strlen;

using namespace absyntax;
using namespace trans;

using vm::item;
using vm::get;


#include "policy.h"

coenv &coenvInOngoingProcess();
void runInOngoingProcess(absyntax::runnable *r);

void runExp(absyntax::exp *e)
{
 absyntax::expStm s(nullPos, e);
 runInOngoingProcess(&s);
}

class ImpDatum;
class ImpArguments;

ImpDatum *datumError(const char *msg);

// Expression used for non-item datums.
class errorExp : public absyntax::exp {
public:
 errorExp() : exp(nullPos) {}

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

 void complain() {
   em.error(nullPos); em << "cannot use datum as expression";
 }

 types::ty *getType(coenv &) { return types::primError(); }
 types::ty *trans(coenv &e) { complain(); return getType(e); }

 void transAsType(coenv &e, types::ty *target) { complain(); }
};

// Abstract base class for Datum types.
class ImpDatum {
public:
 virtual operator handle_typ() { return (handle_typ)(this); }

 virtual int_typ toInt() {
   datumError("cannot convert to integer");

   // Return a weird value that will hopefully be noticed.
   return -777777;
 }

 virtual bool toBool() {
   datumError("cannot convert to bool");
   return false;
 }

 virtual double toDouble() {
   datumError("cannot convert to double");
   return -777e77;
 }

 virtual string_typ toString() {
   datumError("cannot convert to string");

   string_typ s = { "XXXXX", 5 };
   return s;
 }

 virtual absyntax::exp *getExp() {
   datumError("invalid use of datum");
   return new errorExp;
 }

 // How to access a field of the datum.
 virtual absyntax::exp *getFieldExp(symbol id) {
   assert(id);
   return new fieldExp(nullPos, this->getExp(), id);
 }

 virtual ImpDatum *getField(const char *name);

 virtual ImpDatum *getCell(ImpDatum *index) {
   return datumError("cannot index datatype");
 }

 virtual void addField(const char *name, ImpDatum *init)
 {
   datumError("cannot set field of datatype");
 }

};

// An ever-growing list of handles, used to avoid garbage collecting the data.
// TODO: Implement effective releaseHandle.
mem::vector<handle_typ> handles;

handle_typ wrap(ImpDatum *d)
{
 handle_typ h = (handle_typ)(d);
 handles.push_back(h);
 return h;
}

ImpDatum *unwrap(handle_typ handle)
{
 assert(handle != 0);
 return (ImpDatum *)(handle);
}

class ErrorDatum : public ImpDatum {
};

error_callback_typ errorCallback = 0;

ImpDatum *datumError(const char *msg)
{
 static ErrorDatum ed;

 if (errorCallback) {
   string_typ s = { msg, strlen(msg) };
   errorCallback(s);
 }
 else {
   cerr << msg << '\n';
 }

 return &ed;
}

handle_typ imp_copyHandle(handle_typ handle)
{
 //cout << "+";
 // For now, don't do anything.
 return handle;
}

void imp_releaseHandle()
{
 //cout << "-";
 // Do nothing, for now.
}

// A datum representing a value in Asymptote.  Both the runtime representation
// of the value and its type are stored.
class ItemDatum : public ImpDatum {
 item i;
 types::ty *t;

public:
 // Every itemDatum has a fixed (non-overloaded) type, t
 ItemDatum(types::ty *t) : t(t) {
   assert(t);
   assert(t->isNotOverloaded());
   assert(t->isNotError());
 }

 // An expression that can be used to get and set the datum.
 // The value should only be set once, when the datum is created, and not
 // changed.
 absyntax::exp *getExp() {
   // It may be faster to create this once on start, but then the datum will
   // require more space.  For now, we create the access and expression on
   // demand.
   return new varEntryExp(nullPos, t, new itemRefAccess(&i));
 }

 int_typ toInt() {
   // TODO: Decide if we want to use casting.
   if (t->kind == types::ty_Int)
     return static_cast<int_typ>(get<Int>(i));
   else
     return ImpDatum::toInt();
 }

 bool toBool() {
   if (t->kind == types::ty_boolean)
     return get<bool>(i);
   else
     return ImpDatum::toBool();
 }

 double toDouble() {
   if (t->kind == types::ty_real)
     return get<double>(i);
   else
     return ImpDatum::toDouble();
 }

 string_typ toString() {
   if (t->kind == types::ty_string) {
     // TODO: Fix for strings containing NUL.
     string *s = get<string *>(i);
     string_typ st = { s->c_str(), s->length() };
     return st;
   }
   else
     return ImpDatum::toString();
 }
};

ItemDatum *ItemDatumFromExp(types::ty *t, absyntax::exp *e)
{
 ItemDatum *d = new ItemDatum(t);
 assignExp ae(nullPos, d->getExp(), e);
 runExp(&ae);

 return d;
}

ItemDatum *ItemDatumFromInt(int_typ x)
{
 intExp ie(nullPos, static_cast<Int>(x));
 return ItemDatumFromExp(types::primInt(), &ie);
}

ItemDatum *ItemDatumFromBool(bool x)
{
 booleanExp be(nullPos, x);
 return ItemDatumFromExp(types::primBoolean(), &be);
}

ItemDatum *ItemDatumFromDouble(double x)
{
 realExp re(nullPos, x);
 return ItemDatumFromExp(types::primReal(), &re);
}

ItemDatum *ItemDatumFromString(string_typ x)
{
 mem::string s(x.buf, (size_t)x.length);
 stringExp se(nullPos, s);
 return ItemDatumFromExp(types::primString(), &se);
}


// If the interface is asked to return a field which is overloaded, a handle
// to and OverloadedDatum is returned.  No evaluation actually occurs.  The
// datum simply consists of the containing datum and the name of the field
// requested.  Subsequent use of the datum will resolve the overloading (or
// report an error).
class OverloadedDatum : public ImpDatum {
 ImpDatum *parent;
 symbol id;

public:
 OverloadedDatum(ImpDatum *parent, symbol id) : parent(parent), id(id)
 {
   assert(parent);
   assert(id);
 }

 absyntax::exp *getExp() {
   return parent->getFieldExp(id);
   return new fieldExp(nullPos, parent->getExp(), id);
 }
};

ImpDatum *ImpDatum::getField(const char *name)
{
 coenv &e = coenvInOngoingProcess();
 symbol id = symbol::trans(name);

 absyntax::exp *ex = getFieldExp(id);

 types::ty *t = ex->getType(e);
 if (t->isError())
   return datumError("no field of that name");

 if (t->isOverloaded())
   return new OverloadedDatum(this, id);

 // Create a new datum and assign the variable to it.
 ItemDatum *d = new ItemDatum(t);
 assignExp ae(nullPos, d->getExp(), ex);
 runExp(&ae);

 return d;
}

handle_typ imp_handleFromInt(int_typ x)
{
 return wrap(ItemDatumFromInt(x));
}

handle_typ imp_handleFromBool(int_typ x)
{
 if (x != 0 && x != 1)
   return wrap(datumError("invalid boolean value"));

 return wrap(ItemDatumFromBool(x == 1));
}

handle_typ imp_handleFromDouble(double x)
{
 return wrap(ItemDatumFromDouble(x));
}

int_typ imp_IntFromHandle(handle_typ handle)
{
 return unwrap(handle)->toInt();
}

int_typ imp_boolFromHandle(handle_typ handle)
{
 return unwrap(handle)->toBool() ? 1 : 0;
}

double imp_doubleFromHandle(handle_typ handle)
{
 return unwrap(handle)->toDouble();
}


handle_typ imp_handleFromString(string_typ x)
{
 return wrap(ItemDatumFromString(x));
}

string_typ imp_stringFromHandle(handle_typ handle)
{
 return unwrap(handle)->toString();
}

handle_typ imp_getField(handle_typ handle, const char *name)
{
 return wrap(unwrap(handle)->getField(name));
}

handle_typ imp_getCell(handle_typ handle, handle_typ index)
{
 return wrap(unwrap(handle)->getCell(unwrap(index)));
}

void imp_addField(handle_typ handle, const char *name, handle_typ init)
{
 unwrap(handle)->addField(name, unwrap(init));
}

class ImpArguments /* TODO: gc visible but not collected */ {
 arglist args;
public:

 ImpArguments() {}

 void add(const char *name, ImpDatum *arg, arg_rest_option isRest)
 {
   assert(isRest == NORMAL_ARG); // TODO: Implement rest.
   symbol id = (name && name[0]) ? symbol::trans(name) : symbol::nullsym;

   args.add(arg->getExp(), id);
 }

 arglist *getArgs() { return &args; }
};

arguments_typ wrapArgs(ImpArguments *args)
{
 return (arguments_typ)(args);
}
ImpArguments *unwrapArgs(arguments_typ args)
{
 return (ImpArguments *)(args);
}

arguments_typ imp_newArguments()
{
 return wrapArgs(new ImpArguments);
}

void imp_releaseArguments(arguments_typ args)
{
 // For now, do nothing.
}

void imp_addArgument(arguments_typ args, const char *name, handle_typ handle,
                    arg_rest_option isRest)
{
 unwrapArgs(args)->add(name, unwrap(handle), isRest);
}

ImpDatum *callDatum(ImpDatum *callee, ImpArguments *args)
{
 coenv &e = coenvInOngoingProcess();

 callExp callex(nullPos, callee->getExp(), args->getArgs());

 types::ty *t = callex.getType(e);
 if (t->isError()) {
   // Run for errors.
   runExp(&callex);
   em.sync(true);
   return datumError("invalid call");
 }

 assert(t->isNotOverloaded()); // Calls are never overloaded.

 if (t->kind == types::ty_void) {
   // Execute the call and return 0 to indicate void.
   runExp(&callex);
   return 0;
 }
 else
   return ItemDatumFromExp(t, &callex);
}

handle_typ imp_call(handle_typ callee, arguments_typ args)
{
 return wrap(callDatum(unwrap(callee), unwrapArgs(args)));
}

class GlobalsDatum : public ImpDatum {
 typedef std::map<const char*, ImpDatum *> gmap;
 gmap base;

 virtual absyntax::exp *getFieldExp(symbol id)
 {
   // Fields of the globals datum are global variables.  Use the unqualified
   // name.
   return new nameExp(nullPos, id);
 }

 virtual void addField(const char *name, ImpDatum *init) {
   datumError("addField not yet re-implemented");
 }
};

class ImpState {
 //ImpArguments *params;

 ImpDatum *retval;
public:
 ImpState() : retval(0) {}

 ImpDatum *globals() {
   return new GlobalsDatum();
 }

 int_typ numParams() {
   /*if (params)
     return params->val.size();
     else */ {
     datumError("parameters accessed outside of function");
     return 0;
   }
 }

 ImpDatum *getParam(int_typ index) {
   /*if (params) {
     if (index >= 0 && index < static_cast<int_typ>(params->val.size()))
     return params->val[index];
     else
     return datumError("invalid index for parameter");
     }
     else */ {
     return datumError("parameters accessed outside of function");
   }
 }

 void setReturnValue(ImpDatum *retval)
 {
   /*if (params) {
     if (this->retval)
     datumError("return value set more than once");
     else
     this->retval = retval;
     }
     else */ {
     datumError("return value set outside of function");
   }
 }

 ImpDatum *getReturnValue()
 {
   return retval;
 }
};

state_typ wrapState(ImpState *s)
{
 return (state_typ)(s);
}
ImpState *unwrapState(state_typ s)
{
 return (ImpState *)(s);
}


handle_typ imp_globals(state_typ state)
{
 return wrap(unwrapState(state)->globals());
}

int_typ imp_numParams(state_typ state)
{
 return unwrapState(state)->numParams();
}

handle_typ imp_getParam(state_typ state, int_typ index)
{
 return wrap(unwrapState(state)->getParam(index));
}

void imp_setReturnValue(state_typ state, handle_typ handle)
{
 unwrapState(state)->setReturnValue(unwrap(handle));
}

state_typ cheatState()
{
 return wrapState(new ImpState());
}

#if 0
class FunctionDatum : public ImpDatum {
 function_typ f;
 void *data;

public:
 FunctionDatum(function_typ f, void *data) : f(f), data(data) {}

 ImpDatum *call(ImpArguments *args) {
   ImpState state(args);

   // Call the function.
   f(wrapState(&state),data);

   if (state.getReturnValue())
     return state.getReturnValue();
   else
     // TODO: Decide on datum for void return.
     return 0;
 }
};
#endif

handle_typ imp_handleFromFunction(const char *signature,
                                 function_typ f, void *data)
{
 // TODO: Re-implement.
 return 0; //wrap(new FunctionDatum(f, data));
}

void imp_setErrorCallback(error_callback_typ callback)
{
 errorCallback = callback;
}

extern policy_typ imp_policy;
policy_typ imp_policy =
{
 /* version = */ 101,
 imp_copyHandle,
 imp_releaseHandle,
 imp_handleFromInt,
 imp_handleFromBool,
 imp_handleFromDouble,
 imp_handleFromString,
 imp_handleFromFunction,
 imp_IntFromHandle,
 imp_boolFromHandle,
 imp_doubleFromHandle,
 imp_stringFromHandle,
 imp_getField,
 imp_getCell,
 imp_addField,
 imp_newArguments,
 imp_releaseArguments,
 imp_addArgument,
 imp_call,
 imp_globals,
 imp_numParams,
 imp_getParam,
 imp_setReturnValue,
 imp_setErrorCallback,
};

// Defined in process.cc
void init(bool resetpath=true);

extern "C" {

 policy_typ *_asy_getPolicy()
 {
   return &imp_policy;
 }

 state_typ _asy_getState()
 {
   static state_typ state = cheatState();

   // TODO: Make sure this runs once.
   char buf[] = "asymptote.so";
   char *argv [] = { buf };
   settings::setOptions(1,argv);

   // Ensures uptodate is not used.
   init();

   return state;
 }

}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.