From b6d7986249087c365952dd58ed0c2e6f097cb9d9 Mon Sep 17 00:00:00 2001
From: David Schmenk <dschmenk@gmail.com>
Date: Fri, 15 Dec 2017 10:51:44 -0800
Subject: [PATCH] Consistent API names for SANE

---
 src/inc/sane.plh     |  22 ++--
 src/libsrc/fpstr.pla |   8 +-
 src/libsrc/fpu.pla   | 232 +++++++++++++++++++++----------------------
 3 files changed, 131 insertions(+), 131 deletions(-)

diff --git a/src/inc/sane.plh b/src/inc/sane.plh
index 311d409..5637360 100644
--- a/src/inc/sane.plh
+++ b/src/inc/sane.plh
@@ -130,17 +130,17 @@ end
 // SANE PLASMA interface
 //
 struc t_sane
-    word fpInit
-    word fpHalt
-    word fpOp0
-    word fpOp1
-    word fpOp2
-    word fpOp3
-    word elOp1
-    word elOp2
-    word elOp3
-    word zpSave
-    word zpRestore
+    word initFP
+    word haltFP
+    word op0FP
+    word op1FP
+    word op2FP
+    word op3FP
+    word op1ELEM
+    word op2ELEM
+    word op3ELEM
+    word saveZP
+    word restoreZP
 end
 word sane
 end
diff --git a/src/libsrc/fpstr.pla b/src/libsrc/fpstr.pla
index 7b5a1c7..0ae7537 100644
--- a/src/libsrc/fpstr.pla
+++ b/src/libsrc/fpstr.pla
@@ -124,8 +124,8 @@ export def str2ext(str, ext)
         decrec.sig = 1
         decrec.sig.1 = '0'
     fin
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFEXT|FOD2B, ext, @decrec))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFEXT|FOD2B, ext, @decrec))
 end
 //
 // Convert extended FP to string using , return string
@@ -139,8 +139,8 @@ export def ext2str(ext, str, intdigits, fracdigits, format)
     numdigits = intdigits + fracdigits
     decform:style  = format & $01
     decform:digits = decform:style ?? fracdigits :: numdigits
-    sane:zpSave()
-    sane:zpRestore(sane:fpOp3(FFEXT|FOB2D, @decrec, ext, @decform))
+    sane:saveZP()
+    sane:restoreZP(sane:op3FP(FFEXT|FOB2D, @decrec, ext, @decform))
     ^(str+1) = decrec.sgn ?? '-' :: ' '
     if decrec.sig.1 == 'I'
         ^(str+2) = 'I'
diff --git a/src/libsrc/fpu.pla b/src/libsrc/fpu.pla
index 937886c..73cb454 100644
--- a/src/libsrc/fpu.pla
+++ b/src/libsrc/fpu.pla
@@ -53,28 +53,28 @@ word stackRegs[4]
 // Environment access
 //
 def setEnv(env)
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp1(FOSETENV, env))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1FP(FOSETENV, env))
 end
 def getEnv
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp0(FOGETENV))
+    sane:saveZP()
+    return sane:restoreZP(sane:op0FP(FOGETENV))
 end
 def testExcept(except)
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp1(FOTESTXCP, except))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1FP(FOTESTXCP, except))
 end
 def setExcept(except)
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp1(FOSETXCP, except))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1FP(FOSETXCP, except))
 end
 def enterProc(pEnv)
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp1(FOPROCENTRY, pEnv))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1FP(FOPROCENTRY, pEnv))
 end
 def exitProc(env)
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp1(FOPROCEXIT, env))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1FP(FOPROCEXIT, env))
 end
 //
 // Stack manipulation routines
@@ -118,79 +118,79 @@ end
 def clear
     word zero
     zero = 0
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFINT|FOZ2X, stackRegs[0], @zero))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFINT|FOZ2X, stackRegs[0], @zero))
 end
 //
 // Stack access
 //
 def pushInt(pInt)
     stackRegs[0], stackRegs[1], stackRegs[2], stackRegs[3] = stackRegs[3], stackRegs[0], stackRegs[1], stackRegs[2]
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFINT|FOZ2X, stackRegs[0], pInt))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFINT|FOZ2X, stackRegs[0], pInt))
 end
 def pullInt(pInt)
-    sane:zpSave()
-    return _drop(sane:zpRestore(sane:fpOp2(FFINT|FOX2Z, pInt, stackRegs[0])))
+    sane:saveZP()
+    return _drop(sane:restoreZP(sane:op2FP(FFINT|FOX2Z, pInt, stackRegs[0])))
 end
 def loadInt(pInt, reg)
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFINT|FOZ2X, stackRegs[reg & $03], pInt))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFINT|FOZ2X, stackRegs[reg & $03], pInt))
 end
 def storInt(pInt, reg)
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFINT|FOX2Z, pInt, stackRegs[reg & $03]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFINT|FOX2Z, pInt, stackRegs[reg & $03]))
 end
 def pushSgl(pSgl)
     stackRegs[0], stackRegs[1], stackRegs[2], stackRegs[3] = stackRegs[3], stackRegs[0], stackRegs[1], stackRegs[2]
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFSGL|FOZ2X, stackRegs[0], pSgl))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFSGL|FOZ2X, stackRegs[0], pSgl))
 end
 def pullSgl(pSgl)
-    sane:zpSave()
-    return _drop(sane:zpRestore(sane:fpOp2(FFSGL|FOX2Z, pSgl, stackRegs[0])))
+    sane:saveZP()
+    return _drop(sane:restoreZP(sane:op2FP(FFSGL|FOX2Z, pSgl, stackRegs[0])))
 end
 def loadSgl(pSgl, reg)
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFSGL|FOZ2X, stackRegs[reg & $03], pSgl))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFSGL|FOZ2X, stackRegs[reg & $03], pSgl))
 end
 def storSgl(pSgl, reg)
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFSGL|FOX2Z, pSgl, stackRegs[reg & $03]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFSGL|FOX2Z, pSgl, stackRegs[reg & $03]))
 end
 def pushDbl(pDbl)
     stackRegs[0], stackRegs[1], stackRegs[2], stackRegs[3] = stackRegs[3], stackRegs[0], stackRegs[1], stackRegs[2]
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFDBL|FOZ2X, stackRegs[0], pDbl))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFDBL|FOZ2X, stackRegs[0], pDbl))
 end
 def pullDbl(pDbl)
-    sane:zpSave()
-    return _drop(sane:zpRestore(sane:fpOp2(FFDBL|FOX2Z, pDbl, stackRegs[0])))
+    sane:saveZP()
+    return _drop(sane:restoreZP(sane:op2FP(FFDBL|FOX2Z, pDbl, stackRegs[0])))
 end
 def loadDbl(pDbl, reg)
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFDBL|FOZ2X, stackRegs[reg & $03], pDbl))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFDBL|FOZ2X, stackRegs[reg & $03], pDbl))
 end
 def storDbl(pDbl, reg)
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFDBL|FOX2Z, pDbl, stackRegs[reg & $03]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFDBL|FOX2Z, pDbl, stackRegs[reg & $03]))
 end
 def pushExt(pExt)
     stackRegs[0], stackRegs[1], stackRegs[2], stackRegs[3] = stackRegs[3], stackRegs[0], stackRegs[1], stackRegs[2]
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFEXT|FOZ2X, stackRegs[0], pExt))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFEXT|FOZ2X, stackRegs[0], pExt))
 end
 def pullExt(pExt)
-    sane:zpSave()
-    return _drop(sane:zpRestore(sane:fpOp2(FFEXT|FOX2Z, pExt, stackRegs[0])))
+    sane:saveZP()
+    return _drop(sane:restoreZP(sane:op2FP(FFEXT|FOX2Z, pExt, stackRegs[0])))
 end
 def loadExt(pExt, reg)
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFEXT|FOZ2X, stackRegs[reg & $03], pExt))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFEXT|FOZ2X, stackRegs[reg & $03], pExt))
 end
 def storExt(pExt, reg)
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFEXT|FOX2Z, pExt, stackRegs[reg & $03]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFEXT|FOX2Z, pExt, stackRegs[reg & $03]))
 end
 def pushStr(pStr)
     stackRegs[0], stackRegs[1], stackRegs[2], stackRegs[3] = stackRegs[3], stackRegs[0], stackRegs[1], stackRegs[2]
@@ -209,139 +209,139 @@ end
 // Basic math operations
 //
 def add
-    sane:zpSave()
-    return _drop(sane:zpRestore(sane:fpOp2(FFEXT|FOADD, stackRegs[1], stackRegs[0])))
+    sane:saveZP()
+    return _drop(sane:restoreZP(sane:op2FP(FFEXT|FOADD, stackRegs[1], stackRegs[0])))
 end
 def sub
-    sane:zpSave()
-    return _drop(sane:zpRestore(sane:fpOp2(FFEXT|FOSUB, stackRegs[1], stackRegs[0])))
+    sane:saveZP()
+    return _drop(sane:restoreZP(sane:op2FP(FFEXT|FOSUB, stackRegs[1], stackRegs[0])))
 end
 def mul
-    sane:zpSave()
-    return _drop(sane:zpRestore(sane:fpOp2(FFEXT|FOMUL, stackRegs[1], stackRegs[0])))
+    sane:saveZP()
+    return _drop(sane:restoreZP(sane:op2FP(FFEXT|FOMUL, stackRegs[1], stackRegs[0])))
 end
 def div
-    sane:zpSave()
-    return _drop(sane:zpRestore(sane:fpOp2(FFEXT|FODIV, stackRegs[1], stackRegs[0])))
+    sane:saveZP()
+    return _drop(sane:restoreZP(sane:op2FP(FFEXT|FODIV, stackRegs[1], stackRegs[0])))
 end
 def rem
-    sane:zpSave()
-    return _drop(sane:zpRestore(sane:fpOp2(FFEXT|FOREM, stackRegs[1], stackRegs[0])))
+    sane:saveZP()
+    return _drop(sane:restoreZP(sane:op2FP(FFEXT|FOREM, stackRegs[1], stackRegs[0])))
 end
 def neg
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp1(FFEXT|FONEG, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1FP(FFEXT|FONEG, stackRegs[0]))
 end
 def abs
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp1(FFEXT|FOABS, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1FP(FFEXT|FOABS, stackRegs[0]))
 end
 def type
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp1(FFEXT|FOCLASS, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1FP(FFEXT|FOCLASS, stackRegs[0]))
 end
 def cmp
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFEXT|FOCMP, stackRegs[1], stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFEXT|FOCMP, stackRegs[1], stackRegs[0]))
 end
 def trunc
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp1(FFEXT|FOTTI, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1FP(FFEXT|FOTTI, stackRegs[0]))
 end
 def round
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp1(FFEXT|FORTI, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1FP(FFEXT|FORTI, stackRegs[0]))
 end
 def sqrt
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp1(FFEXT|FOSQRT, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1FP(FFEXT|FOSQRT, stackRegs[0]))
 end
 def squared
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFEXT|FOMUL, stackRegs[0], stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFEXT|FOMUL, stackRegs[0], stackRegs[0]))
 end
 def logb
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp1(FFEXT|FOLOGB, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1FP(FFEXT|FOLOGB, stackRegs[0]))
 end
 def scalb(scale)
-    sane:zpSave()
-    return sane:zpRestore(sane:fpOp2(FFEXT|FOSCALB, stackRegs[0], scale))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2FP(FFEXT|FOSCALB, stackRegs[0], scale))
 end
 //
 // Elems operations
 //
 def cos
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp1(FFEXT|FOCOSX, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1ELEM(FFEXT|FOCOSX, stackRegs[0]))
 end
 def sin
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp1(FFEXT|FOSINX, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1ELEM(FFEXT|FOSINX, stackRegs[0]))
 end
 def tan
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp1(FFEXT|FOTANX, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1ELEM(FFEXT|FOTANX, stackRegs[0]))
 end
 def atan
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp1(FFEXT|FOATANX, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1ELEM(FFEXT|FOATANX, stackRegs[0]))
 end
 def log2X
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp1(FFEXT|FOLOG2X, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1ELEM(FFEXT|FOLOG2X, stackRegs[0]))
 end
 def log21X
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp1(FFEXT|FOLOG21X, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1ELEM(FFEXT|FOLOG21X, stackRegs[0]))
 end
 def lnX
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp1(FFEXT|FOLNX, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1ELEM(FFEXT|FOLNX, stackRegs[0]))
 end
 def ln1X
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp1(FFEXT|FOLN1X, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1ELEM(FFEXT|FOLN1X, stackRegs[0]))
 end
 def pow2X
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp1(FFEXT|FOEXP2X, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1ELEM(FFEXT|FOEXP2X, stackRegs[0]))
 end
 def pow21X
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp1(FFEXT|FOEXP21X, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1ELEM(FFEXT|FOEXP21X, stackRegs[0]))
 end
 def powEX
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp1(FFEXT|FOEXPX, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1ELEM(FFEXT|FOEXPX, stackRegs[0]))
 end
 def powE1X
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp1(FFEXT|FOEXP1X, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1ELEM(FFEXT|FOEXP1X, stackRegs[0]))
 end
 def powE21X
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp1(FFEXT|FOEXP21X, stackRegs[0]))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1ELEM(FFEXT|FOEXP21X, stackRegs[0]))
     end
 def powXInt(powInt)
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp2(FFEXT|FOXPWRI, stackRegs[0], powInt))
+    sane:saveZP()
+    return sane:restoreZP(sane:op2ELEM(FFEXT|FOXPWRI, stackRegs[0], powInt))
 end
 def powXY
-    sane:zpSave()
-    return sane:zpRestore(_drop(_swap(sane:elOp2(FFEXT|FOXPWRY, stackRegs[0], stackRegs[1]))))
+    sane:saveZP()
+    return sane:restoreZP(_drop(_swap(sane:op2ELEM(FFEXT|FOXPWRY, stackRegs[0], stackRegs[1]))))
 end
 def compXY
-    sane:zpSave()
-    return sane:zpRestore(_drop(_swap(sane:elOp2(FFEXT|FOCOMPND, stackRegs[0], stackRegs[1]))))
+    sane:saveZP()
+    return sane:restoreZP(_drop(_swap(sane:op2ELEM(FFEXT|FOCOMPND, stackRegs[0], stackRegs[1]))))
 end
 def annuityXY
-    sane:zpSave()
-    return sane:zpRestore(_drop(_swap(sane:elOp2(FFEXT|FOANNUIT, stackRegs[0], stackRegs[1]))))
+    sane:saveZP()
+    return sane:restoreZP(_drop(_swap(sane:op2ELEM(FFEXT|FOANNUIT, stackRegs[0], stackRegs[1]))))
 end
 def randNum(pSeed)
-    sane:zpSave()
-    return sane:zpRestore(sane:elOp1(FFEXT|FORANDX, pSeed))
+    sane:saveZP()
+    return sane:restoreZP(sane:op1ELEM(FFEXT|FORANDX, pSeed))
 end
 //
 // Push useful constants
@@ -360,12 +360,12 @@ def reset
     word zero
 
     zero = 0
-    sane:fpInit()
-    sane:zpSave()
+    sane:initFP()
+    sane:saveZP()
     for i = 0 to 3
         stackRegs[i] = @stack[i * t_extended]
-        sane:fpOp2(FFINT|FOZ2X, stackRegs[i], @zero)
+        sane:op2FP(FFINT|FOZ2X, stackRegs[i], @zero)
     next
-    return sane:zpRestore(0)
+    return sane:restoreZP(0)
 end
 done