Class ScriptCompiler

java.lang.Object
org.jmol.script.ScriptTokenParser
org.jmol.script.ScriptCompiler

public class ScriptCompiler extends ScriptTokenParser
  • Field Details

    • filename

      private String filename
    • isSilent

      private boolean isSilent
    • contextVariables

      private Map<String,SV> contextVariables
    • aatokenCompiled

      private T[][] aatokenCompiled
    • lineNumbers

      private short[] lineNumbers
    • lineIndices

      private int[][] lineIndices
    • lnLength

      private int lnLength
    • preDefining

      private boolean preDefining
    • isShowScriptOutput

      private boolean isShowScriptOutput
    • isCheckOnly

      private boolean isCheckOnly
    • haveComments

      private boolean haveComments
    • isPrivateFunc

      private boolean isPrivateFunc
    • isPrivateScript

      private boolean isPrivateScript
    • scriptExtensions

      String scriptExtensions
    • thisFunction

      private ScriptFunction thisFunction
    • flowContext

      private ScriptFlowContext flowContext
    • ltoken

      private javajs.util.Lst<T> ltoken
    • lltoken

      private javajs.util.Lst<T[]> lltoken
    • vBraces

      private javajs.util.Lst<T> vBraces
    • ichBrace

      private int ichBrace
    • cchToken

      private int cchToken
    • cchScript

      private int cchScript
    • nSemiSkip

      private int nSemiSkip
    • parenCount

      private int parenCount
    • braceCount

      private int braceCount
    • setBraceCount

      private int setBraceCount
    • bracketCount

      private int bracketCount
    • ptSemi

      private int ptSemi
    • forPoint3

      private int forPoint3
    • setEqualPt

      private int setEqualPt
    • iBrace

      private int iBrace
    • iHaveQuotedString

      private boolean iHaveQuotedString
    • isEndOfCommand

      private boolean isEndOfCommand
    • needRightParen

      private boolean needRightParen
    • endOfLine

      private boolean endOfLine
    • comment

      private String comment
    • OK

      private static final int OK
      See Also:
    • OK2

      private static final int OK2
      See Also:
    • CONTINUE

      private static final int CONTINUE
      See Also:
    • EOL

      private static final int EOL
      See Also:
    • ERROR

      private static final int ERROR
      See Also:
    • RESTART

      private static final int RESTART
      See Also:
    • tokLastMath

      private int tokLastMath
    • checkImpliedScriptCmd

      private boolean checkImpliedScriptCmd
    • vFunctionStack

      private javajs.util.Lst<ScriptFunction> vFunctionStack
    • allowMissingEnd

      private boolean allowMissingEnd
    • isShowCommand

      private boolean isShowCommand
    • isComment

      private boolean isComment
    • isUserToken

      private boolean isUserToken
    • implicitString

      private boolean implicitString
    • tokInitialPlusPlus

      private int tokInitialPlusPlus
    • afterWhite

      private int afterWhite
    • isDotDot

      private boolean isDotDot
    • ident

      private String ident
    • identLC

      private String identLC
    • vPush

      private javajs.util.Lst<T> vPush
    • pushCount

      private int pushCount
    • forceFlowContext

      private ScriptFlowContext forceFlowContext
    • isWhere

      private boolean isWhere
    • haveENDIF

      private boolean haveENDIF
    • chFirst

      private char chFirst
    • afterMath

      private int afterMath
  • Constructor Details

    • ScriptCompiler

      public ScriptCompiler(Viewer vwr)
      Parameters:
      vwr -
  • Method Details

    • compile

      ScriptContext compile(String filename, String script, boolean isPredefining, boolean isSilent, boolean debugScript, boolean isCheckOnly)
    • newContextVariable

      private void newContextVariable(String ident)
    • addContextVariable

      static void addContextVariable(Map<String,SV> contextVariables, String name)
    • isContextVariable

      private boolean isContextVariable(String ident)
    • cleanScriptComments

      private String cleanScriptComments(String script)
      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!
      Parameters:
      script -
      Returns:
      cleaned script
    • addTokenToPrefix

      private void addTokenToPrefix(T token)
    • compile0

      private boolean compile0(boolean isFull)
    • setAaTokenCompiled

      private void setAaTokenCompiled()
    • lookingAtLeadingWhitespace

      private boolean lookingAtLeadingWhitespace()
    • isLineContinuation

      private boolean isLineContinuation(int ichT, boolean checkMathop)
    • lookingAtMathContinuation

      private boolean lookingAtMathContinuation(int ichT)
    • lookingAtEndOfLine

      private boolean lookingAtEndOfLine()
      Look for end of script or a new line. Set ichEnd to this point or end of string; if found, set cchToken to the number of eol characters;
      Returns:
      true if eol
    • nCharNewLine

      private int nCharNewLine(int ichT)
      Check for line ending at this point in script.
      Parameters:
      ichT -
      Returns:
      1 if \n or \r, 2 if \r\n, or 0 otherwise (including end of script)
    • lookingAtTerminator

      private boolean lookingAtTerminator()
      Look for valid terminating semicolon -- one not within for(), for example.
      Returns:
      true if valid semi
    • lookingAtComment

      private int lookingAtComment()
    • charAt

      private char charAt(int i)
    • processTokenList

      private int processTokenList(short iLine, boolean doCompile)
    • addBrace

      private void addBrace(T t)
      Parameters:
      t - could be { or } or a command such as FOR or WHILE
    • pushContext

      private void pushContext(T t)
    • wasImpliedScript

      private boolean wasImpliedScript()
      Check for improperly parsed implied script command: only two tokens: [implied script] xxx.SORT/REVERSE/PUSH/POP more than two tokens: xxxx.spt(3,4,5)
      Returns:
      true if found
    • compileCommand

      private boolean compileCommand()
    • tokenAt

      private T tokenAt(int i)
    • tokAt

      protected int tokAt(int i)
      Overrides:
      tokAt in class ScriptTokenParser
    • setCommand

      private T setCommand(T token)
    • replaceCommand

      private void replaceCommand(T token)
    • getPrefixToken

      private int getPrefixToken()
    • checkSpecialParameterSyntax

      private int checkSpecialParameterSyntax()
      Check for special parameters, including: +, -, \, *, /, invalid input: '&', |, =, period, or [, single or double quote, command-specific parameters, $.... identifiers, exponential notation, decimal numbers, sequence codes, integers, bitsets ({....}) or [{....}], or matrices
      Returns:
      OK, CONTINUE, or ERROR
    • addNumber

      private void addNumber(int tok, int i, Object v)
    • lookingAtMatrix

      private Object lookingAtMatrix()
    • parseKnownToken

      private int parseKnownToken()
    • tokenizePlusPlus

      private void tokenizePlusPlus(int tok, boolean isPlusPlusX)
    • checkNewSetCommand

      private boolean checkNewSetCommand()
    • parseCommandParameter

      private int parseCommandParameter(short iLine, boolean isFull)
    • setNewSetCommand

      private T setNewSetCommand(boolean isSetBrace, String ident)
    • checkUnquotedFileName

      private void checkUnquotedFileName()
    • checkFlowStartBrace

      private boolean checkFlowStartBrace(boolean atEnd)
    • checkFlowEndBrace

      private int checkFlowEndBrace()
      process a pending explicit right brace }
      Returns:
      continuation status
    • forceFlowEnd

      private int forceFlowEnd(T token)
    • flowStart

      private T flowStart(T token)
    • isBreakableContext

      static boolean isBreakableContext(int tok)
    • checkFlowCommand

      private int checkFlowCommand(String ident)
    • setFlowEnd

      private void setFlowEnd(int tokCommand, String ident)
      generate a new end token with pointer to the start or to default as the intValue and set it as the command token
      Parameters:
      tokCommand - end or endif
      ident - "end" or "endif"
    • isFlowIfContextOK

      private boolean isFlowIfContextOK(ScriptFlowContext f)
      check for proper sequence: if...[any number of elseif]...[zero or one else]...[endif]
      Parameters:
      f -
      Returns:
      true if OK
    • checkFlowEnd

      private boolean checkFlowEnd(int tok, String ident, int pt1, boolean isExplicitEnd)
      Parameters:
      tok - the XXX in END XXX
      ident -
      pt1 -
      isExplicitEnd - actual END IF or END FOR, etc.
      Returns:
      true if no error
    • fixFlowAddLine

      private void fixFlowAddLine(ScriptFlowContext flowContext)
    • getData

      private boolean getData(String key)
    • incrementLineCount

      private int incrementLineCount(String str)
    • isSpaceOrTab

      private static boolean isSpaceOrTab(char ch)
    • eol

      private boolean eol(char ch)
      look for end-of-line character \r, \n, or ; that is not within a command such as for (var i=0;i invalid input: '<' 10; i++)
      Parameters:
      ch -
      Returns:
      true if end of line
    • lookingAtSetBraceSyntax

      private boolean lookingAtSetBraceSyntax()
      look for '{' at the start of a command, allowing for syntaxes {xxx}.yyy = ... or {xxx}[yy] = ...
      Returns:
      true only if found
    • lookingAtString

      private boolean lookingAtString(boolean allowPrime)
      look for a quoted string, possibly allowing single quotes.
      Parameters:
      allowPrime - cd, echo, gotocmd, help, hover, javascript, label, message, and pause all are implicitly strings. You CAN use "..." but you don't have to, and you cannot use '...'. This way the introduction of single quotes as an equivalent of double quotes cannot break existing scripts. -- BH 06/2009
      Returns:
      true only if found
    • getUnescapedStringLiteral

      private String getUnescapedStringLiteral(boolean isFileName)
      lookingAtString returned true, and we need to unescape any t, r, n, ", ', x, u, or backslash after a backslash
      Parameters:
      isFileName - in certain cases, such as load "c:\temp\myfile.xyz" we only want to decode unicode, not other characters.
      Returns:
      quoted string
    • unescapeString

      public static String unescapeString(String script, int ich, int nChar)
    • lookingAtLoadFormat

      private boolean lookingAtLoadFormat(boolean allchar)
    • lookingAtImpliedString

      private boolean lookingAtImpliedString(boolean allowSpace, boolean allowEquals, boolean allowSptParen)
      An "implied string" is a parameter that is not quoted but because of its position in a command is implied to be a string. First we must exclude the
      Parameters:
      allowSpace - as in commands such as echo
      allowEquals - as in the load command, first parameter load =xxx but NOT any other command
      allowSptParen - specifically for script/load command, first parameter xxx.spt(3,4,4)
      Returns:
      true or false
    • lookingAtExponential

      private Float lookingAtExponential()
    • lookingAtDecimal

      private boolean lookingAtDecimal()
    • lookingAtSeqcode

      private boolean lookingAtSeqcode()
    • lookingAtInteger

      private int lookingAtInteger()
    • lookingAtBitset

      javajs.util.BS lookingAtBitset()
    • lookingAtObjectID

      private boolean lookingAtObjectID()
      Look for a valid $... sequence. This must be alphanumeric or _ or ~ only. We skip any $"...". That will be handled later.
      Returns:
      true only if valid $....
    • lookingAtLookupToken

      private boolean lookingAtLookupToken(int ichT)
    • lookForSyncID

      private boolean lookForSyncID()
      Check for a set of characters that does not start with double quote or at-sign and terminates with #, }, or an end of line. Only used for the SYNC command's second character.
      Returns:
      true if ID is found.
    • ERROR

      private int ERROR(int error)
    • ERROR

      private int ERROR(int error, String value)
    • handleError

      private boolean handleError()