* $Author: hansonr $

* $Date: 2009-06-12 07:58:28 -0500 (Fri, 12 Jun 2009) $

* $Revision: 11009 $

*

* Copyright (C) 2003-2006  Miguel, Jmol Development, www.jmol.org

*

* Contact: jmol-developers@lists.sf.net

*

*  This library is free software; you can redistribute it and/or

*  modify it under the terms of the GNU Lesser General Public

*  License as published by the Free Software Foundation; either

*  version 2.1 of the License, or (at your option) any later version.

*

*  This library 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

*  Lesser General Public License for more details.

*

*  You should have received a copy of the GNU Lesser General Public

*  License along with this library; if not, write to the Free Software

*  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

*/

  /**

   * Reverse Polish Notation Engine for IF, SET, and %{...} -- Bob Hanson

   * 2/16/2007 Just a (not so simple?) RPN processor that can handle boolean,

   * int, float, String, Point3f, and BitSet

   *

   * hansonr@stolaf.edu

   *

   */

  private boolean isSyntaxCheck;

  private boolean wasSyntaxCheck;

  private boolean logMessages;

  private ScriptEvaluator eval;

  private Viewer viewer;

  private Token[] oStack = new Token[8];

  private ScriptVariable[] xStack = new ScriptVariable[8];

  private char[] ifStack = new char[8];

  private int ifPt = -1;

  private int oPt = -1;

  private int xPt = -1;

  private int parenCount;

  private int squareCount;

  private int braceCount;

  private boolean wasX;

  private int incrementX;

  private boolean isArrayItem;

  private boolean asVector;

  private boolean asBitSet;

  private int ptid = 0;

  private int ptx = Integer.MAX_VALUE;

  ScriptMathProcessor(ScriptEvaluator eval, boolean isArrayItem,

      boolean asVector, boolean asBitSet) {

    this.eval = eval;

    this.viewer = eval.viewer;

    this.logMessages = eval.logMessages;

    this.isSyntaxCheck = wasSyntaxCheck = eval.isSyntaxCheck;

    this.isArrayItem = isArrayItem;

    this.asVector = asVector || isArrayItem;

    this.asBitSet = asBitSet;

    wasX = isArrayItem;

    if (logMessages)

      Logger.info("initialize RPN");

  }

 

  ScriptVariable getResult(boolean allowUnderflow)

      throws ScriptException {

    boolean isOK = true;

    ScriptVariable x = null;

    while (isOK && oPt >= 0)

      isOK = operate();

    if (isOK) {

      if (asVector) {

        List result = new ArrayList();

        for (int i = 0; i <= xPt; i++)

          result.add(ScriptVariable.selectItem(xStack[i]));

        return new ScriptVariable(Token.vector, result);

      }

      if (xPt == 0) {

        if (x == null)

          x = xStack[0];

        if (x.tok == Token.bitset || x.tok == Token.varray

            || x.tok == Token.string || x.tok == Token.matrix3f

            || x.tok == Token.matrix4f)

          x = ScriptVariable.selectItem(x);

        if (asBitSet && x.tok ==

          Token.varray)

          x = new ScriptVariable(Token.bitset, ScriptVariable.unEscapeBitSetArray((List)x.value, false));

        return x;

      }

    }

    if (!allowUnderflow && (xPt >= 0 || oPt >= 0)) {

      // iToken--;

      eval.error(ScriptEvaluator.ERROR_invalidArgument);

    }

    return null;

  }

  private void putX(ScriptVariable x) {

    // System.out.println("putX skipping : " + skipping + " " + x);

    if (skipping)

      return;

    if (++xPt == xStack.length)

      xStack = (ScriptVariable[]) ArrayUtil.doubleLength(xStack);

    if (logMessages) {

      Logger.info("\nputX: " + x);

    }

    xStack[xPt] = x;

    ptx = ++ptid;

  }

  private void putOp(Token op) {

    if (++oPt >= oStack.length)

      oStack = (Token[]) ArrayUtil.doubleLength(oStack);

    oStack[oPt] = op;

    ptid++;

  }

  private void putIf(char c) {

    if (++ifPt >= ifStack.length)

      ifStack = (char[]) ArrayUtil.doubleLength(ifStack);

    ifStack[ifPt] = c;

  }

  boolean addX(ScriptVariable x) {

    // the standard entry point

    putX(x);

    return wasX = true;

  }

  boolean addX(Object x) {

    // the standard entry point

    ScriptVariable v = ScriptVariable.getVariable(x);

    if (v == null)

      return false;

    putX(v);

    return wasX = true;

  }

  boolean addX(BitSet bs) {

    // the standard entry point for bit sets

    ScriptVariable v = new ScriptVariable(Token.bitset, bs);

    if (v == null)

      return false;

    putX(v);

    return wasX = true;

  }

  boolean addX(Point3f pt) {

    // the standard entry point for bit sets

    ScriptVariable v = new ScriptVariable(Token.point3f, pt);

    if (v == null)

      return false;

    putX(v);

    return wasX = true;

  }

  boolean addXNum(ScriptVariable x) throws ScriptException {

    // corrects for x -3 being x - 3

    // only when coming from expression() or parameterExpression()

    if (wasX)

      switch (x.tok) {

      case Token.integer:

        if (x.intValue < 0) {

          addOp(Token.tokenMinus);

          x = ScriptVariable.intVariable(-x.intValue);

        }

        break;

      case Token.decimal:

        float f = ((Float) x.value).floatValue();

        if (f < 0 || f == 0 && 1 / f == Float.NEGATIVE_INFINITY) {

          addOp(Token.tokenMinus);

          x = new ScriptVariable(Token.decimal, new Float(-f));

        }

        break;

      }

    putX(x);

    return wasX = true;

  }

  private boolean addX(boolean x) {

    putX(ScriptVariable.getVariable(x ? Boolean.TRUE : Boolean.FALSE));

    return wasX = true;

  }

  private boolean addX(int x) {

    // no check for unary minus

    putX(ScriptVariable.intVariable(x));

    return wasX = true;

  }

  private boolean addX(float x) {

    // no check for unary minus

    return Float.isNaN(x) ? addX("NaN") : addX(new Float(x));

  }

  private static boolean isOpFunc(Token op) {

    return (Token.tokAttr(op.tok, Token.mathfunc) && op != Token.tokenArraySquare

        || op.tok == Token.propselector

        && Token.tokAttr(op.intValue, Token.mathfunc));

  }

  private boolean skipping;

  /**

   * addOp The primary driver of the Reverse Polish Notation evaluation engine.

   *

   * This method loads operators onto the oStack[] and processes them based on a

   * precedence system. Operands are added by addX() onto the xStack[].

   *

   * We check here for syntax issues that were not caught in the compiler. I

   * suppose that should be done at compilation stage, but this is how it is for

   * now.

   *

   * The processing of functional arguments and (___?___:___) constructs is

   * carried out by pushing markers onto the stacks that later can be used to

   * fill argument lists or turn "skipping" on or off. Note that in the case of

   * skipped sections of ( ? : ) no attempt is made to do syntax checking.

   * [That's not entirely true -- when syntaxChecking is true, that is, when the

   * user is typing at the Jmol application console, then this code is being

   * traversed with dummy variables. That could be improved, for sure.

   *

   * Actually, there's plenty of room for improvement here. I did this based on

   * what I learned in High School in 1974 -- 35 years ago! -- when I managed to

   * build a mini FORTRAN compiler from scratch in machine code. That was fun.

   * (This was fun, too.)

   *

   * -- Bob Hanson, hansonr@stolaf.edu 6/9/2009

   *

   *

   * @param op

   * @return false if an error condition arises

   * @throws ScriptException

   */

  boolean addOp(Token op) throws ScriptException {

    return addOp(op, true);

  }

  private boolean haveSpaceBeforeSquare;

  private int equalCount;

 

  boolean addOp(Token op, boolean allowMathFunc) throws ScriptException {

    if (logMessages) {

      Logger.info("addOp entry\naddOp: " + op ); //+ " oPt=" + oPt + " ifPt = "

         // + ifPt + " skipping=" + skipping + " wasX=" + wasX);

    }

    // are we skipping due to a ( ? : ) construct?

    int tok0 = (oPt >= 0 ? oStack[oPt].tok : 0);

    skipping = (ifPt >= 0 && (ifStack[ifPt] == 'F' || ifStack[ifPt] == 'X'));

    if (skipping) {

      switch (op.tok) {

      case Token.leftparen:

        putOp(op);

        return true;

      case Token.colon:

        // dumpStacks("skipping -- :");

        if (tok0 != Token.colon || ifStack[ifPt] == 'X')

          return true; // ignore if not a clean opstack or T already processed

        // no object here because we were skipping

        // set to flag end of this parens

        ifStack[ifPt] = 'T';

        wasX = false;

        // dumpStacks("(..False...? .skip.. :<--here.... )");

        skipping = false;

        return true;

      case Token.rightparen:

        if (tok0 == Token.leftparen) {

          oPt--; // clear opstack

          return true;

        }

        // dumpStacks("skipping -- )");

        if (tok0 != Token.colon) {

          putOp(op);

          return true;

        }

        wasX = true;

        // and remove markers

        ifPt--;

        oPt -= 2;

        skipping = false;

        // dumpStacks("(..True...? ... : ...skip...)<--here ");

        return true;

      default:

        return true;

      }

    }

    // Do we have the appropriate context for this operator?

    Token newOp = null;

    int tok;

    boolean isLeftOp = false;

    boolean isDotSelector = (op.tok == Token.propselector);

    if (isDotSelector && !wasX)

      return false;

    boolean isMathFunc = (allowMathFunc && isOpFunc(op));