Autounravel

.clang-format

@@ -21,7 +21,7 @@ BreakBeforeBraces: Custom
 BraceWrapping:
   AfterCaseLabel: false
   AfterClass: true
-  AfterControlStatement: Always
+  AfterControlStatement: false
   AfterEnum: true
   AfterFunction: true
   AfterNamespace: true
@@ -35,8 +35,8 @@ BreakBeforeBinaryOperators: None
 BreakBeforeTernaryOperators: true
 BreakConstructorInitializers: BeforeColon
 BreakInheritanceList: BeforeColon
-BinPackArguments: false
-ColumnLimit: 120
+BinPackArguments: true
+ColumnLimit: 80
 CompactNamespaces: false
 ContinuationIndentWidth: 8
 IndentCaseLabels: true
@@ -49,7 +49,7 @@ ObjCSpaceAfterProperty: false
 ObjCSpaceBeforeProtocolList: true
 PointerAlignment: Left
 ReferenceAlignment: Left
-ReflowComments: false
+ReflowComments: true
 SpaceAfterCStyleCast: true
 SpaceAfterLogicalNot: false
 SpaceAfterTemplateKeyword: false

base/rational.asy

@@ -41,107 +41,108 @@ struct rational {
     this.q=q;
     if(reduce) reduce();
   }
-}
 
-rational operator cast(int p)
-{
-  return rational(p,false);
-}
+  autounravel rational operator cast(int p)
+  {
+    return rational(p,false);
+  }
 
-rational[] operator cast(int[] a)
-{
-  return sequence(new rational(int i) {return a[i];},a.length);
-}
+  autounravel rational[] operator cast(int[] a)
+  {
+    return sequence(new rational(int i) {return a[i];},a.length);
+  }
 
-rational[][] operator cast(int[][] a)
-{
-  return sequence(new rational[](int i) {return a[i];},a.length);
-}
+  autounravel rational[][] operator cast(int[][] a)
+  {
+    return sequence(new rational[](int i) {return a[i];},a.length);
+  }
 
-real operator ecast(rational r)
-{
-  return r.p/r.q;
-}
+  real operator ecast(rational r)
+  {
+    return r.p/r.q;
+  }
 
-rational operator ecast(real x)
-{
-  int sign=x >= 0.0 ? 1 : -1;
-  x=abs(x);
-  int a=floor(x); int b=1;
-  int c=a+1; int d=1;
-
-  while(true) {
-    int e=a+c;
-    int f=b+d;
-    if(f > maxDenominator) break;
-    if(e/f == x)
-      return rational(sign*e,f);
-    else {
-      if(e/f < x) {
-        a=e;
-        b=f;
-      } else {
-        c=e;
-        d=f;
+  autounravel rational operator ecast(real x)
+  {
+    int sign=x >= 0.0 ? 1 : -1;
+    x=abs(x);
+    int a=floor(x); int b=1;
+    int c=a+1; int d=1;
+
+    while(true) {
+      int e=a+c;
+      int f=b+d;
+      if(f > maxDenominator) break;
+      if(e/f == x)
+        return rational(sign*e,f);
+      else {
+        if(e/f < x) {
+          a=e;
+          b=f;
+        } else {
+          c=e;
+          d=f;
+        }
       }
     }
+    return abs(a/b-x) < abs(c/d-x) ? rational(sign*a,b) : rational(sign*c,d);
   }
-  return abs(a/b-x) < abs(c/d-x) ? rational(sign*a,b) : rational(sign*c,d);
-}
 
-rational operator -(rational r)
-{
-  return rational(-r.p,r.q,false);
-}
+  autounravel rational operator -(rational r)
+  {
+    return rational(-r.p,r.q,false);
+  }
 
-rational operator +(rational r, rational s)
-{
-  return rational(r.p*s.q+s.p*r.q,r.q*s.q);
-}
+  autounravel rational operator +(rational r, rational s)
+  {
+    return rational(r.p*s.q+s.p*r.q,r.q*s.q);
+  }
 
-rational operator -(rational r, rational s)
-{
-  return rational(r.p*s.q-s.p*r.q,r.q*s.q);
-}
+  autounravel rational operator -(rational r, rational s)
+  {
+    return rational(r.p*s.q-s.p*r.q,r.q*s.q);
+  }
 
-rational operator *(rational r, rational s)
-{
-  return rational(r.p*s.p,r.q*s.q);
-}
+  autounravel rational operator *(rational r, rational s)
+  {
+    return rational(r.p*s.p,r.q*s.q);
+  }
 
-rational operator /(rational r, rational s)
-{
-  return rational(r.p*s.q,r.q*s.p);
-}
+  autounravel rational operator /(rational r, rational s)
+  {
+    return rational(r.p*s.q,r.q*s.p);
+  }
 
-bool operator ==(rational r, rational s)
-{
-  return r.p == s.p && r.q == s.q;
-}
+  autounravel bool operator ==(rational r, rational s)
+  {
+    return r.p == s.p && r.q == s.q;
+  }
 
-bool operator !=(rational r, rational s)
-{
-  return r.p != s.p || r.q != s.q;
-}
+  autounravel bool operator !=(rational r, rational s)
+  {
+    return r.p != s.p || r.q != s.q;
+  }
 
-bool operator <(rational r, rational s)
-{
-  return r.p*s.q-s.p*r.q < 0;
-}
+  autounravel bool operator <(rational r, rational s)
+  {
+    return r.p*s.q-s.p*r.q < 0;
+  }
 
-bool operator >(rational r, rational s)
-{
-  return r.p*s.q-s.p*r.q > 0;
-}
+  autounravel bool operator >(rational r, rational s)
+  {
+    return r.p*s.q-s.p*r.q > 0;
+  }
 
-bool operator <=(rational r, rational s)
-{
-  return r.p*s.q-s.p*r.q <= 0;
-}
+  autounravel bool operator <=(rational r, rational s)
+  {
+    return r.p*s.q-s.p*r.q <= 0;
+  }
+
+  autounravel bool operator >=(rational r, rational s)
+  {
+    return r.p*s.q-s.p*r.q >= 0;
+  }
 
-bool operator >=(rational r, rational s)
-{
-  return r.p*s.q-s.p*r.q >= 0;
 }
 
 bool[] operator ==(rational[] r, rational s)

builtin.cc

@@ -127,7 +127,7 @@ function *functionFromFormals(ty *result,
   return fun;
 }
 
-void addFunc(venv &ve, access *a, ty *result, symbol id,
+varEntry *addFunc(venv &ve, access *a, ty *result, symbol id,
              formal f1=noformal, formal f2=noformal, formal f3=noformal,
              formal f4=noformal, formal f5=noformal, formal f6=noformal,
              formal f7=noformal, formal f8=noformal, formal f9=noformal,
@@ -143,10 +143,11 @@ void addFunc(venv &ve, access *a, ty *result, symbol id,
   varEntry *ent = new varEntry(fun, a, 0, nullPos);
 
   ve.enter(id, ent);
+  return ent;
 }
 
 // Add a function with one or more default arguments.
-void addFunc(venv &ve, bltin f, ty *result, symbol name,
+varEntry *addFunc(venv &ve, bltin f, ty *result, symbol name,
              formal f1, formal f2, formal f3, formal f4, formal f5, formal f6,
              formal f7, formal f8, formal f9, formal fA, formal fB, formal fC,
              formal fD, formal fE, formal fF, formal fG, formal fH, formal fI)
@@ -171,8 +172,8 @@ void addFunc(venv &ve, bltin f, ty *result, symbol name,
 #endif
 
   access *a = new bltinAccess(f);
-  addFunc(ve,a,result,name,f1,f2,f3,f4,f5,f6,f7,f8,f9,
-          fA,fB,fC,fD,fE,fF,fG,fH,fI);
+  return addFunc(ve,a,result,name,f1,f2,f3,f4,f5,f6,f7,f8,f9,
+                 fA,fB,fC,fD,fE,fF,fG,fH,fI);
 }
 
 void addOpenFunc(venv &ve, bltin f, ty *result, symbol name)
@@ -659,22 +660,26 @@ void addArrayOps(venv &ve, types::array *t)
   }
 }
 
-void addRecordOps(venv &ve, record *r)
+void addRecordOps(record* r)
 {
-  addFunc(ve, run::boolMemEq, primBoolean(), SYM(alias), formal(r, SYM(a)),
-          formal(r, SYM(b)));
-  addFunc(ve, run::boolMemEq, primBoolean(), SYM_EQ, formal(r, SYM(a)),
-          formal(r, SYM(b)));
-  addFunc(ve, run::boolMemNeq, primBoolean(), SYM_NEQ, formal(r, SYM(a)),
-          formal(r, SYM(b)));
+  assert(r);
+  trans::venv &ve = r->e.ve;
+  auto addOp= [&ve](vm::bltin f, ty* result, symbol name, auto&&... formals) {
+    varEntry* fVar=
+            addFunc(ve, f, result, name, std::forward<formal>(formals)...);
+    ve.registerAutoUnravel(name, fVar, AutounravelPriority::OFFER);
+  };
+  // alias
+  addOp(run::boolMemEq, primBoolean(), SYM(alias), formal(r, SYM(a)),
+        formal(r, SYM(b)));
+  // operator==
+  addOp(run::boolMemEq, primBoolean(), SYM_EQ, formal(r, SYM(a)),
+        formal(r, SYM(b)));
+  // operator!=
+  addOp(run::boolMemNeq, primBoolean(), SYM_NEQ, formal(r, SYM(a)),
+        formal(r, SYM(b)));
 }
 
-void addFunctionOps(venv &ve, function *f)
-{
-  // No function ops.
-}
-
-
 void addOperators(venv &ve)
 {
   addSimpleOperator(ve,binaryOp<string,plus>,primString(),SYM_PLUS);
@@ -755,7 +760,7 @@ dummyRecord *createDummyRecord(venv &ve, symbol name)
   dummyRecord *r=new dummyRecord(name);
   vm::vmFrame *f = make_dummyframe(name);
   addConstant(ve, f, r, name);
-  addRecordOps(ve, r);
+  addRecordOps(r);
   return r;
 }
 

builtin.h

@@ -23,21 +23,20 @@ void base_venv(venv &);
 extern const types::formal noformal;
 
 // Add a function with one or more default arguments.
-void addFunc(venv &ve, vm::bltin f, types::ty *result, symbol name,
-             types::formal f1=noformal, types::formal f2=noformal,
-             types::formal f3=noformal, types::formal f4=noformal,
-             types::formal f5=noformal, types::formal f6=noformal,
-             types::formal f7=noformal, types::formal f8=noformal,
-             types::formal f9=noformal, types::formal fA=noformal,
-             types::formal fB=noformal, types::formal fC=noformal,
-             types::formal fD=noformal, types::formal fE=noformal,
-             types::formal fF=noformal, types::formal fG=noformal,
-             types::formal fH=noformal, types::formal fI=noformal);
+varEntry *addFunc(venv &ve, vm::bltin f, types::ty *result, symbol name,
+                  types::formal f1=noformal, types::formal f2=noformal,
+                  types::formal f3=noformal, types::formal f4=noformal,
+                  types::formal f5=noformal, types::formal f6=noformal,
+                  types::formal f7=noformal, types::formal f8=noformal,
+                  types::formal f9=noformal, types::formal fA=noformal,
+                  types::formal fB=noformal, types::formal fC=noformal,
+                  types::formal fD=noformal, types::formal fE=noformal,
+                  types::formal fF=noformal, types::formal fG=noformal,
+                  types::formal fH=noformal, types::formal fI=noformal);
 
 // Adds standard functions for a newly added types.
 void addArrayOps(venv &ve, types::array *t);
-void addRecordOps(venv &ve, types::record *r);
-void addFunctionOps(venv &ve, types::function *f);
+void addRecordOps(types::record *r);
 
 #ifdef HAVE_LIBGSL
 types::record *getGSLModule();

camp.l

@@ -372,6 +372,8 @@ include            {adjust(); return INCLUDE; }
 quote              {adjust(); return QUOTE; }
 static             {adjust(); makemod(trans::EXPLICIT_STATIC);
                               return MODIFIER; }
+autounravel        {adjust(); makemod(trans::AUTOUNRAVEL);
+                              return MODIFIER; }
 public             {adjust(); makeperm(trans::PUBLIC); return PERM; }
 private            {adjust(); makeperm(trans::PRIVATE); return PERM; }
 restricted         {adjust(); makeperm(trans::RESTRICTED); return PERM; }

coder.h

@@ -149,8 +149,13 @@ class coder {
     assert(s != DEFAULT_STATIC && s != DEFAULT_DYNAMIC);
 
     /* Non-default static overrules. */
-    if (sord != EXPLICIT_STATIC)
+    if (s == AUTOUNRAVEL || sord == AUTOUNRAVEL) {
+      sord = AUTOUNRAVEL;
+    } else if (s == EXPLICIT_STATIC || sord == EXPLICIT_STATIC) {
+      sord = EXPLICIT_STATIC;
+    } else {
       sord = s;
+    }
 
     sord_stack.push(sord);
   }
@@ -161,6 +166,7 @@ class coder {
     switch(sord) {
       case DEFAULT_STATIC:
       case EXPLICIT_STATIC:
+      case AUTOUNRAVEL:
         return true;
       case DEFAULT_DYNAMIC:
       case EXPLICIT_DYNAMIC:
@@ -171,6 +177,11 @@ class coder {
     }
   }
 
+  bool isAutoUnravel()
+  {
+    return sord == AUTOUNRAVEL;
+  }
+
 
   /* Remove a modifier. */
   void popModifier()