public String transform(String message) { String rv = message; try { log.debug("in=" + message); // decode the message org.jengine.tools.hl7.Message msg = org.jengine.tools.hl7.Message.read(new java.io.StringReader(message)); // pass the decoded message to beanshell interpreter.eval("org.jengine.tools.hl7.Message message"); interpreter.set("message", msg); // pass the logging category to beanshell interpreter.eval("org.apache.log4j.Category log"); interpreter.set("log", log); // call the script interpreter.eval(script); // encode the possibly modified message java.io.StringWriter sw = new java.io.StringWriter(); msg.write(sw); rv = sw.toString(); log.debug("out=" + rv); } catch (Exception e) { log.error("Problem processing transformation", e); } return rv; }
private void setCommonVars(Interpreter i, BRoom room) throws EvalError { i.getNameSpace().clear(); BRoomBuilder builder = new BRoomBuilder(room); i.set("room", builder.room()); i.set("builder", builder); i.eval("void addLayers(String[][] s){ builder.addLayers(s); }"); i.eval( "void setDoorDestination(String doorIndex, String destRoomId, String destDoorIndex){ room.setDoorDestination(doorIndex,destRoomId,destDoorIndex); }"); }
public void run() { Element config = getPersist(); try { bsh.set("qbean", this); bsh.set("log", getLog()); bsh.set("cfg", getConfiguration()); bsh.eval(config.getText()); String source = config.getAttributeValue("source"); if (source != null) bsh.source(source); } catch (Throwable e) { getLog().warn(e); } }
public void set_variable(String s, Object o) { try { main_interpreter.set(s, o); } catch (EvalError evalError) { evalError.printStackTrace(); } }
/** * Runs a BeanShell script. Errors are passed to the caller. * * <p>If the <code>in</code> parameter is non-null, the script is read from that stream; otherwise * it is read from the file identified by <code>path</code> . * * <p>The <code>scriptPath</code> BeanShell variable is set to the path name of the script. * * @param path The script file's VFS path. * @param in The reader to read the script from, or <code>null</code> . * @param namespace The namespace to run the script in. * @exception Exception instances are thrown when various BeanShell errors occur * @since jEdit 4.2pre5 */ public void _runScript(String path, Reader in, NameSpace namespace) throws Exception { log.info("Running script " + path); Interpreter interp = createInterpreter(namespace); try { if (in == null) { in = res.getResourceAsReader(path); } setupDefaultVariables(namespace); interp.set("scriptPath", path); running = true; interp.eval(in, namespace, path); } catch (Exception e) { unwrapException(e); } finally { running = false; try { // no need to do this for macros! if (namespace == global) { resetDefaultVariables(namespace); interp.unset("scriptPath"); } } catch (EvalError e) { // do nothing } } } // }}}
/** * Set Environment for Interpreter * * @param i Interpreter */ private void loadEnvironment(Interpreter i) { if (m_ctx == null) return; Iterator<String> it = m_ctx.keySet().iterator(); while (it.hasNext()) { String key = it.next(); Object value = m_ctx.get(key); try { if (value instanceof Boolean) i.set(key, ((Boolean) value).booleanValue()); else if (value instanceof Integer) i.set(key, ((Integer) value).intValue()); else if (value instanceof Double) i.set(key, ((Double) value).doubleValue()); else i.set(key, value); } catch (EvalError ee) { log.log(Level.SEVERE, "", ee); } } } // setEnvironment
public Map<String, Object> eval( Set<String> allowedClasses, Map<String, Object> inputObjects, Set<String> outputNames, String script) throws ScriptingException { if (allowedClasses != null) { throw new ExecutionException("Constrained execution not supported for BeanShell"); } try { Interpreter interpreter = new Interpreter(); for (Map.Entry<String, Object> entry : inputObjects.entrySet()) { interpreter.set(entry.getKey(), entry.getValue()); } interpreter.eval(script); if (outputNames == null) { return null; } Map<String, Object> outputObjects = new HashMap<String, Object>(); for (String outputName : outputNames) { outputObjects.put(outputName, interpreter.get(outputName)); } return outputObjects; } catch (Exception e) { throw new ScriptingException(e.getMessage(), e); } }
private void source(Interpreter interpreter) { for (IConfigurationElement config : getExtensionInfo("org.jactr.tools.shell.commands", "source")) { String url = config.getAttribute("url"); String resource = config.getAttribute("resource"); URL actualURL = null; if (resource != null) actualURL = getClass().getClassLoader().getResource(resource); else if (url != null) try { actualURL = new URL(url); } catch (Exception e) { if (LOGGER.isWarnEnabled()) LOGGER.warn(url + " is not a valid url ", e); } if (actualURL != null) try { interpreter.set("tmpURL", actualURL); interpreter.eval("source(tmpURL)"); interpreter.unset("tmpURL"); } catch (EvalError e) { if (LOGGER.isDebugEnabled()) LOGGER.debug("Could not source " + url + " ", e); } } }
public void configure(Interpreter interpreter) { if (LOGGER.isDebugEnabled()) LOGGER.debug("Starting server on 9999"); try { interpreter.set("currentModel", null); URL commonURL = Controller.class.getClassLoader().getResource("org/jactr/tools/shell/common.bsh"); interpreter.set("commonURL", commonURL); interpreter.eval("source(commonURL);"); interpreter.eval("importCommands(\"org.jactr.tools.shell.commands\");"); interpreter.eval("server(9999);"); interpreter.set("runState", "[?]"); } catch (EvalError e) { /** Error : */ LOGGER.error("Could not configure default settings ", e); } configureOthers(interpreter); }
synchronized void createInterpreter() { // create interpreter just-in-time if (interpreter == null) { interpreter = new Interpreter(); try { interpreter.set("bsh_prot", this); } catch (EvalError evalError) { } } }
Object evalScript( String script, StringBuffer scriptOutput, boolean captureOutErr, HttpServletRequest request, HttpServletResponse response) throws EvalError { // Create a PrintStream to capture output ByteArrayOutputStream baos = new ByteArrayOutputStream(); PrintStream pout = new PrintStream(baos); // Create an interpreter instance with a null inputstream, // the capture out/err stream, non-interactive Interpreter bsh = new Interpreter(null, pout, pout, false); // set up interpreter bsh.set("bsh.httpServletRequest", request); bsh.set("bsh.httpServletResponse", response); // Eval the text, gathering the return value or any error. Object result = null; String error = null; PrintStream sout = System.out; PrintStream serr = System.err; if (captureOutErr) { System.setOut(pout); System.setErr(pout); } try { // Eval the user text result = bsh.eval(script); } finally { if (captureOutErr) { System.setOut(sout); System.setErr(serr); } } pout.flush(); scriptOutput.append(baos.toString()); return result; }
/** * execute * * @param env OpenKM API internal environment data. * @param params Action configured parameters. */ private void execute(HashMap<String, Object> env, Object... params) { String script = AutomationUtils.getString(0, params); NodeBase node = AutomationUtils.getNode(env); String uuid = AutomationUtils.getUuid(env); File file = AutomationUtils.getFile(env); try { Interpreter i = new Interpreter(); i.set("node", node); i.set("uuid", uuid); i.set("file", file); if (env.get(AutomationUtils.NODE_UUID) != null) { i.set(AutomationUtils.NODE_UUID, env.get(AutomationUtils.NODE_UUID)); } if (env.get(AutomationUtils.NODE_PATH) != null) { i.set(AutomationUtils.NODE_PATH, env.get(AutomationUtils.NODE_PATH)); } if (env.get(AutomationUtils.PROPERTY_GROUP_NAME) != null) { i.set(AutomationUtils.PROPERTY_GROUP_NAME, env.get(AutomationUtils.PROPERTY_GROUP_NAME)); } if (env.get(AutomationUtils.PROPERTY_GROUP_PROPERTIES) != null) { i.set( AutomationUtils.PROPERTY_GROUP_PROPERTIES, env.get(AutomationUtils.PROPERTY_GROUP_PROPERTIES)); } i.eval(script); } catch (Exception e) { log.error(e.getMessage(), e); } }
/** * 初始化变量环境 * * @param i * @throws EvalError */ private void initEvalContext(Interpreter i) throws EvalError { Set vars = this.context.getVars(); Iterator iterator = vars.iterator(); while (iterator.hasNext()) { String var = iterator.next() + ""; Object obj = context.getVar(var); try { i.set(var, obj); } catch (EvalError e) { e.printStackTrace(); } } }
private Number calcYears(Integer age, String script) { if (StringUtils.isEmpty(script)) { return Double.NaN; } Interpreter interpreter = new Interpreter(); try { interpreter.set("age", new Integer(30)); Number years = (Number) interpreter.eval("41 - age"); return years.intValue(); } catch (EvalError e) { throw new RuntimeException(e); } }
/** * Faz a evaluation dos dados statements contidos na string, permitindo a utilizacão da informacão * do dado contexto. */ public static Object eval(String statements, Map context) { bsh.Interpreter bsh = new bsh.Interpreter(); try { if (context != null) { Iterator entries = context.entrySet().iterator(); while (entries.hasNext()) { Map.Entry entry = (Map.Entry) entries.next(); bsh.set((String) entry.getKey(), entry.getValue()); } } return bsh.eval(statements); } catch (EvalError e) { log.error(e.getMessage()); return null; } }
protected void initializeToolbox(ToolboxDialog toolbox) { try { toolbox.setIconImage(icon.getImage()); final JConsole console = new JConsole(); console.setPreferredSize(new Dimension(430, 240)); console.print( I18N.get("ui.plugin.BeanShellPlugIn.the-workbenchcontext-may-be-referred-to-as-wc")); console.print( I18N.get( "ui.plugin.BeanShellPlugIn.warning-pasting-in-multiple-statements-may-cause-the-application-to-freeze")); toolbox.getCenterPanel().add(console, BorderLayout.CENTER); Interpreter interpreter = new Interpreter(console); interpreter.setClassLoader( toolbox.getContext().getWorkbench().getPlugInManager().getClassLoader()); interpreter.set("wc", toolbox.getContext()); interpreter.eval("setAccessibility(true)"); interpreter.eval("import com.vividsolutions.jts.geom.*"); interpreter.eval("import com.vividsolutions.jump.feature.*"); new Thread(interpreter).start(); } catch (EvalError e) { toolbox.getContext().getErrorHandler().handleThrowable(e); } }
/** * resolution des variables d'une string puis evaluation dynamique d'une string de la forme * $eval{{.....}} */ public final String resolveAndEvalString(String pStr) throws IOException, IllegalArgumentException { int index = pStr.indexOf("$eval{{"); if (index == -1) { return resolveString(pStr); } else { if (index != 0) { throw new IllegalArgumentException( "(Unable to evaluate " + pStr + " because string is not beginning with \"$eval{{\" sequence."); } int index_fin = pStr.indexOf("}}"); if (index_fin != pStr.length() - 2) { throw new IllegalArgumentException( "(unable to evaluate " + pStr + " because string is not endding with \"}}\" sequence."); } String resolvedString = pStr.substring(0, index_fin); resolvedString = resolvedString.substring(7); resolvedString = resolveString(resolvedString); // evaluation dynamique String evaluatedString = null; try { Interpreter bsh = new Interpreter(); bsh.set("value", new String()); bsh.eval(resolvedString); evaluatedString = (String) bsh.get("value"); } catch (EvalError e) { throw new IllegalArgumentException("(unable to evaluate " + resolvedString, e); } return evaluatedString; } }
/** * documentStorageID and document reference for use in script name resolving * * @param aParams All parameters; pure, out params are undefined in sequence, i.e., the value has * to be ignored by the callee * @param aOutParamIndex Out indices * @param aOutParam Out parameters * @returns The value returned from the function being invoked * @throws IllegalArgumentException If there is no matching script name * @throws CannotConvertException If args do not match or cannot be converted the those of the * invokee * @throws InvocationTargetException If the running script throws an exception this information is * captured and rethrown as this exception type. */ public Object invoke( /*IN*/ Object[] aParams, /*OUT*/ short[][] aOutParamIndex, /*OUT*/ Object[][] aOutParam) throws ScriptFrameworkErrorException, InvocationTargetException { // Initialise the out parameters - not used at the moment aOutParamIndex[0] = new short[0]; aOutParam[0] = new Object[0]; ClassLoader cl = null; URL sourceUrl = null; try { cl = ClassLoaderFactory.getURLClassLoader(metaData); sourceUrl = metaData.getSourceURL(); } catch (java.net.MalformedURLException mfu) { // Framework error throw new ScriptFrameworkErrorException( mfu.getMessage(), null, metaData.getLanguageName(), metaData.getLanguage(), ScriptFrameworkErrorType.MALFORMED_URL); } catch (NoSuitableClassLoaderException nsc) { // Framework error throw new ScriptFrameworkErrorException( nsc.getMessage(), null, metaData.getLanguageName(), metaData.getLanguage(), ScriptFrameworkErrorType.UNKNOWN); } // Set class loader to be used for class files // and jar files Thread.currentThread().setContextClassLoader(cl); Interpreter interpreter = new Interpreter(); interpreter.getNameSpace().clear(); // Set class loader to be used by interpreter // to look for classes by source e.g. interpreter // will use this classloader to search classpath // for source file ( bla.java ) on import or reference interpreter.setClassLoader(cl); try { interpreter.set( "XSCRIPTCONTEXT", ScriptContext.createContext( m_xModel, m_xInvocContext, m_xContext, m_xMultiComponentFactory)); interpreter.set("ARGUMENTS", aParams); } catch (bsh.EvalError e) { // Framework error setting up context throw new ScriptFrameworkErrorException( e.getMessage(), null, metaData.getLanguageName(), metaData.getLanguage(), ScriptFrameworkErrorType.UNKNOWN); } try { String source = null; Object result = null; ScriptEditorForBeanShell editor = ScriptEditorForBeanShell.getEditor(sourceUrl); if (editor != null) { result = editor.execute(); if (result == null) { return new Any(new Type(), null); } return result; } metaData.loadSource(); source = metaData.getSource(); if (source == null || source.length() == 0) { throw new ScriptFrameworkErrorException( "Failed to read script", null, metaData.getLanguageName(), metaData.getLanguage(), ScriptFrameworkErrorType.NO_SUCH_SCRIPT); } result = interpreter.eval(source); if (result == null) { return new Any(new Type(), null); } return result; } catch (bsh.ParseException pe) { throw new InvocationTargetException( "Beanshell failed to parse " + metaData.getLanguageName(), null, processBshException(pe, metaData.getLanguageName())); } catch (bsh.TargetError te) { throw new InvocationTargetException( "Beanshell uncaught exception for " + metaData.getLanguageName(), null, processBshException(te, metaData.getLanguageName())); } catch (bsh.EvalError ex) { throw new InvocationTargetException( "Beanshell error for " + metaData.getLanguageName(), null, processBshException(ex, metaData.getLanguageName())); } catch (Exception e) { throw new ScriptFrameworkErrorException( "Failed to read script", null, metaData.getLanguageName(), metaData.getLanguage(), ScriptFrameworkErrorType.UNKNOWN); } }
protected void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException { try { // A good request looks like /mljam/contextid/verb?name=varname // The extra path info includes the context id and verb String extra = req.getPathInfo(); // "/contextid/verb" if (extra == null || extra.equals("")) { throw new ClientProblemException( "Request requires a context id and verb in its extra path info"); } String[] parts = extra.split("/"); // { "", "contextid", "verb" } if (parts.length < 2) { throw new ClientProblemException( "Request requires a context id and verb in its extra path info"); } else if (parts.length < 3) { throw new ClientProblemException("Request requires a verb in its extra path info"); } String contextId = parts[1]; String verb = parts[2]; String method = req.getMethod(); if (method.equalsIgnoreCase("get")) { // We have three GET verbs: get, get-stdout, get-stderr. // These are all idempotent, while the POST verbs aren't. The get // verb accept a "name" query string parameter. The get verb returns // either XQuery to evaluate (indicated by x-marklogic/xquery content type) // or a raw binary (indicated by an application/binary-encoded content type). if (verb.equalsIgnoreCase("get")) { String name = req.getParameter("name"); if (name == null || name.equals("")) { throw new ClientProblemException("The get verb requires a name parameter"); } Interpreter i = getInterpreter(contextId); Object o = i.get(name); if (o instanceof byte[]) { sendBinaryResponse(res, (byte[]) o); } else if (o instanceof String) { sendStringResponse(res, (String) o); } else { sendXQueryResponse(res, o); } } else if (verb.equalsIgnoreCase("get-stdout")) { Interpreter i = getInterpreter(contextId); i.getOut().flush(); CircularByteArrayOutputStream circ = (CircularByteArrayOutputStream) i.get("mljamout"); if (circ != null) { sendStringResponse(res, circ.toString()); circ.reset(); } else { throw new ServerProblemException("Could not fetch mljamout from interpreter context"); } } else if (verb.equalsIgnoreCase("get-stderr")) { Interpreter i = getInterpreter(contextId); i.getErr().flush(); CircularByteArrayOutputStream circ = (CircularByteArrayOutputStream) i.get("mljamerr"); if (circ != null) { sendStringResponse(res, circ.toString()); circ.reset(); } else { throw new ServerProblemException("Could not fetch mljamerr from interpreter context"); } } else { throw new ClientProblemException("Unrecognized GET verb: " + verb); } } else if (method.equalsIgnoreCase("post")) { // We have six POST verbs: eval, unset, end, source, set-string, and set-binary. // These are POST verbs because they aren't idempotent. // The set-string, set-binary, unset, and source verbs accept a "name" // query string parameter. The set-string and set-binary verbs accept // a value in their post body. The eval verb accepts code in its post body. if (verb.equalsIgnoreCase("set-string")) { String name = req.getParameter("name"); if (name == null || name.equals("")) { throw new ClientProblemException("The set-string verb requires a name parameter"); } String body = getBody(req); // a value of "" is legit Interpreter i = getInterpreter(contextId); i.unset(name); i.set(name, body); sendNoResponse(res); } else if (verb.equalsIgnoreCase("set-binary")) { String name = req.getParameter("name"); if (name == null || name.equals("")) { throw new ClientProblemException("The set-binary verb requires a name parameter"); } String body = getBody(req); // a value of "" is legit byte[] bodyBytes = hexDecode(body); // later could do this streaming for speed Interpreter i = getInterpreter(contextId); i.unset(name); i.set(name, bodyBytes); sendNoResponse(res); } else if (verb.equalsIgnoreCase("eval")) { String body = getBody(req); if (body == null || body.equals("")) { throw new ClientProblemException( "The eval verb requires a post body containing code to eval"); } Interpreter i = getInterpreter(contextId); i.eval(body); sendNoResponse(res); } else if (verb.equalsIgnoreCase("eval-get")) { String body = getBody(req); if (body == null || body.equals("")) { throw new ClientProblemException( "The eval-get verb requires a post body containing code to eval"); } Interpreter i = getInterpreter(contextId); Object o = i.eval(body); if (o instanceof byte[]) { sendBinaryResponse(res, (byte[]) o); } else if (o instanceof String) { sendStringResponse(res, (String) o); } else { sendXQueryResponse(res, o); } } else if (verb.equalsIgnoreCase("unset")) { String name = req.getParameter("name"); if (name == null || name.equals("")) { throw new ClientProblemException("The unset verb requires a name parameter"); } Interpreter i = getInterpreter(contextId); i.unset(name); sendNoResponse(res); } else if (verb.equalsIgnoreCase("end")) { endInterpreter(contextId); sendNoResponse(res); } else if (verb.equalsIgnoreCase("source")) { String name = req.getParameter("name"); if (name == null || name.equals("")) { throw new ClientProblemException("The source verb requires a name parameter"); } Interpreter i = getInterpreter(contextId); i.source(name); sendNoResponse(res); } else { throw new ClientProblemException("Unrecognized POST verb: " + verb); } } } catch (TargetError e) { Throwable target = e.getTarget(); Log.log(e); Log.log("Target: " + target); sendServerProblemResponse( res, target.getClass().getName() + ": " + target.getMessage() + " when executing Java code: " + e.getErrorText()); // include full trace? } catch (EvalError e) { Log.log(e); sendServerProblemResponse( res, e.getClass().getName() + ": " + e.getMessage()); // include full trace? } catch (ClientProblemException e) { Log.log(e); sendClientProblemResponse(res, e.getMessage()); } catch (ServerProblemException e) { Log.log(e); sendServerProblemResponse(res, e.getMessage()); } }
@Override public boolean exec(MethodContext methodContext) throws MiniLangException { Interpreter bsh = new Interpreter(); bsh.setClassLoader(methodContext.getLoader()); try { // setup environment for (Map.Entry<String, Object> entry : methodContext.getEnvMap().entrySet()) { bsh.set(entry.getKey(), entry.getValue()); } // run external, from resource, first if resource specified if (UtilValidate.isNotEmpty(this.resource)) { InputStream is = methodContext.getLoader().getResourceAsStream(this.resource); if (is == null) { this.simpleMethod.addErrorMessage( methodContext, "Could not find bsh resource: " + this.resource); } else { BufferedReader reader = null; try { reader = new BufferedReader(new InputStreamReader(is)); StringBuilder outSb = new StringBuilder(); String tempStr = null; while ((tempStr = reader.readLine()) != null) { outSb.append(tempStr); outSb.append('\n'); } Object resourceResult = bsh.eval(outSb.toString()); // if map is returned, copy values into env if ((resourceResult != null) && (resourceResult instanceof Map<?, ?>)) { methodContext.putAllEnv(UtilGenerics.<String, Object>checkMap(resourceResult)); } } catch (IOException e) { this.simpleMethod.addErrorMessage( methodContext, "IO error loading bsh resource: " + e.getMessage()); } finally { if (reader != null) { try { reader.close(); } catch (IOException e) { this.simpleMethod.addErrorMessage( methodContext, "IO error closing BufferedReader: " + e.getMessage()); } } } } } if (Debug.verboseOn()) Debug.logVerbose("Running inline BSH script: " + inline, module); // run inlined second to it can override the one from the property Object inlineResult = bsh.eval(inline); if (Debug.verboseOn()) Debug.logVerbose("Result of inline BSH script: " + inlineResult, module); // if map is returned, copy values into env if ((inlineResult != null) && (inlineResult instanceof Map<?, ?>)) { methodContext.putAllEnv(UtilGenerics.<String, Object>checkMap(inlineResult)); } } catch (EvalError e) { Debug.logWarning(e, "BeanShell execution caused an error", module); this.simpleMethod.addErrorMessage( methodContext, "BeanShell execution caused an error: " + e.getMessage()); } // always return true, error messages just go on the error list return true; }
private static Interpreter getInterpreter(String contextId) throws EvalError { // Get the appropriate interpreter Interpreter i = null; boolean createdInterp = false; synchronized (interpreters) { // serialize two gets of the same name i = interpreters.get(contextId); if (i == null) { i = new Interpreter(); interpreters.put(contextId, i); createdInterp = true; } } if (createdInterp) { Log.log("Created context: " + contextId + " (" + i + ")"); // Now configure stdin and stdout to capture 10k of content // Store references to the circular buffers within the interpreter itself. // This provides a nice place to store them plus theoretically allows // advanced use from within the bsh environment. // On Windows print() outputs \r\n but in XQuery that's normalized to \n // so the 10k of Java buffer may produce less than 10k of content in XQuery! OutputStream circularOutput = new CircularByteArrayOutputStream(10240); PrintStream printOutput = new PrintStream(circularOutput); i.setOut(printOutput); i.set("mljamout", circularOutput); OutputStream circularError = new CircularByteArrayOutputStream(10240); PrintStream printError = new PrintStream(circularError); i.setErr(printError); i.set("mljamerr", circularError); // Capture the built-in System.out and System.err also. // (Commented out since System appears global, can't do per interpreter.) // i.set("mljamprintout", printOutput); // i.set("mljamprinterr", printError); // i.eval("System.setOut(mljamprintout);"); // i.eval("System.setErr(mljamprinterr);"); // Need to expose hexdecode() and base64decode() built-in functions i.eval("hexdecode(String s) { return com.xqdev.jam.MLJAM.hexDecode(s); }"); i.eval("base64decode(String s) { return com.xqdev.jam.MLJAM.base64Decode(s); }"); // Let's tell the context what its id is i.set("mljamid", contextId); } // Update the last accessed time, used for cleaning i.set("mljamlast", System.currentTimeMillis()); // If it's been long enough, go snooping for stale contexts if (System.currentTimeMillis() > lastClean + CLEAN_INTERVAL) { Log.log("Initiated periodic scan for stale context objects"); lastClean = System.currentTimeMillis(); Iterator<Interpreter> itr = interpreters.values().iterator(); while (itr.hasNext()) { Interpreter interp = itr.next(); Long last = (Long) interp.get("mljamlast"); if (System.currentTimeMillis() > last + STALE_TIMEOUT) { itr.remove(); Log.log("Staled context: " + interp.get("mljamid") + " (" + interp + ")"); } else if ((System.currentTimeMillis() > last + TEMP_STALE_TIMEOUT) && ("" + interp.get("mljamid")).startsWith("temp:")) { itr.remove(); Log.log("Staled temp context: " + interp.get("mljamid") + " (" + interp + ")"); } } } return i; }