public CallStackItem[] getSnapshot(){ if (callStackTop < 0) { return new CallStackItem[] { }; } CallStackItem[] result = new CallStackItem[callStackTop]; int i = 0; for(CallStackItem el : callStack){ if (i == callStackTop) break; result[i] = new CallStackItem(el); i++; } return result; }
public CallStackItem pop() { try { CallStackItem result = callStack[--callStackTop]; result.clear(); // clear for GC return result; } catch (ArrayIndexOutOfBoundsException e) { throw new IllegalThreadStateException(); } }
public CallStackItem push(TraceInfo trace, IObject self, Memory[] args, String function, String clazz, String staticClazz) { if (callStackTop >= callStack.length){ CallStackItem[] newCallStack = new CallStackItem[callStack.length * 2]; System.arraycopy(callStack, 0, newCallStack, 0, callStack.length); callStack = newCallStack; } CallStackItem result; if (callStackTop < maxCallStackTop) { result = callStack[callStackTop++]; result.setParameters(trace, self, args, function, clazz, staticClazz); } else { callStack[callStackTop++] = result = new CallStackItem(trace, self, args, function, clazz, staticClazz); } maxCallStackTop = callStackTop; return result; }
TraceInfo trace = prevLast.getTrace(); prevLast.setTrace(new TraceInfo( trace.getContext(), last.getTrace().getStartLine(), trace.getEndLine(), last.getTrace().getStartPosition(), trace.getEndLine() )); last.setTrace(tick.getTrace()); stack.setAttribute("lineno", String.valueOf(stackItem.trace.getStartLine() + 1)); stack.setAttribute("where", stackItem.getWhere());
@Override public String toString() { return toString(false); }
public ArrayMemory toArray(){ return toArray(true, false); }
public String toString(boolean withArgs) { StringBuilder sb = new StringBuilder(); int i = 0; for (CallStackItem el : this){ sb.append("#").append(i).append(" "); sb.append(el.toString(withArgs)); if (i != result.size() - 1) sb.append("\n"); i++; } return sb.toString(); } }
public static Memory debug_backtrace(Environment env, TraceInfo trace, int options, int limit) { boolean provideObject = (options & LangConstants.DEBUG_BACKTRACE_PROVIDE_OBJECT.toInteger()) == LangConstants.DEBUG_BACKTRACE_PROVIDE_OBJECT.toInteger(); boolean ignoreArgs = (options & LangConstants.DEBUG_BACKTRACE_IGNORE_ARGS.toInteger()) == LangConstants.DEBUG_BACKTRACE_IGNORE_ARGS.toInteger(); ArrayMemory result = new ArrayMemory(); for (int i = 0; i < env.getCallStackTop(); i++) { if (limit != 0 && i >= limit) break; CallStackItem item = env.peekCall(i); ArrayMemory el = item.toArray(provideObject, ignoreArgs); result.add(el); } return result.toConstant(); }
public CallStackItem pushCallEx(TraceInfo trace, IObject self, Memory[] args, String function, ClassEntity clazz, String staticClazz) { CallStackItem stackItem = new CallStackItem(trace, self, args, function, clazz.getName(), staticClazz); stackItem.classEntity = clazz; return getCallStack().push(stackItem); }
public static String toString(CallStackItem[] items, boolean withArgs) { int i = 0; StringBuilder sb = new StringBuilder(); if (items != null){ for (CallStackItem e : items){ if (i != 0) sb.append("\n"); sb.append("#").append(i).append(" ").append(e.toString(withArgs)); i++; } if (i != 0) sb.append("\n"); sb.append("#").append(i).append(" {main}"); } return sb.toString(); }
@Override public ArrayMemory getProperties() { if (!init){ init = true; if (trace != null) { Memory m; m = clazz.refOfProperty(props, "file"); if (m.isNull()) { m.assign(trace.getFileName()); } m = clazz.refOfProperty(props, "line"); if (m.isNull()) { m.assign(trace.getStartLine() + 1); } m = clazz.refOfProperty(props, "position"); if (m.isNull()) { m.assign(trace.getStartPosition() + 1); } ArrayMemory backTrace = new ArrayMemory(); for(CallStackItem el : callStack) { backTrace.add(el.toArray()); } clazz.refOfProperty(props, "trace").assign(backTrace); } } return props; }
public CallStackItem pushCallEx(TraceInfo trace, IObject self, Memory[] args, String function, ClassEntity clazz, ClassEntity staticClazz) { CallStackItem stackItem = new CallStackItem(trace, self, args, function, clazz.getName(), staticClazz.getName()); stackItem.classEntity = clazz; stackItem.staticClassEntity = staticClazz; return getCallStack().push(stackItem); }
@Signature public Memory getTraceAsString(Environment env, Memory... args){ int i = 0; StringBuilder sb = new StringBuilder(); if (callStack != null){ for (CallStackItem e : getCallStack()){ if (i != 0) sb.append("\n"); sb.append("#").append(i).append(" ").append(e.toString(false)); i++; } if (i != 0) sb.append("\n"); sb.append("#").append(i).append(" {main}"); } return new StringMemory(sb.toString()); }
protected void triggerError(ErrorException err) { ErrorType type = err.getType(); if (type.isFatal() || isHandleErrors(type)) { lastMessage = new CustomSystemMessage( err.getType(), new CallStackItem(err.getTraceInfo()), new Messages.Item(err.getMessage()) ); throw err; } }
public void error(TraceInfo trace, ErrorType type, Messages.Item message, Object... args) { if (type.isFatal()) { if (scope.getLangMode() == LangMode.MODERN) { if (type == E_PARSE) { exception(trace, new BaseParseError(this), message.fetch(args)); } else { exception(trace, new BaseError(this, type), message.fetch(args)); } } if (type.isHandled() && errorHandler != null && ErrorType.check(errorHandler.errorHandlerFlags, type)) { triggerMessage(new CustomSystemMessage(type, new CallStackItem(trace), message, args)); } else triggerError(new CustomErrorException(type, message.fetch(args), trace)); } else { triggerMessage(new CustomSystemMessage(type, new CallStackItem(trace), message, args)); } }
public Generator(final Environment env, ClassEntity generator, Memory self, Memory[] uses) { super(env, generator); if (generator == null) { throw new CriticalException("Unable to create generator"); } env.registerObjectInGC(this); this.self = self; this.uses = uses; CallStackItem stackItem = env.peekCall(0); this.callStack = env.getCallStack(); this.callStackItem = stackItem == null ? null : new CallStackItem(stackItem); gen = new php.runtime.util.generator.Generator<Bucket>() { @Override protected void run(YieldAdapterIterator<Bucket> yieldAdapter) { try { currentGenerator.set(Generator.this); env.__replaceCallStack(Generator.this.callStack); Generator.this._run(env); } catch (Throwable e) { lastThrowable = e; Generator.this.setCurrent(Memory.NULL); } } }; iterator = gen.iterator(); }
CallStackItem stackItem = new CallStackItem(bootstrap.getTrace()); environment.pushCall(stackItem); try {
protected Memory _next(Environment env) { if (busy) { env.error(env.trace(), "Cannot resume an already running generator"); } boolean x2 = false; if (callStackItem != null) { env.pushCall(new CallStackItem(callStackItem)); x2 = true; } try { counter += 1; busy = true; return iterator.next().getValue(); } catch (NoSuchElementException e) { valid = false; callStackItem = null; } finally { if (x2) env.popCall(); busy = false; checkThrow(); } return null; }