* $Date: 2011-05-29 01:32:52 +0200 (dim., 29 mai 2011) $

* $Revision: 15508 $

*

* Copyright (C) 2002-2005  The Jmol Development Team

*

* 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.

*/

  /*

   * The Compiler class is really two parts --

   *

   * Compiler.class          going from characters to tokens

   * CompilationTokenParser  further syntax checking and modifications

   *

   * The data structures follow the following sequences:

   *

   * String script ==> List lltoken[][] --> Token[][] aatokenCompiled[][]

   *

   * A given command goes through the sequence:

   *

   * String characters --> Token token --> List ltoken[] --> Token[][] aatokenCompiled[][]

   *

   */

 

  public ScriptCompiler(Viewer viewer) {

    this.viewer = viewer;

  }

 

  public ScriptCompiler(ScriptCompiler compiler) {

    this.viewer = compiler.viewer;

  }

  private String filename;

  private boolean isSilent;

  // returns:

 

  private Hashtable contextVariables;

  private Token[][] aatokenCompiled;

  private short[] lineNumbers;

  private int[][] lineIndices;

 

  private int lnLength = 8;

  private boolean preDefining;

  private boolean isShowScriptOutput;

  private boolean isCheckOnly;

  private boolean haveComments;

  String scriptExtensions;

 

  private ScriptFunction thisFunction;

 

  /**

   * return a structure that is only the first part of the process - identifying lines and commands

   * for the scriptEditor

   *

   * @param script

   * @return        ScriptContext

   */

 

  ScriptContext parseScriptForTokens(String script) {

    this.script = script;

    filename = null;

    isCheckOnly = true;

    isSilent = true;

    logMessages = false;

    preDefining = false;

    return parseScript(false);

  }

  private ScriptContext parseScript(boolean doFull) {

    if (!compile0(doFull))

      handleError();

    ScriptContext sc = new ScriptContext();

    sc.script = script;

    sc.scriptExtensions = scriptExtensions;

    sc.errorType = errorType;

    if (errorType != null) {

      sc.iCommandError = iCommand;

      setAaTokenCompiled();

    }

    sc.aatoken = aatokenCompiled;

    sc.errorMessage = errorMessage;

    sc.errorMessageUntranslated = (errorMessageUntranslated == null

        ? errorMessage : errorMessageUntranslated);

    sc.lineIndices = lineIndices;

    sc.lineNumbers = lineNumbers;

    sc.contextVariables = contextVariables;

    return sc;

  }

  ScriptContext compile(String filename, String script, boolean isPredefining,

                  boolean isSilent, boolean debugScript, boolean isCheckOnly) {

    this.isCheckOnly = isCheckOnly;

    this.filename = filename;

    this.isSilent = isSilent;

    this.script = script;

    logMessages = (!isSilent && !isPredefining && debugScript);

    preDefining = (filename == "#predefine");

    return parseScript(true);

  }

  private void addContextVariable(String ident) {

    theToken = new Token(Token.identifier, ident);

    if (pushCount > 0) {

      ContextToken ct = (ContextToken) vPush.get(pushCount - 1);

      ct.addName(ident);

      if (ct.tok != Token.trycmd)

        return;

    }

    if (thisFunction == null) {

      if (contextVariables == null)

        contextVariables = new Hashtable();

      addContextVariable(contextVariables, ident);

    } else {

      thisFunction.addVariable(ident, false);

    }

  }

 

  static void addContextVariable(Hashtable contextVariables, String ident) {

    contextVariables.put(ident, (new ScriptVariable(Token.string, "")).setName(ident));

  }

  private boolean isContextVariable(String ident) {

    for (int i = vPush.size(); --i >= 0;) {

      ContextToken ct = (ContextToken) vPush.get(i);

      if (ct.contextVariables != null && ct.contextVariables.containsKey(ident))

        return true;

    }

    return (thisFunction != null ? thisFunction.isVariable(ident)

        : contextVariables != null && contextVariables.containsKey(ident));

  }

 

  /**

   * allows for three kinds of comments.

   * NOTE: closing involves asterisks and slash together, but that can't be shown here.

   *

   * 1) /** .... ** /  super-comment

   * 2) /* ..... * /   may be INSIDE /**....** /).

   * 3)  \n//.....\n   single-line comments -- like #, but removed entirely

   * The reason is that /* ... * / will appear as standard in MOVETO command

   * but we still might want to escape it, so around that you can have /** .... ** /

   *

   * The terminator is not necessary -- so you can quickly escape anything in a file

   * after /** or /*

   *

   * In addition, we can have [/*|/**] .... **** Jmol Embedded Script ****  [script commands] [** /|* /]

   * Then ONLY that script is taken. This is a powerful and simple way then to include Jmol scripting

   * in any file -- including, for example, HTML as an HTML comment. Just send the whole file to

   * Jmol, and it will find its script!

   *

   * @param script

   * @return cleaned script

   */

  private String cleanScriptComments(String script) {

    int pt = (script.indexOf("\1##"));

    if (pt >= 0) {

      // these are for jmolConsole and scriptEditor

      scriptExtensions = script.substring(pt + 1);

      script = script.substring(0, pt);

    }

    haveComments = (script.indexOf("#") >= 0); // speeds processing

    return getEmbeddedScript(script);

  }

 

  public static String getEmbeddedScript(String script) {

    if (script == null)

      return script;

    int pt = script.indexOf(JmolConstants.EMBEDDED_SCRIPT_TAG);

    if (pt < 0)

      return script;

    int pt1 = script.lastIndexOf("/*", pt);

    int pt2 = script.indexOf((script.charAt(pt1 + 2) == '*' ? "*" : "") + "*/",

        pt);

    if (pt1 >= 0 && pt2 >= pt)

      script = script.substring(

          pt + JmolConstants.EMBEDDED_SCRIPT_TAG.length(), pt2)

          + "\n";

    while ((pt1 = script.indexOf(JpegEncoder.CONTINUE_STRING)) >= 0)

      script = script.substring(0, pt1)

          + script.substring(pt1 + JpegEncoder.CONTINUE_STRING.length() + 4);

    if (Logger.debugging)

      Logger.info(script);

    return script;

  }

  private ScriptFlowContext flowContext;

  private List ltoken;

  private List lltoken;

  private List vBraces;

  private int ichBrace;

  private int cchToken;

  private int cchScript;

  private int nSemiSkip;

  private int parenCount;

  private int braceCount;

  private int setBraceCount;

  private int bracketCount;

  private int ptSemi;

  private int forPoint3;

  private int setEqualPt;

  private int iBrace;

  private boolean iHaveQuotedString;

  private boolean isEndOfCommand;

  private boolean needRightParen;

  private boolean endOfLine;

  private String comment;

  private void addTokenToPrefix(Token token) {

    if (logMessages)

      Logger.info("addTokenToPrefix" + token);

    ltoken.add(token);

    lastToken = token;

  }

  private final static int OK = 0;

  private final static int OK2 = 1;

  private final static int CONTINUE = 2;

  private final static int EOL = 3;

  private final static int ERROR = 4;

  private int tokLastMath;

 

  private List vFunctionStack;

 

  private boolean compile0(boolean isFull) {

    vFunctionStack = new ArrayList();

    htUserFunctions = new Hashtable();

    script = script.replace('\u201C', '"').replace('\u201D', '"');

    script = cleanScriptComments(script);

    ichToken = script.indexOf(Viewer.STATE_VERSION_STAMP);

    isStateScript = (ichToken >= 0);

    if (isStateScript) {

      ptSemi = script.indexOf(";", ichToken);

      if (ptSemi >= ichToken)

        viewer.setStateScriptVersion(script.substring(

            ichToken + Viewer.STATE_VERSION_STAMP.length(), ptSemi).trim());

    }

    cchScript = this.script.length();

    // these four will be returned:

    contextVariables = null;

    lineNumbers = null;

    lineIndices = null;

    aatokenCompiled = null;

    thisFunction = null;

    flowContext = null;

    errorType = null;

    errorMessage = null;

    errorMessageUntranslated = null;

    errorLine = null;

    nSemiSkip = 0;

    ichToken = 0;

    ichCurrentCommand = 0;

    ichComment = 0;

    ichBrace = 0;

    lineCurrent = 1;

    iCommand = 0;

    tokLastMath = 0;

    lastToken = Token.tokenOff;

    vBraces = new ArrayList();

    vPush = new ArrayList();

    pushCount = 0;

    iBrace = 0;

    braceCount = 0;

    parenCount = 0;

    ptSemi = -10;

    cchToken = 0;

    lnLength = 8;

    lineNumbers = new short[lnLength];

    lineIndices = new int[lnLength][2];

    isNewSet = isSetBrace = false;

    ptNewSetModifier = 1;

    isShowScriptOutput = false;

    iHaveQuotedString = false;

    lltoken = new ArrayList();

    ltoken = new ArrayList();

    tokCommand = Token.nada;

    lastFlowCommand = null;

    tokenAndEquals = null;

    setBraceCount = 0;

    bracketCount = 0;

    forPoint3 = -1;

    setEqualPt = Integer.MAX_VALUE;

    endOfLine = false;

    comment = null;

    isEndOfCommand = false;

    needRightParen = false;

    theTok = Token.nada;

    short iLine = 1;

    for (; true; ichToken += cchToken) {

      if ((nTokens = ltoken.size()) == 0) {

        if (thisFunction != null && thisFunction.chpt0 == 0)

          thisFunction.chpt0 = ichToken;

        ichCurrentCommand = ichToken;

        iLine = lineCurrent;

      }

      if (lookingAtLeadingWhitespace())

        continue;

      endOfLine = false;

      if (!isEndOfCommand) {

        endOfLine = lookingAtEndOfLine();

        switch (endOfLine ? OK : lookingAtComment()) {

        case CONTINUE: //  short /*...*/ or comment to completely ignore

          continue;

        case EOL: // /* .... \n ... */ -- flag as end of line but ignore

          isEndOfCommand = true;

          continue;

        case OK2: // really just line-ending comment -- mark it for later inclusion

          isEndOfCommand = true;

          // start-of line comment -- include as Token.nada

          comment = script.substring(ichToken, ichToken + cchToken).trim();

          break;

        }

        isEndOfCommand = isEndOfCommand || endOfLine

            || lookingAtEndOfStatement();

      }

      if (isEndOfCommand) {

        isEndOfCommand = false;

        switch (processTokenList(iLine, isFull)) {

        case CONTINUE:

          continue;

        case ERROR:

          return false;

        }

        if (ichToken < cchScript)

          continue;

        setAaTokenCompiled();

        return (flowContext == null || error(ERROR_missingEnd, Token

            .nameOf(flowContext.token.tok)));

      }

      if (nTokens > 0) {

        switch (checkSpecialParameterSyntax()) {

        case CONTINUE:

          continue;

        case ERROR:

          return false;

        }

      }

      if (lookingAtLookupToken(ichToken)) {

        String ident = getPrefixToken();

        //System.out.println(ident);

        switch (parseKnownToken(ident)) {

        case CONTINUE:

          continue;

        case ERROR:

          return false;

        }

        switch (parseCommandParameter(ident)) {

        case CONTINUE:

          continue;

        case ERROR:

          return false;

        }

        addTokenToPrefix(theToken);

        continue;

      }

      if (nTokens == 0 || (isNewSet || isSetBrace)

          && nTokens == ptNewSetModifier) {

        if (nTokens == 0) {

          if (lookingAtString(true)) {

            addTokenToPrefix(setCommand(Token.tokenScript));

            cchToken = 0;

            continue;

          }

          if (lookingAtImpliedString(true))

            ichEnd = ichToken + cchToken;

        }

        return commandExpected();

      }

      return error(ERROR_unrecognizedToken, script.substring(ichToken,

          ichToken + 1));

    }

  }

 

  private void setAaTokenCompiled() {

    aatokenCompiled = new Token[lltoken.size()][];

    for (int i = lltoken.size(); --i >= 0;)

      aatokenCompiled[i] = (Token[]) lltoken.get(i);

  }

  private boolean lookingAtLeadingWhitespace() {

    int ichT = ichToken;

    while (ichT < cchScript && isSpaceOrTab(script.charAt(ichT)))

      ++ichT;

    if (isLineContinuation(ichT, true))

      ichT += 1 + nCharNewLine(ichT + 1);

    cchToken = ichT - ichToken;

    return cchToken > 0;

  }

  private boolean isLineContinuation(int ichT, boolean checkMathop) {

    boolean isEscaped = (ichT + 2 < cchScript && script.charAt(ichT) == '\\' && nCharNewLine(ichT + 1) > 0

        || checkMathop && lookingAtMathContinuation(ichT));  

    if (isEscaped)

      lineCurrent++;

    return isEscaped;

  }

  private boolean lookingAtMathContinuation(int ichT) {

    int n;

    if (ichT >= cchScript || (n = nCharNewLine(ichT)) == 0 || lastToken.tok == Token.leftbrace)

      return false;

    if (parenCount > 0 || bracketCount > 0)

      return true;

    if ((tokCommand != Token.set || !isNewSet) && tokCommand != Token.print && tokCommand != Token.log)

        return false;

    if (lastToken.tok == tokLastMath)

      return true;

    ichT += n;

    while (ichT < cchScript && isSpaceOrTab(script.charAt(ichT)))

      ++ichT;

    return (lookingAtLookupToken(ichT)

        && tokLastMath == 1);

  }

  private boolean lookingAtEndOfLine() {

    int ichT = ichEnd = ichToken;

    if (ichToken >= cchScript) {

      ichEnd = cchScript;

      return true;

    }

    int n = nCharNewLine(ichT);

    if (n == 0)

      return false;

    ichEnd = ichToken;

    cchToken = n;

    return true;   

  }

 

  private int nCharNewLine(int ichT) {

    char ch;

    return (ichT >= cchScript ? 0

        : (ch = script.charAt(ichT)) != '\r' ? (ch == '\n' ? 1 : 0)

        : ++ichT < cchScript && script.charAt(ichT) == '\n' ? 2 : 1);

  }

  private boolean lookingAtEndOfStatement() {

    boolean isSemi = (script.charAt(ichToken) == ';');

    if (isSemi && nTokens > 0)

      ptSemi = nTokens;

    if (!isSemi || nSemiSkip-- > 0)

      return false;

    cchToken = 1;

    return true;

  }

  private boolean isShowCommand;

 

  private int lookingAtComment() {

    char ch = script.charAt(ichToken);

    int ichT = ichToken;

    int ichFirstSharp = -1;

    // return CONTINUE: totally ignore

    // return EOL: treat as line end, even though it isn't

    // return OK: no comment here

    /*

     * New in Jmol 11.1.9: we allow for output from the set showScript command

     * to be used as input. These lines start with $ and have a [...] phrase

     * after them. Their presence switches us to this new mode where we use

     * those statements as our commands and any line WITHOUT those as comments.

     */

    if (ichToken == ichCurrentCommand && ch == '$') {

      isShowScriptOutput = true;

      isShowCommand = true;

      while (ch != ']' && ichT < cchScript && !eol(ch = script.charAt(ichT)))

        ++ichT;

      cchToken = ichT - ichToken;

      return CONTINUE;

    } else if (isShowScriptOutput && !isShowCommand) {

      ichFirstSharp = ichT;

    }

    if (ch == '/' && ichT + 1 < cchScript)

      switch (script.charAt(++ichT)) {

      case '/':

        ichFirstSharp = ichToken;

        ichEnd = ichT - 1;

        break;

      case '*':

        ichEnd = ichT - 1;

        String terminator = (++ichT < cchScript && (ch = script.charAt(ichT)) == '*'

            ? "**/" : "*/");

        ichT = script.indexOf(terminator, ichToken + 2);

        if (ichT < 0) {

          ichToken = cchScript;

          return EOL;

        }

        // ichT points at char after /*, whatever that is. So even /***/ will be caught

        incrementLineCount(script.substring(ichToken, ichT));

        cchToken = ichT + (ch == '*' ? 3 : 2) - ichToken;

        return CONTINUE;

      default:

        return OK;

      }

    boolean isSharp = (ichFirstSharp < 0);

    if (isSharp && !haveComments)

      return OK;

    // old way:

    // first, find the end of the statement and scan for # (sharp) signs

    if (ichComment > ichT)

      ichT = ichComment;

    for (; ichT < cchScript; ichT++) {

      if (eol(ch = script.charAt(ichT))) {

        ichEnd = ichT;

        if (isLineContinuation(ichT - 1, false)) {

          ichT += nCharNewLine(ichT);

          continue;

        }

        if (!isSharp && ch == ';')

          continue;

        break;

      }

      if (ichFirstSharp >= 0)

        continue;

      if (ch == '#')

        ichFirstSharp = ichT;

    }

    if (ichFirstSharp < 0) // there were no sharps found

      return OK;

    ichComment = ichFirstSharp;

    /****************************************************************

     * check for #jc comment if it occurs anywhere in the statement, then the

     * statement is not executed. This allows statements which are executed in

     * RasMol but are comments in Jmol

     ****************************************************************/

    if (isSharp && nTokens == 0 && cchScript - ichFirstSharp >= 3

        && script.charAt(ichFirstSharp + 1) == 'j'

        && script.charAt(ichFirstSharp + 2) == 'c') {

      // statement contains a #jc before then end ... strip it all

      cchToken = ichT - ichToken;

      return CONTINUE;

    }

    // if the sharp was not the first character then it isn't a comment

    if (ichFirstSharp != ichToken)

      return OK;

    /****************************************************************

     * check for leading #jx <space> or <tab> if you see it, then only strip

     * those 4 characters. if they put in #jx <newline> then they are not going

     * to execute anything, and the regular code will take care of it

     ****************************************************************/

    if (isSharp && cchScript > ichToken + 3 && script.charAt(ichToken + 1) == 'j'

        && script.charAt(ichToken + 2) == 'x'

        && isSpaceOrTab(script.charAt(ichToken + 3))) {

      cchToken = 4; // #jx[\s\t]

      return CONTINUE;

    }

   

    if (ichT == ichToken)

      return OK;

    // first character was a sharp, but was not #jx ... strip it all

    cchToken = ichT - ichToken;

    return (nTokens == 0 ? OK2 : CONTINUE);

  }

  private int processTokenList(short iLine, boolean doCompile) {

    if (nTokens > 0 || comment != null) {

      if (nTokens == 0) {

        // just a comment

        ichCurrentCommand = ichToken;

        if (comment != null)

          addTokenToPrefix(new Token(Token.nada, comment));

      } else if (setBraceCount > 0 && endOfLine && ichToken < cchScript) {

        return CONTINUE;

      }

      // end of command or comment

      iCommand = lltoken.size();

      if (thisFunction != null && thisFunction.cmdpt0 < 0) {

        thisFunction.cmdpt0 = iCommand;

      }

      if (nTokens == 1 && braceCount == 1) {

        // ...{...

        if (lastFlowCommand == null) {

          parenCount = setBraceCount = braceCount = 0;

          ltoken.remove(0);

          iBrace++;

          Token t = new ContextToken(Token.push, 0, "{");

          addTokenToPrefix(setCommand(t));

          pushCount++;

          vPush.add(t);

          vBraces.add(tokenCommand);

        } else {

          parenCount = setBraceCount = 0;

          setCommand(lastFlowCommand);

          if (lastFlowCommand.tok != Token.process

              && (tokAt(0) == Token.leftbrace))

            ltoken.remove(0);

          lastFlowCommand = null;

        }

      }

      if (bracketCount > 0 || setBraceCount > 0 || parenCount > 0

          || braceCount == 1 && !checkFlowStartBrace(true)) {

        error(nTokens == 1 ? ERROR_commandExpected

            : ERROR_endOfCommandUnexpected);

        return ERROR;

      }

      if (needRightParen) {

        addTokenToPrefix(Token.tokenRightParen);

        needRightParen = false;

      }

      if (ltoken.size() > 0) {

        if (doCompile && !compileCommand())

          return ERROR;

        if (logMessages) {

          Logger.debug("-------------------------------------");

        }

        boolean doEval = true;

        switch (tokCommand) {

        case Token.trycmd:

        case Token.parallel:

        case Token.function: // formerly "noeval"

        case Token.end:         

          // end switch may have - or + intValue, depending upon default or not

          // end function and the function call itself has intValue 0,

          // but the FUNCTION declaration itself will have MAX_VALUE intValue

          doEval = (atokenInfix.length > 0 && atokenInfix[0].intValue != Integer.MAX_VALUE);

          break;

        }

        if (doEval) {

          if (iCommand == lnLength) {

            short[] lnT = new short[lnLength * 2];

            System.arraycopy(lineNumbers, 0, lnT, 0, lnLength);

            lineNumbers = lnT;

            int[][] lnI = new int[lnLength * 2][2];

            System.arraycopy(lineIndices, 0, lnI, 0, lnLength);

            lineIndices = lnI;

            lnLength *= 2;

          }

          lineNumbers[iCommand] = iLine;

          lineIndices[iCommand][0] = ichCurrentCommand;

          lineIndices[iCommand][1] = Math.max(ichCurrentCommand, Math.min(

              cchScript, ichEnd == ichCurrentCommand ? ichToken : ichEnd));

          lltoken.add(atokenInfix);

          iCommand = lltoken.size();

        }

        if (tokCommand == Token.set)

          lastFlowCommand = null;

      }

      setCommand(null);

      comment = null;

      iHaveQuotedString = isNewSet = isSetBrace = needRightParen = false;

      ptNewSetModifier = 1;

      ltoken.clear();

      nTokens = nSemiSkip = 0;

      tokenAndEquals = null;

      ptSemi = -10;

      forPoint3 = -1;

      setEqualPt = Integer.MAX_VALUE;

    }

    if (endOfLine) {

      if (flowContext != null && flowContext.checkForceEndIf(1)) {

        forceFlowEnd(flowContext.token);

        isEndOfCommand = true;

        cchToken = 0;

        ichCurrentCommand = ichToken;

        lineCurrent--;

        return CONTINUE;

      }