{

// data for parsing

InterpreterData itsData;

static final int EXCEPTION_TRY_START_SLOT = 0;

static final int EXCEPTION_TRY_END_SLOT = 1;

static final int EXCEPTION_HANDLER_SLOT = 2;

static final int EXCEPTION_TYPE_SLOT = 3;

static final int EXCEPTION_LOCAL_SLOT = 4;

static final int EXCEPTION_SCOPE_SLOT = 5;

// SLOT_SIZE: space for try start/end, handler, start, handler type,

// exception local and scope local

static final int EXCEPTION_SLOT_SIZE = 6;

/**

private static class CallFrame implements Cloneable, Serializable

{

private static final long serialVersionUID = -2843792508994958978L;

// fields marked "final" in a comment are effectively final except when they're modified immediately after cloning.

/*final*/ CallFrame parentFrame;

// amount of stack frames before this one on the interpretation stack

/*final*/ int frameIndex;

// If true indicates read-only frame that is a part of continuation

boolean frozen;

final InterpretedFunction fnOrScript;

final InterpreterData idata;

/*final*/ Object[] stack;

/*final*/ int[] stackAttributes;

/*final*/ double[] sDbl;

final CallFrame varSource; // defaults to this unless continuation frame

final int localShift;

final int emptyStackTop;

final DebugFrame debuggerFrame;

final boolean useActivation;

boolean isContinuationsTopFrame;

final Scriptable thisObj;

Object result;

double resultDbl;

int pc;

int pcPrevBranch;

int pcSourceLineStart;

Scriptable scope;

int savedStackTop;

int savedCallOp;

Object throwable;

CallFrame(Context cx, Scriptable thisObj, InterpretedFunction fnOrScript, CallFrame parentFrame) {

idata = fnOrScript.idata;

debuggerFrame = cx.debugger != null ? cx.debugger.getFrame(cx, idata) : null;

useActivation = debuggerFrame != null || idata.itsNeedsActivation;

emptyStackTop = idata.itsMaxVars + idata.itsMaxLocals - 1;

this.fnOrScript = fnOrScript;

varSource = this;

localShift = idata.itsMaxVars;

this.thisObj = thisObj;

this.parentFrame = parentFrame;

frameIndex = (parentFrame == null) ? 0 : parentFrame.frameIndex + 1;

if(frameIndex > cx.getMaximumInterpreterStackDepth()) {

throw Context.reportRuntimeError("Exceeded maximum stack depth");

}

// Initialize initial values of variables that change during

// interpretation.

result = Undefined.instance;

pcSourceLineStart = idata.firstLinePC;

savedStackTop = emptyStackTop;

}

void initializeArgs(Context cx, Scriptable callerScope, Object[] args, double[] argsDbl, int argShift, int argCount) {

if (useActivation) {

// Copy args to new array to pass to enterActivationFunction

// or debuggerFrame.onEnter

if (argsDbl != null) {

args = getArgsArray(args, argsDbl, argShift, argCount);

}

argShift = 0;

argsDbl = null;

}

if (idata.itsFunctionType != 0) {

scope = fnOrScript.getParentScope();

if (useActivation) {

if (idata.itsFunctionType == FunctionNode.ARROW_FUNCTION) {

scope = ScriptRuntime.createArrowFunctionActivation(fnOrScript, scope, args, idata.isStrict);

} else {

scope = ScriptRuntime.createFunctionActivation(fnOrScript, scope, args, idata.isStrict);

}

}

} else {

scope = callerScope;

ScriptRuntime.initScript(fnOrScript, thisObj, cx, scope,

fnOrScript.idata.evalScriptFlag);

}

if (idata.itsNestedFunctions != null) {

if (idata.itsFunctionType != 0 && !idata.itsNeedsActivation)

Kit.codeBug();

for (int i = 0; i < idata.itsNestedFunctions.length; i++) {

InterpreterData fdata = idata.itsNestedFunctions[i];

if (fdata.itsFunctionType == FunctionNode.FUNCTION_STATEMENT) {

initFunction(cx, scope, fnOrScript, i);

}

}

}

final int maxFrameArray = idata.itsMaxFrameArray;

// TODO: move this check into InterpreterData construction

if (maxFrameArray != emptyStackTop + idata.itsMaxStack + 1)

Kit.codeBug();

// Initialize args, vars, locals and stack

stack = new Object[maxFrameArray];

stackAttributes = new int[maxFrameArray];

sDbl = new double[maxFrameArray];

int varCount = idata.getParamAndVarCount();

for (int i = 0; i < varCount; i++) {

if (idata.getParamOrVarConst(i))

stackAttributes[i] = ScriptableObject.CONST;

}

int definedArgs = idata.argCount;

if (definedArgs > argCount) { definedArgs = argCount; }

// Fill the frame structure

System.arraycopy(args, argShift, stack, 0, definedArgs);

if (argsDbl != null) {

System.arraycopy(argsDbl, argShift, sDbl, 0, definedArgs);

}

for (int i = definedArgs; i != idata.itsMaxVars; ++i) {

stack[i] = Undefined.instance;

}

}

CallFrame cloneFrozen()

{

if (!frozen) Kit.codeBug();

CallFrame copy;

try {

copy = (CallFrame)clone();

} catch (CloneNotSupportedException ex) {

throw new IllegalStateException();

}

// clone stack but keep varSource to point to values

// from this frame to share variables.

copy.stack = stack.clone();

copy.stackAttributes = stackAttributes.clone();

copy.sDbl = sDbl.clone();

copy.frozen = false;

return copy;

}

@Override

public boolean equals(Object other) {

// Overridden for semantic equality comparison. These objects

// are typically exposed as NativeContinuation.implementation,

// comparing them allows establishing whether the continuations

// are semantically equal.

if (other instanceof CallFrame) {

// If the call is not within a Context with a top call, we force

// one. It is required as some objects within fully initialized

// global scopes (notably, XMLLibImpl) need to have a top scope

// in order to evaluate their attributes.

final Context cx = Context.enter();

try {

if (ScriptRuntime.hasTopCall(cx)) {

return equalsInTopScope(other);

}

final Scriptable top = ScriptableObject.getTopLevelScope(scope);

return (Boolean)ScriptRuntime.doTopCall(

(Callable)(c, scope, thisObj, args) -> equalsInTopScope(other),

cx, top, top, ScriptRuntime.emptyArgs, isStrictTopFrame());

} finally {

Context.exit();

}

}

return false;

}

@Override

public int hashCode() {

// Overridden for consistency with equals.

// Trying to strike a balance between speed of calculation and

// distribution. Not hashing stack variables as those could have

// unbounded computational cost and limit it to topmost 8 frames.

int depth = 0;

CallFrame f = this;

int h = 0;

do {

h = 31 * (31 * h + f.pc) + f.idata.icodeHashCode();

f = f.parentFrame;

} while(f != null && depth++ < 8);

return h;

}

private boolean equalsInTopScope(Object other) {

return EqualObjectGraphs.withThreadLocal(eq -> equals(this, (CallFrame)other, eq));

}

private boolean isStrictTopFrame() {

CallFrame f = this;

for(;;) {

final CallFrame p = f.parentFrame;

if (p == null) {

return f.idata.isStrict;

}

f = p;

}

}

private static boolean equals(CallFrame f1, CallFrame f2, EqualObjectGraphs equal) {

// Iterative instead of recursive, as interpreter stack depth can

// be larger than JVM stack depth.

for(;;) {

if (f1 == f2) {

return true;

} else if (f1 == null || f2 == null) {

return false;

} else if (!f1.fieldsEqual(f2, equal)) {

return false;

} else {

f1 = f1.parentFrame;

f2 = f2.parentFrame;

}

}

}

private boolean fieldsEqual(CallFrame other, EqualObjectGraphs equal) {

return frameIndex == other.frameIndex &&

pc == other.pc &&

compareIdata(idata, other.idata) &&

equal.equalGraphs(varSource.stack, other.varSource.stack) &&

Arrays.equals(varSource.sDbl, other.varSource.sDbl) &&

equal.equalGraphs(thisObj, other.thisObj) &&

equal.equalGraphs(fnOrScript, other.fnOrScript) &&

equal.equalGraphs(scope, other.scope);

}

}

private static boolean compareIdata(InterpreterData i1, InterpreterData i2) {

return i1 == i2 || Objects.equals(getEncodedSource(i1), getEncodedSource(i2));

}

private static final class ContinuationJump implements Serializable

{

private static final long serialVersionUID = 7687739156004308247L;

CallFrame capturedFrame;

CallFrame branchFrame;

Object result;

double resultDbl;

ContinuationJump(NativeContinuation c, CallFrame current)

{

this.capturedFrame = (CallFrame)c.getImplementation();

if (this.capturedFrame == null || current == null) {

// Continuation and current execution does not share

// any frames if there is nothing to capture or

// if there is no currently executed frames

this.branchFrame = null;

} else {

// Search for branch frame where parent frame chains starting

// from captured and current meet.

CallFrame chain1 = this.capturedFrame;

CallFrame chain2 = current;

// First work parents of chain1 or chain2 until the same

// frame depth.

int diff = chain1.frameIndex - chain2.frameIndex;

if (diff != 0) {

if (diff < 0) {

// swap to make sure that

// chain1.frameIndex > chain2.frameIndex and diff > 0

chain1 = current;

chain2 = this.capturedFrame;

diff = -diff;

}

do {

chain1 = chain1.parentFrame;

} while (--diff != 0);

if (chain1.frameIndex != chain2.frameIndex) Kit.codeBug();

}

// Now walk parents in parallel until a shared frame is found

// or until the root is reached.

while (chain1 != chain2 && chain1 != null) {

chain1 = chain1.parentFrame;

chain2 = chain2.parentFrame;

}

this.branchFrame = chain1;

if (this.branchFrame != null && !this.branchFrame.frozen)

Kit.codeBug();

}

}

}

private static CallFrame captureFrameForGenerator(CallFrame frame) {

frame.frozen = true;

CallFrame result = frame.cloneFrozen();

frame.frozen = false;

// now isolate this frame from its previous context

result.parentFrame = null;

result.frameIndex = 0;

return result;

}

static {

// Checks for byte code consistencies, good compiler can eliminate them

if (Token.LAST_BYTECODE_TOKEN > 127) {

String str = "Violation of Token.LAST_BYTECODE_TOKEN <= 127";

System.err.println(str);

throw new IllegalStateException(str);

}

if (MIN_ICODE < -128) {

String str = "Violation of Interpreter.MIN_ICODE >= -128";

System.err.println(str);

throw new IllegalStateException(str);

}

}

@Override

public Object compile(CompilerEnvirons compilerEnv,

ScriptNode tree,

String encodedSource,

boolean returnFunction)

{

CodeGenerator cgen = new CodeGenerator();

itsData = cgen.compile(compilerEnv, tree, encodedSource, returnFunction);

return itsData;

}

@Override

public Script createScriptObject(Object bytecode, Object staticSecurityDomain)

{

if(bytecode != itsData)

{

Kit.codeBug();

}

return InterpretedFunction.createScript(itsData,

staticSecurityDomain);

}

@Override

public void setEvalScriptFlag(Script script) {

((InterpretedFunction)script).idata.evalScriptFlag = true;

}

@Override

public Function createFunctionObject(Context cx, Scriptable scope,

Object bytecode, Object staticSecurityDomain)

{

if(bytecode != itsData)

{

Kit.codeBug();

}

return InterpretedFunction.createFunction(cx, scope, itsData,

staticSecurityDomain);

}

private static int getShort(byte[] iCode, int pc) {

return (iCode[pc] << 8) | (iCode[pc + 1] & 0xFF);

}

private static int getIndex(byte[] iCode, int pc) {

return ((iCode[pc] & 0xFF) << 8) | (iCode[pc + 1] & 0xFF);

}

private static int getInt(byte[] iCode, int pc) {

return (iCode[pc] << 24) | ((iCode[pc + 1] & 0xFF) << 16)

| ((iCode[pc + 2] & 0xFF) << 8) | (iCode[pc + 3] & 0xFF);

}

private static int getExceptionHandler(CallFrame frame,

boolean onlyFinally)

{

int[] exceptionTable = frame.idata.itsExceptionTable;

if (exceptionTable == null) {

// No exception handlers

return -1;

}

// Icode switch in the interpreter increments PC immediately

// and it is necessary to subtract 1 from the saved PC

// to point it before the start of the next instruction.

int pc = frame.pc - 1;

// OPT: use binary search

int best = -1, bestStart = 0, bestEnd = 0;

for (int i = 0; i != exceptionTable.length; i += EXCEPTION_SLOT_SIZE) {

int start = exceptionTable[i + EXCEPTION_TRY_START_SLOT];

int end = exceptionTable[i + EXCEPTION_TRY_END_SLOT];

if (!(start <= pc && pc < end)) {

continue;

}

if (onlyFinally && exceptionTable[i + EXCEPTION_TYPE_SLOT] != 1) {

continue;

}

if (best >= 0) {

// Since handlers always nest and they never have shared end

// although they can share start it is sufficient to compare

// handlers ends

if (bestEnd < end) {

continue;

}

// Check the above assumption

if (bestStart > start) Kit.codeBug(); // should be nested

if (bestEnd == end) Kit.codeBug(); // no ens sharing

}

best = i;

bestStart = start;

bestEnd = end;

}

return best;

}

static void dumpICode(InterpreterData idata)

{

if (!Token.printICode) {

return;

}

byte iCode[] = idata.itsICode;

int iCodeLength = iCode.length;

String[] strings = idata.itsStringTable;

PrintStream out = System.out;

out.println("ICode dump, for " + idata.itsName

+ ", length = " + iCodeLength);

out.println("MaxStack = " + idata.itsMaxStack);

int indexReg = 0;

for (int pc = 0; pc < iCodeLength; ) {

out.flush();

out.print(" [" + pc + "] ");

int token = iCode[pc];

int icodeLength = bytecodeSpan(token);

String tname = Icode.bytecodeName(token);

int old_pc = pc;

++pc;

switch (token) {

default:

if (icodeLength != 1) Kit.codeBug();

out.println(tname);

break;

case Icode_GOSUB :

case Token.GOTO :

case Token.IFEQ :

case Token.IFNE :

case Icode_IFEQ_POP :

case Icode_LEAVEDQ : {

int newPC = pc + getShort(iCode, pc) - 1;

out.println(tname + " " + newPC);

pc += 2;

break;

}

case Icode_VAR_INC_DEC :

case Icode_NAME_INC_DEC :

case Icode_PROP_INC_DEC :

case Icode_ELEM_INC_DEC :

case Icode_REF_INC_DEC: {

int incrDecrType = iCode[pc];

out.println(tname + " " + incrDecrType);

++pc;

break;

}

case Icode_CALLSPECIAL : {

int callType = iCode[pc] & 0xFF;

boolean isNew = (iCode[pc + 1] != 0);

int line = getIndex(iCode, pc+2);

out.println(tname+" "+callType+" "+isNew+" "+indexReg+" "+line);

pc += 4;

break;

}

case Token.CATCH_SCOPE:

{

boolean afterFisrtFlag = (iCode[pc] != 0);

out.println(tname+" "+afterFisrtFlag);

++pc;

}

break;

case Token.REGEXP :

out.println(tname+" "+idata.itsRegExpLiterals[indexReg]);

break;

case Token.OBJECTLIT :

case Icode_SPARE_ARRAYLIT :

out.println(tname+" "+idata.literalIds[indexReg]);

break;

case Icode_CLOSURE_EXPR :

case Icode_CLOSURE_STMT :

out.println(tname+" "+idata.itsNestedFunctions[indexReg]);

break;

case Token.CALL :

case Icode_TAIL_CALL :

case Token.REF_CALL :

case Token.NEW :

out.println(tname+' '+indexReg);

break;

case Token.THROW :

case Token.YIELD :

case Icode_GENERATOR :

case Icode_GENERATOR_END :

{

int line = getIndex(iCode, pc);

out.println(tname + " : " + line);

pc += 2;

break;

}

case Icode_SHORTNUMBER : {

int value = getShort(iCode, pc);

out.println(tname + " " + value);

pc += 2;

break;

}

case Icode_INTNUMBER : {

int value = getInt(iCode, pc);

out.println(tname + " " + value);

pc += 4;

break;

}

case Token.NUMBER : {

double value = idata.itsDoubleTable[indexReg];

out.println(tname + " " + value);

break;

}

case Icode_LINE : {

int line = getIndex(iCode, pc);

out.println(tname + " : " + line);

pc += 2;

break;

}

case Icode_REG_STR1: {

String str = strings[0xFF & iCode[pc]];

out.println(tname + " \"" + str + '"');

++pc;

break;

}

case Icode_REG_STR2: {

String str = strings[getIndex(iCode, pc)];

out.println(tname + " \"" + str + '"');

pc += 2;

break;

}

case Icode_REG_STR4: {

String str = strings[getInt(iCode, pc)];

out.println(tname + " \"" + str + '"');

pc += 4;

break;

}

case Icode_REG_IND_C0:

indexReg = 0;

out.println(tname);

break;

case Icode_REG_IND_C1:

indexReg = 1;

out.println(tname);

break;

case Icode_REG_IND_C2:

indexReg = 2;

out.println(tname);

break;

case Icode_REG_IND_C3:

indexReg = 3;

out.println(tname);

break;

case Icode_REG_IND_C4:

indexReg = 4;

out.println(tname);

break;

case Icode_REG_IND_C5:

indexReg = 5;

out.println(tname);

break;

case Icode_REG_IND1: {

indexReg = 0xFF & iCode[pc];

out.println(tname+" "+indexReg);

++pc;

break;

}

case Icode_REG_IND2: {

indexReg = getIndex(iCode, pc);

out.println(tname+" "+indexReg);

pc += 2;

break;

}

case Icode_REG_IND4: {

indexReg = getInt(iCode, pc);

out.println(tname+" "+indexReg);

pc += 4;

break;

}

case Icode_GETVAR1:

case Icode_SETVAR1:

case Icode_SETCONSTVAR1:

indexReg = iCode[pc];

out.println(tname+" "+indexReg);

++pc;

break;

}

if (old_pc + icodeLength != pc) Kit.codeBug();

}

int[] table = idata.itsExceptionTable;

if (table != null) {

out.println("Exception handlers: "

+table.length / EXCEPTION_SLOT_SIZE);

for (int i = 0; i != table.length;

i += EXCEPTION_SLOT_SIZE)

{

int tryStart = table[i + EXCEPTION_TRY_START_SLOT];

int tryEnd = table[i + EXCEPTION_TRY_END_SLOT];

int handlerStart = table[i + EXCEPTION_HANDLER_SLOT];

int type = table[i + EXCEPTION_TYPE_SLOT];

int exceptionLocal = table[i + EXCEPTION_LOCAL_SLOT];

out.println(" tryStart="+tryStart+" tryEnd="+tryEnd

+" handlerStart="+handlerStart

+" type="+(type == 0 ? "catch" : "finally")

+" exceptionLocal="+exceptionLocal);

}

}

out.flush();

}

private static int bytecodeSpan(int bytecode)

{

switch (bytecode) {

case Token.THROW :

case Token.YIELD:

case Icode_GENERATOR:

case Icode_GENERATOR_END:

// source line

return 1 + 2;

case Icode_GOSUB :

case Token.GOTO :

case Token.IFEQ :

case Token.IFNE :

case Icode_IFEQ_POP :

case Icode_LEAVEDQ :

// target pc offset

return 1 + 2;

case Icode_CALLSPECIAL :

// call type

// is new

// line number

return 1 + 1 + 1 + 2;

case Token.CATCH_SCOPE:

// scope flag

return 1 + 1;

case Icode_VAR_INC_DEC:

case Icode_NAME_INC_DEC:

case Icode_PROP_INC_DEC:

case Icode_ELEM_INC_DEC:

case Icode_REF_INC_DEC:

// type of ++/--

return 1 + 1;

case Icode_SHORTNUMBER :

// short number

return 1 + 2;

case Icode_INTNUMBER :

// int number

return 1 + 4;

case Icode_REG_IND1:

// ubyte index

return 1 + 1;

case Icode_REG_IND2:

// ushort index

return 1 + 2;

case Icode_REG_IND4:

// int index

return 1 + 4;

case Icode_REG_STR1:

// ubyte string index

return 1 + 1;

case Icode_REG_STR2:

// ushort string index

return 1 + 2;

case Icode_REG_STR4:

// int string index

return 1 + 4;

case Icode_GETVAR1:

case Icode_SETVAR1:

case Icode_SETCONSTVAR1:

// byte var index

return 1 + 1;

case Icode_LINE :

// line number

return 1 + 2;

}

if (!validBytecode(bytecode)) throw Kit.codeBug();

return 1;

}

static int[] getLineNumbers(InterpreterData data)

{

UintMap presentLines = new UintMap();

byte[] iCode = data.itsICode;

int iCodeLength = iCode.length;

for (int pc = 0; pc != iCodeLength;) {

int bytecode = iCode[pc];

int span = bytecodeSpan(bytecode);

if (bytecode == Icode_LINE) {

if (span != 3) Kit.codeBug();

int line = getIndex(iCode, pc + 1);

presentLines.put(line, 0);

}

pc += span;

}

return presentLines.getKeys();

}

@Override

public void captureStackInfo(RhinoException ex)

{

Context cx = Context.getCurrentContext();

if (cx == null || cx.lastInterpreterFrame == null) {

// No interpreter invocations

ex.interpreterStackInfo = null;

ex.interpreterLineData = null;

return;

}

// has interpreter frame on the stack

CallFrame[] array;

if (cx.previousInterpreterInvocations == null

|| cx.previousInterpreterInvocations.size() == 0)

{

array = new CallFrame[1];

} else {

int previousCount = cx.previousInterpreterInvocations.size();

if (cx.previousInterpreterInvocations.peek()

== cx.lastInterpreterFrame)

{

// It can happen if exception was generated after

// frame was pushed to cx.previousInterpreterInvocations

// but before assignment to cx.lastInterpreterFrame.

// In this case frames has to be ignored.

--previousCount;

}

array = new CallFrame[previousCount + 1];

cx.previousInterpreterInvocations.toArray(array);

}

array[array.length - 1] = (CallFrame)cx.lastInterpreterFrame;

int interpreterFrameCount = 0;

for (int i = 0; i != array.length; ++i) {

interpreterFrameCount += 1 + array[i].frameIndex;

}

int[] linePC = new int[interpreterFrameCount];

// Fill linePC with pc positions from all interpreter frames.

// Start from the most nested frame

int linePCIndex = interpreterFrameCount;

for (int i = array.length; i != 0;) {

--i;

CallFrame frame = array[i];

while (frame != null) {

--linePCIndex;

linePC[linePCIndex] = frame.pcSourceLineStart;

frame = frame.parentFrame;

}

}

if (linePCIndex != 0) Kit.codeBug();

ex.interpreterStackInfo = array;

ex.interpreterLineData = linePC;

}

@Override

public String getSourcePositionFromStack(Context cx, int[] linep)

{

CallFrame frame = (CallFrame)cx.lastInterpreterFrame;

InterpreterData idata = frame.idata;

if (frame.pcSourceLineStart >= 0) {

linep[0] = getIndex(idata.itsICode, frame.pcSourceLineStart);

} else {

linep[0] = 0;

}

return idata.itsSourceFile;

}

@Override

public String getPatchedStack(RhinoException ex,

String nativeStackTrace)

{

String tag = "org.mozilla.javascript.Interpreter.interpretLoop";

StringBuilder sb = new StringBuilder(nativeStackTrace.length() + 1000);

String lineSeparator = SecurityUtilities.getSystemProperty("line.separator");

CallFrame[] array = (CallFrame[])ex.interpreterStackInfo;

int[] linePC = ex.interpreterLineData;

int arrayIndex = array.length;

int linePCIndex = linePC.length;

int offset = 0;

while (arrayIndex != 0) {

--arrayIndex;

int pos = nativeStackTrace.indexOf(tag, offset);

if (pos < 0) {

break;

}

// Skip tag length

pos += tag.length();

// Skip until the end of line

for (; pos != nativeStackTrace.length(); ++pos) {

char c = nativeStackTrace.charAt(pos);

if (c == '\n' || c == '\r') {

break;

}

}

sb.append(nativeStackTrace.substring(offset, pos));

offset = pos;

CallFrame frame = array[arrayIndex];

while (frame != null) {

if (linePCIndex == 0) Kit.codeBug();

--linePCIndex;

InterpreterData idata = frame.idata;

sb.append(lineSeparator);

sb.append("\tat script");

if (idata.itsName != null && idata.itsName.length() != 0) {

sb.append('.');

sb.append(idata.itsName);

}

sb.append('(');

sb.append(idata.itsSourceFile);

int pc = linePC[linePCIndex];

if (pc >= 0) {

// Include line info only if available

sb.append(':');

sb.append(getIndex(idata.itsICode, pc));

}

sb.append(')');

frame = frame.parentFrame;

}

}

sb.append(nativeStackTrace.substring(offset));

return sb.toString();

}

@Override

public List<String> getScriptStack(RhinoException ex) {

ScriptStackElement[][] stack = getScriptStackElements(ex);

List<String> list = new ArrayList<String>(stack.length);

String lineSeparator =

SecurityUtilities.getSystemProperty("line.separator");

for (ScriptStackElement[] group : stack) {

StringBuilder sb = new StringBuilder();

for (ScriptStackElement elem : group) {

elem.renderJavaStyle(sb);

sb.append(lineSeparator);

}

list.add(sb.toString());

}

return list;

}

public ScriptStackElement[][] getScriptStackElements(RhinoException ex)

{

if (ex.interpreterStackInfo == null) {

return null;

}

List<ScriptStackElement[]> list = new ArrayList<ScriptStackElement[]>();

CallFrame[] array = (CallFrame[])ex.interpreterStackInfo;

int[] linePC = ex.interpreterLineData;

int arrayIndex = array.length;

int linePCIndex = linePC.length;

while (arrayIndex != 0) {

--arrayIndex;

CallFrame frame = array[arrayIndex];

List<ScriptStackElement> group = new ArrayList<ScriptStackElement>();

while (frame != null) {

if (linePCIndex == 0) Kit.codeBug();

--linePCIndex;

InterpreterData idata = frame.idata;

String fileName = idata.itsSourceFile;

String functionName = null;

int lineNumber = -1;

int pc = linePC[linePCIndex];

if (pc >= 0) {

lineNumber = getIndex(idata.itsICode, pc);

}

if (idata.itsName != null && idata.itsName.length() != 0) {

functionName = idata.itsName;

}

frame = frame.parentFrame;

group.add(new ScriptStackElement(fileName, functionName, lineNumber));

}

list.add(group.toArray(new ScriptStackElement[group.size()]));

}

return list.toArray(new ScriptStackElement[list.size()][]);

}

static String getEncodedSource(InterpreterData idata)

{

if (idata.encodedSource == null) {

return null;

}

return idata.encodedSource.substring(idata.encodedSourceStart,

idata.encodedSourceEnd);

}

private static void initFunction(Context cx, Scriptable scope,

InterpretedFunction parent, int index)

{

InterpretedFunction fn;

fn = InterpretedFunction.createFunction(cx, scope, parent, index);

ScriptRuntime.initFunction(cx, scope, fn, fn.idata.itsFunctionType,

parent.idata.evalScriptFlag);

}

static Object interpret(InterpretedFunction ifun,

Context cx, Scriptable scope,

Scriptable thisObj, Object[] args)

{

if (!ScriptRuntime.hasTopCall(cx)) Kit.codeBug();

if (cx.interpreterSecurityDomain != ifun.securityDomain) {

Object savedDomain = cx.interpreterSecurityDomain;

cx.interpreterSecurityDomain = ifun.securityDomain;

try {

return ifun.securityController.callWithDomain(

ifun.securityDomain, cx, ifun, scope, thisObj, args);

} finally {

cx.interpreterSecurityDomain = savedDomain;