import java.io.*;
import java.util.*;
import java.awt.Color;
import java.text.DecimalFormat;
import edu.jsu.leathrum.mathlets.shared.*;

public class TParserInputSet extends InputSet {
  private static StringReader collector = new StringReader("\n");
  private static TParser parser = new TParser(collector);
  boolean dirty = true;
  boolean errorDetected = false;
  Node parseReturn = new Node();

  public TParserInputSet(String namestr, int size, boolean chbox, Color c) { 
    super(namestr, size, chbox, c);
    parser.ReInit(collector);
  }
  
  public TParserInputSet(String namestr, int size, boolean chbox) {
    super(namestr, size, chbox);
    parser.ReInit(collector);
  }

  public TParserInputSet(String namestr, int size) {
    super(namestr, size);
    parser.ReInit(collector);
  }

  public TParserInputSet(String namestr, int size, Color c) {
    super(namestr, size, c);
    parser.ReInit(collector);
  }

  private String msgString = "";

  public String getMsgString() {
    return msgString;
  }

  private void addToMsgString(String s) {
    msgString += s;
  }

  boolean dapplied = false;

  private void evaluate(String expr) {
    StringReader collector = new StringReader(expr+"\n");
    parser.ReInit(collector);
      parseReturn = parser.getTree();
      dapplied = false;
      parseReturn = dsearch(parseReturn);
  }

  public Node dsearch(Node n) {
    if (!dapplied) {
      try { if (((Integer) n.type).intValue() == TParser.DERIV)
        return derivator(n.children[0], 
                         ((Integer) n.children[1].type).intValue());
      else {
        for (int i=0; i<n.numchildren; i++)
          n.children[i] = dsearch(n.children[i]);
        return n;
      } } catch (ClassCastException e) { return n; }
    }
    else return n;
  }
  
  private DecimalFormat nf = null;

// strings here need to stay hard-coded in order to be sure output will parse
  private String evaluateTree(Node s) {
      int top = ((Integer) s.type).intValue(); 
      String a, b, c, d, temp;
      int tt;
      boolean parena, parenb;
      if (nf == null) { 
        nf = (DecimalFormat) AMathlet.getNumberFormat().clone();
        nf.setMinimumFractionDigits(0);
      }

      switch (top) {
      case TParser.DBL:
       return nf.format(s.children[0].type);
      case TParser.PLUS:
    a = evaluateTree(s.children[0]);
    b = evaluateTree(s.children[1]);
        parenb = (b.charAt(0)=='-');
    return a + "+" + (parenb?"(":"")+b+(parenb?")":"");
      case TParser.MINUS:
    a = evaluateTree(s.children[0]);
    b = evaluateTree(s.children[1]);
        parenb = (b.charAt(0)=='-');
    return a + "-" + (parenb?"(":"")+b+(parenb?")":"");
      case TParser.MULT:
    a = evaluateTree(s.children[0]);
    b = evaluateTree(s.children[1]);
        tt = ((Integer) s.children[0].type).intValue();
        parena = ((tt == TParser.PLUS) || (tt == TParser.MINUS) ||
              (tt == TParser.DIV));
        tt = ((Integer) s.children[1].type).intValue();
        parenb = ((tt == TParser.PLUS) || (tt == TParser.MINUS) ||
              (b.charAt(0) == '-'));
    return (parena?"(":"")+ a +(parena?")":"")+ "*" + (parenb?"(":"")+b+(parenb?")":"");
      case TParser.DIV:
    a = evaluateTree(s.children[0]);
    b = evaluateTree(s.children[1]);
        tt = ((Integer) s.children[0].type).intValue();
        parena = ((tt == TParser.PLUS) || (tt == TParser.MINUS) ||
              (tt == TParser.DIV));
        tt = ((Integer) s.children[1].type).intValue();
        parenb = ((tt == TParser.PLUS) || (tt == TParser.MINUS) ||
              (b.charAt(0) == '-') || (tt == TParser.MULT) ||
          (tt == TParser.DIV));
    return (parena?"(":"")+ a +(parena?")":"")+ "/" + (parenb?"(":"")+b+(parenb?")":"");
      case TParser.POW:
    a = evaluateTree(s.children[0]);
    b = evaluateTree(s.children[1]);
        tt = ((Integer) s.children[0].type).intValue();
        parena = ((tt == TParser.PLUS) || (tt == TParser.MINUS)
               || (tt == TParser.MULT) || (tt == TParser.DIV)
           || (tt == TParser.POW));
        tt = ((Integer) s.children[1].type).intValue();
        parenb = ((tt == TParser.PLUS) || (tt == TParser.MINUS)
               || (tt == TParser.MULT) || (tt == TParser.DIV)
           || (b.charAt(0) == '-') || (tt == TParser.POW));
    return (parena?"(":"")+ a +(parena?")":"")+ "^" + (parenb?"(":"")+b+(parenb?")":"");
      case TParser.NEG:
        tt = ((Integer) s.children[0].type).intValue();
        parena = ((tt == TParser.PLUS) || (tt == TParser.MINUS));
    a = evaluateTree(s.children[0]);
    return "-" + (parena?"(":"")+ a +(parena?")":"");
      case TParser.PI:
    return "pi";
      case TParser.E:
    return "e";
      case TParser.VARXH:
        return "";
      case TParser.VARX:
        return "x";
      case TParser.VARY:
        return "y";
      case TParser.VARZ:
        return "z";
      case TParser.VARU:
        return "u";
      case TParser.VARV:
        return "v";
      case TParser.VARR:
        return "r";
      case TParser.VARS:
        return "s";
      case TParser.VART:
        return "t";
      case TParser.ABS:
    a = evaluateTree(s.children[0]);
    return "abs(" + a + ")"; 
      case TParser.SQRT:
    a = evaluateTree(s.children[0]);
    return "sqrt(" + a + ")"; 
      case TParser.SIN:
    a = evaluateTree(s.children[0]);
    return "sin(" + a + ")"; 
      case TParser.COS:
    a = evaluateTree(s.children[0]);
    return "cos(" + a + ")"; 
      case TParser.TAN:
    a = evaluateTree(s.children[0]);
    return "tan(" + a + ")"; 
      case TParser.SEC:
    a = evaluateTree(s.children[0]);
    return "sec(" + a + ")"; 
      case TParser.CSC:
    a = evaluateTree(s.children[0]);
    return "csc(" + a + ")"; 
      case TParser.COT:
    a = evaluateTree(s.children[0]);
    return "cot(" + a + ")"; 
      case TParser.EXP:
    a = evaluateTree(s.children[0]);
    return "exp(" + a + ")"; 
      case TParser.LN:
    a = evaluateTree(s.children[0]);
    return "ln(" + a + ")"; 
      case TParser.LOG:
    a = evaluateTree(s.children[0]);
    return "log(" + a + ")"; 
      case TParser.ASIN:
    a = evaluateTree(s.children[0]);
    return "arcsin(" + a + ")"; 
      case TParser.ACOS:
    a = evaluateTree(s.children[0]);
    return "arccos(" + a + ")"; 
      case TParser.ATAN:
    a = evaluateTree(s.children[0]);
    return "arctan(" + a + ")"; 
      case TParser.ASEC:
    a = evaluateTree(s.children[0]);
    return "arcsec(" + a + ")"; 
      case TParser.DERIV:
      return "D"+evaluateTree(s.children[1])+"[" + 
                   evaluateTree(s.children[0])+ "]";
      case TParser.ERROR:
        select(0,getInput().length());
        requestFocus();
        errorDetected = true;
        return ""; 
      default:
    return "";
      }
  }

  private boolean isConst(Node n, int var) {
    int t = ((Integer) n.type).intValue();
    if (var == TParser.VARXH) var = TParser.VARX;
    if ( t == TParser.DBL || t == TParser.PI || t == TParser.E )
      return true;
    else if ((t == TParser.VARX || t == TParser.VARY || t == TParser.VARZ
              || t == TParser.VARU || t == TParser.VARV || t == TParser.VARR
              || t == TParser.VARS || t == TParser.VART) 
             && t != var) 
      return true;
    else {
      switch (t) {
      case TParser.PLUS:
      case TParser.MINUS:
      case TParser.MULT:
      case TParser.DIV:
      case TParser.POW:
        return (isConst(n.children[0], var) && isConst(n.children[1], var));
      case TParser.NEG:
      case TParser.EXP:
      case TParser.LN:
      case TParser.SIN:
      case TParser.COS:
      case TParser.TAN:
      case TParser.ASIN:
      case TParser.ACOS:
      case TParser.ATAN:
      case TParser.ABS:
      case TParser.SQRT:
        return isConst(n.children[0], var);
      default:
        return false;
      }
    }
  }

  private boolean hasVar(Node n) {
    int t = ((Integer) n.type).intValue();
    if (t == TParser.VARX || t == TParser.VARY || t == TParser.VARZ
        || t == TParser.VARU || t == TParser.VARV || t == TParser.VARR
        || t == TParser.VARS || t == TParser.VART)
      return true;
    else {
      switch (t) {
      case TParser.PLUS:
      case TParser.MINUS:
      case TParser.MULT:
      case TParser.DIV:
      case TParser.POW:
        return (hasVar(n.children[0]) || hasVar(n.children[1]));
      case TParser.NEG:
      case TParser.EXP:
      case TParser.LN:
      case TParser.SIN:
      case TParser.COS:
      case TParser.TAN:
      case TParser.ASIN:
      case TParser.ACOS:
      case TParser.ATAN:
      case TParser.ABS:
      case TParser.SQRT:
        return hasVar(n.children[0]);
      default:
        return false;
      }
    }
  }

  private void msgchain(Node n, TreeBuilder t, String s, int var) {
    if (isConst(n,var)) {
      t.addNodeByType(new Double(0.0));
      t.addNodeByType(new Integer(TParser.DBL));
    }
    else {
      if (((Integer) n.type).intValue() != 
             ((var==TParser.VARXH)?TParser.VARX:var)) {
        t.addByNode(n);
        t.addNodeByType(new Integer(var));
        t.addNodeByType(new Integer(TParser.DERIV));
        t.addNodeByType(new Integer(TParser.MULT));
        addToMsgString(s);
      }
    }
  }

  private void nomsgchain(Node n, TreeBuilder t, int var) {
    msgchain(n,t,"",var);
  }

  private void chain(Node n, TreeBuilder t, int var) {
    msgchain(n,t," "+AMathlet.getProperty("DerivCalc.andchain"),var);
  }

  private Node derivator(Node s, int var) {
      TreeBuilder t = new TreeBuilder();
      int top = ((Integer) s.type).intValue(); 
      String a, b, c, d;
      double dd = 0.0;

      if (isConst(s,var)) {
        t.addNodeByType(new Double(0.0));
        t.addNodeByType(new Integer(TParser.DBL));
        addToMsgString(AMathlet.getProperty("DerivCalc.derivconst"));
        if (hasVar(s)) 
          addToMsgString(" "+AMathlet.getProperty("DerivCalc.othervarsconst"));
      }
      else switch (top) {
      case TParser.NEG:
        t.addByNode(s.children[0]);
         t.addNodeByType(new Integer(var));
        t.addNodeByType(new Integer(TParser.DERIV));
        t.addNodeByType(new Integer(TParser.NEG));
        addToMsgString(AMathlet.getProperty("DerivCalc.constmultnegone"));
        break;
      case TParser.VARX:
    if (var == TParser.VARXH) var = TParser.VARX;
      case TParser.VARY:
      case TParser.VARZ:
      case TParser.VARU:
      case TParser.VARV:
      case TParser.VARR:
      case TParser.VARS:
      case TParser.VART:
    if (top == var) {
          t.addNodeByType(new Double(1.0));
          t.addNodeByType(new Integer(TParser.DBL));
          addToMsgString(AMathlet.getProperty("DerivCalc.derivofvar"));
    }
        else {
          t.addNodeByType(new Double(0.0));
          t.addNodeByType(new Integer(TParser.DBL));
          addToMsgString(AMathlet.getProperty("DerivCalc.derivofothervar"));
    }
        break;
      case TParser.PLUS:
        if (isConst(s.children[0],var)) {
            t.addByNode(s.children[1]);
            t.addNodeByType(new Integer(var));
            t.addNodeByType(new Integer(TParser.DERIV));
            addToMsgString(AMathlet.getProperty("DerivCalc.sumwithconst"));
            if (hasVar(s.children[0])) 
              addToMsgString(" "+AMathlet.getProperty("DerivCalc.othervarsconst"));
        }
        else if (isConst(s.children[1],var)) {
            t.addByNode(s.children[0]);
            t.addNodeByType(new Integer(var));
            t.addNodeByType(new Integer(TParser.DERIV));
            addToMsgString(AMathlet.getProperty("DerivCalc.sumwithconst"));
            if (hasVar(s.children[1])) 
              addToMsgString(" "+AMathlet.getProperty("DerivCalc.othervarsconst"));
        }
        else {
      t.addByNode(s.children[0]);
          t.addNodeByType(new Integer(var));
          t.addNodeByType(new Integer(TParser.DERIV));
          t.addByNode(s.children[1]);
          t.addNodeByType(new Integer(var));
          t.addNodeByType(new Integer(TParser.DERIV));
          t.addNodeByType(new Integer(TParser.PLUS));
            addToMsgString(AMathlet.getProperty("DerivCalc.sumrule"));
        }
        break;
      case TParser.MINUS:
        if (isConst(s.children[0],var)) {
            t.addByNode(s.children[1]);
            t.addNodeByType(new Integer(var));
            t.addNodeByType(new Integer(TParser.DERIV));
            addToMsgString(AMathlet.getProperty("DerivCalc.diffwithconst"));
            if (hasVar(s.children[0])) 
              addToMsgString(" "+AMathlet.getProperty("DerivCalc.othervarsconst"));
        }
        else if (isConst(s.children[1], var)) {
            t.addByNode(s.children[0]);
            t.addNodeByType(new Integer(var));
            t.addNodeByType(new Integer(TParser.DERIV));
            addToMsgString(AMathlet.getProperty("DerivCalc.diffwithconst"));
            if (hasVar(s.children[1])) 
              addToMsgString(" "+AMathlet.getProperty("DerivCalc.othervarsconst"));
        }
        else {
          t.addByNode(s.children[0]);
          t.addNodeByType(new Integer(var));
          t.addNodeByType(new Integer(TParser.DERIV));
          t.addByNode(s.children[1]);
          t.addNodeByType(new Integer(var));
          t.addNodeByType(new Integer(TParser.DERIV));
          t.addNodeByType(new Integer(TParser.MINUS));
            addToMsgString(AMathlet.getProperty("DerivCalc.diffrule"));
        }
        break;
      case TParser.MULT:
        if (isConst(s.children[0], var)) {
            addToMsgString(AMathlet.getProperty("DerivCalc.constmultrule"));
            t.addByNode(s.children[0]);
            nomsgchain(s.children[1],t,var);
            if (hasVar(s.children[0])) 
              addToMsgString(" "+AMathlet.getProperty("DerivCalc.othervarsconst"));
        }
        else if (isConst(s.children[1], var)) {
            addToMsgString(AMathlet.getProperty("DerivCalc.constmultrule"));
            t.addByNode(s.children[1]);
            nomsgchain(s.children[0],t,var);
            if (hasVar(s.children[1])) 
              addToMsgString(" "+AMathlet.getProperty("DerivCalc.othervarsconst"));
        }
        else {
            addToMsgString(AMathlet.getProperty("DerivCalc.prodrule"));
          t.addByNode(s.children[0]);
          nomsgchain(s.children[1],t,var);
          t.addByNode(s.children[1]);
          nomsgchain(s.children[0],t,var);
          t.addNodeByType(new Integer(TParser.PLUS));
        }
        break;
      case TParser.DIV:
        if (isConst(s.children[0], var)) {
            addToMsgString(AMathlet.getProperty("DerivCalc.quotbypower"));
            t.addByNode(s.children[0]);
            chain(s.children[1],t,var);
            t.addByNode(s.children[1]);
            t.addNodeByType(new Double(2.0));
            t.addNodeByType(new Integer(TParser.DBL));
            t.addNodeByType(new Integer(TParser.POW));
            t.addNodeByType(new Integer(TParser.DIV));
            t.addNodeByType(new Integer(TParser.NEG));
            if (hasVar(s.children[0])) 
              addToMsgString(" "+AMathlet.getProperty("DerivCalc.othervarsconst"));
        }
        else if (isConst(s.children[1], var)) {
            t.addByNode(s.children[0]);
            t.addNodeByType(new Integer(var));
            t.addNodeByType(new Integer(TParser.DERIV));
            t.addByNode(s.children[1]);
            t.addNodeByType(new Integer(TParser.DIV));
            addToMsgString(AMathlet.getProperty("DerivCalc.constmultrule"));
            if (hasVar(s.children[1])) 
              addToMsgString(" "+AMathlet.getProperty("DerivCalc.othervarsconst"));
        }
        else {
            addToMsgString(AMathlet.getProperty("DerivCalc.quotrule"));
          t.addByNode(s.children[1]);
          nomsgchain(s.children[0],t,var);
          t.addByNode(s.children[0]);
          nomsgchain(s.children[1],t,var);
          t.addNodeByType(new Integer(TParser.MINUS));
          t.addByNode(s.children[1]);
            t.addNodeByType(new Double(2.0));
            t.addNodeByType(new Integer(TParser.DBL));
            t.addNodeByType(new Integer(TParser.POW));
            t.addNodeByType(new Integer(TParser.DIV));
        }
        break;
      case TParser.POW:
        if (isConst(s.children[0], var)) {
            t.addByNode(s.children[0]);
            t.addNodeByType(new Integer(TParser.LN));
            t.addByNode(s);
            t.addNodeByType(new Integer(TParser.MULT));
            addToMsgString(AMathlet.getProperty("DerivCalc.exprule")
                +" "+AMathlet.getProperty("DerivCalc.withchangebase"));
            chain(s.children[1],t,var);
            if (hasVar(s.children[0])) 
              addToMsgString(" "+AMathlet.getProperty("DerivCalc.othervarsconst"));
        }
        else if (isConst(s.children[1], var)) {
          if (((Integer) s.children[1].type).intValue() == TParser.DBL) {
            dd = ((Double) s.children[1].children[0].type).doubleValue();
            if (dd == 0.0) {
              addToMsgString(AMathlet.getProperty("DerivCalc.derivofconst")
                  +" "+AMathlet.getProperty("DerivCalc.expzero"));
              t.addNodeByType(new Double(0.0));
              t.addNodeByType(new Integer(TParser.DBL));
            }
            else if (dd == 1.0) {
              addToMsgString(AMathlet.getProperty("DerivCalc.exponerm")+" ");
              t.addByNode(derivator(s.children[0],var));
            }
            else {
            addToMsgString(AMathlet.getProperty("DerivCalc.powerrule")
                +" "+AMathlet.getProperty("DerivCalc.posexp"));
          if (dd == 2.0) {
                t.addNodeByType(new Double(2.0));
                t.addNodeByType(new Integer(TParser.DBL));
                t.addByNode(s.children[0]);
                t.addNodeByType(new Integer(TParser.MULT));
                chain(s.children[0],t,var);
              }
              else if ((dd>0.0) && (dd<1.0)) {
                t.addByNode(s.children[1]);
                t.addByNode(s.children[0]);
                t.addNodeByType(new Double(Math.abs(dd-1)));
                t.addNodeByType(new Integer(TParser.DBL));
                t.addNodeByType(new Integer(TParser.NEG));
                t.addNodeByType(new Integer(TParser.POW));
                t.addNodeByType(new Integer(TParser.MULT));
                chain(s.children[0],t,var);
              }
              else {
                t.addByNode(s.children[1]);
                t.addByNode(s.children[0]);
                t.addNodeByType(new Double(dd-1));
                t.addNodeByType(new Integer(TParser.DBL));
                t.addNodeByType(new Integer(TParser.POW));
                t.addNodeByType(new Integer(TParser.MULT));
                chain(s.children[0],t,var);
              }
            }
          }
          else if ((((Integer) s.children[1].type).intValue() == TParser.NEG) &&
                   (((Integer) s.children[1].children[0].type).intValue() == TParser.DBL) ) {
            dd = ((Double) s.children[1].children[0].children[0].type).doubleValue();
            t.addByNode(s.children[1]);
            t.addByNode(s.children[0]);
            t.addNodeByType(new Double(dd+1));
            t.addNodeByType(new Integer(TParser.DBL));
            t.addNodeByType(new Integer(TParser.NEG));
            t.addNodeByType(new Integer(TParser.POW));
            t.addNodeByType(new Integer(TParser.MULT));
            addToMsgString(AMathlet.getProperty("DerivCalc.powerrule")
                +" "+AMathlet.getProperty("DerivCalc.negexp"));
            chain(s.children[0],t,var);
      }
          else {
        t.addByNode(s.children[1]);
            t.addByNode(s.children[0]);
            t.addByNode(s.children[1]);
            t.addNodeByType(new Double(1.0));
            t.addNodeByType(new Integer(TParser.DBL));
            t.addNodeByType(new Integer(TParser.MINUS));
            t.addNodeByType(new Integer(TParser.POW));
            t.addNodeByType(new Integer(TParser.MULT));
            addToMsgString(AMathlet.getProperty("DerivCalc.powerrule")+" "+AMathlet.getProperty("constexprexp"));
            if (hasVar(s.children[1])) 
              addToMsgString(" "+AMathlet.getProperty("DerivCalc.othervarsconst"));
            addToMsgString(")");
            chain(s.children[0],t,var);
          }
        }
        else {
          addToMsgString(AMathlet.getProperty("DerivCalc.logdiff"));
          t.addByNode(s);
          t.addByNode(s.children[1]);
          nomsgchain(s.children[0],t,var);
          t.addByNode(s.children[0]);
          t.addNodeByType(new Integer(TParser.DIV));
          t.addByNode(s.children[0]);
          t.addNodeByType(new Integer(TParser.LN));
          nomsgchain(s.children[1],t,var);
          t.addNodeByType(new Integer(TParser.PLUS));
          t.addNodeByType(new Integer(TParser.MULT));
        }
        break;
      case TParser.EXP:
        t.addByNode(s);
        addToMsgString(AMathlet.getProperty("DerivCalc.exprule"));
        chain(s.children[0],t,var);
        break;
      case TParser.LN:
        t.addNodeByType(new Double(1.0));
        t.addNodeByType(new Integer(TParser.DBL));
        addToMsgString(AMathlet.getProperty("DerivCalc.logrule"));
        chain(s.children[0],t,var);
        if (((Integer) t.getTop().type).intValue() == TParser.MULT)
          t.addByNode(t.getTop().children[1]);
        t.addByNode(s.children[0]);
        t.addNodeByType(new Integer(TParser.DIV));
        break;
      case TParser.LOG:
        t.addNodeByType(new Double(1.0));
        t.addNodeByType(new Integer(TParser.DBL));
        addToMsgString(AMathlet.getProperty("DerivCalc.logrule")+" "+AMathlet.getProperty("DerivCalc.baseten"));
        chain(s.children[0],t,var);
        if (((Integer) t.getTop().type).intValue() == TParser.MULT)
          t.addByNode(t.getTop().children[1]);
        t.addByNode(s.children[0]);
        t.addNodeByType(new Double(10.0));
        t.addNodeByType(new Integer(TParser.DBL));
        t.addNodeByType(new Integer(TParser.LN));
        t.addNodeByType(new Integer(TParser.MULT));
        t.addNodeByType(new Integer(TParser.DIV));
        break;
      case TParser.SIN:
        t.addByNode(s.children[0]);
        t.addNodeByType(new Integer(TParser.COS));
        addToMsgString(AMathlet.getProperty("DerivCalc.sinrule"));
        chain(s.children[0],t,var);
        break;
      case TParser.COS:
        t.addByNode(s.children[0]);
        t.addNodeByType(new Integer(TParser.SIN));
        t.addNodeByType(new Integer(TParser.NEG));
        addToMsgString(AMathlet.getProperty("DerivCalc.cosrule"));
        chain(s.children[0],t,var);
        break;
      case TParser.TAN:
        addToMsgString(AMathlet.getProperty("DerivCalc.tanrule"));
        t.addByNode(s.children[0]);
        t.addNodeByType(new Integer(TParser.SEC));
        t.addNodeByType(new Double(2.0));
        t.addNodeByType(new Integer(TParser.DBL));
        t.addNodeByType(new Integer(TParser.POW));
        chain(s.children[0],t,var);
        break;
      case TParser.SEC:
        addToMsgString(AMathlet.getProperty("DerivCalc.secrule"));
        t.addByNode(s.children[0]);
        t.addNodeByType(new Integer(TParser.SEC));
        t.addByNode(s.children[0]);
        t.addNodeByType(new Integer(TParser.TAN));
        t.addNodeByType(new Integer(TParser.MULT));
        chain(s.children[0],t,var);
        break;
      case TParser.CSC:
        addToMsgString(AMathlet.getProperty("DerivCalc.cscrule"));
        t.addByNode(s.children[0]);
        t.addNodeByType(new Integer(TParser.CSC));
        t.addByNode(s.children[0]);
        t.addNodeByType(new Integer(TParser.COT));
        t.addNodeByType(new Integer(TParser.MULT));
        t.addNodeByType(new Integer(TParser.NEG));
        chain(s.children[0],t,var);
        break;
      case TParser.COT:
        addToMsgString(AMathlet.getProperty("DerivCalc.cotrule"));
        t.addByNode(s.children[0]);
        t.addNodeByType(new Integer(TParser.CSC));
        t.addNodeByType(new Double(2.0));
        t.addNodeByType(new Integer(TParser.DBL));
        t.addNodeByType(new Integer(TParser.POW));
        t.addNodeByType(new Integer(TParser.NEG));
        chain(s.children[0],t,var);
        break;
      case TParser.ASIN:
        addToMsgString(AMathlet.getProperty("DerivCalc.asinrule"));
        t.addNodeByType(new Double(1.0));
        t.addNodeByType(new Integer(TParser.DBL));
        chain(s.children[0],t,var);
        if (((Integer) t.getTop().type).intValue() == TParser.MULT)
          t.addByNode(t.getTop().children[1]);
        t.addNodeByType(new Double(1.0));
        t.addNodeByType(new Integer(TParser.DBL));
        t.addByNode(s.children[0]);
        t.addNodeByType(new Double(2.0));
        t.addNodeByType(new Integer(TParser.DBL));
        t.addNodeByType(new Integer(TParser.POW));
        t.addNodeByType(new Integer(TParser.MINUS));
        t.addNodeByType(new Integer(TParser.SQRT));
        t.addNodeByType(new Integer(TParser.DIV));
        break;
      case TParser.ACOS:
        addToMsgString(AMathlet.getProperty("DerivCalc.acosrule"));
        t.addNodeByType(new Double(1.0));
        t.addNodeByType(new Integer(TParser.DBL));
        chain(s.children[0],t,var);
        if (((Integer) t.getTop().type).intValue() == TParser.MULT)
          t.addByNode(t.getTop().children[1]);
        t.addNodeByType(new Integer(TParser.NEG));
        t.addNodeByType(new Double(1.0));
        t.addNodeByType(new Integer(TParser.DBL));
        t.addByNode(s.children[0]);
        t.addNodeByType(new Double(2.0));
        t.addNodeByType(new Integer(TParser.DBL));
        t.addNodeByType(new Integer(TParser.POW));
        t.addNodeByType(new Integer(TParser.MINUS));
        t.addNodeByType(new Integer(TParser.SQRT));
        t.addNodeByType(new Integer(TParser.DIV));
        break;
      case TParser.ATAN:
        addToMsgString(AMathlet.getProperty("DerivCalc.atanrule"));
        t.addNodeByType(new Double(1.0));
        t.addNodeByType(new Integer(TParser.DBL));
        chain(s.children[0],t,var);
        if (((Integer) t.getTop().type).intValue() == TParser.MULT)
          t.addByNode(t.getTop().children[1]);
        t.addNodeByType(new Double(1.0));
        t.addNodeByType(new Integer(TParser.DBL));
        t.addByNode(s.children[0]);
        t.addNodeByType(new Double(2.0));
        t.addNodeByType(new Integer(TParser.DBL));
        t.addNodeByType(new Integer(TParser.POW));
        t.addNodeByType(new Integer(TParser.PLUS));
        t.addNodeByType(new Integer(TParser.DIV));
        break;
      case TParser.ASEC:
        addToMsgString(AMathlet.getProperty("DerivCalc.asecrule"));
        t.addNodeByType(new Double(1.0));
        t.addNodeByType(new Integer(TParser.DBL));
        chain(s.children[0],t,var);
        if (((Integer) t.getTop().type).intValue() == TParser.MULT)
          t.addByNode(t.getTop().children[1]);
        t.addByNode(s.children[0]);
        t.addByNode(s.children[0]);
        t.addNodeByType(new Double(2.0));
        t.addNodeByType(new Integer(TParser.DBL));
        t.addNodeByType(new Integer(TParser.POW));
        t.addNodeByType(new Double(1.0));
        t.addNodeByType(new Integer(TParser.DBL));
        t.addNodeByType(new Integer(TParser.MINUS));
        t.addNodeByType(new Integer(TParser.SQRT));
        t.addNodeByType(new Integer(TParser.MULT));
        t.addNodeByType(new Integer(TParser.DIV));
        break;
      case TParser.ABS:
        addToMsgString(AMathlet.getProperty("DerivCalc.absvalrule"));
        t.addByNode(s);
        chain(s.children[0],t,var);
        t.addByNode(s.children[0]);
        t.addNodeByType(new Integer(TParser.DIV));
        break;
      case TParser.SQRT:
        addToMsgString(AMathlet.getProperty("DerivCalc.sqrtaspower"));
        t.addNodeByType(new Double(1.0));
        t.addNodeByType(new Integer(TParser.DBL));
        chain(s.children[0],t,var);
        if (((Integer) t.getTop().type).intValue() == TParser.MULT)
          t.addByNode(t.getTop().children[1]);
        t.addNodeByType(new Double(2.0));
        t.addNodeByType(new Integer(TParser.DBL));
        t.addByNode(s.children[0]);
        t.addNodeByType(new Integer(TParser.SQRT));
        t.addNodeByType(new Integer(TParser.MULT));
        t.addNodeByType(new Integer(TParser.DIV));
        break;
      case TParser.DERIV:
      int tvar = ((Integer) s.children[1].type).intValue();
        t.addByNode(derivator(s.children[0],tvar));
        t.addNodeByType(new Integer(var));
        t.addNodeByType(new Integer(TParser.DERIV));
        break;
      default:
        t.addNodeByType(new Integer(TParser.ERROR));
        break;
      }
      dapplied = true;
      return (Node) t.getTop().clone();
  }

  public String evaluatef() {
      msgString="";
      if (dirty) {
        String expr = super.getInput();
        if (expr.length() == 0) return "";
        else evaluate(expr);
        dirty = false;
      }
      String s = evaluateTree((Node) parseReturn.clone());
      if (errorDetected) {
        msgString = "";
        return "";
      }
      else return s;
  }

  public void setDirty() {
    dirty = true;
    errorDetected = false;
  }

}