diff options
Diffstat (limited to 'Build/source/utils/asymptote/runtime.in')
-rw-r--r-- | Build/source/utils/asymptote/runtime.in | 1213 |
1 files changed, 1213 insertions, 0 deletions
diff --git a/Build/source/utils/asymptote/runtime.in b/Build/source/utils/asymptote/runtime.in new file mode 100644 index 00000000000..27cde400748 --- /dev/null +++ b/Build/source/utils/asymptote/runtime.in @@ -0,0 +1,1213 @@ +/***** + * runtime.in + * Tom Prince 2005/4/15 + * + * Generate the runtime functions used by the vm::stack machine. + * + *****/ + +/* Autogenerated routines are specified like this (separated by a formfeed): + type asyname:cname(cparams) + { + C code + } + +*/ + +// Use Void f() instead of void f() to force an explicit Stack argument. + + +pen => primPen() +pair => primPair() +triple => primTriple() +path => primPath() +path3 => primPath3() +guide* => primGuide() +cycleToken => primCycleToken() +tensionSpecifier => primTensionSpecifier() +curlSpecifier => primCurlSpecifier() +file* => primFile() +picture* => primPicture() +transform => primTransform() +callable* => voidFunction() +runnable* => primCode() +boolarray* => booleanArray() +Intarray* => IntArray() +Intarray2* => IntArray2() +realarray* => realArray() +realarray2* => realArray2() +pairarray* => pairArray() +pairarray2* => pairArray2() +triplearray* => tripleArray() +triplearray2* => tripleArray2() +patharray* => pathArray() +patharray2* => pathArray2() +guidearray* => guideArray() +transformarray* => transformArray() +penarray* => penArray() +penarray2* => penArray2() +stringarray* => stringArray() +stringarray2* => stringArray2() + +#include <cfloat> +#include <iostream> +#include <fstream> +#include <time.h> +#include <sys/times.h> +#include <locale.h> + +#include "angle.h" +#include "pair.h" +#include "triple.h" +#include "transform.h" +#include "path.h" +#include "path3.h" +#include "pen.h" +#include "drawpath.h" +#include "guide.h" +#include "picture.h" +#include "fileio.h" +#include "genv.h" +#include "builtin.h" +#include "texfile.h" +#include "pipestream.h" +#include "parser.h" +#include "stack.h" +#include "util.h" +#include "locate.h" +#include "mathop.h" +#include "callable.h" +#include "stm.h" +#include "lexical.h" +#include "process.h" +#include "arrayop.h" +#include "seconds.h" + +#if defined(USEGC) && defined(GC_DEBUG) && defined(GC_BACKTRACE) + extern "C" { + void *GC_generate_random_valid_address(void); + void GC_debug_print_heap_obj_proc(void *); + } +#endif + +using namespace vm; +using namespace camp; +using namespace settings; +using namespace utils; + +#undef OUT +#undef IN + +namespace run { +using camp::pair; +using vm::array; +using vm::frame; +using vm::stack; +using camp::transform; +using absyntax::runnable; + +typedef array boolarray; +typedef array Intarray; +typedef array Intarray2; +typedef array realarray; +typedef array realarray2; +typedef array pairarray; +typedef array pairarray2; +typedef array triplearray; +typedef array triplearray2; +typedef array patharray; +typedef array patharray2; +typedef array guidearray; +typedef array transformarray; +typedef array penarray; +typedef array penarray2; +typedef array stringarray; +typedef array stringarray2; +} + +using vm::array; +using types::function; + +#define PRIMITIVE(name,Name,asyName) using types::prim##Name; +#include <primitives.h> +#undef PRIMITIVE + +using types::booleanArray; +using types::IntArray; +using types::IntArray2; +using types::realArray; +using types::realArray2; +using types::pairArray; +using types::pairArray2; +using types::tripleArray; +using types::tripleArray2; +using types::pathArray; +using types::pathArray2; +using types::guideArray; +using types::transformArray; +using types::penArray; +using types::penArray2; +using types::stringArray; +using types::stringArray2; +using types::formal; + +function *realRealFunction() +{ + return new function(primReal(),primReal()); +} + +function *realTripleFunction() +{ + return new function(primReal(),primTriple()); +} + +const size_t camp::ColorComponents[]={0,0,1,3,4,0}; + +namespace vm { +#if COMPACT +const Int DefaultValue=0x7fffffffffffffffLL; +const Int Undefined=0x7ffffffffffffffeLL; + +const Int BoolTruthValue=0xABABABABABABABACLL; +const Int BoolFalseValue=0xABABABABABABABABLL; + +const item Default=DefaultValue; +#else +const item Default=item(default_t()); +#endif +} + +namespace run { + +const char *arrayempty="cannot take min or max of empty array"; +const char *noruntime="no runtime environment for embedded eval"; + +void writestring(stack *s) +{ + callable *suffix=pop<callable *>(s,NULL); + string S=pop<string>(s); + vm::item it=pop(s); + bool defaultfile=isdefault(it); + camp::ofile *f=defaultfile ? &camp::Stdout : vm::get<camp::ofile*>(it); + if(!f->isOpen() || !f->enabled()) return; + if(S != "") f->write(S); + if(f->text()) { + if(suffix) { + s->push(f); + suffix->call(s); + } else if(defaultfile) f->writeline(); + } +} + +string toplocation() { + ostringstream buf; + position& topPos=processData().topPos; + buf << topPos.Line() << "." << topPos.Column(); + return buf.str(); +} + +string emptystring; +pair zero; + +} + +static string defaulttransparency=string("Compatible"); + +void unused(void *) +{ +} + +// Autogenerated routines: + + + +// Initializers + +Int :IntZero() +{ + return 0; +} + +real :realZero() +{ + return 0.0; +} + +bool :boolFalse() +{ + return false; +} + +bool isnan(real x) +{ + return std::isnan(x); +} + +array* :pushNullArray() +{ + return 0; +} + +frame* :pushNullRecord() +{ + return 0; +} + +item :pushNullFunction() +{ + return nullfunc::instance(); +} + + +// Default operations + +// Put the default value token on the stack (in place of an argument when +// making a function call). +item :pushDefault() +{ + return Default; +} + + +// Test if the value on the stack is the default value token. +bool :isDefault(item i) +{ + return isdefault(i); +} + + +// Casts + +guide* :pairToGuide(pair z) +{ + return new pairguide(z); +} + +guide* :pathToGuide(path p) +{ + return new pathguide(p); +} + +path :guideToPath(guide *g) +{ + return g->solve(); +} + + +// Pen operations + +pen :newPen() +{ + return pen(); +} + +bool ==(pen a, pen b) +{ + return a == b; +} + +bool !=(pen a, pen b) +{ + return a != b; +} + +pen +(pen a, pen b) +{ + return a+b; +} + +pen Operator *(real a, pen b) +{ + return a*b; +} + +pen Operator *(pen a, real b) +{ + return b*a; +} + +pair max(pen p) +{ + return p.bounds().Max(); +} + +pair min(pen p) +{ + return p.bounds().Min(); +} + +// Reset the meaning of pen default attributes. +void resetdefaultpen() +{ + processData().defaultpen=camp::pen::initialpen(); +} + +void defaultpen(pen p) +{ + processData().defaultpen=pen(resolvepen,p); +} + +pen defaultpen() +{ + return processData().defaultpen; +} + +bool invisible(pen p) +{ + return p.invisible(); +} + +pen invisible() +{ + return pen(invisiblepen); +} + +pen gray(pen p) +{ + p.togrey(); + return p; +} + +pen rgb(pen p) +{ + p.torgb(); + return p; +} + +pen cmyk(pen p) +{ + p.tocmyk(); + return p; +} + +pen interp(pen a, pen b, real t) +{ + return interpolate(a,b,t); +} + +pen rgb(real r, real g, real b) +{ + return pen(r,g,b); +} + +pen cmyk(real c, real m, real y, real k) +{ + return pen(c,m,y,k); +} + +pen gray(real gray) +{ + return pen(gray); +} + +realarray *colors(pen p) +{ + size_t n=ColorComponents[p.colorspace()]; + array *a=new array(n); + + switch(n) { + case 0: + break; + case 1: + (*a)[0]=p.gray(); + break; + case 3: + (*a)[0]=p.red(); + (*a)[1]=p.green(); + (*a)[2]=p.blue(); + break; + case 4: + (*a)[0]=p.cyan(); + (*a)[1]=p.magenta(); + (*a)[2]=p.yellow(); + (*a)[3]=p.black(); + break; + default: + break; + } + return a; +} + +string hex(pen p) +{ + return p.hex(); +} + +Int byte(real x) +{ + return camp::byte(x); +} + +string colorspace(pen p) +{ + string s=ColorDeviceSuffix[p.colorspace()]; + std::transform(s.begin(),s.end(),s.begin(),tolower); + return s; +} + +pen pattern(string *s) +{ + return pen(setpattern,*s); +} + +string pattern(pen p) +{ + return p.fillpattern(); +} + +pen fillrule(Int n) +{ + return pen(n >= 0 && n < nFill ? (FillRule) n : DEFFILL); +} + +Int fillrule(pen p) +{ + return p.Fillrule(); +} + +pen opacity(real opacity=1.0, string blend=defaulttransparency) +{ + for(Int i=0; i < nBlendMode; ++i) + if(blend == BlendMode[i]) return pen(Transparency(blend,opacity)); + + ostringstream buf; + buf << "Unknown blend mode: " << "'" << blend << "'"; + error(buf); +} + +real opacity(pen p) +{ + return p.opacity(); +} + +string blend(pen p) +{ + return p.blend(); +} + +pen linetype(realarray *pattern, real offset=0, bool scale=true, + bool adjust=true) +{ + size_t size=checkArray(pattern); + array *a=new array(size); + for(size_t i=0; i < size; ++i) + (*a)[i]=::max(vm::read<double>(pattern,i),0.0); + + return pen(LineType(*a,offset,scale,adjust)); +} + +realarray *linetype(pen p=CURRENTPEN) +{ + array a=p.linetype()->pattern; + return copyArray(&a); +} + +real offset(pen p) +{ + return p.linetype()->offset; +} + +bool scale(pen p) +{ + return p.linetype()->scale; +} + +bool adjust(pen p) +{ + return p.linetype()->adjust; +} + +pen adjust(pen p, real arclength, bool cyclic) +{ + return adjustdash(p,arclength,cyclic); +} + +pen linecap(Int n) +{ + return pen(setlinecap,n >= 0 && n < nCap ? n : DEFCAP); +} + +Int linecap(pen p=CURRENTPEN) +{ + return p.cap(); +} + +pen linejoin(Int n) +{ + return pen(setlinejoin,n >= 0 && n < nJoin ? n : DEFJOIN); +} + +Int linejoin(pen p=CURRENTPEN) +{ + return p.join(); +} + +pen miterlimit(real x) +{ + return pen(setmiterlimit,x >= 1.0 ? x : DEFJOIN); +} + +real miterlimit(pen p=CURRENTPEN) +{ + return p.miter(); +} + +pen linewidth(real x) +{ + return pen(setlinewidth,x >= 0.0 ? x : DEFWIDTH); +} + +real linewidth(pen p=CURRENTPEN) +{ + return p.width(); +} + +pen fontcommand(string *s) +{ + return pen(setfont,*s); +} + +string font(pen p=CURRENTPEN) +{ + return p.Font(); +} + +pen fontsize(real size, real lineskip) +{ + return pen(setfontsize,size > 0.0 ? size : 0.0, + lineskip > 0.0 ? lineskip : 0.0); +} + +real fontsize(pen p=CURRENTPEN) +{ + return p.size(); +} + +real lineskip(pen p=CURRENTPEN) +{ + return p.Lineskip(); +} + +pen overwrite(Int n) +{ + return pen(setoverwrite,n >= 0 && n < nOverwrite ? (overwrite_t) n : + DEFWRITE); +} + +Int overwrite(pen p=CURRENTPEN) +{ + return p.Overwrite(); +} + +pen basealign(Int n) +{ + return pen(n >= 0 && n < nBaseLine ? (BaseLine) n : DEFBASE); +} + +Int basealign(pen p=CURRENTPEN) +{ + return p.Baseline(); +} + +transform transform(pen p) +{ + return p.getTransform(); +} + +path nib(pen p) +{ + return p.Path(); +} + +pen makepen(path p) +{ + return pen(p); +} + +pen colorless(pen p) +{ + p.colorless(); + return p; +} + +// Interactive mode + +bool interactive() +{ + return interact::interactive; +} + +bool uptodate() +{ + return interact::uptodate; +} + + +// System commands + +Int system(stringarray *s) +{ + if(safe) error("system() call disabled; override with option -nosafe"); + size_t size=checkArray(s); + if(size == 0) return 0; + mem::vector<string> cmd; + for(size_t i=0; i < size; ++i) + cmd.push_back(read<string>(s,i)); + return System(cmd); +} + +bool view() +{ + return view(); +} + +string asydir() +{ + return systemDir; +} + +string locale(string s=emptystring) +{ + char *L=setlocale(LC_ALL,s.empty() ? NULL : s.c_str()); + return L != NULL ? string(L) : ""; +} + +void abort(string s=emptystring) +{ + if(s.empty()) throw handled_error(); + error(s.c_str()); +} + +void exit() +{ + throw quit(); +} + +void assert(bool b, string s=emptystring) +{ + flush(cout); + if(!b) { + ostringstream buf; + buf << "assert FAILED"; + if(s != "") buf << ": " << s; + error(buf); + } +} + +void sleep(Int seconds) +{ + if(seconds <= 0) return; + sleep(seconds); +} + +void usleep(Int microseconds) +{ + if(microseconds <= 0) return; + usleep((unsigned long) microseconds); +} + +void _eval(string *s, bool embedded, bool interactiveWrite=false) +{ + if(embedded) { + trans::coenv *e=Stack->getEnvironment(); + vm::interactiveStack *is=dynamic_cast<vm::interactiveStack *>(Stack); + if(e && is) + runStringEmbedded(*s, *e, *is); + else + error(noruntime); + } else + runString(*s,interactiveWrite); +} + +void _eval(runnable *s, bool embedded) +{ + absyntax::block *ast=new absyntax::block(s->getPos(), false); + ast->add(s); + + if(embedded) { + trans::coenv *e=Stack->getEnvironment(); + vm::interactiveStack *is=dynamic_cast<vm::interactiveStack *>(Stack); + if(e && is) + runCodeEmbedded(ast, *e, *is); + else + error(noruntime); + } else + runCode(ast); +} + +string xasyKEY() { + processDataStruct *P=&processData(); + xkey_t *xkey=&P->xkey; + xkey_t::iterator p=xkey->find(P->topPos.LineColumn()); + return p != xkey->end() ? p->second+" 1" : toplocation()+" 0"; +} + +void xasyKEY(string *s) { + processData().KEY=*s; +} + +string toplocation() { + return toplocation(); +} + +string location() { + ostringstream buf; + buf << getPos(); + return buf.str(); +} + +// Wrapper for the stack::load() method. +void :loadModule(string *index) +{ + Stack->load(*index); +} + +string cd(string s=emptystring) +{ + if(!globalread()) readDisabled(); + if(!s.empty() && !globalwrite()) { + string outname=settings::outname(); + string dir=stripFile(outname); + if(dir.empty()) Setting("outname")=getPath()+dirsep+outname; + } + return setPath(s.c_str()); +} + +void list(string *s, bool imports=false) +{ + if(*s == "-") return; + trans::genv ge; + symbol name=symbol::trans(*s); + record *r=ge.getModule(name,*s); + r->e.list(imports ? 0 : r); +} + + +// Guide operations + +guide* :nullGuide() +{ + return new pathguide(path()); +} + +guide* :dotsGuide(guidearray *a) +{ + guidevector v; + size_t size=checkArray(a); + for (size_t i=0; i < size; ++i) + v.push_back(a->read<guide*>(i)); + + return new multiguide(v); +} + +guide* :dashesGuide(guidearray *a) +{ + static camp::curlSpec curly; + static camp::specguide curlout(&curly, camp::OUT); + static camp::specguide curlin(&curly, camp::IN); + + size_t n=checkArray(a); + + // a--b is equivalent to a{curl 1}..{curl 1}b + guidevector v; + if (n > 0) + v.push_back(a->read<guide*>(0)); + + if (n==1) { + v.push_back(&curlout); + v.push_back(&curlin); + } + else + for (size_t i=1; i<n; ++i) { + v.push_back(&curlout); + v.push_back(&curlin); + v.push_back(a->read<guide*>(i)); + } + + return new multiguide(v); +} + +cycleToken :newCycleToken() +{ + return cycleToken(); +} + +guide *operator cast(cycleToken tok) +{ +// Avoid unused variable warning messages. + unused(&tok); + return new cycletokguide(); +} + +guide* operator spec(pair z, Int p) +{ + camp::side d=(camp::side) p; + camp::dirSpec *sp=new camp::dirSpec(z); + + return new specguide(sp,d); +} + +curlSpecifier operator curl(real gamma, Int p) +{ + camp::side s=(camp::side) p; + return curlSpecifier(gamma,s); +} + +real :curlSpecifierValuePart(curlSpecifier spec) +{ + return spec.getValue(); +} + +Int :curlSpecifierSidePart(curlSpecifier spec) +{ + return spec.getSide(); +} + +guide *operator cast(curlSpecifier spec) +{ + return new specguide(spec); +} + +tensionSpecifier operator tension(real tout, real tin, bool atleast) +{ + return tensionSpecifier(tout, tin, atleast); +} + +real :tensionSpecifierOutPart(tensionSpecifier t) +{ + return t.getOut(); +} + +real :tensionSpecifierInPart(tensionSpecifier t) +{ + return t.getIn(); +} + +bool :tensionSpecifierAtleastPart(tensionSpecifier t) +{ + return t.getAtleast(); +} + +guide *operator cast(tensionSpecifier t) +{ + return new tensionguide(t); +} + +guide* operator controls(pair zout, pair zin) +{ + return new controlguide(zout, zin); +} + +Int size(guide *g) +{ + flatguide f; + g->flatten(f,false); + return f.size(); +} + +Int length(guide *g) +{ + flatguide f; + g->flatten(f,false); + return g->cyclic() ? f.size() : f.size()-1; +} + +bool cyclic(guide *g) +{ + flatguide f; + g->flatten(f,false); + return g->cyclic(); +} + +pair point(guide *g, Int t) +{ + flatguide f; + g->flatten(f,false); + return f.Nodes(adjustedIndex(t,f.size(),g->cyclic())).z; +} + +pairarray *dirSpecifier(guide *g, Int t) +{ + flatguide f; + g->flatten(f,false); + Int n=f.size(); + if(!g->cyclic() && (t < 0 || t >= n-1)) return new array(0); + array *c=new array(2); + (*c)[0]=f.Nodes(t).out->dir(); + (*c)[1]=f.Nodes(t+1).in->dir(); + return c; +} + +pairarray *controlSpecifier(guide *g, Int t) +{ + flatguide f; + g->flatten(f,false); + Int n=f.size(); + if(!g->cyclic() && (t < 0 || t >= n-1)) return new array(0); + knot curr=f.Nodes(t); + knot next=f.Nodes(t+1); + if(curr.out->controlled()) { + assert(next.in->controlled()); + array *c=new array(2); + (*c)[0]=curr.out->control(); + (*c)[1]=next.in->control(); + return c; + } else return new array(0); +} + +tensionSpecifier tensionSpecifier(guide *g, Int t) +{ + flatguide f; + g->flatten(f,false); + Int n=f.size(); + if(!g->cyclic() && (t < 0 || t >= n-1)) return tensionSpecifier(1.0,1.0,false); + knot curr=f.Nodes(t); + return tensionSpecifier(curr.tout.val,f.Nodes(t+1).tin.val,curr.tout.atleast); +} + +realarray *curlSpecifier(guide *g, Int t) +{ + flatguide f; + g->flatten(f,false); + Int n=f.size(); + if(!g->cyclic() && (t < 0 || t >= n-1)) return new array(0); + array *c=new array(2); + real c0=f.Nodes(t).out->curl(); + real c1=f.Nodes(t+1).in->curl(); + (*c)[0]=c0 >= 0.0 ? c0 : 1.0; + (*c)[1]=c1 >= 0.0 ? c1 : 1.0; + return c; +} + +guide *reverse(guide *g) +{ + flatguide f; + g->flatten(f,false); + if(f.precyclic()) + return new pathguide(g->solve().reverse()); + + size_t n=f.size(); + bool cyclic=g->cyclic(); + guidevector v; + size_t start=cyclic ? n : n-1; + knot curr=f.Nodes(start); + knot next=curr; + for(size_t i=start; i > 0; --i) { + next=f.Nodes(i-1); + v.push_back(new pairguide(curr.z)); + if(next.out->controlled()) { + assert(curr.in->controlled()); + v.push_back(new controlguide(curr.in->control(),next.out->control())); + } else { + pair d=curr.in->dir(); + if(d != zero) + v.push_back(new specguide(new dirSpec(-d),camp::OUT)); + else { + real C=curr.in->curl(); + if(C >= 0.0) + v.push_back(new specguide(new curlSpec(C),camp::OUT)); + } + real tout=curr.tin.val; + real tin=next.tout.val; + bool atleast=next.tout.atleast; + if(tout != 1.0 || tin != 1.0 || next.tout.atleast) + v.push_back(new tensionguide(tensionSpecifier(tout,tin,atleast))); + d=next.out->dir(); + if(d != zero) + v.push_back(new specguide(new dirSpec(-d),camp::IN)); + else { + real C=next.out->curl(); + if(C >= 0.0) + v.push_back(new specguide(new curlSpec(C),camp::IN)); + } + } + curr=next; + } + if(cyclic) + v.push_back(new cycletokguide()); + else + v.push_back(new pairguide(next.z)); + + return new multiguide(v); +} + + +realarray *_cputime() +{ + static const real ticktime=1.0/sysconf(_SC_CLK_TCK); + struct tms buf; + + ::times(&buf); + array *t=new array(5); + (*t)[0]=((real) buf.tms_utime)*ticktime; + (*t)[1]=((real) buf.tms_stime)*ticktime; + (*t)[2]=((real) buf.tms_cutime)*ticktime; + (*t)[3]=((real) buf.tms_cstime)*ticktime; + (*t)[4]=utils::totalseconds(); + return t; +} + + +// Transforms + +bool ==(transform a, transform b) +{ + return a == b; +} + +bool !=(transform a, transform b) +{ + return a != b; +} + +transform +(transform a, transform b) +{ + return a+b; +} + +transform Operator *(transform a, transform b) +{ + return a*b; +} + +pair Operator *(transform t, pair z) +{ + return t*z; +} + +path Operator *(transform t, path g) +{ + return transformed(t,g); +} + +pen Operator *(transform t, pen p) +{ + return transformed(t,p); +} + +picture * Operator *(transform t, picture *f) +{ + return transformed(t,f); +} + +picture * Operator *(realarray2 *t, picture *f) +{ + return transformed(*t,f); +} + +transform ^(transform t, Int n) +{ + transform T; + if(n < 0) { + n=-n; + t=inverse(t); + } + for(Int i=0; i < n; i++) T=T*t; + return T; +} + +real :transformXPart(transform t) +{ + return t.getx(); +} + +real :transformYPart(transform t) +{ + return t.gety(); +} + +real :transformXXPart(transform t) +{ + return t.getxx(); +} + +real :transformXYPart(transform t) +{ + return t.getxy(); +} + +real :transformYXPart(transform t) +{ + return t.getyx(); +} + +real :transformYYPart(transform t) +{ + return t.getyy(); +} + +transform :real6ToTransform(real x, real y, real xx, real xy, + real yx, real yy) +{ + return transform(x,y,xx,xy,yx,yy); +} + +transform shift(transform t) +{ + return transform(t.getx(),t.gety(),0,0,0,0); +} + +transform shiftless(transform t) +{ + return transform(0,0,t.getxx(),t.getxy(),t.getyx(),t.getyy()); +} + +transform identity:transformIdentity() +{ + return identity; +} + +transform inverse(transform t) +{ + return inverse(t); +} + +transform shift(pair z) +{ + return shift(z); +} + +transform shift(real x, real y) +{ + return shift(pair(x,y)); +} + +transform xscale(real x) +{ + return xscale(x); +} + +transform yscale(real y) +{ + return yscale(y); +} + +transform scale(real x) +{ + return scale(x); +} + +transform scale(real x, real y) +{ + return scale(x,y); +} + +transform slant(real s) +{ + return slant(s); +} + +transform rotate(real angle, pair z=0) +{ + return rotatearound(z,radians(angle)); +} + +transform reflect(pair a, pair b) +{ + return reflectabout(a,b); +} + +bool isometry(transform t) +{ + return t.isIsometry(); +} |