diff options
author | Denis Bitouzé <dbitouze@wanadoo.fr> | 2021-02-25 18:23:07 +0000 |
---|---|---|
committer | Denis Bitouzé <dbitouze@wanadoo.fr> | 2021-02-25 18:23:07 +0000 |
commit | c6101f91d071883b48b1b4b51e5eba0f36d9a78d (patch) | |
tree | 1bf7f5a881d7a4f5c5bf59d0b2821943dd822372 /Build/source/utils/asymptote/exp.h | |
parent | 07ee7222e389b0777456b427a55c22d0e6ffd267 (diff) |
French translation for tlmgr updated
git-svn-id: svn://tug.org/texlive/trunk@57912 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/utils/asymptote/exp.h')
-rw-r--r-- | Build/source/utils/asymptote/exp.h | 1101 |
1 files changed, 0 insertions, 1101 deletions
diff --git a/Build/source/utils/asymptote/exp.h b/Build/source/utils/asymptote/exp.h deleted file mode 100644 index 562e2299657..00000000000 --- a/Build/source/utils/asymptote/exp.h +++ /dev/null @@ -1,1101 +0,0 @@ -/***** - * exp.h - * 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. - *****/ - -#ifndef EXP_H -#define EXP_H - -#include "types.h" -#include "symbol.h" -#include "absyn.h" -#include "varinit.h" -#include "name.h" -#include "guideflags.h" - -namespace trans { -class coenv; -class coder; - -struct label_t; -typedef label_t *label; - -class application; -} - -namespace absyntax { - -using trans::coenv; -using trans::label; -using trans::application; -using trans::access; -using sym::symbol; -using types::record; -using types::array; - -class exp : public varinit { -protected: - // The cached type (from a call to cgetType). - types::ty *ct; -public: - exp(position pos) - : varinit(pos), ct(0) {} - - void prettyprint(ostream &out, Int indent) = 0; - - // When reporting errors with function calls, it is nice to say "no - // function f(int)" instead of "no function matching signature - // (int)." Hence, this method returns the name of the expression if - // there is one. - virtual symbol getName() - { - return symbol::nullsym; - } - - // Checks if the expression can be used as the right side of a scale - // expression. ie. 3sin(x) - // If a "non-scalable" expression is scaled a warning is issued. - virtual bool scalable() { return true; } - - // Specifies if the value of the expression should be written to interactive - // prompt if typed as a stand-alone expression. For example: - // > 2+3; - // should write 5, but - // > x=2+3; - // shouldn't. (These choices are largely aesthetic) - virtual bool writtenToPrompt() { return true; } - - // Translates the expression to the given target type. This should only be - // called with a type returned by getType(). It does not perform implicit - // casting. - virtual void transAsType(coenv &e, types::ty *target); - - // Translates the expression to the given target type, possibly using an - // implicit cast. - void transToType(coenv &e, types::ty *target); - - // Translates the expression and returns the resultant type. - // For some expressions, this will be ambiguous and return an error. - // Trans may only return ty_error, if it (or one of its recursively - // called children in the syntax tree) reported an error to em. - virtual types::ty *trans(coenv &) = 0; - - // getType() figures out the type of the expression without translating - // the code into the virtual machine language or reporting errors to em. - // This must follow a few rules to ensure proper translation: - // 1. If this returns a valid type, t, trans(e) must return t or - // report an error, and transToType(e, t) must run either reporting - // an error or reporting no error and yielding the same result as - // trans(e). - // 2. If this returns a superposition of types (ie. for overloaded - // functions), trans must not return a singular type, and every - // type in the superposition must run without error properly - // if fed to transAsType(e, t). - // 3. If this returns ty_error, then so must a call to trans(e) and any - // call to trans, transAsType, or transToType must report an error - // to em. - // 4. Any call to transAsType(e, t) with a type that is not returned by - // getType() (or one of the subtypes in case of a superposition) - // must report an error. - // Any call to transToType(e, t) with a type that is not returned by - // getType() (or one of the subtypes in case of a superposition) - // or any type not implicitly castable from the above must report an - // error. - virtual types::ty *getType(coenv &) = 0; - - // This is an optimization which works in some cases to by-pass the slow - // overloaded function resolution provided by the application class. - // - // If an expression is called with arguments given by sig, getCallee must - // either return 0 (the default), or if it returns a varEntry, the varEntry - // must correspond to the function which would be called after normal - // function resolution. - // - // The callee must produce no side effects as there are no guarantees when - // the varEntry will be translated. - virtual trans::varEntry *getCallee(coenv &e, types::signature *sig) { -//#define DEBUG_GETAPP -#if DEBUG_GETAPP - cout << "exp fail" << endl; - cout << "exp fail at " << getPos() << endl; - prettyprint(cout, 2); -#endif - return 0; - } - - // Same result as getType, but caches the result so that subsequent - // calls are faster. For this to work correctly, the expression should - // only be used in one place, so the environment doesn't change between - // calls. - virtual types::ty *cgetType(coenv &e) { -#ifdef DEBUG_CACHE - testCachedType(e); -#endif - return ct ? ct : ct = getType(e); - } - - void testCachedType(coenv &e); - - // The expression is being written. Translate code such that the value - // (represented by the exp value) is stored into the address represented by - // this expression. - // In terms of side-effects, this expression must be evaluated (once) before - // value is evaluated (once). - virtual void transWrite(coenv &e, types::ty *t, exp *value) { - em.error(getPos()); - em << "expression cannot be used as an address"; - - // Translate the value for errors. - value->transToType(e, t); - } - - // Translates code for calling a function. The arguments, in the order they - // appear in the function's signature, must all be on the stack. - virtual void transCall(coenv &e, types::ty *target); - - // transConditionalJump must produce code equivalent to the following: - // Evaluate the expression as a boolean. If the result equals cond, jump to - // the label dest, otherwise do not jump. In either case, no value is left - // on the stack. - virtual void transConditionalJump(coenv &e, bool cond, label dest); - - // This is used to ensure the proper order and number of evaluations. When - // called, it immediately translates code to perform the side-effects - // consistent with a corresponding call to transAsType(e, target). - // - // The return value, called an evaluation for lack of a better name, is - // another expression that responds to the trans methods exactly as would the - // original expression, but without producing side-effects. It is also no - // longer overloaded, due to the resolution effected by giving a target type - // to evaluate(). - // - // The methods transAsType, transWrite, and transCall of the evaluation must - // be called with the same target type as the original call to evaluate. - // When evaluate() is called during the translation of a function, that - // function must still be in translation when the evaluation is translated. - // - // The base implementation uses a tempExp (see below). This is - // sufficient for most expressions. - virtual exp *evaluate(coenv &e, types::ty *target); - - // NOTE: could add a "side-effects" method which says if the expression has - // side-effects. This might allow some small optimizations in translating. -}; - -class tempExp : public exp { - access *a; - types::ty *t; - -public: - tempExp(coenv &e, varinit *v, types::ty *t); - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - - types::ty *getType(coenv &) { - return t; - } -}; - -// Wrap a varEntry so that it can be used as an expression. -// Translating the varEntry must cause no side-effects. -class varEntryExp : public exp { - trans::varEntry *v; -public: - varEntryExp(position pos, trans::varEntry *v) - : exp(pos), v(v) {} - varEntryExp(position pos, types::ty *t, access *a); - varEntryExp(position pos, types::ty *t, vm::bltin f); - - void prettyprint(ostream &out, Int indent); - - types::ty *getType(coenv &); - types::ty *trans(coenv &e); - trans::varEntry *getCallee(coenv &e, types::signature *sig); - - void transAct(action act, coenv &e, types::ty *target); - void transAsType(coenv &e, types::ty *target); - void transWrite(coenv &e, types::ty *t, exp *value); - void transCall(coenv &e, types::ty *target); -}; - -class nameExp : public exp { - name *value; - -public: - nameExp(position pos, name *value) - : exp(pos), value(value) {} - - nameExp(position pos, symbol id) - : exp(pos), value(new simpleName(pos, id)) {} - - nameExp(position pos, string s) - : exp(pos), value(new simpleName(pos, symbol::trans(s))) {} - - void prettyprint(ostream &out, Int indent); - - symbol getName() - { - return value->getName(); - } - - void transAsType(coenv &e, types::ty *target) { - value->varTrans(trans::READ, e, target); - - // After translation, the cached type is no longer needed and should be - // garbage collected. This could presumably be done in every class derived - // from exp, but here it is most important as nameExp can have heavily - // overloaded types cached. - ct=0; - } - - types::ty *trans(coenv &e) { - types::ty *t=cgetType(e); - if (t->kind == types::ty_error) { - em.error(getPos()); - em << "no matching variable \'" << *value << "\'"; - return types::primError(); - } - if (t->kind == types::ty_overloaded) { - em.error(getPos()); - em << "use of variable \'" << *value << "\' is ambiguous"; - return types::primError(); - } - else { - transAsType(e, t); - return t; - } - } - - types::ty *getType(coenv &e) { - types::ty *t=value->varGetType(e); - return t ? t : types::primError(); - } - - trans::varEntry *getCallee(coenv &e, types::signature *sig) { -#ifdef DEBUG_GETAPP - cout << "nameExp" << endl; -#endif - return value->getCallee(e, sig); - } - - void transWrite(coenv &e, types::ty *target, exp *newValue) { - newValue->transToType(e, target); - this->value->varTrans(trans::WRITE, e, target); - - ct=0; // See note in transAsType. - } - - void transCall(coenv &e, types::ty *target) { - value->varTrans(trans::CALL, e, target); - - ct=0; // See note in transAsType. - } - - exp *evaluate(coenv &, types::ty *) { - // Names have no side-effects. - return this; - } -}; - -// Most fields accessed are handled as parts of qualified names, but in cases -// like f().x or (new t).x, a separate expression is needed. -class fieldExp : public nameExp { - exp *object; - symbol field; - - // fieldExp has a lot of common functionality with qualifiedName, so we - // essentially hack qualifiedName, by making our object expression look - // like a name. - class pseudoName : public name { - exp *object; - - public: - pseudoName(exp *object) - : name(object->getPos()), object(object) {} - - // As a variable: - void varTrans(trans::action act, coenv &e, types::ty *target) { - assert(act == trans::READ); - object->transToType(e, target); - } - types::ty *varGetType(coenv &e) { - return object->getType(e); - } - trans::varEntry *getCallee(coenv &, types::signature *) { -#ifdef DEBUG_GETAPP - cout << "pseudoName" << endl; -#endif - return 0; - } - - // As a type: - types::ty *typeTrans(coenv &, bool tacit = false) { - if (!tacit) { - em.error(getPos()); - em << "expression is not a type"; - } - return types::primError(); - } - - trans::varEntry *getVarEntry(coenv &) { - em.compiler(getPos()); - em << "expression cannot be used as part of a type"; - return 0; - } - - trans::tyEntry *tyEntryTrans(coenv &) { - em.compiler(getPos()); - em << "expression cannot be used as part of a type"; - return 0; - } - - trans::frame *tyFrameTrans(coenv &) { - return 0; - } - - void prettyprint(ostream &out, Int indent); - void print(ostream& out) const { - out << "<exp>"; - } - symbol getName() { - return object->getName(); - } - }; - - // Try to get this into qualifiedName somehow. - types::ty *getObject(coenv &e); - -public: - fieldExp(position pos, exp *object, symbol field) - : nameExp(pos, new qualifiedName(pos, - new pseudoName(object), - field)), - object(object), field(field) {} - - void prettyprint(ostream &out, Int indent); - - symbol getName() - { - return field; - } - - exp *evaluate(coenv &e, types::ty *) { - // Evaluate the object. - return new fieldExp(getPos(), - new tempExp(e, object, getObject(e)), - field); - } -}; - -class arrayExp : public exp { -protected: - exp *set; - - array *getArrayType(coenv &e); - array *transArray(coenv &e); - -public: - arrayExp(position pos, exp *set) - : exp(pos), set(set) {} -}; - - -class subscriptExp : public arrayExp { - exp *index; - -public: - subscriptExp(position pos, exp *set, exp *index) - : arrayExp(pos, set), index(index) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &e); - void transWrite(coenv &e, types::ty *t, exp *value); - - exp *evaluate(coenv &e, types::ty *) { - return new subscriptExp(getPos(), - new tempExp(e, set, getArrayType(e)), - new tempExp(e, index, types::primInt())); - } -}; - -class slice : public absyn { - exp *left; - exp *right; - -public: - slice(position pos, exp *left, exp *right) - : absyn(pos), left(left), right(right) {} - - void prettyprint(ostream &out, Int indent); - - exp *getLeft() { return left; } - exp *getRight() { return right; } - - // Translates code to put the left and right expressions on the stack (in that - // order). If left is omitted, zero is pushed on the stack in it's place. If - // right is omitted, nothing is pushed in its place. - void trans(coenv &e); - - slice *evaluate(coenv &e) { - return new slice(getPos(), - left ? new tempExp(e, left, types::primInt()) : 0, - right ? new tempExp(e, right, types::primInt()) : 0); - } -}; - -class sliceExp : public arrayExp { - slice *index; - -public: - sliceExp(position pos, exp *set, slice *index) - : arrayExp(pos, set), index(index) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &e); - void transWrite(coenv &e, types::ty *t, exp *value); - - exp *evaluate(coenv &e, types::ty *) { - return new sliceExp(getPos(), - new tempExp(e, set, getArrayType(e)), - index->evaluate(e)); - } -}; - - -// The expression "this," that evaluates to the lexically enclosing record. -class thisExp : public exp { -public: - thisExp(position pos) - : exp(pos) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &e); - - exp *evaluate(coenv &, types::ty *) { - // this has no side-effects - return this; - } -}; - -class literalExp : public exp { -public: - literalExp(position pos) - : exp(pos) {} - - bool scalable() { return false; } - - exp *evaluate(coenv &, types::ty *) { - // Literals are constant, they have no side-effects. - return this; - } -}; - -class intExp : public literalExp { - Int value; - -public: - intExp(position pos, Int value) - : literalExp(pos), value(value) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &) { return types::primInt(); } -}; - -class realExp : public literalExp { -protected: - double value; - -public: - realExp(position pos, double value) - : literalExp(pos), value(value) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &) { return types::primReal(); } -}; - - -class stringExp : public literalExp { - string str; - -public: - stringExp(position pos, string str) - : literalExp(pos), str(str) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &) { return types::primString(); } - - const string& getString() { return str; } -}; - -class booleanExp : public literalExp { - bool value; - -public: - booleanExp(position pos, bool value) - : literalExp(pos), value(value) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &) { return types::primBoolean(); } -}; - -class cycleExp : public literalExp { - -public: - cycleExp(position pos) - : literalExp(pos) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &) { return types::primCycleToken(); } -}; - -class newPictureExp : public literalExp { - -public: - newPictureExp(position pos) - : literalExp(pos) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &) { return types::primPicture(); } -}; - -class nullPathExp : public literalExp { - -public: - nullPathExp(position pos) - : literalExp(pos) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &) { return types::primPath(); } -}; - -class nullExp : public literalExp { - -public: - nullExp(position pos) - : literalExp(pos) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &) { return types::primNull(); } -}; - -class quoteExp : public exp { - runnable *value; - -public: - quoteExp(position pos, runnable *value) - : exp(pos), value(value) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &) { return types::primCode(); } -}; - -// A list of expressions used in a function call. -class explist : public absyn { - typedef mem::vector<exp *> expvector; - expvector exps; - -public: - explist(position pos) - : absyn(pos) {} - - virtual ~explist() {} - - virtual void add(exp *e) { - exps.push_back(e); - } - - virtual void prettyprint(ostream &out, Int indent); - - virtual size_t size() { - return exps.size(); - } - - virtual exp * operator[] (size_t index) { - return exps[index]; - } -}; - -struct argument { - exp *val; - symbol name; - - // No constructor due to the union in camp.y -#if 0 - argument(exp *val=0, symbol name=0) - : val(val), name(name) {} -#endif - - void prettyprint(ostream &out, Int indent); -}; - -class arglist : public gc { -public: - typedef mem::vector<argument> argvector; - - argvector args; - argument rest; - - // As the language allows named arguments after rest arguments, store the - // index of the rest argument in order to ensure proper left-to-right - // execution. - static const size_t DUMMY_REST_POSITION = 9999; - size_t restPosition; - - arglist() - : args(), rest(), restPosition(DUMMY_REST_POSITION) {} - - virtual ~arglist() {} - - virtual void addFront(argument a) { - args.insert(args.begin(), a); - } - - virtual void addFront(exp *val, symbol name=symbol::nullsym) { - argument a; a.val=val; a.name=name; - addFront(a); - } - - virtual void add(argument a) { - if (rest.val && !a.name) { - em.error(a.val->getPos()); - em << "unnamed argument after rest argument"; - return; - } - args.push_back(a); - } - - virtual void add(exp *val, symbol name=symbol::nullsym) { - argument a; a.val=val; a.name=name; - add(a); - } - - virtual void addRest(argument a) { - if (rest.val) { - em.error(a.val->getPos()); - em << "additional rest argument"; - return; - } - - rest = a; - - assert(restPosition == DUMMY_REST_POSITION); - restPosition = size(); - } - - virtual void prettyprint(ostream &out, Int indent); - - virtual size_t size() { - return args.size(); - } - - virtual argument& operator[] (size_t index) { - return args[index]; - } - - virtual argument& getRest() { - return rest; - } -}; - -// callExp has a global cache of resolved overloaded functions. This clears -// this cache so the associated data can be garbage collected. -void clearCachedCalls(); - -class callExp : public exp { -protected: - exp *callee; - arglist *args; - -private: - // Per object caching - Cache the application when it's determined. - application *cachedApp; - - // In special cases, no application object is needed and we can store the - // varEntry used in advance. - trans::varEntry *cachedVarEntry; - - types::signature *argTypes(coenv& e, bool *searchable); - void reportArgErrors(coenv &e); - application *resolve(coenv &e, - types::overloaded *o, - types::signature *source, - bool tacit); - application *resolveWithCache(coenv &e, - types::overloaded *o, - types::signature *source, - bool tacit); - void reportMismatch(types::function *ft, - types::signature *source); - - void reportNonFunction(); - - // Caches either the application object used to apply the function to the - // arguments, or in cases where the arguments match the function perfectly, - // the varEntry of the callee (or neither in case of an error). Returns - // what getType should return. - types::ty *cacheAppOrVarEntry(coenv &e, bool tacit); - - types::ty *transPerfectMatch(coenv &e); -public: - callExp(position pos, exp *callee, arglist *args) - : exp(pos), callee(callee), args(args), - cachedApp(0), cachedVarEntry(0) { assert(args); } - - callExp(position pos, exp *callee) - : exp(pos), callee(callee), args(new arglist()), - cachedApp(0), cachedVarEntry(0) {} - - callExp(position pos, exp *callee, exp *arg1) - : exp(pos), callee(callee), args(new arglist()), - cachedApp(0), cachedVarEntry(0) { - args->add(arg1); - } - - callExp(position pos, exp *callee, exp *arg1, exp *arg2) - : exp(pos), callee(callee), args(new arglist()), - cachedApp(0), cachedVarEntry(0) { - args->add(arg1); - args->add(arg2); - } - - callExp(position pos, exp *callee, exp *arg1, exp *arg2, exp *arg3) - : exp(pos), callee(callee), args(new arglist()), - cachedApp(0), cachedVarEntry(0) { - args->add(arg1); - args->add(arg2); - args->add(arg3); - } - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &e); - - // Returns true if the function call resolves uniquely without error. Used - // in implementing the special == and != operators for functions. - virtual bool resolved(coenv &e); -}; - - -class pairExp : public exp { - exp *x; - exp *y; - -public: - pairExp(position pos, exp *x, exp *y) - : exp(pos), x(x), y(y) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &) { return types::primPair(); } -}; - -class tripleExp : public exp { - exp *x; - exp *y; - exp *z; - -public: - tripleExp(position pos, exp *x, exp *y, exp *z) - : exp(pos), x(x), y(y), z(z) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &) { return types::primTriple(); } -}; - -class transformExp : public exp { - exp *x; - exp *y; - exp *xx,*xy,*yx,*yy; - -public: - transformExp(position pos, exp *x, exp *y, exp *xx, exp *xy, exp *yx, - exp *yy) - : exp(pos), x(x), y(y), xx(xx), xy(xy), yx(yx), yy(yy) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &) { return types::primTransform(); } -}; - -class castExp : public exp { - ty *target; - exp *castee; - - types::ty *tryCast(coenv &e, types::ty *t, types::ty *s, - symbol csym); -public: - castExp(position pos, ty *target, exp *castee) - : exp(pos), target(target), castee(castee) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &e); -}; - -class nullaryExp : public callExp { -public: - nullaryExp(position pos, symbol op) - : callExp(pos, new nameExp(pos, op)) {} -}; - -class unaryExp : public callExp { -public: - unaryExp(position pos, exp *base, symbol op) - : callExp(pos, new nameExp(pos, op), base) {} -}; - -class binaryExp : public callExp { -public: - binaryExp(position pos, exp *left, symbol op, exp *right) - : callExp(pos, new nameExp(pos, op), left, right) {} -}; - -class equalityExp : public callExp { -public: - equalityExp(position pos, exp *left, symbol op, exp *right) - : callExp(pos, new nameExp(pos, op), left, right) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &e); -}; - - -// Scaling expressions such as 3sin(x). -class scaleExp : public binaryExp { - exp *getLeft() { - return (*this->args)[0].val; - } - exp *getRight() { - return (*this->args)[1].val; - } -public: - scaleExp(position pos, exp *left, exp *right) - : binaryExp(pos, left, symbol::trans("*"), right) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - //types::ty *getType(coenv &e); - - bool scalable() { return false; } -}; - -// Used for tension, which takes two real values, and a boolean to denote if it -// is a tension atleast case. -class ternaryExp : public callExp { -public: - ternaryExp(position pos, exp *left, symbol op, exp *right, exp *last) - : callExp(pos, new nameExp(pos, op), left, right, last) {} -}; - -// The a ? b : c ternary operator. -class conditionalExp : public exp { - exp *test; - exp *onTrue; - exp *onFalse; - -public: - conditionalExp(position pos, exp *test, exp *onTrue, exp *onFalse) - : exp(pos), test(test), onTrue(onTrue), onFalse(onFalse) {} - - void prettyprint(ostream &out, Int indent); - - void baseTransToType(coenv &e, types::ty *target); - - void transToType(coenv &e, types::ty *target); - types::ty *trans(coenv &e); - types::ty *getType(coenv &e); - -}; - -class andOrExp : public exp { -protected: - exp *left; - symbol op; - exp *right; - -public: - andOrExp(position pos, exp *left, symbol op, exp *right) - : exp(pos), left(left), op(op), right(right) {} - - virtual types::ty *trans(coenv &e) = 0; - virtual types::ty *getType(coenv &) { - return types::primBoolean(); - } -}; - -class orExp : public andOrExp { -public: - orExp(position pos, exp *left, symbol op, exp *right) - : andOrExp(pos, left, op, right) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - void transConditionalJump(coenv &e, bool cond, label dest); -}; - -class andExp : public andOrExp { -public: - andExp(position pos, exp *left, symbol op, exp *right) - : andOrExp(pos, left, op, right) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - void transConditionalJump(coenv &e, bool cond, label dest); -}; - -class joinExp : public callExp { -public: - joinExp(position pos, symbol op) - : callExp(pos, new nameExp(pos, op)) {} - - void pushFront(exp *e) { - args->addFront(e); - } - void pushBack(exp *e) { - args->add(e); - } - - void prettyprint(ostream &out, Int indent); -}; - -class specExp : public exp { - symbol op; - exp *arg; - camp::side s; - -public: - specExp(position pos, symbol op, exp *arg, camp::side s=camp::OUT) - : exp(pos), op(op), arg(arg), s(s) {} - - void setSide(camp::side ss) { - s=ss; - } - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &e); -}; - -class assignExp : public exp { -protected: - exp *dest; - exp *value; - - // This is basically a hook to facilitate selfExp. dest is given as an - // argument since it will be a temporary in translation in order to avoid - // multiple evaluation. - virtual exp *ultimateValue(exp *) { - return value; - } - -public: - assignExp(position pos, exp *dest, exp *value) - : exp(pos), dest(dest), value(value) {} - - void prettyprint(ostream &out, Int indent); - - // Don't write the result of an assignment to the prompt. - bool writtenToPrompt() { return false; } - - void transAsType(coenv &e, types::ty *target); - types::ty *trans(coenv &e); - types::ty *getType(coenv &e); -}; - -class selfExp : public assignExp { - symbol op; - - exp *ultimateValue(exp *dest) { - return new binaryExp(getPos(), dest, op, value); - } - -public: - selfExp(position pos, exp *dest, symbol op, exp *value) - : assignExp(pos, dest, value), op(op) {} - - void prettyprint(ostream &out, Int indent); - - void transAsType(coenv &e, types::ty *target); -}; - -class prefixExp : public exp { - exp *dest; - symbol op; - -public: - prefixExp(position pos, exp *dest, symbol op) - : exp(pos), dest(dest), op(op) {} - - void prettyprint(ostream &out, Int indent); - - bool scalable() { return false; } - - // Don't write the result to the prompt. - bool writtenToPrompt() { return false; } - - types::ty *trans(coenv &e); - types::ty *getType(coenv &e); -}; - -// Postfix expresions are illegal. This is caught here as we can give a -// more meaningful error message to the user, rather than a "parse -// error." -class postfixExp : public exp { - exp *dest; - symbol op; - -public: - postfixExp(position pos, exp *dest, symbol op) - : exp(pos), dest(dest), op(op) {} - - void prettyprint(ostream &out, Int indent); - - types::ty *trans(coenv &e); - types::ty *getType(coenv &) { return types::primError(); } -}; - -} // namespace absyntax - -#endif |