Exemplo n.º 1
0
 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);
   }
 }
  /**
   * 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);
    }
  }
Exemplo n.º 3
0
 @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;
 }