/*************************************************************************
 *
 * 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"
          );
}