| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| package com.sun.star.script.framework.provider.beanshell; |
| |
| import com.sun.star.uno.XComponentContext; |
| import com.sun.star.lang.XMultiComponentFactory; |
| import com.sun.star.lang.XMultiServiceFactory; |
| import com.sun.star.lang.XSingleServiceFactory; |
| import com.sun.star.registry.XRegistryKey; |
| import com.sun.star.comp.loader.FactoryHelper; |
| import com.sun.star.frame.XModel; |
| import com.sun.star.uno.Type; |
| import com.sun.star.uno.Any; |
| |
| import com.sun.star.reflection.InvocationTargetException; |
| |
| import java.util.StringTokenizer; |
| |
| import java.net.URL; |
| |
| import bsh.Interpreter; |
| |
| import com.sun.star.document.XScriptInvocationContext; |
| import com.sun.star.script.provider.XScript; |
| import com.sun.star.script.provider.ScriptErrorRaisedException; |
| import com.sun.star.script.provider.ScriptExceptionRaisedException; |
| import com.sun.star.script.provider.ScriptFrameworkErrorException; |
| import com.sun.star.script.provider.ScriptFrameworkErrorType; |
| |
| |
| import com.sun.star.script.framework.provider.*; |
| import com.sun.star.script.framework.log.*; |
| import com.sun.star.script.framework.container.ScriptMetaData; |
| |
| public class ScriptProviderForBeanShell |
| { |
| public static class _ScriptProviderForBeanShell extends ScriptProvider |
| { |
| public _ScriptProviderForBeanShell(XComponentContext ctx) |
| { |
| super (ctx, "BeanShell"); |
| } |
| |
| public XScript getScript( /*IN*/String scriptURI ) |
| throws com.sun.star.uno.RuntimeException, |
| ScriptFrameworkErrorException |
| { |
| ScriptMetaData scriptData = null; |
| try |
| { |
| scriptData = getScriptData( scriptURI ); |
| ScriptImpl script = new ScriptImpl( m_xContext, scriptData, m_xModel, m_xInvocContext ); |
| return script; |
| } |
| catch ( com.sun.star.uno.RuntimeException re ) |
| { |
| throw new ScriptFrameworkErrorException( "Failed to create script object: " + re.getMessage(), |
| null, scriptData.getLanguageName(), language, ScriptFrameworkErrorType.UNKNOWN ); |
| } |
| } |
| |
| public boolean hasScriptEditor() |
| { |
| return true; |
| } |
| |
| public ScriptEditor getScriptEditor() |
| { |
| return ScriptEditorForBeanShell.getEditor(); |
| } |
| } |
| |
| /** |
| * Returns a factory for creating the service. |
| * This method is called by the <code>JavaLoader</code> |
| * <p> |
| * |
| * @param implName the name of the implementation for which a service is desired |
| * @param multiFactory the service manager to be used if needed |
| * @param regKey the registryKey |
| * @return returns a <code>XSingleServiceFactory</code> for creating |
| * the component |
| * @see com.sun.star.comp.loader.JavaLoader |
| */ |
| public static XSingleServiceFactory __getServiceFactory( String implName, |
| XMultiServiceFactory multiFactory, |
| XRegistryKey regKey ) |
| { |
| XSingleServiceFactory xSingleServiceFactory = null; |
| |
| if ( implName.equals( ScriptProviderForBeanShell._ScriptProviderForBeanShell.class.getName() ) ) |
| { |
| xSingleServiceFactory = FactoryHelper.getServiceFactory( |
| ScriptProviderForBeanShell._ScriptProviderForBeanShell.class, |
| "com.sun.star.script.ScriptProviderForBeanShell", |
| multiFactory, |
| regKey ); |
| } |
| |
| return xSingleServiceFactory; |
| } |
| } |
| |
| class ScriptImpl implements XScript |
| { |
| private ScriptMetaData metaData; |
| private XComponentContext m_xContext; |
| private XMultiComponentFactory m_xMultiComponentFactory; |
| private XModel m_xModel; |
| private XScriptInvocationContext m_xInvocContext; |
| |
| ScriptImpl( XComponentContext ctx, ScriptMetaData metaData, XModel xModel, |
| XScriptInvocationContext xContext ) throws com.sun.star.uno.RuntimeException |
| { |
| this.metaData = metaData; |
| this.m_xContext = ctx; |
| this.m_xModel = xModel; |
| this.m_xInvocContext = xContext; |
| |
| try |
| { |
| this.m_xMultiComponentFactory = m_xContext.getServiceManager(); |
| } |
| catch ( Exception e ) |
| { |
| LogUtils.DEBUG( LogUtils.getTrace( e ) ); |
| throw new com.sun.star.uno.RuntimeException( |
| "Error constructing ScriptImpl [beanshell]: " |
| + e.getMessage() ); |
| } |
| |
| LogUtils.DEBUG("ScriptImpl [beanshell] script data = " + metaData ); |
| } |
| /** |
| * 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 paramters - 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 ); |
| } |
| } |
| private void raiseEditor( int lineNum ) |
| { |
| ScriptEditorForBeanShell editor = null; |
| try |
| { |
| URL sourceUrl = metaData.getSourceURL(); |
| editor = ScriptEditorForBeanShell.getEditor( sourceUrl ); |
| if ( editor == null ) |
| { |
| editor = ScriptEditorForBeanShell.getEditor(); |
| editor.edit( |
| ScriptContext.createContext(m_xModel, m_xInvocContext, |
| m_xContext, m_xMultiComponentFactory), metaData ); |
| editor = ScriptEditorForBeanShell.getEditor( sourceUrl ); |
| } |
| if ( editor != null ) |
| { |
| editor.indicateErrorLine( lineNum ); |
| } |
| } |
| catch( Exception ignore ) |
| { |
| } |
| } |
| |
| private ScriptErrorRaisedException processBshException( bsh.EvalError e, String script ) |
| { |
| LogUtils.DEBUG("Beanshell error RAW message " + e.getMessage()); |
| String message = e.getMessage(); |
| int usefullInfoIndex = message.lastIndexOf("\' :" ); |
| int lineNum = e.getErrorLineNumber(); |
| |
| raiseEditor( lineNum ); |
| |
| //String stackTrace = te.getScriptStackTrace(); // never seems to have any info?? |
| if ( usefullInfoIndex > -1 ) |
| { |
| message = message.substring( usefullInfoIndex + 2 ); |
| } |
| if ( e instanceof bsh.TargetError ) |
| { |
| LogUtils.DEBUG("got instance of TargetError"); |
| if ( usefullInfoIndex == -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 ); |
| } |
| } |
| } |
