diff options
author | Norbert Preining <norbert@preining.info> | 2019-09-02 13:46:59 +0900 |
---|---|---|
committer | Norbert Preining <norbert@preining.info> | 2019-09-02 13:46:59 +0900 |
commit | e0c6872cf40896c7be36b11dcc744620f10adf1d (patch) | |
tree | 60335e10d2f4354b0674ec22d7b53f0f8abee672 /graphics/asymptote/runtime.cc |
Initial commit
Diffstat (limited to 'graphics/asymptote/runtime.cc')
-rw-r--r-- | graphics/asymptote/runtime.cc | 2120 |
1 files changed, 2120 insertions, 0 deletions
diff --git a/graphics/asymptote/runtime.cc b/graphics/asymptote/runtime.cc new file mode 100644 index 0000000000..e2a6cdbdfe --- /dev/null +++ b/graphics/asymptote/runtime.cc @@ -0,0 +1,2120 @@ +/***** Autogenerated from runtime.in; changes will be overwritten *****/ + +#line 1 "runtimebase.in" +/***** + * runtimebase.in + * Andy Hammerlindl 2009/07/28 + * + * Common declarations needed for all code-generating .in files. + * + *****/ + + +#line 1 "runtime.in" +/***** + * 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. + + +#line 1 "runtimebase.in" +#include "stack.h" +#include "types.h" +#include "builtin.h" +#include "entry.h" +#include "errormsg.h" +#include "array.h" +#include "triple.h" +#include "callable.h" +#include "opsymbols.h" + +using vm::stack; +using vm::error; +using vm::array; +using vm::read; +using vm::callable; +using types::formal; +using types::function; +using camp::triple; + +#define PRIMITIVE(name,Name,asyName) using types::prim##Name; +#include <primitives.h> +#undef PRIMITIVE + +typedef double real; + +void unused(void *); + +namespace run { +array *copyArray(array *a); +array *copyArray2(array *a); +array *copyArray3(array *a); + +double *copyTripleArray2Components(array *a, size_t &N, + GCPlacement placement=NoGC); +triple *copyTripleArray2C(array *a, size_t &N, + GCPlacement placement=NoGC); +} + +function *realRealFunction(); + +#define CURRENTPEN processData().currentpen + +#line 55 "runtime.in" +#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" + +#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; + +#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; + +typedef callable callableBp; +typedef callable callableReal; +typedef callable callableTransform; +} + +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: + + + +#ifndef NOSYM +#include "runtime.symbols.h" + +#endif +namespace run { + +// Initializers +#line 230 "runtime.in" +void IntZero(stack *Stack) +{ +#line 231 "runtime.in" + {Stack->push<Int>(0); return;} +} + +#line 236 "runtime.in" +void realZero(stack *Stack) +{ +#line 237 "runtime.in" + {Stack->push<real>(0.0); return;} +} + +#line 241 "runtime.in" +void boolFalse(stack *Stack) +{ +#line 242 "runtime.in" + {Stack->push<bool>(false); return;} +} + +#line 246 "runtime.in" +// bool isnan(real x); +void gen_runtime3(stack *Stack) +{ + real x=vm::pop<real>(Stack); +#line 247 "runtime.in" + {Stack->push<bool>(std::isnan(x)); return;} +} + +#line 251 "runtime.in" +void pushNullArray(stack *Stack) +{ +#line 252 "runtime.in" + {Stack->push<array*>(0); return;} +} + +#line 256 "runtime.in" +void pushNullRecord(stack *Stack) +{ +#line 257 "runtime.in" + {Stack->push<frame*>(0); return;} +} + +#line 261 "runtime.in" +void pushNullFunction(stack *Stack) +{ +#line 262 "runtime.in" + {Stack->push(nullfunc::instance()); return;} +} + + +// Default operations + +// Put the default value token on the stack (in place of an argument when +// making a function call). +#line 271 "runtime.in" +void pushDefault(stack *Stack) +{ +#line 272 "runtime.in" + {Stack->push(Default); return;} +} + + +// Test if the value on the stack is the default value token. +#line 278 "runtime.in" +void isDefault(stack *Stack) +{ + item i=vm::pop(Stack); +#line 279 "runtime.in" + {Stack->push<bool>(isdefault(i)); return;} +} + + +// Casts +#line 285 "runtime.in" +void pairToGuide(stack *Stack) +{ + pair z=vm::pop<pair>(Stack); +#line 286 "runtime.in" + {Stack->push<guide*>(new pairguide(z)); return;} +} + +#line 291 "runtime.in" +void pathToGuide(stack *Stack) +{ + path p=vm::pop<path>(Stack); +#line 292 "runtime.in" + {Stack->push<guide*>(new pathguide(p)); return;} +} + +#line 296 "runtime.in" +void guideToPath(stack *Stack) +{ + guide * g=vm::pop<guide *>(Stack); +#line 297 "runtime.in" + {Stack->push<path>(g->solve()); return;} +} + + +// Pen operations +#line 303 "runtime.in" +void newPen(stack *Stack) +{ +#line 304 "runtime.in" + {Stack->push<pen>(pen()); return;} +} + +#line 309 "runtime.in" +// bool ==(pen a, pen b); +void gen_runtime13(stack *Stack) +{ + pen b=vm::pop<pen>(Stack); + pen a=vm::pop<pen>(Stack); +#line 310 "runtime.in" + {Stack->push<bool>(a == b); return;} +} + +#line 314 "runtime.in" +// bool !=(pen a, pen b); +void gen_runtime14(stack *Stack) +{ + pen b=vm::pop<pen>(Stack); + pen a=vm::pop<pen>(Stack); +#line 315 "runtime.in" + {Stack->push<bool>(a != b); return;} +} + +#line 319 "runtime.in" +// pen +(pen a, pen b); +void gen_runtime15(stack *Stack) +{ + pen b=vm::pop<pen>(Stack); + pen a=vm::pop<pen>(Stack); +#line 320 "runtime.in" + {Stack->push<pen>(a+b); return;} +} + +#line 324 "runtime.in" +// pen *(real a, pen b); +void gen_runtime16(stack *Stack) +{ + pen b=vm::pop<pen>(Stack); + real a=vm::pop<real>(Stack); +#line 325 "runtime.in" + {Stack->push<pen>(a*b); return;} +} + +#line 329 "runtime.in" +// pen *(pen a, real b); +void gen_runtime17(stack *Stack) +{ + real b=vm::pop<real>(Stack); + pen a=vm::pop<pen>(Stack); +#line 330 "runtime.in" + {Stack->push<pen>(b*a); return;} +} + +#line 334 "runtime.in" +// pair max(pen p); +void gen_runtime18(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 335 "runtime.in" + {Stack->push<pair>(p.bounds().Max()); return;} +} + +#line 339 "runtime.in" +// pair min(pen p); +void gen_runtime19(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 340 "runtime.in" + {Stack->push<pair>(p.bounds().Min()); return;} +} + +// Reset the meaning of pen default attributes. +#line 345 "runtime.in" +// void resetdefaultpen(); +void gen_runtime20(stack *) +{ +#line 346 "runtime.in" + processData().defaultpen=camp::pen::initialpen(); +} + +#line 350 "runtime.in" +// void defaultpen(pen p); +void gen_runtime21(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 351 "runtime.in" + processData().defaultpen=pen(resolvepen,p); +} + +#line 355 "runtime.in" +// pen defaultpen(); +void gen_runtime22(stack *Stack) +{ +#line 356 "runtime.in" + {Stack->push<pen>(processData().defaultpen); return;} +} + +#line 360 "runtime.in" +// bool invisible(pen p); +void gen_runtime23(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 361 "runtime.in" + {Stack->push<bool>(p.invisible()); return;} +} + +#line 365 "runtime.in" +// pen invisible(); +void gen_runtime24(stack *Stack) +{ +#line 366 "runtime.in" + {Stack->push<pen>(pen(invisiblepen)); return;} +} + +#line 370 "runtime.in" +// pen gray(pen p); +void gen_runtime25(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 371 "runtime.in" + p.togrey(); + {Stack->push<pen>(p); return;} +} + +#line 376 "runtime.in" +// pen rgb(pen p); +void gen_runtime26(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 377 "runtime.in" + p.torgb(); + {Stack->push<pen>(p); return;} +} + +#line 382 "runtime.in" +// pen cmyk(pen p); +void gen_runtime27(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 383 "runtime.in" + p.tocmyk(); + {Stack->push<pen>(p); return;} +} + +#line 388 "runtime.in" +// pen interp(pen a, pen b, real t); +void gen_runtime28(stack *Stack) +{ + real t=vm::pop<real>(Stack); + pen b=vm::pop<pen>(Stack); + pen a=vm::pop<pen>(Stack); +#line 389 "runtime.in" + {Stack->push<pen>(interpolate(a,b,t)); return;} +} + +#line 393 "runtime.in" +// pen rgb(real r, real g, real b); +void gen_runtime29(stack *Stack) +{ + real b=vm::pop<real>(Stack); + real g=vm::pop<real>(Stack); + real r=vm::pop<real>(Stack); +#line 394 "runtime.in" + {Stack->push<pen>(pen(r,g,b)); return;} +} + +#line 398 "runtime.in" +// pen cmyk(real c, real m, real y, real k); +void gen_runtime30(stack *Stack) +{ + real k=vm::pop<real>(Stack); + real y=vm::pop<real>(Stack); + real m=vm::pop<real>(Stack); + real c=vm::pop<real>(Stack); +#line 399 "runtime.in" + {Stack->push<pen>(pen(c,m,y,k)); return;} +} + +#line 403 "runtime.in" +// pen gray(real gray); +void gen_runtime31(stack *Stack) +{ + real gray=vm::pop<real>(Stack); +#line 404 "runtime.in" + {Stack->push<pen>(pen(gray)); return;} +} + +#line 408 "runtime.in" +// realarray* colors(pen p); +void gen_runtime32(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 409 "runtime.in" + 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; + } + {Stack->push<realarray*>(a); return;} +} + +#line 436 "runtime.in" +// string hex(pen p); +void gen_runtime33(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 437 "runtime.in" + {Stack->push<string>(p.hex()); return;} +} + +#line 441 "runtime.in" +// Int byte(real x); +void gen_runtime34(stack *Stack) +{ + real x=vm::pop<real>(Stack); +#line 442 "runtime.in" + {Stack->push<Int>(camp::byte(x)); return;} +} + +#line 446 "runtime.in" +// string colorspace(pen p); +void gen_runtime35(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 447 "runtime.in" + string s=ColorDeviceSuffix[p.colorspace()]; + std::transform(s.begin(),s.end(),s.begin(),tolower); + {Stack->push<string>(s); return;} +} + +#line 453 "runtime.in" +// pen pattern(string *s); +void gen_runtime36(stack *Stack) +{ + string * s=vm::pop<string *>(Stack); +#line 454 "runtime.in" + {Stack->push<pen>(pen(setpattern,*s)); return;} +} + +#line 458 "runtime.in" +// string pattern(pen p); +void gen_runtime37(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 459 "runtime.in" + {Stack->push<string>(p.fillpattern()); return;} +} + +#line 463 "runtime.in" +// pen fillrule(Int n); +void gen_runtime38(stack *Stack) +{ + Int n=vm::pop<Int>(Stack); +#line 464 "runtime.in" + {Stack->push<pen>(pen(n >= 0 && n < nFill ? (FillRule) n : DEFFILL)); return;} +} + +#line 468 "runtime.in" +// Int fillrule(pen p); +void gen_runtime39(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 469 "runtime.in" + {Stack->push<Int>(p.Fillrule()); return;} +} + +#line 473 "runtime.in" +// pen opacity(real opacity=1.0, string blend=defaulttransparency); +void gen_runtime40(stack *Stack) +{ + string blend=vm::pop<string>(Stack,defaulttransparency); + real opacity=vm::pop<real>(Stack,1.0); +#line 474 "runtime.in" + for(Int i=0; i < nBlendMode; ++i) + if(blend == BlendMode[i]) {Stack->push<pen>(pen(Transparency(blend,opacity))); return;} + + ostringstream buf; + buf << "Unknown blend mode: " << "'" << blend << "'"; + error(buf); +} + +#line 483 "runtime.in" +// real opacity(pen p); +void gen_runtime41(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 484 "runtime.in" + {Stack->push<real>(p.opacity()); return;} +} + +#line 488 "runtime.in" +// string blend(pen p); +void gen_runtime42(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 489 "runtime.in" + {Stack->push<string>(p.blend()); return;} +} + +#line 493 "runtime.in" +// pen linetype(realarray *pattern, real offset=0, bool scale=true, bool adjust=true); +void gen_runtime43(stack *Stack) +{ + bool adjust=vm::pop<bool>(Stack,true); + bool scale=vm::pop<bool>(Stack,true); + real offset=vm::pop<real>(Stack,0); + realarray * pattern=vm::pop<realarray *>(Stack); +#line 495 "runtime.in" + 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); + + {Stack->push<pen>(pen(LineType(*a,offset,scale,adjust))); return;} +} + +#line 504 "runtime.in" +// realarray* linetype(pen p=CURRENTPEN); +void gen_runtime44(stack *Stack) +{ + pen p=vm::pop<pen>(Stack,CURRENTPEN); +#line 505 "runtime.in" + array a=p.linetype()->pattern; + {Stack->push<realarray*>(copyArray(&a)); return;} +} + +#line 510 "runtime.in" +// real offset(pen p); +void gen_runtime45(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 511 "runtime.in" + {Stack->push<real>(p.linetype()->offset); return;} +} + +#line 515 "runtime.in" +// bool scale(pen p); +void gen_runtime46(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 516 "runtime.in" + {Stack->push<bool>(p.linetype()->scale); return;} +} + +#line 520 "runtime.in" +// bool adjust(pen p); +void gen_runtime47(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 521 "runtime.in" + {Stack->push<bool>(p.linetype()->adjust); return;} +} + +#line 525 "runtime.in" +// pen adjust(pen p, real arclength, bool cyclic); +void gen_runtime48(stack *Stack) +{ + bool cyclic=vm::pop<bool>(Stack); + real arclength=vm::pop<real>(Stack); + pen p=vm::pop<pen>(Stack); +#line 526 "runtime.in" + {Stack->push<pen>(adjustdash(p,arclength,cyclic)); return;} +} + +#line 530 "runtime.in" +// pen linecap(Int n); +void gen_runtime49(stack *Stack) +{ + Int n=vm::pop<Int>(Stack); +#line 531 "runtime.in" + {Stack->push<pen>(pen(setlinecap,n >= 0 && n < nCap ? n : DEFCAP)); return;} +} + +#line 535 "runtime.in" +// Int linecap(pen p=CURRENTPEN); +void gen_runtime50(stack *Stack) +{ + pen p=vm::pop<pen>(Stack,CURRENTPEN); +#line 536 "runtime.in" + {Stack->push<Int>(p.cap()); return;} +} + +#line 540 "runtime.in" +// pen linejoin(Int n); +void gen_runtime51(stack *Stack) +{ + Int n=vm::pop<Int>(Stack); +#line 541 "runtime.in" + {Stack->push<pen>(pen(setlinejoin,n >= 0 && n < nJoin ? n : DEFJOIN)); return;} +} + +#line 545 "runtime.in" +// Int linejoin(pen p=CURRENTPEN); +void gen_runtime52(stack *Stack) +{ + pen p=vm::pop<pen>(Stack,CURRENTPEN); +#line 546 "runtime.in" + {Stack->push<Int>(p.join()); return;} +} + +#line 550 "runtime.in" +// pen miterlimit(real x); +void gen_runtime53(stack *Stack) +{ + real x=vm::pop<real>(Stack); +#line 551 "runtime.in" + {Stack->push<pen>(pen(setmiterlimit,x >= 1.0 ? x : DEFJOIN)); return;} +} + +#line 555 "runtime.in" +// real miterlimit(pen p=CURRENTPEN); +void gen_runtime54(stack *Stack) +{ + pen p=vm::pop<pen>(Stack,CURRENTPEN); +#line 556 "runtime.in" + {Stack->push<real>(p.miter()); return;} +} + +#line 560 "runtime.in" +// pen linewidth(real x); +void gen_runtime55(stack *Stack) +{ + real x=vm::pop<real>(Stack); +#line 561 "runtime.in" + {Stack->push<pen>(pen(setlinewidth,x >= 0.0 ? x : DEFWIDTH)); return;} +} + +#line 565 "runtime.in" +// real linewidth(pen p=CURRENTPEN); +void gen_runtime56(stack *Stack) +{ + pen p=vm::pop<pen>(Stack,CURRENTPEN); +#line 566 "runtime.in" + {Stack->push<real>(p.width()); return;} +} + +#line 570 "runtime.in" +// pen fontcommand(string *s); +void gen_runtime57(stack *Stack) +{ + string * s=vm::pop<string *>(Stack); +#line 571 "runtime.in" + {Stack->push<pen>(pen(setfont,*s)); return;} +} + +#line 575 "runtime.in" +// string font(pen p=CURRENTPEN); +void gen_runtime58(stack *Stack) +{ + pen p=vm::pop<pen>(Stack,CURRENTPEN); +#line 576 "runtime.in" + {Stack->push<string>(p.Font()); return;} +} + +#line 580 "runtime.in" +// pen fontsize(real size, real lineskip); +void gen_runtime59(stack *Stack) +{ + real lineskip=vm::pop<real>(Stack); + real size=vm::pop<real>(Stack); +#line 581 "runtime.in" + {Stack->push<pen>(pen(setfontsize,size > 0.0 ? size : 0.0, + lineskip > 0.0 ? lineskip : 0.0)); return;} +} + +#line 586 "runtime.in" +// real fontsize(pen p=CURRENTPEN); +void gen_runtime60(stack *Stack) +{ + pen p=vm::pop<pen>(Stack,CURRENTPEN); +#line 587 "runtime.in" + {Stack->push<real>(p.size()); return;} +} + +#line 591 "runtime.in" +// real lineskip(pen p=CURRENTPEN); +void gen_runtime61(stack *Stack) +{ + pen p=vm::pop<pen>(Stack,CURRENTPEN); +#line 592 "runtime.in" + {Stack->push<real>(p.Lineskip()); return;} +} + +#line 596 "runtime.in" +// pen overwrite(Int n); +void gen_runtime62(stack *Stack) +{ + Int n=vm::pop<Int>(Stack); +#line 597 "runtime.in" + {Stack->push<pen>(pen(setoverwrite,n >= 0 && n < nOverwrite ? (overwrite_t) n : + DEFWRITE)); return;} +} + +#line 602 "runtime.in" +// Int overwrite(pen p=CURRENTPEN); +void gen_runtime63(stack *Stack) +{ + pen p=vm::pop<pen>(Stack,CURRENTPEN); +#line 603 "runtime.in" + {Stack->push<Int>(p.Overwrite()); return;} +} + +#line 607 "runtime.in" +// pen basealign(Int n); +void gen_runtime64(stack *Stack) +{ + Int n=vm::pop<Int>(Stack); +#line 608 "runtime.in" + {Stack->push<pen>(pen(n >= 0 && n < nBaseLine ? (BaseLine) n : DEFBASE)); return;} +} + +#line 612 "runtime.in" +// Int basealign(pen p=CURRENTPEN); +void gen_runtime65(stack *Stack) +{ + pen p=vm::pop<pen>(Stack,CURRENTPEN); +#line 613 "runtime.in" + {Stack->push<Int>(p.Baseline()); return;} +} + +#line 617 "runtime.in" +// transform transform(pen p); +void gen_runtime66(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 618 "runtime.in" + {Stack->push<transform>(p.getTransform()); return;} +} + +#line 622 "runtime.in" +// path nib(pen p); +void gen_runtime67(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 623 "runtime.in" + {Stack->push<path>(p.Path()); return;} +} + +#line 627 "runtime.in" +// pen makepen(path p); +void gen_runtime68(stack *Stack) +{ + path p=vm::pop<path>(Stack); +#line 628 "runtime.in" + {Stack->push<pen>(pen(p)); return;} +} + +#line 632 "runtime.in" +// pen colorless(pen p); +void gen_runtime69(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); +#line 633 "runtime.in" + p.colorless(); + {Stack->push<pen>(p); return;} +} + +// Interactive mode +#line 639 "runtime.in" +// bool interactive(); +void gen_runtime70(stack *Stack) +{ +#line 640 "runtime.in" + {Stack->push<bool>(interact::interactive); return;} +} + +#line 645 "runtime.in" +// bool uptodate(); +void gen_runtime71(stack *Stack) +{ +#line 646 "runtime.in" + {Stack->push<bool>(interact::uptodate); return;} +} + + +// System commands +#line 652 "runtime.in" +// Int system(stringarray *s); +void gen_runtime72(stack *Stack) +{ + stringarray * s=vm::pop<stringarray *>(Stack); +#line 653 "runtime.in" + if(safe) error("system() call disabled; override with option -nosafe"); + size_t size=checkArray(s); + if(size == 0) {Stack->push<Int>(0); return;} + mem::vector<string> cmd; + for(size_t i=0; i < size; ++i) + cmd.push_back(read<string>(s,i)); + {Stack->push<Int>(System(cmd)); return;} +} + +#line 664 "runtime.in" +// bool view(); +void gen_runtime73(stack *Stack) +{ +#line 665 "runtime.in" + {Stack->push<bool>(view()); return;} +} + +#line 669 "runtime.in" +// string asydir(); +void gen_runtime74(stack *Stack) +{ +#line 670 "runtime.in" + {Stack->push<string>(systemDir); return;} +} + +#line 674 "runtime.in" +// string locale(string s=emptystring); +void gen_runtime75(stack *Stack) +{ + string s=vm::pop<string>(Stack,emptystring); +#line 675 "runtime.in" + char *L=setlocale(LC_ALL,s.empty() ? NULL : s.c_str()); + {Stack->push<string>(L != NULL ? string(L) : ""); return;} +} + +#line 680 "runtime.in" +// void abort(string s=emptystring); +void gen_runtime76(stack *Stack) +{ + string s=vm::pop<string>(Stack,emptystring); +#line 681 "runtime.in" + if(s.empty()) throw handled_error(); + error(s.c_str()); +} + +#line 686 "runtime.in" +// void exit(); +void gen_runtime77(stack *) +{ +#line 687 "runtime.in" + throw quit(); +} + +#line 691 "runtime.in" +// void assert(bool b, string s=emptystring); +void gen_runtime78(stack *Stack) +{ + string s=vm::pop<string>(Stack,emptystring); + bool b=vm::pop<bool>(Stack); +#line 692 "runtime.in" + flush(cout); + if(!b) { + ostringstream buf; + buf << "assert FAILED"; + if(s != "") buf << ": " << s; + error(buf); + } +} + +#line 702 "runtime.in" +// void sleep(Int seconds); +void gen_runtime79(stack *Stack) +{ + Int seconds=vm::pop<Int>(Stack); +#line 703 "runtime.in" + if(seconds <= 0) return; + sleep(seconds); +} + +#line 708 "runtime.in" +// void usleep(Int microseconds); +void gen_runtime80(stack *Stack) +{ + Int microseconds=vm::pop<Int>(Stack); +#line 709 "runtime.in" + if(microseconds <= 0) return; + usleep((unsigned long) microseconds); +} + +#line 714 "runtime.in" +// void _eval(string *s, bool embedded, bool interactiveWrite=false); +void gen_runtime81(stack *Stack) +{ + bool interactiveWrite=vm::pop<bool>(Stack,false); + bool embedded=vm::pop<bool>(Stack); + string * s=vm::pop<string *>(Stack); +#line 715 "runtime.in" + 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); +} + +#line 727 "runtime.in" +// void _eval(runnable *s, bool embedded); +void gen_runtime82(stack *Stack) +{ + bool embedded=vm::pop<bool>(Stack); + runnable * s=vm::pop<runnable *>(Stack); +#line 728 "runtime.in" + 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); +} + +#line 743 "runtime.in" +// string xasyKEY(); +void gen_runtime83(stack *Stack) +{ +#line 744 "runtime.in" + processDataStruct *P=&processData(); + xkey_t *xkey=&P->xkey; + xkey_t::iterator p=xkey->find(P->topPos.LineColumn()); + {Stack->push<string>(p != xkey->end() ? p->second+" 1" : toplocation()+" 0"); return;} +} + +#line 750 "runtime.in" +// void xasyKEY(string *s); +void gen_runtime84(stack *Stack) +{ + string * s=vm::pop<string *>(Stack); +#line 751 "runtime.in" + processData().KEY=*s; +} + +#line 754 "runtime.in" +// string toplocation(); +void gen_runtime85(stack *Stack) +{ +#line 755 "runtime.in" + {Stack->push<string>(toplocation()); return;} +} + +#line 758 "runtime.in" +// string location(); +void gen_runtime86(stack *Stack) +{ +#line 759 "runtime.in" + ostringstream buf; + buf << getPos(); + {Stack->push<string>(buf.str()); return;} +} + +// Wrapper for the stack::load() method. +#line 765 "runtime.in" +void loadModule(stack *Stack) +{ + string * index=vm::pop<string *>(Stack); +#line 766 "runtime.in" + Stack->load(*index); +} + +#line 770 "runtime.in" +// string cd(string s=emptystring); +void gen_runtime88(stack *Stack) +{ + string s=vm::pop<string>(Stack,emptystring); +#line 771 "runtime.in" + if(!s.empty() && !globalwrite()) { + string outname=getSetting<string>("outname"); + string dir=stripDir(outname); + if(dir.empty()) Setting("outname")=getPath()+dirsep+outname; + } + {Stack->push<string>(setPath(s.c_str())); return;} +} + +#line 780 "runtime.in" +// void list(string *s, bool imports=false); +void gen_runtime89(stack *Stack) +{ + bool imports=vm::pop<bool>(Stack,false); + string * s=vm::pop<string *>(Stack); +#line 781 "runtime.in" + 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 +#line 791 "runtime.in" +void nullGuide(stack *Stack) +{ +#line 792 "runtime.in" + {Stack->push<guide*>(new pathguide(path())); return;} +} + +#line 797 "runtime.in" +void dotsGuide(stack *Stack) +{ + guidearray * a=vm::pop<guidearray *>(Stack); +#line 798 "runtime.in" + guidevector v; + size_t size=checkArray(a); + for (size_t i=0; i < size; ++i) + v.push_back(a->read<guide*>(i)); + + {Stack->push<guide*>(new multiguide(v)); return;} +} + +#line 807 "runtime.in" +void dashesGuide(stack *Stack) +{ + guidearray * a=vm::pop<guidearray *>(Stack); +#line 808 "runtime.in" + 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)); + } + + {Stack->push<guide*>(new multiguide(v)); return;} +} + +#line 834 "runtime.in" +void newCycleToken(stack *Stack) +{ +#line 835 "runtime.in" + {Stack->push<cycleToken>(cycleToken()); return;} +} + +#line 839 "runtime.in" +// guide* operator cast(cycleToken tok); +void gen_runtime94(stack *Stack) +{ + cycleToken tok=vm::pop<cycleToken>(Stack); +#line 840 "runtime.in" +// Avoid unused variable warning messages. + unused(&tok); + {Stack->push<guide*>(new cycletokguide()); return;} +} + +#line 846 "runtime.in" +// guide* operator spec(pair z, Int p); +void gen_runtime95(stack *Stack) +{ + Int p=vm::pop<Int>(Stack); + pair z=vm::pop<pair>(Stack); +#line 847 "runtime.in" + camp::side d=(camp::side) p; + camp::dirSpec *sp=new camp::dirSpec(z); + + {Stack->push<guide*>(new specguide(sp,d)); return;} +} + +#line 854 "runtime.in" +// curlSpecifier operator curl(real gamma, Int p); +void gen_runtime96(stack *Stack) +{ + Int p=vm::pop<Int>(Stack); + real gamma=vm::pop<real>(Stack); +#line 855 "runtime.in" + camp::side s=(camp::side) p; + {Stack->push<curlSpecifier>(curlSpecifier(gamma,s)); return;} +} + +#line 860 "runtime.in" +void curlSpecifierValuePart(stack *Stack) +{ + curlSpecifier spec=vm::pop<curlSpecifier>(Stack); +#line 861 "runtime.in" + {Stack->push<real>(spec.getValue()); return;} +} + +#line 865 "runtime.in" +void curlSpecifierSidePart(stack *Stack) +{ + curlSpecifier spec=vm::pop<curlSpecifier>(Stack); +#line 866 "runtime.in" + {Stack->push<Int>(spec.getSide()); return;} +} + +#line 870 "runtime.in" +// guide* operator cast(curlSpecifier spec); +void gen_runtime99(stack *Stack) +{ + curlSpecifier spec=vm::pop<curlSpecifier>(Stack); +#line 871 "runtime.in" + {Stack->push<guide*>(new specguide(spec)); return;} +} + +#line 875 "runtime.in" +// tensionSpecifier operator tension(real tout, real tin, bool atleast); +void gen_runtime100(stack *Stack) +{ + bool atleast=vm::pop<bool>(Stack); + real tin=vm::pop<real>(Stack); + real tout=vm::pop<real>(Stack); +#line 876 "runtime.in" + {Stack->push<tensionSpecifier>(tensionSpecifier(tout, tin, atleast)); return;} +} + +#line 880 "runtime.in" +void tensionSpecifierOutPart(stack *Stack) +{ + tensionSpecifier t=vm::pop<tensionSpecifier>(Stack); +#line 881 "runtime.in" + {Stack->push<real>(t.getOut()); return;} +} + +#line 885 "runtime.in" +void tensionSpecifierInPart(stack *Stack) +{ + tensionSpecifier t=vm::pop<tensionSpecifier>(Stack); +#line 886 "runtime.in" + {Stack->push<real>(t.getIn()); return;} +} + +#line 890 "runtime.in" +void tensionSpecifierAtleastPart(stack *Stack) +{ + tensionSpecifier t=vm::pop<tensionSpecifier>(Stack); +#line 891 "runtime.in" + {Stack->push<bool>(t.getAtleast()); return;} +} + +#line 895 "runtime.in" +// guide* operator cast(tensionSpecifier t); +void gen_runtime104(stack *Stack) +{ + tensionSpecifier t=vm::pop<tensionSpecifier>(Stack); +#line 896 "runtime.in" + {Stack->push<guide*>(new tensionguide(t)); return;} +} + +#line 900 "runtime.in" +// guide* operator controls(pair zout, pair zin); +void gen_runtime105(stack *Stack) +{ + pair zin=vm::pop<pair>(Stack); + pair zout=vm::pop<pair>(Stack); +#line 901 "runtime.in" + {Stack->push<guide*>(new controlguide(zout, zin)); return;} +} + +#line 905 "runtime.in" +// Int size(guide *g); +void gen_runtime106(stack *Stack) +{ + guide * g=vm::pop<guide *>(Stack); +#line 906 "runtime.in" + flatguide f; + g->flatten(f,false); + {Stack->push<Int>(f.size()); return;} +} + +#line 912 "runtime.in" +// Int length(guide *g); +void gen_runtime107(stack *Stack) +{ + guide * g=vm::pop<guide *>(Stack); +#line 913 "runtime.in" + flatguide f; + g->flatten(f,false); + {Stack->push<Int>(g->cyclic() ? f.size() : f.size()-1); return;} +} + +#line 919 "runtime.in" +// bool cyclic(guide *g); +void gen_runtime108(stack *Stack) +{ + guide * g=vm::pop<guide *>(Stack); +#line 920 "runtime.in" + flatguide f; + g->flatten(f,false); + {Stack->push<bool>(g->cyclic()); return;} +} + +#line 926 "runtime.in" +// pair point(guide *g, Int t); +void gen_runtime109(stack *Stack) +{ + Int t=vm::pop<Int>(Stack); + guide * g=vm::pop<guide *>(Stack); +#line 927 "runtime.in" + flatguide f; + g->flatten(f,false); + {Stack->push<pair>(f.Nodes(adjustedIndex(t,f.size(),g->cyclic())).z); return;} +} + +#line 933 "runtime.in" +// pairarray* dirSpecifier(guide *g, Int t); +void gen_runtime110(stack *Stack) +{ + Int t=vm::pop<Int>(Stack); + guide * g=vm::pop<guide *>(Stack); +#line 934 "runtime.in" + flatguide f; + g->flatten(f,false); + Int n=f.size(); + if(!g->cyclic() && (t < 0 || t >= n-1)) {Stack->push<pairarray*>(new array(0)); return;} + array *c=new array(2); + (*c)[0]=f.Nodes(t).out->dir(); + (*c)[1]=f.Nodes(t+1).in->dir(); + {Stack->push<pairarray*>(c); return;} +} + +#line 945 "runtime.in" +// pairarray* controlSpecifier(guide *g, Int t); +void gen_runtime111(stack *Stack) +{ + Int t=vm::pop<Int>(Stack); + guide * g=vm::pop<guide *>(Stack); +#line 946 "runtime.in" + flatguide f; + g->flatten(f,false); + Int n=f.size(); + if(!g->cyclic() && (t < 0 || t >= n-1)) {Stack->push<pairarray*>(new array(0)); return;} + 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(); + {Stack->push<pairarray*>(c); return;} + } else {Stack->push<pairarray*>(new array(0)); return;} +} + +#line 962 "runtime.in" +// tensionSpecifier tensionSpecifier(guide *g, Int t); +void gen_runtime112(stack *Stack) +{ + Int t=vm::pop<Int>(Stack); + guide * g=vm::pop<guide *>(Stack); +#line 963 "runtime.in" + flatguide f; + g->flatten(f,false); + Int n=f.size(); + if(!g->cyclic() && (t < 0 || t >= n-1)) {Stack->push<tensionSpecifier>(tensionSpecifier(1.0,1.0,false)); return;} + knot curr=f.Nodes(t); + {Stack->push<tensionSpecifier>(tensionSpecifier(curr.tout.val,f.Nodes(t+1).tin.val,curr.tout.atleast)); return;} +} + +#line 972 "runtime.in" +// realarray* curlSpecifier(guide *g, Int t); +void gen_runtime113(stack *Stack) +{ + Int t=vm::pop<Int>(Stack); + guide * g=vm::pop<guide *>(Stack); +#line 973 "runtime.in" + flatguide f; + g->flatten(f,false); + Int n=f.size(); + if(!g->cyclic() && (t < 0 || t >= n-1)) {Stack->push<realarray*>(new array(0)); return;} + 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; + {Stack->push<realarray*>(c); return;} +} + +#line 986 "runtime.in" +// guide* reverse(guide *g); +void gen_runtime114(stack *Stack) +{ + guide * g=vm::pop<guide *>(Stack); +#line 987 "runtime.in" + flatguide f; + g->flatten(f,false); + if(f.precyclic()) + {Stack->push<guide*>(new pathguide(g->solve().reverse())); return;} + + 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)); + + {Stack->push<guide*>(new multiguide(v)); return;} +} + +#line 1039 "runtime.in" +// realarray* _cputime(); +void gen_runtime115(stack *Stack) +{ +#line 1040 "runtime.in" + static const real ticktime=1.0/sysconf(_SC_CLK_TCK); + struct tms buf; + + ::times(&buf); + array *t=new array(4); + (*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; + {Stack->push<realarray*>(t); return;} +} + + +// Transforms +#line 1055 "runtime.in" +// bool ==(transform a, transform b); +void gen_runtime116(stack *Stack) +{ + transform b=vm::pop<transform>(Stack); + transform a=vm::pop<transform>(Stack); +#line 1056 "runtime.in" + {Stack->push<bool>(a == b); return;} +} + +#line 1061 "runtime.in" +// bool !=(transform a, transform b); +void gen_runtime117(stack *Stack) +{ + transform b=vm::pop<transform>(Stack); + transform a=vm::pop<transform>(Stack); +#line 1062 "runtime.in" + {Stack->push<bool>(a != b); return;} +} + +#line 1066 "runtime.in" +// transform +(transform a, transform b); +void gen_runtime118(stack *Stack) +{ + transform b=vm::pop<transform>(Stack); + transform a=vm::pop<transform>(Stack); +#line 1067 "runtime.in" + {Stack->push<transform>(a+b); return;} +} + +#line 1071 "runtime.in" +// transform *(transform a, transform b); +void gen_runtime119(stack *Stack) +{ + transform b=vm::pop<transform>(Stack); + transform a=vm::pop<transform>(Stack); +#line 1072 "runtime.in" + {Stack->push<transform>(a*b); return;} +} + +#line 1076 "runtime.in" +// pair *(transform t, pair z); +void gen_runtime120(stack *Stack) +{ + pair z=vm::pop<pair>(Stack); + transform t=vm::pop<transform>(Stack); +#line 1077 "runtime.in" + {Stack->push<pair>(t*z); return;} +} + +#line 1081 "runtime.in" +// path *(transform t, path g); +void gen_runtime121(stack *Stack) +{ + path g=vm::pop<path>(Stack); + transform t=vm::pop<transform>(Stack); +#line 1082 "runtime.in" + {Stack->push<path>(transformed(t,g)); return;} +} + +#line 1086 "runtime.in" +// pen *(transform t, pen p); +void gen_runtime122(stack *Stack) +{ + pen p=vm::pop<pen>(Stack); + transform t=vm::pop<transform>(Stack); +#line 1087 "runtime.in" + {Stack->push<pen>(transformed(t,p)); return;} +} + +#line 1091 "runtime.in" +// picture* *(transform t, picture *f); +void gen_runtime123(stack *Stack) +{ + picture * f=vm::pop<picture *>(Stack); + transform t=vm::pop<transform>(Stack); +#line 1092 "runtime.in" + {Stack->push<picture*>(transformed(t,f)); return;} +} + +#line 1096 "runtime.in" +// picture* *(realarray2 *t, picture *f); +void gen_runtime124(stack *Stack) +{ + picture * f=vm::pop<picture *>(Stack); + realarray2 * t=vm::pop<realarray2 *>(Stack); +#line 1097 "runtime.in" + {Stack->push<picture*>(transformed(*t,f)); return;} +} + +#line 1101 "runtime.in" +// transform ^(transform t, Int n); +void gen_runtime125(stack *Stack) +{ + Int n=vm::pop<Int>(Stack); + transform t=vm::pop<transform>(Stack); +#line 1102 "runtime.in" + transform T; + if(n < 0) { + n=-n; + t=inverse(t); + } + for(Int i=0; i < n; i++) T=T*t; + {Stack->push<transform>(T); return;} +} + +#line 1112 "runtime.in" +void transformXPart(stack *Stack) +{ + transform t=vm::pop<transform>(Stack); +#line 1113 "runtime.in" + {Stack->push<real>(t.getx()); return;} +} + +#line 1117 "runtime.in" +void transformYPart(stack *Stack) +{ + transform t=vm::pop<transform>(Stack); +#line 1118 "runtime.in" + {Stack->push<real>(t.gety()); return;} +} + +#line 1122 "runtime.in" +void transformXXPart(stack *Stack) +{ + transform t=vm::pop<transform>(Stack); +#line 1123 "runtime.in" + {Stack->push<real>(t.getxx()); return;} +} + +#line 1127 "runtime.in" +void transformXYPart(stack *Stack) +{ + transform t=vm::pop<transform>(Stack); +#line 1128 "runtime.in" + {Stack->push<real>(t.getxy()); return;} +} + +#line 1132 "runtime.in" +void transformYXPart(stack *Stack) +{ + transform t=vm::pop<transform>(Stack); +#line 1133 "runtime.in" + {Stack->push<real>(t.getyx()); return;} +} + +#line 1137 "runtime.in" +void transformYYPart(stack *Stack) +{ + transform t=vm::pop<transform>(Stack); +#line 1138 "runtime.in" + {Stack->push<real>(t.getyy()); return;} +} + +#line 1142 "runtime.in" +void real6ToTransform(stack *Stack) +{ + real yy=vm::pop<real>(Stack); + real yx=vm::pop<real>(Stack); + real xy=vm::pop<real>(Stack); + real xx=vm::pop<real>(Stack); + real y=vm::pop<real>(Stack); + real x=vm::pop<real>(Stack); +#line 1144 "runtime.in" + {Stack->push<transform>(transform(x,y,xx,xy,yx,yy)); return;} +} + +#line 1148 "runtime.in" +// transform shift(transform t); +void gen_runtime133(stack *Stack) +{ + transform t=vm::pop<transform>(Stack); +#line 1149 "runtime.in" + {Stack->push<transform>(transform(t.getx(),t.gety(),0,0,0,0)); return;} +} + +#line 1153 "runtime.in" +// transform shiftless(transform t); +void gen_runtime134(stack *Stack) +{ + transform t=vm::pop<transform>(Stack); +#line 1154 "runtime.in" + {Stack->push<transform>(transform(0,0,t.getxx(),t.getxy(),t.getyx(),t.getyy())); return;} +} + +#line 1158 "runtime.in" +// transform identity(); +void transformIdentity(stack *Stack) +{ +#line 1159 "runtime.in" + {Stack->push<transform>(identity); return;} +} + +#line 1163 "runtime.in" +// transform inverse(transform t); +void gen_runtime136(stack *Stack) +{ + transform t=vm::pop<transform>(Stack); +#line 1164 "runtime.in" + {Stack->push<transform>(inverse(t)); return;} +} + +#line 1168 "runtime.in" +// transform shift(pair z); +void gen_runtime137(stack *Stack) +{ + pair z=vm::pop<pair>(Stack); +#line 1169 "runtime.in" + {Stack->push<transform>(shift(z)); return;} +} + +#line 1173 "runtime.in" +// transform shift(real x, real y); +void gen_runtime138(stack *Stack) +{ + real y=vm::pop<real>(Stack); + real x=vm::pop<real>(Stack); +#line 1174 "runtime.in" + {Stack->push<transform>(shift(pair(x,y))); return;} +} + +#line 1178 "runtime.in" +// transform xscale(real x); +void gen_runtime139(stack *Stack) +{ + real x=vm::pop<real>(Stack); +#line 1179 "runtime.in" + {Stack->push<transform>(xscale(x)); return;} +} + +#line 1183 "runtime.in" +// transform yscale(real y); +void gen_runtime140(stack *Stack) +{ + real y=vm::pop<real>(Stack); +#line 1184 "runtime.in" + {Stack->push<transform>(yscale(y)); return;} +} + +#line 1188 "runtime.in" +// transform scale(real x); +void gen_runtime141(stack *Stack) +{ + real x=vm::pop<real>(Stack); +#line 1189 "runtime.in" + {Stack->push<transform>(scale(x)); return;} +} + +#line 1193 "runtime.in" +// transform scale(real x, real y); +void gen_runtime142(stack *Stack) +{ + real y=vm::pop<real>(Stack); + real x=vm::pop<real>(Stack); +#line 1194 "runtime.in" + {Stack->push<transform>(scale(x,y)); return;} +} + +#line 1198 "runtime.in" +// transform slant(real s); +void gen_runtime143(stack *Stack) +{ + real s=vm::pop<real>(Stack); +#line 1199 "runtime.in" + {Stack->push<transform>(slant(s)); return;} +} + +#line 1203 "runtime.in" +// transform rotate(real angle, pair z=0); +void gen_runtime144(stack *Stack) +{ + pair z=vm::pop<pair>(Stack,0); + real angle=vm::pop<real>(Stack); +#line 1204 "runtime.in" + {Stack->push<transform>(rotatearound(z,radians(angle))); return;} +} + +#line 1208 "runtime.in" +// transform reflect(pair a, pair b); +void gen_runtime145(stack *Stack) +{ + pair b=vm::pop<pair>(Stack); + pair a=vm::pop<pair>(Stack); +#line 1209 "runtime.in" + {Stack->push<transform>(reflectabout(a,b)); return;} +} + +} // namespace run + +namespace trans { + +void gen_runtime_venv(venv &ve) +{ +#line 228 "runtime.in" + REGISTER_BLTIN(run::IntZero,"IntZero"); +#line 236 "runtime.in" + REGISTER_BLTIN(run::realZero,"realZero"); +#line 241 "runtime.in" + REGISTER_BLTIN(run::boolFalse,"boolFalse"); +#line 246 "runtime.in" + addFunc(ve, run::gen_runtime3, primBoolean(), SYM(isnan), formal(primReal(), SYM(x), false, false)); +#line 251 "runtime.in" + REGISTER_BLTIN(run::pushNullArray,"pushNullArray"); +#line 256 "runtime.in" + REGISTER_BLTIN(run::pushNullRecord,"pushNullRecord"); +#line 261 "runtime.in" + REGISTER_BLTIN(run::pushNullFunction,"pushNullFunction"); +#line 266 "runtime.in" + REGISTER_BLTIN(run::pushDefault,"pushDefault"); +#line 276 "runtime.in" + REGISTER_BLTIN(run::isDefault,"isDefault"); +#line 283 "runtime.in" + REGISTER_BLTIN(run::pairToGuide,"pairToGuide"); +#line 291 "runtime.in" + REGISTER_BLTIN(run::pathToGuide,"pathToGuide"); +#line 296 "runtime.in" + REGISTER_BLTIN(run::guideToPath,"guideToPath"); +#line 301 "runtime.in" + REGISTER_BLTIN(run::newPen,"newPen"); +#line 309 "runtime.in" + addFunc(ve, run::gen_runtime13, primBoolean(), SYM_EQ, formal(primPen(), SYM(a), false, false), formal(primPen(), SYM(b), false, false)); +#line 314 "runtime.in" + addFunc(ve, run::gen_runtime14, primBoolean(), SYM_NEQ, formal(primPen(), SYM(a), false, false), formal(primPen(), SYM(b), false, false)); +#line 319 "runtime.in" + addFunc(ve, run::gen_runtime15, primPen(), SYM_PLUS, formal(primPen(), SYM(a), false, false), formal(primPen(), SYM(b), false, false)); +#line 324 "runtime.in" + addFunc(ve, run::gen_runtime16, primPen(), SYM_TIMES, formal(primReal(), SYM(a), false, false), formal(primPen(), SYM(b), false, false)); +#line 329 "runtime.in" + addFunc(ve, run::gen_runtime17, primPen(), SYM_TIMES, formal(primPen(), SYM(a), false, false), formal(primReal(), SYM(b), false, false)); +#line 334 "runtime.in" + addFunc(ve, run::gen_runtime18, primPair(), SYM(max), formal(primPen(), SYM(p), false, false)); +#line 339 "runtime.in" + addFunc(ve, run::gen_runtime19, primPair(), SYM(min), formal(primPen(), SYM(p), false, false)); +#line 344 "runtime.in" + addFunc(ve, run::gen_runtime20, primVoid(), SYM(resetdefaultpen)); +#line 350 "runtime.in" + addFunc(ve, run::gen_runtime21, primVoid(), SYM(defaultpen), formal(primPen(), SYM(p), false, false)); +#line 355 "runtime.in" + addFunc(ve, run::gen_runtime22, primPen(), SYM(defaultpen)); +#line 360 "runtime.in" + addFunc(ve, run::gen_runtime23, primBoolean(), SYM(invisible), formal(primPen(), SYM(p), false, false)); +#line 365 "runtime.in" + addFunc(ve, run::gen_runtime24, primPen(), SYM(invisible)); +#line 370 "runtime.in" + addFunc(ve, run::gen_runtime25, primPen(), SYM(gray), formal(primPen(), SYM(p), false, false)); +#line 376 "runtime.in" + addFunc(ve, run::gen_runtime26, primPen(), SYM(rgb), formal(primPen(), SYM(p), false, false)); +#line 382 "runtime.in" + addFunc(ve, run::gen_runtime27, primPen(), SYM(cmyk), formal(primPen(), SYM(p), false, false)); +#line 388 "runtime.in" + addFunc(ve, run::gen_runtime28, primPen(), SYM(interp), formal(primPen(), SYM(a), false, false), formal(primPen(), SYM(b), false, false), formal(primReal(), SYM(t), false, false)); +#line 393 "runtime.in" + addFunc(ve, run::gen_runtime29, primPen(), SYM(rgb), formal(primReal(), SYM(r), false, false), formal(primReal(), SYM(g), false, false), formal(primReal(), SYM(b), false, false)); +#line 398 "runtime.in" + addFunc(ve, run::gen_runtime30, primPen(), SYM(cmyk), formal(primReal(), SYM(c), false, false), formal(primReal(), SYM(m), false, false), formal(primReal(), SYM(y), false, false), formal(primReal(), SYM(k), false, false)); +#line 403 "runtime.in" + addFunc(ve, run::gen_runtime31, primPen(), SYM(gray), formal(primReal(), SYM(gray), false, false)); +#line 408 "runtime.in" + addFunc(ve, run::gen_runtime32, realArray(), SYM(colors), formal(primPen(), SYM(p), false, false)); +#line 436 "runtime.in" + addFunc(ve, run::gen_runtime33, primString() , SYM(hex), formal(primPen(), SYM(p), false, false)); +#line 441 "runtime.in" + addFunc(ve, run::gen_runtime34, primInt(), SYM(byte), formal(primReal(), SYM(x), false, false)); +#line 446 "runtime.in" + addFunc(ve, run::gen_runtime35, primString() , SYM(colorspace), formal(primPen(), SYM(p), false, false)); +#line 453 "runtime.in" + addFunc(ve, run::gen_runtime36, primPen(), SYM(pattern), formal(primString(), SYM(s), false, false)); +#line 458 "runtime.in" + addFunc(ve, run::gen_runtime37, primString() , SYM(pattern), formal(primPen(), SYM(p), false, false)); +#line 463 "runtime.in" + addFunc(ve, run::gen_runtime38, primPen(), SYM(fillrule), formal(primInt(), SYM(n), false, false)); +#line 468 "runtime.in" + addFunc(ve, run::gen_runtime39, primInt(), SYM(fillrule), formal(primPen(), SYM(p), false, false)); +#line 473 "runtime.in" + addFunc(ve, run::gen_runtime40, primPen(), SYM(opacity), formal(primReal(), SYM(opacity), true, false), formal(primString() , SYM(blend), true, false)); +#line 483 "runtime.in" + addFunc(ve, run::gen_runtime41, primReal(), SYM(opacity), formal(primPen(), SYM(p), false, false)); +#line 488 "runtime.in" + addFunc(ve, run::gen_runtime42, primString() , SYM(blend), formal(primPen(), SYM(p), false, false)); +#line 493 "runtime.in" + addFunc(ve, run::gen_runtime43, primPen(), SYM(linetype), formal(realArray(), SYM(pattern), false, false), formal(primReal(), SYM(offset), true, false), formal(primBoolean(), SYM(scale), true, false), formal(primBoolean(), SYM(adjust), true, false)); +#line 504 "runtime.in" + addFunc(ve, run::gen_runtime44, realArray(), SYM(linetype), formal(primPen(), SYM(p), true, false)); +#line 510 "runtime.in" + addFunc(ve, run::gen_runtime45, primReal(), SYM(offset), formal(primPen(), SYM(p), false, false)); +#line 515 "runtime.in" + addFunc(ve, run::gen_runtime46, primBoolean(), SYM(scale), formal(primPen(), SYM(p), false, false)); +#line 520 "runtime.in" + addFunc(ve, run::gen_runtime47, primBoolean(), SYM(adjust), formal(primPen(), SYM(p), false, false)); +#line 525 "runtime.in" + addFunc(ve, run::gen_runtime48, primPen(), SYM(adjust), formal(primPen(), SYM(p), false, false), formal(primReal(), SYM(arclength), false, false), formal(primBoolean(), SYM(cyclic), false, false)); +#line 530 "runtime.in" + addFunc(ve, run::gen_runtime49, primPen(), SYM(linecap), formal(primInt(), SYM(n), false, false)); +#line 535 "runtime.in" + addFunc(ve, run::gen_runtime50, primInt(), SYM(linecap), formal(primPen(), SYM(p), true, false)); +#line 540 "runtime.in" + addFunc(ve, run::gen_runtime51, primPen(), SYM(linejoin), formal(primInt(), SYM(n), false, false)); +#line 545 "runtime.in" + addFunc(ve, run::gen_runtime52, primInt(), SYM(linejoin), formal(primPen(), SYM(p), true, false)); +#line 550 "runtime.in" + addFunc(ve, run::gen_runtime53, primPen(), SYM(miterlimit), formal(primReal(), SYM(x), false, false)); +#line 555 "runtime.in" + addFunc(ve, run::gen_runtime54, primReal(), SYM(miterlimit), formal(primPen(), SYM(p), true, false)); +#line 560 "runtime.in" + addFunc(ve, run::gen_runtime55, primPen(), SYM(linewidth), formal(primReal(), SYM(x), false, false)); +#line 565 "runtime.in" + addFunc(ve, run::gen_runtime56, primReal(), SYM(linewidth), formal(primPen(), SYM(p), true, false)); +#line 570 "runtime.in" + addFunc(ve, run::gen_runtime57, primPen(), SYM(fontcommand), formal(primString(), SYM(s), false, false)); +#line 575 "runtime.in" + addFunc(ve, run::gen_runtime58, primString() , SYM(font), formal(primPen(), SYM(p), true, false)); +#line 580 "runtime.in" + addFunc(ve, run::gen_runtime59, primPen(), SYM(fontsize), formal(primReal(), SYM(size), false, false), formal(primReal(), SYM(lineskip), false, false)); +#line 586 "runtime.in" + addFunc(ve, run::gen_runtime60, primReal(), SYM(fontsize), formal(primPen(), SYM(p), true, false)); +#line 591 "runtime.in" + addFunc(ve, run::gen_runtime61, primReal(), SYM(lineskip), formal(primPen(), SYM(p), true, false)); +#line 596 "runtime.in" + addFunc(ve, run::gen_runtime62, primPen(), SYM(overwrite), formal(primInt(), SYM(n), false, false)); +#line 602 "runtime.in" + addFunc(ve, run::gen_runtime63, primInt(), SYM(overwrite), formal(primPen(), SYM(p), true, false)); +#line 607 "runtime.in" + addFunc(ve, run::gen_runtime64, primPen(), SYM(basealign), formal(primInt(), SYM(n), false, false)); +#line 612 "runtime.in" + addFunc(ve, run::gen_runtime65, primInt(), SYM(basealign), formal(primPen(), SYM(p), true, false)); +#line 617 "runtime.in" + addFunc(ve, run::gen_runtime66, primTransform(), SYM(transform), formal(primPen(), SYM(p), false, false)); +#line 622 "runtime.in" + addFunc(ve, run::gen_runtime67, primPath(), SYM(nib), formal(primPen(), SYM(p), false, false)); +#line 627 "runtime.in" + addFunc(ve, run::gen_runtime68, primPen(), SYM(makepen), formal(primPath(), SYM(p), false, false)); +#line 632 "runtime.in" + addFunc(ve, run::gen_runtime69, primPen(), SYM(colorless), formal(primPen(), SYM(p), false, false)); +#line 638 "runtime.in" + addFunc(ve, run::gen_runtime70, primBoolean(), SYM(interactive)); +#line 645 "runtime.in" + addFunc(ve, run::gen_runtime71, primBoolean(), SYM(uptodate)); +#line 650 "runtime.in" + addFunc(ve, run::gen_runtime72, primInt(), SYM(system), formal(stringArray(), SYM(s), false, false)); +#line 664 "runtime.in" + addFunc(ve, run::gen_runtime73, primBoolean(), SYM(view)); +#line 669 "runtime.in" + addFunc(ve, run::gen_runtime74, primString() , SYM(asydir)); +#line 674 "runtime.in" + addFunc(ve, run::gen_runtime75, primString() , SYM(locale), formal(primString() , SYM(s), true, false)); +#line 680 "runtime.in" + addFunc(ve, run::gen_runtime76, primVoid(), SYM(abort), formal(primString() , SYM(s), true, false)); +#line 686 "runtime.in" + addFunc(ve, run::gen_runtime77, primVoid(), SYM(exit)); +#line 691 "runtime.in" + addFunc(ve, run::gen_runtime78, primVoid(), SYM(assert), formal(primBoolean(), SYM(b), false, false), formal(primString() , SYM(s), true, false)); +#line 702 "runtime.in" + addFunc(ve, run::gen_runtime79, primVoid(), SYM(sleep), formal(primInt(), SYM(seconds), false, false)); +#line 708 "runtime.in" + addFunc(ve, run::gen_runtime80, primVoid(), SYM(usleep), formal(primInt(), SYM(microseconds), false, false)); +#line 714 "runtime.in" + addFunc(ve, run::gen_runtime81, primVoid(), SYM(_eval), formal(primString(), SYM(s), false, false), formal(primBoolean(), SYM(embedded), false, false), formal(primBoolean(), SYM(interactivewrite), true, false)); +#line 727 "runtime.in" + addFunc(ve, run::gen_runtime82, primVoid(), SYM(_eval), formal(primCode(), SYM(s), false, false), formal(primBoolean(), SYM(embedded), false, false)); +#line 743 "runtime.in" + addFunc(ve, run::gen_runtime83, primString() , SYM(xasyKEY)); +#line 750 "runtime.in" + addFunc(ve, run::gen_runtime84, primVoid(), SYM(xasyKEY), formal(primString(), SYM(s), false, false)); +#line 754 "runtime.in" + addFunc(ve, run::gen_runtime85, primString() , SYM(toplocation)); +#line 758 "runtime.in" + addFunc(ve, run::gen_runtime86, primString() , SYM(location)); +#line 764 "runtime.in" + REGISTER_BLTIN(run::loadModule,"loadModule"); +#line 770 "runtime.in" + addFunc(ve, run::gen_runtime88, primString() , SYM(cd), formal(primString() , SYM(s), true, false)); +#line 780 "runtime.in" + addFunc(ve, run::gen_runtime89, primVoid(), SYM(list), formal(primString(), SYM(s), false, false), formal(primBoolean(), SYM(imports), true, false)); +#line 789 "runtime.in" + REGISTER_BLTIN(run::nullGuide,"nullGuide"); +#line 797 "runtime.in" + REGISTER_BLTIN(run::dotsGuide,"dotsGuide"); +#line 807 "runtime.in" + REGISTER_BLTIN(run::dashesGuide,"dashesGuide"); +#line 834 "runtime.in" + REGISTER_BLTIN(run::newCycleToken,"newCycleToken"); +#line 839 "runtime.in" + addFunc(ve, run::gen_runtime94, primGuide(), symbol::trans("operator cast"), formal(primCycleToken(), SYM(tok), false, false)); +#line 846 "runtime.in" + addFunc(ve, run::gen_runtime95, primGuide(), symbol::trans("operator spec"), formal(primPair(), SYM(z), false, false), formal(primInt(), SYM(p), false, false)); +#line 854 "runtime.in" + addFunc(ve, run::gen_runtime96, primCurlSpecifier(), SYM_CURL, formal(primReal(), SYM(gamma), false, false), formal(primInt(), SYM(p), false, false)); +#line 860 "runtime.in" + REGISTER_BLTIN(run::curlSpecifierValuePart,"curlSpecifierValuePart"); +#line 865 "runtime.in" + REGISTER_BLTIN(run::curlSpecifierSidePart,"curlSpecifierSidePart"); +#line 870 "runtime.in" + addFunc(ve, run::gen_runtime99, primGuide(), symbol::trans("operator cast"), formal(primCurlSpecifier(), SYM(spec), false, false)); +#line 875 "runtime.in" + addFunc(ve, run::gen_runtime100, primTensionSpecifier(), SYM_TENSION, formal(primReal(), SYM(tout), false, false), formal(primReal(), SYM(tin), false, false), formal(primBoolean(), SYM(atleast), false, false)); +#line 880 "runtime.in" + REGISTER_BLTIN(run::tensionSpecifierOutPart,"tensionSpecifierOutPart"); +#line 885 "runtime.in" + REGISTER_BLTIN(run::tensionSpecifierInPart,"tensionSpecifierInPart"); +#line 890 "runtime.in" + REGISTER_BLTIN(run::tensionSpecifierAtleastPart,"tensionSpecifierAtleastPart"); +#line 895 "runtime.in" + addFunc(ve, run::gen_runtime104, primGuide(), symbol::trans("operator cast"), formal(primTensionSpecifier(), SYM(t), false, false)); +#line 900 "runtime.in" + addFunc(ve, run::gen_runtime105, primGuide(), SYM_CONTROLS, formal(primPair(), SYM(zout), false, false), formal(primPair(), SYM(zin), false, false)); +#line 905 "runtime.in" + addFunc(ve, run::gen_runtime106, primInt(), SYM(size), formal(primGuide(), SYM(g), false, false)); +#line 912 "runtime.in" + addFunc(ve, run::gen_runtime107, primInt(), SYM(length), formal(primGuide(), SYM(g), false, false)); +#line 919 "runtime.in" + addFunc(ve, run::gen_runtime108, primBoolean(), SYM(cyclic), formal(primGuide(), SYM(g), false, false)); +#line 926 "runtime.in" + addFunc(ve, run::gen_runtime109, primPair(), SYM(point), formal(primGuide(), SYM(g), false, false), formal(primInt(), SYM(t), false, false)); +#line 933 "runtime.in" + addFunc(ve, run::gen_runtime110, pairArray(), SYM(dirSpecifier), formal(primGuide(), SYM(g), false, false), formal(primInt(), SYM(t), false, false)); +#line 945 "runtime.in" + addFunc(ve, run::gen_runtime111, pairArray(), SYM(controlSpecifier), formal(primGuide(), SYM(g), false, false), formal(primInt(), SYM(t), false, false)); +#line 962 "runtime.in" + addFunc(ve, run::gen_runtime112, primTensionSpecifier(), SYM(tensionSpecifier), formal(primGuide(), SYM(g), false, false), formal(primInt(), SYM(t), false, false)); +#line 972 "runtime.in" + addFunc(ve, run::gen_runtime113, realArray(), SYM(curlSpecifier), formal(primGuide(), SYM(g), false, false), formal(primInt(), SYM(t), false, false)); +#line 986 "runtime.in" + addFunc(ve, run::gen_runtime114, primGuide(), SYM(reverse), formal(primGuide(), SYM(g), false, false)); +#line 1039 "runtime.in" + addFunc(ve, run::gen_runtime115, realArray(), SYM(_cputime)); +#line 1053 "runtime.in" + addFunc(ve, run::gen_runtime116, primBoolean(), SYM_EQ, formal(primTransform(), SYM(a), false, false), formal(primTransform(), SYM(b), false, false)); +#line 1061 "runtime.in" + addFunc(ve, run::gen_runtime117, primBoolean(), SYM_NEQ, formal(primTransform(), SYM(a), false, false), formal(primTransform(), SYM(b), false, false)); +#line 1066 "runtime.in" + addFunc(ve, run::gen_runtime118, primTransform(), SYM_PLUS, formal(primTransform(), SYM(a), false, false), formal(primTransform(), SYM(b), false, false)); +#line 1071 "runtime.in" + addFunc(ve, run::gen_runtime119, primTransform(), SYM_TIMES, formal(primTransform(), SYM(a), false, false), formal(primTransform(), SYM(b), false, false)); +#line 1076 "runtime.in" + addFunc(ve, run::gen_runtime120, primPair(), SYM_TIMES, formal(primTransform(), SYM(t), false, false), formal(primPair(), SYM(z), false, false)); +#line 1081 "runtime.in" + addFunc(ve, run::gen_runtime121, primPath(), SYM_TIMES, formal(primTransform(), SYM(t), false, false), formal(primPath(), SYM(g), false, false)); +#line 1086 "runtime.in" + addFunc(ve, run::gen_runtime122, primPen(), SYM_TIMES, formal(primTransform(), SYM(t), false, false), formal(primPen(), SYM(p), false, false)); +#line 1091 "runtime.in" + addFunc(ve, run::gen_runtime123, primPicture(), SYM_TIMES, formal(primTransform(), SYM(t), false, false), formal(primPicture(), SYM(f), false, false)); +#line 1096 "runtime.in" + addFunc(ve, run::gen_runtime124, primPicture(), SYM_TIMES, formal(realArray2(), SYM(t), false, false), formal(primPicture(), SYM(f), false, false)); +#line 1101 "runtime.in" + addFunc(ve, run::gen_runtime125, primTransform(), SYM_CARET, formal(primTransform(), SYM(t), false, false), formal(primInt(), SYM(n), false, false)); +#line 1112 "runtime.in" + REGISTER_BLTIN(run::transformXPart,"transformXPart"); +#line 1117 "runtime.in" + REGISTER_BLTIN(run::transformYPart,"transformYPart"); +#line 1122 "runtime.in" + REGISTER_BLTIN(run::transformXXPart,"transformXXPart"); +#line 1127 "runtime.in" + REGISTER_BLTIN(run::transformXYPart,"transformXYPart"); +#line 1132 "runtime.in" + REGISTER_BLTIN(run::transformYXPart,"transformYXPart"); +#line 1137 "runtime.in" + REGISTER_BLTIN(run::transformYYPart,"transformYYPart"); +#line 1142 "runtime.in" + REGISTER_BLTIN(run::real6ToTransform,"real6ToTransform"); +#line 1148 "runtime.in" + addFunc(ve, run::gen_runtime133, primTransform(), SYM(shift), formal(primTransform(), SYM(t), false, false)); +#line 1153 "runtime.in" + addFunc(ve, run::gen_runtime134, primTransform(), SYM(shiftless), formal(primTransform(), SYM(t), false, false)); +#line 1158 "runtime.in" + addFunc(ve, run::transformIdentity, primTransform(), SYM(identity)); +#line 1163 "runtime.in" + addFunc(ve, run::gen_runtime136, primTransform(), SYM(inverse), formal(primTransform(), SYM(t), false, false)); +#line 1168 "runtime.in" + addFunc(ve, run::gen_runtime137, primTransform(), SYM(shift), formal(primPair(), SYM(z), false, false)); +#line 1173 "runtime.in" + addFunc(ve, run::gen_runtime138, primTransform(), SYM(shift), formal(primReal(), SYM(x), false, false), formal(primReal(), SYM(y), false, false)); +#line 1178 "runtime.in" + addFunc(ve, run::gen_runtime139, primTransform(), SYM(xscale), formal(primReal(), SYM(x), false, false)); +#line 1183 "runtime.in" + addFunc(ve, run::gen_runtime140, primTransform(), SYM(yscale), formal(primReal(), SYM(y), false, false)); +#line 1188 "runtime.in" + addFunc(ve, run::gen_runtime141, primTransform(), SYM(scale), formal(primReal(), SYM(x), false, false)); +#line 1193 "runtime.in" + addFunc(ve, run::gen_runtime142, primTransform(), SYM(scale), formal(primReal(), SYM(x), false, false), formal(primReal(), SYM(y), false, false)); +#line 1198 "runtime.in" + addFunc(ve, run::gen_runtime143, primTransform(), SYM(slant), formal(primReal(), SYM(s), false, false)); +#line 1203 "runtime.in" + addFunc(ve, run::gen_runtime144, primTransform(), SYM(rotate), formal(primReal(), SYM(angle), false, false), formal(primPair(), SYM(z), true, false)); +#line 1208 "runtime.in" + addFunc(ve, run::gen_runtime145, primTransform(), SYM(reflect), formal(primPair(), SYM(a), false, false), formal(primPair(), SYM(b), false, false)); +} + +} // namespace trans |