root/trunk/scene/parse.d

module scene.parse;

import scene.root, scene.nullobject;
import tools.base, base.types, tools.log;
public import tools.rd, scene.multival;
import tools.mersenne;

/** And in the parser, the nested matching functions and
    confusing declarations will look up and shout "REWRITE US! "
    And I'll whisper: "Maybe later. It sort of works for now. " **/

class ParseException : Exception { this(string s) { super("parse error: "~s); } }

struct parse_fns {
  static {
    alias SceneObject delegate(ref string) KEY;
    alias SceneObject function(ref string) ALTKEY;
    KEY[string] field;
    KEY opIndexAssign(KEY dg, string key) { field[key] = dg; return dg; }
    ALTKEY opIndexAssign(ALTKEY fn, string key) { field[key] = fn /todg; return fn; }
    KEY opIndex(string key) { return field[key]; }
    KEY* opIn_r(string key) { return key in field; }
    int opApply(int delegate(ref string, ref KEY) dg) {
      foreach (key, value; field)
        if (auto res = dg(key, value)) return res;
      return 0;
    }
  }
}

alias scene.multival.concat concat;

bool[string] builtin;

string[string] help;

const string TOKENS = " {}()[]&,.+-*/=<>;\"\n";

string filterComments(string text) {
  string res;
  int nest_level = 0;
  text.glomp_parse([
    "/*": (string pre, ref string post) { if (!nest_level) res ~= pre; nest_level ++; },
    "*/": (string pre, ref string post) { if (!nest_level) throw new Exception("Too many */"); nest_level --; }
  ], (string rest) { res ~= rest; });
  string res2;
  foreach (i, line; res.split("\n")) {
    if (i) res2 ~= "\n";
    res2 ~= line.cutOff("//");
  }
  return res2;
}

string getToken(ref string data) {
  string buffer;
  const string FLUSH = "buffer = buffer.strip(); if (buffer.length) return buffer; ";
  while (data.length) {
    auto old_data = data;
    auto ch = data[0]; data = data[1 .. $];
    if (TOKENS.find((&ch)[0..1]) != -1) {
      data = old_data; // put ch back
      mixin(FLUSH); // flush the buffer.
      buffer ~= ch; // if it was empty ..
      data = data[1 .. $]; // re-remove ch ..
      mixin(FLUSH); // and flush.
    } else buffer ~= ch;
  }
  return buffer;
}

bool gotToken(ref string s, out string token) {
  if (!s.length) return false;
  token = s.getToken();
  return true;
}

static this() {
  help["minus"] = ": minus b: CSG invert";
  help["and"] = ": a and b: CSG intersect";
  help["or"] = ": a or b: CSG merge";
}

extern(C) bool __workaround_gotInfixCSGEx__(ref string, out SceneObject, int arith_level = 0);
bool gotObjCSG(ref string s, out SceneObject so, int arith_level = 0) {
  return s.__workaround_gotInfixCSGEx__(so, arith_level);
}
mixin(getWrap!("ObjCSG"));

bool gotObjRoot(ref string s, out SceneObject so) {
  string s2 = s, t = getToken(s2);
  foreach (key, fn; parse_fns) {
    if (key == t) {
      s = s2;
      so = fn(s);
      return true;
    }
  }
  return false;
}


import tools.compat: atoi, atof, find;
bool gotInt(ref string s, out int i) {
  auto s2 = s, t = getToken(s2), neg = false;
  if (t == "-") {
    neg = true;
    t = getToken(s2);
  }
  bool isNum = true;
  foreach (ch; t) if (ch < '0' || ch > '9') isNum = false;
  if (!isNum) return false;
  s = s2;
  i = t.atoi();
  if (neg) i = -i;
  return true;
}
mixin(getWrap!("Int"));

bool gotFloat(ref string s, out float f) {
  auto s2 = s, token = getToken(s2);
  if (token == "infinity" || token == "infty" || token == "inf") { s = s2; f = FP.infinity; return true; }
  s2 = s;
  string fp_num;
  if (s2.accept("-")) fp_num ~= "-";
  bool isDigit(char c) { return c >= '0' && c <= '9'; }
  while (s2.length && " \n\t".find(s2[0]) != -1) s2 = s2[1 .. $];
  while (s2.length && isDigit(s2[0])) { fp_num ~= s2[0]; s2 = s2[1 .. $]; }
  if (!s2.length || s2[0] != '.') return false;
  s2 = s2[1 .. $]; fp_num ~= ".";
  bool match2;
  while (s2.length && isDigit(s2[0])) { match2 = true; fp_num ~= s2[0]; s2 = s2[1 .. $]; }
  if (!match2) return false; // 2. is not a valid FP number
  f = fp_num.atof();
  s = s2;
  return true;
}
mixin(getWrap!("Float"));

bool gotFloatExt(ref string s, out float f) {
  if (gotFloat(s, f)) return true;
  // this has its own case now.
  // int i;
  // if (gotInt(s, i)) { f = cast(float) i; return true; }
  return false;
}

bool gotString(ref string s, out string str) {
  auto s2 = s;
  if (s2.accept("\"")) {
    string buf;
    while (s2.length && s2[0] != '\"') {
      buf ~= s2[0];
      s2 = s2[1 .. $];
    }
    if (!s2.length) throw new ParseException("Unterminated string constant "~s);
    s = s2[1 .. $];
    str = buf;
    return true;
  }
  s2 = s; auto token = s2.getToken();
  if (Variables.gotSpecific!(string)(token, str)) {
    s = s2;
    return true;
  }
  return false;
}
mixin(getWrap!("String"));

bool accept(ref string s, string what) {
  auto s2 = s;
  while (what.length) {
    auto backup = s2, what_backup = what;
    if (s2.getToken() != what.getToken()) {
      failtext() = what_backup;
      // failsource = backup.next_text();
      return false;
    }
  }
  failtext() = "Unknown";
  s = s2; return true;
}

void expect(ref string s, string what) {
  if (!s.accept(what)) 
    throw new ParseException("Expected `"~what~"' in `"~s~"'");
}

bool gotVector(ref string s, out vec v) {
  float f;
  if (mixin(gotMatchExpr("s: [$f<-gotFloatExt$|<$f$>]"))) {
    v = vec(f);
    return true;
  }
  string fail = *failtext.ptr();
  with (v) if (mixin(gotMatchExpr("s: <$x<-gotFloatExpr$, $y<-gotFloatExpr$, $z<-gotFloatExpr$>"))) return true;
  
  fail ~= " or "~failtext();
  bool isHexDigit(char c) { return c >= '0' && c <= '9' || c >= 'a' && c <= 'f' || c >= 'A' && c <= 'F'; }
  ubyte hexDecode(char c) {
    if (c >= '0' && c <= '9') return c - '0';
    else if (c >= 'a' && c <= 'f') return c - 'a' + 10;
    else if (c >= 'A' && c <= 'F') return c - 'A' + 10;
  }
  // 1/240 = (1/16)/15
  float hexDecode2(char[] ch) in { assert(ch.length == 2); } body { return hexDecode(ch[0])/16f + hexDecode(ch[1])/240f; }
  auto s2 = s, t = s2.getToken();
  if (t[0] != '#') goto brk; t = t[1 .. $];
  if (t.length == 3 || t.length == 6) {
    // foreach (index, value; array)
    foreach (ch; t) if (!isHexDigit(ch)) goto brk;
  } else goto brk;
  if (t.length == 3) v = vec(hexDecode(t[0])/15f, hexDecode(t[1])/15f, hexDecode(t[2])/15f);
  else v = vec(hexDecode2(t[0..2]), hexDecode2(t[2..4]), hexDecode2(t[4..6]));
  s = s2;
  return true;
brk:
  fail ~= " or hexnum";
  fail ~= " or "~failtext();
  failtext() = fail;
  return false;
}
mixin(getWrap!("Vector"));

bool gotMultivalVar(ref string s, out Multival mv) {
  auto s2 = s, token = s2.getToken();
  if (Variables.gotVar(token, mv)) {
    s = s2;
    return true;
  }
  return false;
}

bool gotMultivalSimple(ref string s, out Multival mv, bool allowCSG = false) {
  if (mixin(gotMatchExpr("s: ($mv$)"))) return true;
  int i; float f; vec v; string st; SceneObject so;
  if (allowCSG) return mixin(gotMatchExpr("s: [$f<-gotFloatExt#mv = f$|$i<-gotInt#mv = i$|$v<-gotVector#mv = v$"
    "|$so<-gotObjCSG#mv=so$"
    "|$mv<-gotMultivalVar$"
    "|$st<-gotString#mv = st$"
    "]"));
  else return mixin(gotMatchExpr("s: [$f<-gotFloatExt#mv = f$|$i<-gotInt#mv = i$|$v<-gotVector#mv = v$"
    "|$so<-gotObjRoot#mv=so$"
    "|$mv<-gotMultivalVar$"
    "|$st<-gotString#mv = st$"
    "]"));
}

bool asFloat(Multival mv, out float f) {
  if (mv.isFloat) { f = mv.f; return true; }
  if (mv.isInt) { f = mv.i; return true; }
  return false;
}

Multival merge(string OP)(Multival a, Multival b) {
  Multival res;
  // What the fuck was I thinking. Subtraction and division aren't commutative, idiot.
  // if (b.isFun) swap(a, b); // no need to check for [not-function] [op] [function]
  bool invertOp;
  if (b.isFun && !a.isFun) {
    swap(a, b);
    invertOp = true;
  }
  float af, bf;
  static if (OP == "%") {
    const string TABLE = `
            | Int       | Float
      ------+-----------+------------
      Int   | a.i % b.i | a.f % b.i
      Float | a.i % b.f | a.f % b.f
    `;
  } else {
    const string TABLE = `
            | Int        | Float      | Vec
      ------+------------+------------+------
      Int   | a.i % b.i  | a.f % b.i  | a.v % b.i
      Float | a.i % b.f  | a.f % b.f  | a.v % b.f
      Vec   | a.i % b.v  | a.f % b.v  | a.v % b.v
    `;
  }
  mixin(`if (false) { } ` ~ ctTableUnrollColMajor(
    TABLE,
    `else if (a.is$COL) { if (false) { } $BODY }`,
    `else if (b.is$ROW) {
      // swap operator order
      res = mixin("$CELL".ctReplace("%", OP));
      return res;
    } `
  ));
  if (a.isFun) {
    if (b.isFun) {
      if (!equal(a.ParamType, b.ParamType))
        throw new Exception("Cannot unify "~a.type[0 .. getlen(a.type)]~" and "~b.type[0 .. getlen(b.type)]~"!");
      mixin(`if (false) { } ` ~ ctTableUnrollColMajor(
        TABLE,
        `else if (Multival.sample(a.RetType).is$COL) { if (false) { } $BODY }`,
        `else if (Multival.sample(b.RetType).is$ROW) {
          res = Multival(stuple(a.fun, b.fun) /xapply/ (Multiproc fn1, Multiproc fn2, Multival p) {
            auto a = fn1(p), b = fn2(p);
            return Multival(mixin("$CELL".ctReplace("%", OP)));
          }, concat("d", a.ParamType, TypeToInfo!(typeof(mixin("$CELL".ctReplace("%", OP))))));
        }`
      ));
    }
    const string SetRes = `
      if (invertOp) {
        res = Multival(
          strfix!("Multival(cast($RESTYPE) ($VALUE2 "~OP~" $VALUE1))", Multival)(tag=(a.typestr~" "~OP~" "~b.typestr), $PV),
          concat("d", a.ParamType, TypeToInfo!($RESTYPE))
        );
      } else {
        res = Multival(
          strfix!("Multival(cast($RESTYPE) ($VALUE1 "~OP~" $VALUE2))", Multival)(tag=(a.typestr~" "~OP~" "~b.typestr), $PV),
          concat("d", a.ParamType, TypeToInfo!($RESTYPE))
        );
      }
      return res;`;
    if (a.RetType[0] == 'i' && (b.isInt || b.isFun && b.RetType[0] == 'i')) {
      const SetResAInt = ctReplace(SetRes, "$PV", "a.fun, $PV", "$VALUE1", "left(rest).i");
      if (b.isInt) {
        mixin(ctReplace(SetResAInt, "$PV", "b.i", "$RESTYPE", "int", "$VALUE2", "right"));
      } else if (b.isFun) {
        if (!equal(a.ParamType, b.ParamType))
          throw new Exception(Format("Cannot compose functions of different parameters: ", a, " and ", b));
        mixin(ctReplace(SetResAInt, "$PV", "b.fun", "$RESTYPE", "int", "$VALUE2", "right(rest).i"));
      }
    } else if (a.RetType[0] == 'f' || a.RetType[0] == 'i') {
      const SetResAFloat = ctReplace(SetRes, "$PV", "a.fun, $PV", "$VALUE1", "left(rest).f");
      if (a.RetType[0] == 'i' && b.isInt) {
        mixin(ctReplace(SetResAFloat, "$PV", "b.i", "$RESTYPE", "int", "$VALUE2", "right"));
      } else if (asFloat(b, bf)) {
        mixin(ctReplace(SetResAFloat, "$PV", "bf", "$RESTYPE", "float", "$VALUE2", "right"));
      } else if (OP != "%" && b.isVec) {
        static if (OP != "%") // don't even generate the code
          mixin(ctReplace(SetResAFloat, "$PV", "b.v", "$RESTYPE", "vec", "$VALUE2", "right"));
      } else if (b.isFun) {
        if (!equal(a.ParamType, b.ParamType))
          throw new Exception(Format("Cannot compose functions of different parameters: ", a, " and ", b));
        if (a.RetType[0] == 'i' && b.RetType[0] == 'i') {
          mixin(ctReplace(SetResAFloat, "$PV", "b.fun", "$RESTYPE", "int", "$VALUE2", "right(rest).i"));
        } else if (b.RetType[0] == 'f' || b.RetType[0] == 'i') {
          mixin(ctReplace(SetResAFloat, "$PV", "b.fun", "$RESTYPE", "float", "$VALUE2", "right(rest).f"));
        } else if (OP != "%" && b.RetType[0] == 'v') {
          static if (OP != "%")
            mixin(ctReplace(SetResAFloat, "$PV", "b.fun", "$RESTYPE", "vec", "$VALUE2", "right(rest).v"));
        }
      }
    } else if (OP != "%" && a.RetType[0] == 'v') { // a evaluates to vec
      static if (OP != "%") {
        const SetResAVec = ctReplace(SetRes,
          "$PV", "a.fun, $PV", "$VALUE1", "left(rest).v", "$RESTYPE", "vec"
        );
        if (asFloat(b, bf))
          mixin(ctReplace(SetResAVec, "$PV", "bf", "$VALUE2", "right"));
        else if (b.isVec)
          mixin(ctReplace(SetResAVec, "$PV", "b.v", "$VALUE2", "right"));
        else if (b.isFun) {
          if (!equal(a.ParamType, b.ParamType))
            throw new Exception(Format("Cannot compose functions of different parameters: ", a, " and ", b));
          if (b.RetType[0] == 'f')
            mixin(ctReplace(SetResAVec, "$PV", "b.fun", "$VALUE2", "right(rest).f"));
          else if (b.RetType[0] == 'v')
            mixin(ctReplace(SetResAVec, "$PV", "b.fun", "$VALUE2", "right(rest).v"));
        }
      }
    }
  }
  fail(Format("Cannot merge ", a.type, " and ", b.type, " over ", OP));
}

bool gotValueExpr(ref string s, out Multival mv, int depth = 0, bool paramlist = false) {
  const string MatchBlock = `
      if (mixin(gotMatchExpr("s: $mv<-gotValueExpr/DEPTH+1, paramlist$"))) {
        Multival second;
        while (true) {
          bool match;
          foreach (i, bogus; Tuple!(OPS)) {
            const OP = Tuple!(OPS)[i];
            if (mixin(gotMatchExpr("s: "~OP~" $second<-gotValueExpr/DEPTH, paramlist$"))) {
              mv = merge!(OP)(mv, second);
              match = true;
            }
          }
          if (!match) break;
        }
        return true;
      } else return false;
  `;
  switch (depth) {
    case 0: // match comma expressions (tuples)
      auto backup = s;
      if (!s.gotValueExpr(mv, 1, paramlist)) return false;
recheck0:
      bool changed;
      Multival next;
      if (paramlist && mixin(gotMatchExpr("s: , $next<-gotValueExpr/0, true$"))) {
        mv.append(next);
        changed = true;
      }
      if (changed) goto recheck0;
      return true;
    case 1: mixin(ctReplace(MatchBlock, "OPS", `"+"[], "-"[]`, "DEPTH", "1")); // match +-
    case 2: mixin(ctReplace(MatchBlock, "OPS", `"*"[], "/"[]`, "DEPTH", "2")); // match */
    case 3: mixin(ctReplace(MatchBlock, "OPS", `"%"[]`, "DEPTH", "3")); // match */
    case 4: // match closer expressions (.op, call)
      auto backup1 = s;
      if (!s.gotMultivalSimple(mv, paramlist)) return false;
recheck3:
      bool changed;
      if (mv.isVec || (mv.isFun && equal(mv.RetType(), "v"))) {
        int part; // parse <vec>.x
        if (mixin(gotMatchExpr("s: [.x $# part=0$ |.y $# part=1 $ |.z $# part=2 $ |.length $# part = 3 $]"))) {
          if (mv.isVec) {
            if (part == 3) mv = mv.v.length;
            else mv = mv.v.field[part];
          } else {
            if (part == 3) {
              mv = Multival(mv.fun /xapply/ (Multiproc dg, Multival rest) {
                return Multival(dg(rest).v.length);
              }, concat("d", mv.ParamType, "f"));
            } else {
              mv = Multival(stuple(mv.fun, part) /xapply/ (Multiproc dg, int part, Multival rest) {
                return Multival(dg(rest).v.field[part]);
              }, concat("d", mv.ParamType, "f"));
            }
          }
          changed = true;
        }
      }
      if (mv.isFun) {
        Multival param;
        // function call
        auto backup2 = s;
        if (mixin(gotMatchExpr("s: ($param<-gotValueExpr/0, true$)"))) {
          // logln("Got param: ", param);
          // call and composition
          bool canCall() {
            return equiv(param.type, mv.ParamType) || (param.isFun() && equiv(param.RetType, mv.ParamType));
          }
          if (!canCall) {
            // try to do tail call
            Multival tail;
            SceneObject so;
            string s2 = s;
            if (mixin(gotMatchExpr("s2: [$so<-gotObjSimple#tail=so$|$tail$]"))) {
              param.append(tail);
              if (!canCall) fail("Call syntax used but types invalid");
              else s = s2;
            } else {
              // can't call
              fail(Format("Call syntax used but types invalid: ", param.type, " into ", mv.ParamType,
                "; ", backup2.next_text(), " into ", backup1.next_text()));
            }
          }
          mv = mv.call(param);
          // logln("Call -> ", mv);
          changed = true;
        }
      }
      if (changed) goto recheck3;
      return true;
    default: throw new Exception("Unsupported depth for gotValueExpr!");
  }
}

bool gotFloatExpr(ref string s, out float f) {
  if (mixin(gotMatchExpr("s: -$f<-gotFloatExpr$"))) { f = -f; return true; }
  auto s2 = s; // speculative
  Multival mv;
  if (!s2.gotValueExpr(mv)) return false;
  if (!asFloat(mv, f)) return false;
  s = s2;
  return true;
}

bool gotVecExpr(ref string s, out vec v) {
  if (mixin(gotMatchExpr("s: -$v<-gotVecExpr$"))) { v = -v; return true; }
  auto s2 = s; // speculative again
  Multival mv;
  if (!s2.gotValueExpr(mv)) return false;
  float f;
  if (asFloat(mv, f)) {
    v = vec(f);
  } else if (mv.isVec) {
    v = mv.v;
  } else return false;
  s = s2;
  return true;
}

bool gotFun(ref string s, out Multiproc dg, string full) {
  auto s2 = s;
  Multival mv;
  if (!s2.gotValueExpr(mv)) return false;
  if (!mv.isFun) { logln("Type mismatch: expected ", full, ", got ", mv.type[0 .. getlen(mv.type)]); return false; }
  if (mv.type[0 .. getlen(mv.type)] != full) {
    logln("Type mismatch: got ", mv.type[0 .. getlen(mv.type)], ", expected ", full);
    return false;
  }
  dg = mv.fun;
  s = s2;
  return true;
}

bool gotMultival(ref string s, out Multival mv) {
  auto s2 = s;
  if (!s2.gotValueExpr(mv)) return false;
  s = s2;
  return true;
}

// does not include csg, just evaluation .. well, unless brackets are used
bool gotObjSimple(ref string s, out SceneObject so) {
  if (mixin(gotMatchExpr("s: ($so$)"))) return true;
  auto s2 = s;
  Multival mv;
  if (!s2.gotValueExpr(mv)) return false;
  if (!mv.isObj) return false;
  so = cast(SceneObject) mv.obj;
  s = s2;
  return true;
}

mixin Got!(
  float, gotFloatExpr,
  int, gotInt,
  vec, gotVecExpr,
  string, gotString,
  SceneObject, gotObjCSG,
  Multival, gotMultival
);

bool gotComplex(ref string s, out Multival mv) {
  SceneObject so;
  if (mixin(gotMatchExpr("s: [$so$ | ($so$)]"))) { mv = so; return true; }
  return mixin(gotMatchExpr("s: $mv$"));
}

import tools.simplex;

final class Variables {
  static {
    SceneObject set_fn(ref string s) {
      string name; Multival mv;
      mixin(MatchExpr("s: ($name$) $mv<-gotComplex$"));
      set(name, mv);
      return NullObject;
    }
    Multival[string] vars;
    Object sync;
    void set(string s, Multival mv) { synchronized(sync) vars[s] = mv; }
    private void unset(string s) { synchronized(sync) vars.remove(s); }
    T getSpecific(T)(string name) {
      Multival mv;
      if (!gotVar(name, mv)) throw new Exception("Unknown identifier "~name);
      if (!mv.matches!(T)())
        throw new Exception(Format(
          "Unexpected type: wanted ", T.stringof, ", but variable is  ",
          [0: "float"[], 1: "vec", 2: "SceneObject", 3: "string", 4: "function"][mv.type]
        ));
      return mv.get!(T)();
    }
    void delegate() genScope(T)(string name, T t) {
      Multival backup; bool restore;
      synchronized(sync) if (auto p = name in vars) { backup = *p; restore = true; }
      name.set(Multival(t));
      return stuple(name, backup, restore) /apply/ (string st, Multival mv, bool restore) {
        if (restore) st.set(mv);
        else st.unset();
      };
    }
    bool gotSpecific(T)(string name, out T t) {
      Multival mv;
      if (!gotVar(name, mv)) return false;
      if (!mv.matches!(T)()) return false;
      t = mv.get!(T)();
      return true;
    }
    bool gotVar(string s, out Multival mv) {
      bool res;
      synchronized(sync)
        if (auto p = s in vars) {
          mv = *p;
          // don't need dup now that we moved offset to implicit
          // if (mv.isSO && mv.so) mv.so = mv.so.dup;
          res = true;
        }
      return res;
    }
  }
  static this() {
    sync = new Object;
    parse_fns["set"] = &set_fn;
    builtin["set"] = true;
    vars["x"] = Multival(vec(1, 0, 0));
    vars["y"] = Multival(vec(0, 1, 0));
    vars["z"] = Multival(vec(0, 0, 1));
    vars["sin"] = Multival((Multival mv) { return Multival(cast(float) sin(mv.f)); }, "dff");
    vars["cos"] = Multival((Multival mv) { return Multival(cast(float) cos(mv.f)); }, "dff");
    vars["sqr"] = Multival((Multival mv) { return Multival(mv.f * mv.f); }, "dff");
    vars["sqrt"] = Multival((Multival mv) { return Multival(cast(float) sqrt(mv.f)); }, "dff");
    vars["checker"] = Multival((Multival mv) {
      return Multival(stuple(mv[0].v, mv[1].v) /xapply/ (vec a, vec b, Multival m) {
        auto v = m.v;
        auto x = cast(uint) lrint(v.x), y = cast(uint) lrint(v.y), z = cast(uint) lrint(v.z);
        return Multival(((x&1)^(y&1)^(z&1))?a:b);
      }, TypeToInfo!(vec delegate(vec)));
    }, TypeToInfo!(vec delegate(vec) delegate(vec, vec)));
    vars["gensimplex"] = Multival((Multival mv) {
      auto rng = new Mersenne(lrint(mv.get!(float)));
      auto sim = Simplex({ return rng(); }); // only used to construct
      static Multival simpfunc(ref Simplex si, Multival mv) {
        return Multival(si.noise!(3)(mv.v.tuple));
      }
      return Multival(sim /xapply/ &simpfunc, TypeToInfo!(float delegate(vec)));
    }, TypeToInfo!(float delegate(vec) delegate(float)));
    vars["mkvec"] = Multival((Multival mv) {
      if (equal(mv.type, TypeToInfo!(float delegate(vec), float delegate(vec), float delegate(vec)).ptr)) {
        return Multival(
          strfix!("Multival(vec(data[0](rest).f, data[1](rest).f, data[2](rest).f))", Multival)
          (mv.fun, mv[1].fun, mv[2].fun), "dvv"
        );
      } else if (equal(mv.type, TypeToInfo!(float delegate(float), float delegate(float), float delegate(float)).ptr)) {
        return Multival(
          strfix!("Multival(vec(data[0](rest).f, data[1](rest).f, data[2](rest).f))", Multival)
          (mv.fun, mv[1].fun, mv[2].fun), "dfv"
        );
      } else if (equal(mv.type, TypeToInfo!(float delegate(float)).ptr)) {
        return Multival(
          strfix!("Multival(vec(data[0](rest).f))", Multival)
          (mv.fun), "dfv"
        );
      } else if (equal(mv.type, TypeToInfo!(float delegate(vec)).ptr)) {
        return Multival(
          strfix!("Multival(vec(data[0](rest).f))", Multival)
          (mv.fun), "dvv"
        );
      } else {
        logln("Invalid parameter for mkvec: ", mv);
        dbg_break;
      }
    }, TypeToInfo!(vec delegate(vec) delegate(Multival)));
    vars["ident_float"] = Multival((Multival mv) { return mv; }, TypeToInfo!(float delegate(float)));
    vars["ident_vec"] = Multival((Multival mv) { return mv; }, TypeToInfo!(vec delegate(vec)));
    /*vars["pow"] = Multival((Multival mv) {
      return Multival(mv.f /xapply/ (float factor, Multival mv) {
        return Multival(stuple(factor, mv.fun) /xapply/ (float factor, Multiproc dg, Multival param) {
          return Multival(cast(float) pow(dg(param).f, factor));
        }, TypeToInfo!(float delegate(vec)));
      }, TypeToInfo!(float delegate(vec) delegate(float delegate(vec))));
    }, TypeToInfo!(float delegate(vec) delegate(float delegate(vec)) delegate(float)));*/
    vars["pow"] = Multival((Multival mv) {
      return Multival(mv.f /xapply/ (float factor, Multival mv) {
        return Multival(cast(float) pow(mv.f, factor));
      }, TypeToInfo!(float delegate(float)));
    }, TypeToInfo!(float delegate(float) delegate(float)));
    vars["ifgz"] = Multival((Multival mv) {
      return Multival(stuple(mv.v, mv[1].v) /xapply/ (vec v1, vec v2, Multival mv) {
        return Multival((mv.f > 0)?v1:v2);
      }, TypeToInfo!(vec delegate(float)));
    }, TypeToInfo!(vec delegate(float) delegate(vec, vec)));
    vars["×"] = Multival((Multival mv) {
      return Multival(mv[0].v.cross(mv[1].v));
    }, TypeToInfo!(vec delegate(vec, vec)));
    vars["angle"] = Multival((Multival mv) {
      return Multival(mv[0].v.angle(mv[1].v));
    }, TypeToInfo!(float delegate(vec, vec)));
    vars["rot"] = Multival((Multival mv) {
      return Multival(stuple(mv[0].v, mv[1].f) /xapply/ (vec axis, float deg, vec v) {
        return v.rotate(axis, deg);
      }, TypeToInfo!(vec delegate(vec)));
    }, TypeToInfo!(vec delegate(vec) delegate(vec, float)));
    vars["toSpherical"] = Multival((Multival mv) {
      vec v = mv.v, res = void;
      res.x = v.length;
      res.y = atan2(v.y, v.x);
      res.z = atan2(sqrt(v.x * v.x + v.y * v.y), v.z);
      return Multival(res);
    }, TypeToInfo!(vec delegate(vec)));
    vars["min"] = Multival((Multival mv) {
      return Multival(mv.f /xapply/ (float f1, Multival mv) {
        return Multival(min(f1, mv.f));
      }, TypeToInfo!(float delegate(float)));
    }, TypeToInfo!(float delegate(float) delegate(float)));
    vars["max"] = Multival((Multival mv) {
      return Multival(mv.f /xapply/ (float f1, Multival mv) {
        return Multival(max(f1, mv.f));
      }, TypeToInfo!(float delegate(float)));
    }, TypeToInfo!(float delegate(float) delegate(float)));
    vars["int"] = Multival((Multival mv) { return Multival(cast(int) mv.f); }, TypeToInfo!(int delegate(float)));
    vars["blend"] = Multival((Multival mv) {
      enforce(mv.length == 2, "Cannot blend more than two values as of yet. ");
      enforce(mv[0].selftype == mv[1].selftype, "Cannot blend two values of disparate types: ", mv[0].type, " and ", mv[1].type);
      if (mv[0].isFloat && mv[1].isFloat)
        return Multival(stuple(mv[0].f, mv[1].f) /xapply/ (float a, float b, Multival c) {
          auto f = c.f;
          f -= floor(f);
          return Multival(a * (1f - f) + b * f);
        }, TypeToInfo!(float delegate(float)));
      if (mv[0].isVec && mv[1].isVec)
        return Multival(stuple(mv[0].v, mv[1].v) /xapply/ (vec a, vec b, Multival c) {
          auto f = c.f;
          f -= floor(f);
          return Multival(a * (1f - f) + b * f);
        }, TypeToInfo!(vec delegate(float)));
      assert(false);
    }, TypeToInfo!(Multival delegate(float) delegate(Multival)));
    vars["ddf"] = Multival((Multival mv) { // dense data file; lines of raw-encoded floats
      static Stuple!(int, ubyte[])[string] FileCache;
      ubyte[] data; int width;
      synchronized {
        if (auto p = mv.s in FileCache)
          ptuple(width, data) = *p;
        else {
          auto file = mv.s.read().castLike("");
          width = file.slice("\n").atoi() * 4;
          data = cast(ubyte[]) file;
          FileCache[mv.s] = stuple(width, data);
        }
      }
      return Multival(stuple(data, width) /apply/ (ubyte[] data, int width, Multival mv) {
        auto line = data[width * mv.i .. width * (mv.i + 1)];
        return Multival(line /apply/ (ubyte[] line, Multival mv) {
          int column = mv.i;
          auto chunk = line[column * 4 .. (column + 1) * 4];
          return Multival(*cast(float*) chunk.ptr);
        }, TypeToInfo!(float delegate(int)));
      }, TypeToInfo!(float delegate(int) delegate(int)));
    }, TypeToInfo!(float delegate(int) delegate(int) delegate(string)));
    /// Thank you PoVRay
    vars["ridged_mf"] = Multival((Multival mv) {
      auto H = mv.f, lacun = mv[1].f, octaves = cast(int) (mv[2].f + 0.5),
        offset = mv[3].f, gain = mv[4].f, noise = mv[5].fun;
      float freq = 1f;
      // I'm sorry. I'm so sorry .. 
      const string InnerCode = `
        vec v1 = mv.v;
        float signal = void;
        const string recalcSignal = "
          signal = noise(Multival(v1)).f * 2f - 1f;
          if (signal < 0f) signal = -signal;
          signal = offset - signal;
          signal *= signal; ";
        mixin(recalcSignal);
        auto result = signal, weight = 1f;
        foreach (v; ea[0 .. octaves]) {
          v1 *= lacun;
          weight = signal * gain;
          if (weight > 1f) weight = 1f;
          if (weight < 0f) weight = 0f;
          mixin(recalcSignal);
          signal *= weight;
          result += signal * v;
        }
        return Multival(result);
      `;
      struct FewOctaves { float[10] eas; }
      if (octaves <= 10) {
        FewOctaves fo = void;
        foreach (ref v; fo.eas[0 .. octaves]) {
          v = pow(freq, -H);
          freq *= lacun;
        }
        static Multival octaves1(FewOctaves fea, float lacun, int octaves, float offset, float gain, Multiproc noise, Multival mv) {
          auto ea = fea.eas[0 .. octaves];
          mixin(InnerCode);
        }
        return Multival(stuple(fo, lacun, octaves, offset, gain, noise) /xapply/ &octaves1, TypeToInfo!(float delegate(vec)));
      } else {
        auto ea = new float[octaves];
        foreach (ref v; ea) {
          v = pow(freq, -H);
          freq *= lacun;
        }
        static Multival octaves2(float[] ea, float lacun, int octaves, float offset, float gain, Multiproc noise, Multival mv) {
          mixin(InnerCode);
        }
        return Multival(stuple(ea, lacun, octaves, offset, gain, noise) /xapply/ &octaves2, TypeToInfo!(float delegate(vec)));
      }
    }, TypeToInfo!(float delegate(vec) delegate(Repeat!(float, 5), float delegate(vec))));
  }
}