public Memory bitwiseCheckResult(Environment env, TraceInfo trace) { if (this == UNDEFINED) { env.exception(trace, BaseArithmeticError.class, "Bit shift by negative number"); } return this; }
private ScheduledExecutorService getScheduledExecutorService(Environment env){ if (!(service instanceof ScheduledExecutorService)){ env.exception("Unsupported operation for non-scheduled executor service"); return null; } return (ScheduledExecutorService) service; }
@Signature public void unregister(Environment env) { if (splClassLoader == null) { env.exception("ClassLoader is not registered"); } env.unRegisterAutoloader(splClassLoader); splClassLoader = null; }
@Signature private Memory __sleep(Environment env, Memory... args) { env.exception(env.trace(), "Serialization of 'Generator' is not allowed"); return Memory.NULL; }
@Signature(@Arg("callback")) public Memory onMessage(Environment env, Memory... args) { Invoker invoker = Invoker.valueOf(this.environment, null, args[0]); if (invoker == null) { env.exception("Argument 1 must be callable in environment"); return Memory.NULL; } onMessage = invoker; return Memory.NULL; }
@Signature public static Set<Memory> subscribers(Environment env, Memory observable) { if (observable instanceof ObservableMemory) { return ((ObservableMemory) observable).observerKeys(); } else { env.exception(BaseTypeError.class, "Argument 1 must be observable"); return null; } } }
@Signature(@Arg("message")) public Memory sendMessage(Environment env, Memory... args) throws Throwable { if (onMessage == null) { env.exception("Environment cannot receive messages, onMessage callback is NULL"); return Memory.NULL; } return onMessage.call(args); }
protected ForeachIterator getSelfIterator(Environment env) { if (this.selfIterator == null) this.selfIterator = new ObjectMemory(this).getNewIterator(env); if (!this.valid) env.exception("Unable to iterate the flow repeatedly"); return this.selfIterator; }
@Override @Signature public Memory format(Environment env, Memory... args) { try { return StringMemory.valueOf(gson.toJson(args[0])); } catch (JsonIOException e) { env.exception(ProcessorException.class, e.getMessage()); return Memory.NULL; } }
@Signature(@Arg("position")) public Memory seek(Environment env, Memory... args){ if (memoryStream != null){ if (!memoryStream.seek(args[0].toInteger())) env.exception(WrapIOException.class, "Cannot seek to %s", args[0].toInteger()); this.position = args[0].toInteger(); } else { env.exception(WrapIOException.class, "Cannot seek in input/output stream"); } return Memory.NULL; }
@Signature public void unregister(Environment env) { if (loader == null) { env.exception("PackageLoader is not registered"); } env.getPackageManager().unregisterLoader(loader); loader = null; }
@Override @Signature public Memory format(Environment env, Memory... args) { try { return StringMemory.valueOf(yaml.dump(Memory.unwrap(env, args[0], true))); } catch (YAMLException e) { env.exception(ProcessorException.class, e.getMessage()); return Memory.NULL; } }
@Signature({@Arg("value"), @Arg(value = "length", optional = @Optional("NULL"))}) public Memory write(Environment env, Memory... args){ int len = args[1].toInteger(); byte[] bytes = args[0].getBinaryBytes(env.getDefaultCharset()); try { accessFile.write(bytes, 0, len == 0 ? bytes.length : len); return LongMemory.valueOf(len == 0 ? bytes.length : len); } catch (IOException e) { env.exception(WrapIOException.class, e.getMessage()); } return Memory.FALSE; }
@Signature({ @Arg("name"), @Arg("value"), @Arg(value = "caseSensitive", optional = @Optional(value = "true", type = HintType.BOOLEAN)) }) public Memory defineConstant(Environment env, Memory... args){ Memory val = args[1].toValue(); if (val.isArray() || val.isObject()) env.exception("Argument 2 must be a scalar value"); if (!environment.defineConstant(args[0].toString(), val, args[2].toBoolean())) env.exception("Constant '%s' already registered", args[0]); return Memory.NULL; }
@Signature public void register(Environment env) { if (loader == null) { env.getPackageManager().registerLoader(_getPackageLoader(env)); } else { env.exception("PackageLoader is already registered"); } }
@Signature(@Arg(value = "runnable")) public Memory execute(Environment env, Memory... args) throws Throwable { Invoker invoker = Invoker.valueOf(this.environment, null, args[0]); if (invoker == null) { env.exception("Argument 1 must be callable in environment"); return Memory.NULL; } invoker.setTrace(env.trace()); return invoker.call(); }
@Signature(@Arg("className")) public Memory importClass(Environment env, Memory... args) throws Throwable { ClassEntity classEntity = env.fetchClass(args[0].toString()); if (classEntity == null) { env.exception(Messages.ERR_CLASS_NOT_FOUND.fetch(args[0])); return Memory.NULL; } environment.registerClass(classEntity); return Memory.NULL; }
@Signature(@Arg("functionName")) public Memory exportFunction(Environment env, Memory... args){ FunctionEntity functionEntity = environment.fetchFunction(args[0].toString()); if (functionEntity == null) { env.exception(Messages.ERR_FUNCTION_NOT_FOUND.fetch(args[0])); return Memory.NULL; } env.registerFunction(functionEntity); return Memory.NULL; }
@Signature(@Arg("functionName")) public Memory importFunction(Environment env, Memory... args){ FunctionEntity functionEntity = env.fetchFunction(args[0].toString()); if (functionEntity == null) { env.exception(Messages.ERR_FUNCTION_NOT_FOUND.fetch(args[0])); return Memory.NULL; } environment.registerFunction(functionEntity); return Memory.NULL; }
@Signature(@Arg("extensionClass")) public Memory registerExtension(Environment env, Memory... args) { Extension extension = this.environment.scope.getExtension(args[0].toString()); if (extension != null) { env.exception("Extension '%s' already registered", extension.getName()); } this.environment.scope.registerExtension(args[0].toString()); return Memory.NULL; }