@Override public void pushCall(TraceInfo trace, Memory[] args) { env.pushCall(trace, null, args, entity.getName(), null, null); }
env.pushCall(trace, iObject, args, method.getName(), staticClass, staticClass); } else { env.pushCallEx(trace, iObject, args, method.getName(), method.getClazz(), staticClass);
public static Memory call_user_func(Environment env, TraceInfo trace, Memory function, Memory... args) throws Throwable { Memory[] passed; if (args == null) { passed = new Memory[]{function}; } else { passed = new Memory[args.length + 1]; System.arraycopy(args, 0, passed, 1, args.length); passed[0] = function; } env.pushCall(trace, null, passed, "call_user_func", null, null); try { return _call_user_func(env, trace, function, args); } finally { env.popCall(); } }
protected boolean eof() { env.pushCall(stream, "eof"); try { return stream.eof(env).toBoolean(); } finally { env.popCall(); } }
@Override public void reset() { currentKey = Memory.CONST_INT_M1; env.pushCall(stream, "seek", Memory.CONST_INT_0); try { stream.seek(env, Memory.CONST_INT_0); } catch (IOException e) { env.catchUncaught(e); } finally { env.popCall(); } } }));
@Override public Memory getMemoryKey() { if (keyInit) return (Memory) currentKey; if (!isNative) env.pushCall(trace, ObjectMemory.this.value, null, "key", className, null); try { currentKey = iterator.key(env).toImmutable(); keyInit = true; return (Memory) currentKey; } finally { if (!isNative) env.popCall(); } } };
public static Memory call_user_func_array(Environment env, TraceInfo trace, Memory function, Memory args) throws Throwable { if (expecting(env, trace, 2, args, Memory.Type.ARRAY)) { Memory[] passed = new Memory[]{function, args}; env.pushCall(trace, null, passed, "call_user_func_array", null, null); try { return _call_user_func(env, trace, function, ((ArrayMemory) args).values(false)); } finally { env.popCall(); } } return Memory.FALSE; }
@Signature public Memory call(Environment env, Memory... args) { invoker.setTrace(env.trace()); env.popCall(); try { return invoker.callNoThrow(args); } finally { env.pushCall(this, "call"); } }
/** * Remove all method which does not destruct * * @throws Throwable */ public void finalizeObjects() throws Throwable { cleanGcObjects(); for (WeakReference<IObject> el : new HashSet<>(gcObjects)) { IObject o = el.get(); if (o == null) continue; ClassEntity entity = o.getReflection(); if (entity.methodDestruct != null) { if (!o.isFinalized()) { o.doFinalize(); pushCall(o, entity.methodDestruct.getName()); try { entity.methodDestruct.invokeDynamic(o, this, TraceInfo.UNKNOWN); } finally { popCall(); } } } } gcObjects.clear(); }
if (needNext) { if (!isNative) env.pushCall(trace, ObjectMemory.this.value, null, "next", className, null); try { iterator.next(env); env.pushCall(trace, ObjectMemory.this.value, null, "valid", className, null); try { valid = iterator.valid(env).toBoolean(); if (valid) { if (!isNative) env.pushCall(trace, ObjectMemory.this.value, null, "current", className, null); try { currentValue = iterator.current(env);
protected boolean rewind() { if (getReferences && value instanceof Generator) { if (!((Generator) value).isReturnReferences()) { env.exception(trace, "You can only iterate a generator by-reference if it declared that it yields by-reference"); } } if (!rewind) { if (!isNative) env.pushCall(trace, ObjectMemory.this.value, null, "rewind", className, null); try { return iterator.rewind(env).toValue() != FALSE; } finally { rewind = true; if (!isNative) env.popCall(); } } return true; }
private Memory __import(String path, ArrayMemory locals, TraceInfo trace, String funcName, boolean once, Callback<Void, Void> callback) throws Throwable { synchronized (moduleManager) { if (once && moduleManager.hasModule(path)) { return Memory.TRUE; } ModuleEntity module = moduleManager.fetchModule(path, path.endsWith(".phb")); if (module == null) { callback.call(null); return Memory.FALSE; } CallStackItem stackItem = pushCall( trace, null, new Memory[]{StringMemory.valueOf(path)}, funcName, null, null ); try { if (locals == null) { locals = new ArrayMemory(); } return module.include(this, locals); } finally { popCall(); } } }
@Override protected boolean nextValue() { if (eof()) return false; env.pushCall(stream, "read", LongMemory.valueOf(chunkSize)); try { currentValue = stream.read(env, LongMemory.valueOf(chunkSize)); currentKey = ((LongMemory) currentKey).inc(); } catch (IOException e) { env.catchUncaught(e); } finally { env.popCall(); } return true; }
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; }
env.pushCall( entity.methodMagicToString.getTrace(), value, null, entity.methodMagicToString.getName(), entity.getName(), null
public static Memory call(Environment env, TraceInfo trace, FunctionEntity function, Memory[] args) throws Throwable { Memory result = function.getImmutableResultTyped(env, trace); Memory[] passed = null; if (result != null && !function.hasParameters() && args == null) { return result; } passed = InvokeArgumentHelper.makeArguments( env, args, function.getParameters(), function.getName(), null, null, trace ); if (result != null) { return result; } if (trace != null && function.isUsesStackTrace()) env.pushCall(trace, null, args, function.getName(), null, null); try { result = function.invoke(env, trace, passed); } finally { if (trace != null && function.isUsesStackTrace()) env.popCall(); } return result; }
@Override public void manualUnset(Environment env) { ClassEntity entity = value.getReflection(); if (entity.methodDestruct != null) { if (!value.isFinalized()) { value.doFinalize(); env.pushCall(value, entity.methodDestruct.getName()); try { if (value instanceof IManualDestructable) { ((IManualDestructable) value).onManualDestruct(env); } entity.methodDestruct.invokeDynamic(value, env, env.trace()); } catch (InvocationTargetException e) { env.__throwException(e); } catch (RuntimeException e) { throw e; } catch (Throwable throwable) { throw new CriticalException(throwable); } finally { env.popCall(); } } } }
env.pushCall( trace, object, args, methodMagicIsset.getName(), methodMagicIsset.getClazz().getName(), name );
@Signature(@Arg(value = "collection", type = HintType.TRAVERSABLE)) public static Memory count(Environment env, Memory... args) { if (args[0].isArray()) return LongMemory.valueOf(args[0].toValue(ArrayMemory.class).size()); else if (args[0].isObject()) { ObjectMemory objectMemory = args[0].toValue(ObjectMemory.class); if (objectMemory.value instanceof Countable) { env.pushCall(objectMemory.value, "count"); try { long size = ((Countable) objectMemory.value).count(env).toLong(); return LongMemory.valueOf(size); } finally { env.popCall(); } } else { ForeachIterator iterator = args[0].getNewIterator(env); if (iterator == null) { return Memory.FALSE; } int r = 0; while (iterator.next()) r++; return LongMemory.valueOf(r); } } else return Memory.CONST_INT_0; }
Memory[] args = new Memory[]{ new StringMemory(property) }; env.pushCall(trace, object, args, methodMagicIsset.getName(), methodMagicIsset.getClazz().getName(), name); env.peekCall(0).flags = FLAG_ISSET;