private ScriptErrorRaisedException processBshException(bsh.EvalError e, String script) {
    LogUtils.DEBUG("Beanshell error RAW message " + e.getMessage());
    String message = e.getMessage();
    int usefulInfoIndex = message.lastIndexOf("\' :");
    int lineNum = e.getErrorLineNumber();

    raiseEditor(lineNum);

    // String stackTrace = te.getScriptStackTrace();  // never seems to have any info??
    if (usefulInfoIndex > -1) {
      message = message.substring(usefulInfoIndex + 2);
    }
    if (e instanceof bsh.TargetError) {
      LogUtils.DEBUG("got instance of  TargetError");
      if (usefulInfoIndex == -1) {
        message = ((bsh.TargetError) e).getTarget().getMessage();
      }
      String wrappedException = "";
      String full = e.toString();
      int index = full.indexOf("Target exception:");
      if (index > -1) {
        String toParse = full.substring(index);
        LogUtils.DEBUG("About to parse " + toParse);
        StringTokenizer tokenizer = new StringTokenizer(full.substring(index), ":");
        if (tokenizer.countTokens() > 2) {
          LogUtils.DEBUG("First token = " + (String) tokenizer.nextElement());
          wrappedException = (String) tokenizer.nextElement();
          LogUtils.DEBUG("wrapped exception = = " + wrappedException);
        }
      }
      ScriptExceptionRaisedException se = new ScriptExceptionRaisedException(message);
      se.lineNum = lineNum;
      se.scriptName = script;
      se.exceptionType = wrappedException;
      se.language = "BeanShell";
      LogUtils.DEBUG("UnCaught Exception error: ");
      LogUtils.DEBUG("\tscript: " + script);
      LogUtils.DEBUG("\tline: " + lineNum);
      LogUtils.DEBUG("\twrapped exception: " + wrappedException);
      LogUtils.DEBUG("\tmessage: " + message);
      return se;
    } else {
      LogUtils.DEBUG("Error or ParseError Exception error: ");
      LogUtils.DEBUG("\tscript: " + script);
      LogUtils.DEBUG("\tline: " + lineNum);
      LogUtils.DEBUG("\tmessage: " + message);
      return new ScriptErrorRaisedException(message, null, script, "BeanShell", lineNum);
    }
  }
  /**
   * 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);
    }
  }