From 5df79c53745fde5d6c3340a2979b1429cd5892c1 Mon Sep 17 00:00:00 2001
From: Henrik Rydberg <rydberg@euromail.se>
Date: Sat, 8 Oct 2011 20:30:28 +0200
Subject: Initial import of htcd system 1.0

Signed-off-by: Henrik Rydberg <rydberg@euromail.se>
---
 src/ops/basic.cc | 269 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 269 insertions(+)
 create mode 100644 src/ops/basic.cc

(limited to 'src/ops/basic.cc')

diff --git a/src/ops/basic.cc b/src/ops/basic.cc
new file mode 100644
index 0000000..b30e351
--- /dev/null
+++ b/src/ops/basic.cc
@@ -0,0 +1,269 @@
+/*************************************************************************
+ *
+ * HTCd - Copyright (C) 1998-2006 Henrik Rydberg
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+
+#include <ops/operator.h>
+#include <math.h>
+
+OP1_IMPL(exp) { out<<exp(atof(a)); }
+OP1_IMPL(ln) { out<<log(atof(a)); }
+OP1_IMPL(abs) { out<<fabs(atof(a)); }
+OP1_IMPL(int) { out<<int(atof(a)); }
+
+OP1_IMPL(minus) { out<<-atof(a); }
+OP2_IMPL(minus) { out<<atof(L)-atof(R); }
+OP1_IMPL(plus) { out<<atof(a); }
+OP2_IMPL(plus) { out<<atof(L)+atof(R); }
+OP2_IMPL(mul) { out<<atof(L)*atof(R); }
+OP2_IMPL(divide) { out<<atof(L)/atof(R); }
+OP2_IMPL(mod) {
+  double a=atof(L),b=atof(R);
+  a-=b*int(a/b);
+  if(a<0) a+=fabs(b);
+  out<<a;
+}
+OP2_IMPL(imod) { out<<(atoi(L)%atoi(R)); }
+OP2_IMPL(div) { out<<(atoi(L)/atoi(R)); }
+OP2_IMPL(pow) { out<<pow(atof(L),atof(R)); }
+
+OP2_IMPL(eq) {out<<(L==R); }
+OP2_IMPL(ne) {out<<(L!=R);}
+OP2_IMPL(eqn) {out<<(L.compare(R,cset_lcase)==0);}
+OP2_IMPL(nen) {out<<(L.compare(R,cset_lcase)!=0);}
+OP2_IMPL(eqf) {out<<(atof(L)==atof(R));}
+OP2_IMPL(nef) {out<<(atof(L)!=atof(R));}
+
+OP1_IMPL(not) {out<<!atob(a);}
+OP2_IMPL(and) {out<<(atob(L)&atob(R)); }
+OP2_IMPL(or)  {out<<(atob(L)|atob(R)); }
+OP2_IMPL(xor) {out<<(atob(L)^atob(R)); }
+
+OP2_IMPL(shiftleft) {out<<(atoi(L)<<atoi(R));}
+OP2_IMPL(shiftright) {out<<(atoi(L)>>atoi(R));}
+
+OP1_IMPL(bitnot) {out<<~atoi(a);}
+OP2_IMPL(bitand) {out<<(atoi(L)&atoi(R)); }
+OP2_IMPL(bitor)  {out<<(atoi(L)|atoi(R)); }
+OP2_IMPL(bitxor) {out<<(atoi(L)^atoi(R)); }
+
+OP2_IMPL(SP) {out<<L<<" "<<R;}
+
+OP2_IMPL(comma) {out<<R;}
+
+OP1_IMPL(semi) {}
+OP2_IMPL(semi) {}
+
+void opAddBasic(opmap& M)
+{
+  OP_ADD(32,exp,
+         "C style\n"
+         "Natural exponential function\n"
+         "Syntax:  exp (real)\n"
+         "Returns: (real)\n"
+         );
+  OP_ADD(32,ln,
+         "C style\n"
+         "Natural logarithm function\n"
+         "Syntax:  ln (real)\n"
+         "Returns: (real)\n"
+         );
+  OP_ADD(32,abs,
+         "C style\n"
+         "Absolute value\n"
+         "Syntax:  abs (real)\n"
+         "Returns: (real)\n"
+         );
+  OP_ADD(32,int,
+         "C style\n"
+         "Integer truncation\n"
+         "Syntax:  int (real)\n"
+         "Returns: (int)\n"
+         "\n"
+         "Note that truncation is just as when converting to int, not rounding\n"
+         );
+  
+  OP_ADDN(30,bitnot,~,
+          "C style\n"
+          "Bitwise NOT\n"
+          "Syntax:  ~ (int)\n"
+          "Returns: (int)\n"
+          );
+  OP_ADDN(30,not,!,
+          "C style\n"
+          "Logical NOT\n"
+          "Syntax:  ! (int)\n"
+          "Returns: (int)\n"
+          );
+  OP_ADD2(30,24,plus,+,
+          "C style\n"
+          "Addition\n"
+          "Syntax:  (real) + (real)\n"
+          "Returns: (real)\n"
+          );
+  OP_ADD2(30,24,minus,-,
+          "C style\n"
+          "Subtraction\n"
+          "Syntax:  (real) - (real)\n"
+          "Returns: (real)\n"
+          );
+  
+  OP_ADDN(27,pow,**,
+          "Power\n"
+          "Syntax:  (real) a ** (real) b\n"
+          "Returns: (real) a to the power of b\n"
+          );
+
+  OP_ADDN(26,mul,*,
+          "C style\n"
+          "Multiplication\n"
+          "Syntax:  (real) * (real)\n"
+          "Returns: (real)\n"
+          );
+  OP_ADDN(26,divide,/,
+          "C style\n"
+          "Division\n"
+          "Syntax:  (real) / (real)\n"
+          "Returns: (real)\n"
+          "\n"
+          "Note computerese; same precedence as *\n"
+          );
+  OP_ADDN(26,imod,%,
+          "C style\n"
+          "Integer modulus\n"
+          "Syntax:  (int) % (int)\n"
+          "Returns: (int)\n"
+          );
+
+  OP_ADD(25,div,
+         "Integer division\n"
+         "Syntax:  (int) div (int)\n"
+         "Returns: (int)\n"
+         "\n"
+         "Note that this is the same as integer / in C, but with lower precedence\n"
+         );
+  // plus/minus 24
+  OP_ADD(23,mod,
+         "General moulus\n"
+         "Syntax:  (real) mod (real)\n"
+         "Returns: (real)\n"
+         "\n"
+         "Modulus on ring; negative vals are mapped onto base\n"
+         );
+
+  OP_ADDN(22,shiftleft,<<,
+          "C style\n"
+          "Shift left\n"
+          "Syntax:  (int) << (int)\n"
+          "Returns: (int)\n"
+          );
+  OP_ADDN(22,shiftright,>>,
+          "C style\n"
+          "Shift right\n"
+          "Syntax:  (int) >> (int)\n"
+          "Returns: (int)\n"
+          );
+  
+  OP_ADD(18,eq,
+         "Lexicographic equal\n"
+         "Syntax:  (string) eq (string)\n"
+         "Returns: (int)\n"
+         );
+  OP_ADD(18,eqn,
+         "Lexicographic equal, case insensitive\n"
+         "Syntax:  (string) eqn (string)\n"
+         "Returns: (int)\n"
+         );
+  OP_ADDN(18,eqf,==,
+          "Arithmetic equal\n"
+          "Syntax:  (real) == (real)\n"
+          "Returns: (int)\n"
+          );
+  OP_ADD(18,ne,
+         "Lexicographic not equal\n"
+         "Syntax:  (string) ne (string)\n"
+         "Returns: (int)\n"
+         );
+  OP_ADD(18,nen,
+         "Lexicographic not equal, case insensitive\n"
+         "Syntax:  (string) nen (string)\n"
+         "Returns: (int)\n"
+         );
+  OP_ADDN(18,nef,!=,
+          "Arithmetic not equal\n"
+          "Syntax:  (real) != (real)\n"
+          "Returns: (int)\n"
+          );
+
+  OP_ADDN(16,bitand,&,
+          "C style\n"
+          "Bitwise AND\n"
+          "Syntax:  (int) & (int)\n"
+          "Returns: (int)\n"
+          ); 
+  OP_ADDN(14,bitxor,^,
+          "C style\n"
+          "Bitwise XOR\n"
+          "Syntax:  (int) ^ (int)\n"
+          "Returns: (int)\n"
+          ); 
+  OP_ADDN(12,bitor,|,
+          "C style\n"
+          "Bitwise OR\n"
+          "Syntax:  (int) | (int)\n"
+          "Returns: (int)\n"
+          ); 
+
+  OP_ADDN(10,and,&&,
+          "C style\n"
+          "Logical AND\n"
+          "Syntax:  (int) && (int)\n"
+          "Returns: (int)\n"
+          );
+  OP_ADDN(9,xor,^^,
+          "Logical XOR\n"
+          "Syntax:  (int) ^^ (int)\n"
+          "Returns: (int)\n"
+          );
+  OP_ADDN(8,or,||,
+          "C style\n"
+          "Logical OR\n"
+          "Syntax:  (int) || (int)\n"
+          "Returns: (int)\n"
+          );
+  
+  /*
+  OP_ADD(3,SP,
+         "Whitespace padding\n"
+         "Syntax:  a ws OR ws a OR a ws b\n"
+         "Returns: a b\n"
+         );
+  */
+
+  M.add(new op_t(",",2,impl_comma,
+                 "C style\n"
+                 "Separate expression\n"
+                 "Syntax:  a , b\n"
+                 "Returns: b\n"
+                 ));
+  OP_ADD2(1,1,semi,;,
+          "C style\n"
+          "End expression\n"
+          "Syntax:  a ; OR a ; b\n"
+          "Returns: nothing\n"
+          );
+}
-- 
cgit v1.2.3