private void _lt(ExecutionContext context, LuaFunction comp, Object a, Object b) throws UnresolvedControlThrowable { if (comp != null) { Dispatch.call(context, comp, a, b); } else { Dispatch.lt(context, a, b); } }
@Override public void invoke(ExecutionContext context, Object[] args) throws ResolvedControlThrowable { try { Dispatch.call(context, x); } catch (UnresolvedControlThrowable ct) { throw ct.resolve(this, Arrays.copyOf(args, args.length)); } resume(context, args); }
private static void try_mt_arithmetic(ExecutionContext context, ByteString event, Object a, Object b) throws UnresolvedControlThrowable { Object handler = Metatables.binaryHandlerFor(context, event, a, b); if (handler != null) { call(context, handler, a, b); } else { throw Errors.illegalArithmeticAttempt(a, b); } }
private static void try_mt_bitwise(ExecutionContext context, ByteString event, Object o) throws UnresolvedControlThrowable { Object handler = Metatables.getMetamethod(context, event, o); if (handler != null) { call(context, handler, o, o); } else { throw Errors.illegalBitwiseOperationAttempt(o); } }
private void load(ExecutionContext context, ByteString modName, LuaFunction loader, Object origin) throws ResolvedControlThrowable { try { Dispatch.call(context, loader, modName, origin); } catch (UnresolvedControlThrowable ct) { throw ct.resolve(this, modName); } resumeLoad(context, modName); }
private static void try_mt_bitwise(ExecutionContext context, ByteString event, Object a, Object b) throws UnresolvedControlThrowable { Object handler = Metatables.binaryHandlerFor(context, event, a, b); if (handler != null) { call(context, handler, a, b); } else { throw Errors.illegalBitwiseOperationAttempt(a, b); } }
private static void try_mt_arithmetic(ExecutionContext context, ByteString event, Object o) throws UnresolvedControlThrowable { Object handler = Metatables.getMetamethod(context, event, o); if (handler != null) { call(context, handler, o, o); } else { throw Errors.illegalArithmeticAttempt(o); } }
@Override protected void invoke(ExecutionContext context, ArgumentIterator args) throws ResolvedControlThrowable { IoFile file = lib.getDefaultOutputFile(); ArrayList<Object> callArgs = new ArrayList<>(); callArgs.add(file); callArgs.addAll(Arrays.asList(args.copyAll())); try { Dispatch.call(context, file_write(), callArgs.toArray()); } catch (UnresolvedControlThrowable ct) { throw ct.resolve(this, null); } resume(context, file); }
@Override protected void invoke(ExecutionContext context, ArgumentIterator args) throws ResolvedControlThrowable { IoFile file = lib.getDefaultInputFile(); ArrayList<Object> callArgs = new ArrayList<>(); callArgs.add(file); callArgs.addAll(Arrays.asList(args.copyAll())); try { Dispatch.call(context, file_read(), callArgs.toArray()); } catch (UnresolvedControlThrowable ct) { throw ct.resolve(this, null); } resume(context, file); }
@Override public void resume(ExecutionContext context, Object target) throws ResolvedControlThrowable { try { Dispatch.call(context, target, context.getReturnBuffer().getAsArray()); } catch (UnresolvedControlThrowable ct) { throw ct.resolve(); } }
@Override protected void invoke(ExecutionContext context, ArgumentIterator args) throws ResolvedControlThrowable { IoFile outFile = lib.getDefaultOutputFile(); try { Dispatch.call(context, file_flush()); } catch (UnresolvedControlThrowable ct) { throw ct.resolve(this, outFile); } resume(context, outFile); }
@Override protected void invoke(ExecutionContext context, ArgumentIterator args) throws ResolvedControlThrowable { final IoFile file = args.hasNext() ? args.nextUserdata(IoFile.typeName(), IoFile.class) : lib.getDefaultOutputFile(); try { Dispatch.call(context, file_close(), file); } catch (UnresolvedControlThrowable ct) { throw ct.resolve(this, null); } }
@Override protected void invoke(ExecutionContext context, ArgumentIterator args) throws ResolvedControlThrowable { final ByteString fileName = args.nextOptionalString(null); if (fileName == null) { throw new UnsupportedOperationException("not supported: 'dofile' from stdin"); } // TODO: we'll only be executing this function once -- add functionality to ChunkLoader to give us a "temporary" loader? final LuaFunction fn; try { fn = loadTextChunkFromFile(fileSystem, loader, fileName.toString(), Load.DEFAULT_MODE, env); } catch (LoaderException ex) { throw new LuaRuntimeException(ex.getLuaStyleErrorMessage()); } try { Dispatch.call(context, fn); } catch (UnresolvedControlThrowable ct) { ct.resolve(this, null); } }
private static void _call_comparison_mt(ExecutionContext context, boolean cmpTo, Object handler, Object a, Object b) throws UnresolvedControlThrowable { try { call(context, handler, a, b); } catch (UnresolvedControlThrowable ct) { // suspended in the metamethod call throw ct.resolve(cmpResultResumable(cmpTo), null).unresolve(); } // not suspended: set the result, possibly flipping it ReturnBuffer result = context.getReturnBuffer(); result.setTo(cmpTo == Conversions.booleanValueOf(result.get0())); }
@Override protected void invoke(ExecutionContext context, ArgumentIterator args) throws ResolvedControlThrowable { Object callTarget = args.nextAny(); Object[] callArgs = args.copyRemaining(); try { Dispatch.call(context, callTarget, callArgs); } catch (UnresolvedControlThrowable ct) { throw ct.resolve(this, null); } catch (Exception ex) { resumeError(context, null, Conversions.toErrorObject(ex)); return; } resume(context, null); }
private void handleError(ExecutionContext context, LuaFunction handler, int depth, Object errorObject) throws ResolvedControlThrowable { // we want to be able to handle nil error objects, so we need a separate flag boolean isError = true; while (isError && depth < MAX_DEPTH) { depth += 1; try { Dispatch.call(context, handler, errorObject); isError = false; } catch (UnresolvedControlThrowable ct) { throw ct.resolve(this, new SavedState(handler, depth)); } catch (Exception e) { errorObject = Conversions.toErrorObject(e); isError = true; } } if (!isError) { prependFalseAndTrim(context); } else { // depth must be >= MAX_DEPTH context.getReturnBuffer().setTo(Boolean.FALSE, "error in error handling"); } }
private void format_s(ExecutionContext context, String fmt, StringBuilder bld, ArgumentIterator args, int index, int width, int flags, int precision) throws ResolvedControlThrowable { Object v = args.nextAny(); final String s; ByteString stringValue = Conversions.stringValueOf(v); if (stringValue != null) { s = stringValue.toString(); } else { Object metamethod = Metatables.getMetamethod(context, BasicLib.MT_TOSTRING, v); if (metamethod != null) { // call __tostring try { Dispatch.call(context, metamethod, v); } catch (UnresolvedControlThrowable ct) { throw ct.resolve(this, new SuspendedState(fmt, bld.toString(), args, index, width, flags, precision)); } resume_s(context, bld, width, flags, precision); return; } else { s = Conversions.toHumanReadableString(v).toString(); } } bld.append(justified(width, flags, trimmed(precision, s))); }
@Override protected void invoke(ExecutionContext context, ArgumentIterator args) throws ResolvedControlThrowable { Object arg = args.nextAny(); Object meta = Metatables.getMetamethod(context, MT_TOSTRING, arg); if (meta != null) { try { Dispatch.call(context, meta, arg); } catch (UnresolvedControlThrowable ct) { throw ct.resolve(this, null); } // resume resume(context, null); } else { // no metamethod, just call the default toString ByteString s = Conversions.toHumanReadableString(arg); context.getReturnBuffer().setTo(s); } }
@Override protected void invoke(ExecutionContext context, ArgumentIterator args) throws ResolvedControlThrowable { Table t = args.nextTable(); Object metamethod = Metatables.getMetamethod(context, MT_PAIRS, t); if (metamethod != null) { try { Dispatch.call(context, metamethod, t); } catch (UnresolvedControlThrowable ct) { throw ct.resolve(this, null); } ReturnBuffer rbuf = context.getReturnBuffer(); rbuf.setTo(rbuf.get0(), rbuf.get1(), rbuf.get2()); } else { ReturnBuffer rbuf = context.getReturnBuffer(); rbuf.setTo(NEXT, t, null); } }
@Override protected void invoke(ExecutionContext context, ArgumentIterator args) throws ResolvedControlThrowable { Object callTarget = args.hasNext() ? args.peek() : null; args.skip(); LuaFunction handler = args.nextFunction(); Object[] callArgs = args.copyRemaining(); Object errorObject = null; boolean isError = false; // need to distinguish nil error objects from no-error try { Dispatch.call(context, callTarget, callArgs); } catch (UnresolvedControlThrowable ct) { throw ct.resolve(this, new SavedState(handler, 0)); } catch (Exception e) { errorObject = Conversions.toErrorObject(e); isError = true; } if (!isError) { prependTrue(context); } else { handleError(context, handler, 0, errorObject); } }