Besides Java 1.8.0_111 the problem exists in 9ea-+134 (engine version: "9ea",
language version:
"ECMA 262 - Edition 5.1" ) as well: Nashorn's javax.script factory is used to
get an output
statement and then it is used to execute it:
---> language [ECMAScript]: ---------------------------------------->
1) output statement to process: hello world, this is "ECMAScript"
speaking!
--> testing getOutputStatement(String), produced the following
[ECMAScript] output statement
print(hello world, this is "ECMAScript" speaking! )
... now running "eval(code)" using the scripting engine
[ECMAScript]:
javax.script.ScriptException: <eval>:1:12 Expected , but found world
print(hello world, this is "ECMAScript" speaking! )
^ in <eval> at line number 1 at column number 12 while eval()
the code: print(hello
world, this is "ECMAScript" speaking! )
This time trying to not format the Java code, so hopefully the mailer will not
render it illegible:
... cut ...
// create an output statement and execute output statement with the
script engine
static void testEngine(String name, ScriptEngineFactory sef,
ScriptEngine se)
{
System.out.println("---> language ["+name+"]:
---------------------------------------->\n");
String text="hello world, this is \""+name+"\" speaking! ";
String code=sef.getOutputStatement(text);
System.out.println("\t1) output statement to process: "+text+"\n");
System.out.print("\t--> testing getOutputStatement(String)");
System.out.println(", produced the following ["+name+"] output
statement \n\n"+code+"\n");
System.out.println("\t... now running \"eval(code)\" using the
scripting engine
["+name+"]: \n\n");
try
{
se.eval(code);
System.out.println("\n");
}
catch (ScriptException sexc)
{
System.err.println(sexc+" while eval() the code: "+code+"\n");
}
System.out.print("\t2) testing getMethodCallSyntax(obj, meth,
arg...)");
String methCode=sef.getMethodCallSyntax("object", "method", "arg1",
"arg2");
System.out.println(", produced the following ["+name+"] method call
statement:
\n\n"+methCode+"\n");
System.out.print("\t3) testing getProgram(String...)");
String programCode=sef.getProgram(code, methCode);
System.out.println(" produced the following ["+name+"] program:
\n\n"+programCode+"\n");
System.out.println("<--- end of testing language ["+name+"].
<----------------------------------------\n");
}
... cut ...
If I should file a bug then please advise where and how.
---rony
On 08.12.2016 16:17, Rony G. Flatscher wrote:
> Unfortunately, the mailing list seems to behave as if it was running in the
> 1970's such that the
> formatted text (indented, partially colorized and formatted to preformat and
> Courier) has turned to
> become illegible, unfortunately (using the Thunderbird e-Mail client)!
> :(
>
> The meat is right in the first two paragraphs and the last paragraph before
> the signature. Should
> anyone be interested in the Java-utility, please drop me a personal e-mail
> and I will send that Java
> program as an attachment to you.
>
> ---rony
>
>
>
> On 08.12.2016 16:05, Rony G. Flatscher wrote:
>> Hi there, was directed to this list to report an error with Nashorn's
>> implementation of
>> javax.script.ScriptEngineFactory.getOutputStatement(String toDisplay).
>>
>> The test is simple: one supplies a string, containing double quotes, and
>> immediately use the Nashort
>> script engine to carry out the output statement produced by its factory,
>> yielding a runtime error.
>> In order for you to reproduce, I list the Java utility (it lists all
>> available javax.script engines
>> and tests them with the -t switch and is a little example of how one can
>> take advantage of
>> javax.script very easily) after my signature below to study the code and run
>> it to double-check:
>>
>> F:\work\svn\bsf4oorexx\trunk\samples\Java\jsr223>java RunScript -t --->
>> language [ECMAScript]:
>> ----------------------------------------> 1) output statement to
>> process: hello world, this is
>> "ECMAScript" speaking! --> testing getOutputStatement(String), produced
>> the following
>> [ECMAScript] output statement *print(hello world, this is "ECMAScript"
>> speaking! )* ... now
>> running "eval(code)" using the scripting engine [ECMAScript]:
>> *javax.script.ScriptException:
>> <eval>:1:12 Expected , but found world print(hello world, this is
>> "ECMAScript" speaking! ) ^ in
>> <eval> at line number 1 at column number 12 while eval() the code:
>> print(hello world, this is
>> "ECMAScript" speaking! )* 2) testing getMethodCallSyntax(obj, meth,
>> arg...), produced the
>> following [ECMAScript] method call statement: object.method(arg1,arg2)
>> 3) testing
>> getProgram(String...) produced the following [ECMAScript] program:
>> print(hello world, this is
>> "ECMAScript" speaking! );object.method(arg1,arg2); <--- end of testing
>> language [ECMAScript].
>> <---------------------------------------- ---> language [ooRexx]:
>> ----------------------------------------> ... cut ...
>>
>> The specification for javax.script created by the Java specification request
>> group 223 (a.k.a.
>> JSR-223) can be consulted. BTW, "jrunscript[.exe]" (from the JDK) seems to
>> be broken, it only is be
>> able to execute the Nashorn script engine, despite switches that allow other
>> script engines to be
>> employed.
>>
>> ---rony
>>
>> Code of "RunScript.java" (little utility to list the currently available
>> javax.script languages, run
>> any javax.script program, give helpful information about each javax.script
>> engine and test each one
>> using its own factory means): just compile it and run it with "java
>> RunScript -t":
>>
>> ------------------ cut here ------------------
>> import java.io.File; import java.io.FileReader; import java.util.ArrayList;
>> import java.util.Arrays;
>> import java.util.List; import java.util.HashMap; import java.util.SortedSet;
>> import
>> java.util.TreeSet; import javax.script.Bindings; import
>> javax.script.ScriptContext; import
>> javax.script.ScriptEngine; import javax.script.ScriptEngineFactory; import
>> javax.script.ScriptEngineManager; import javax.script.ScriptException; import
>> javax.script.SimpleScriptContext; /* ------------------------ Apache Version
>> 2.0 license
>> ------------------------- Copyright 2015-2016 Rony G. Flatscher Licensed
>> 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.
>> -----------------------------------------------------------------------------
>> changed: 2016-12-06,
>> rgf: if no argument is given, show the help after the list of currently
>> available javax.script
>> engines */ /** A command line Java utility to query, test and evaluate
>> {@link javax.script}
>> scripting engines that * gets distributed via the beta BSF4ooRexx package
>> from Sourceforge. * *
>> <p>Usage: <code>java RunScript [{-i | -t | -e enginename filename [args...]
>> | filename
>> [args...]}]</code> * <br> * <ul> * <li> ... no arguments: lists the
>> currently available
>> <code>javax.script</code> engines * * <li> <code>-h</code> ... 'help', lists
>> and briefly explains
>> the command line options * * <li> <code>-i</code> ... lists the available
>> <code>javax.script</code>
>> engines and informs about their properties * * <li> <code>-t</code> ...
>> lists the available
>> <code>javax.script</code> engines and tests evaluating their factory's
>> <code>"getOutputStatement(String)"</code> method * * <li> <code>-e
>> enginename filename
>> [args...]</code> ... uses <code>"enginename"</code> to evaluate
>> <code>"filename"</code> supplying the arguments
>> <code>"args..."</code> * * <li>
>> <code>filename [args...]</code> ... the <code>"filename"</code>
>> extension determines the
>> script engine to evaluate it, supplying the arguments
>> <code>"args..."</code> * </ul> * * *
>> @author Rony G. Flatscher * @since 2015-05-20 */ public class RunScript {
>> public static void
>> main(String args[]) { ScriptEngineManager manager = new
>> ScriptEngineManager();
>> List<ScriptEngineFactory> factories = manager.getEngineFactories();
>> HashMap<String,ScriptEngineFactory> n2sef=new
>> HashMap<String,ScriptEngineFactory> ();
>> HashMap<String,ScriptEngine> n2se =new HashMap<String,ScriptEngine> (); //
>> create the Maps for
>> (ScriptEngineFactory factory : factories) { String
>> name=factory.getLanguageName(); // String
>> name=factory.getEngineName(); n2sef.put(name, factory); n2se .put(name,
>> factory.getScriptEngine());
>> } // create a sorted set of key names SortedSet<String> keys = new
>> TreeSet<String>(n2sef.keySet());
>> int argsStartAt=-1; // arguments - if any - for filenmae to execute start at
>> this position
>> ScriptEngine scriptEngineToUse=null; String filename=null; if
>> (args.length==0) // list all available
>> javax.script engines { System.out.println("The following javax.script
>> engines are currently
>> available:\n"); for (String key : keys) { System.out.println('\t'+key); }
>> System.out.println();
>> showHelp(); return; } else // process the first argument to decide what we
>> need to do { String
>> firstWord=args[0]; // get first value if (firstWord.startsWith("-")==true)
>> // a switch at hand! { if
>> (firstWord.length()!=2) // oops an error, we need excactly two chars (-i,
>> -t, -e) { throw new
>> IllegalArgumentException("switch '-' must be followed by one of the letters
>> 'i', 't', or 'e'"); }
>> String uSwitch=firstWord.substring(1).toUpperCase(); // get switch in
>> uppercase if
>> (uSwitch.equals("I")) // list all engines, list all their standard
>> properties { for (String key :
>> keys) // list all engines in order{ { showEngineProperties(key,
>> n2sef.get(key)); } return; } else if
>> (uSwitch.equals("T")) // list all engines, test them { for (String key :
>> keys) // list all engines
>> in order{ { testEngine(key, n2sef.get(key), n2se.get(key)); } return; } else
>> if
>> (uSwitch.equals("H")) // -h ... help text { showHelp(); return; } else if
>> (uSwitch.equals("E")) //
>> -e engineName fileName [arg... ] { if (args.length<3) { throw new
>> IllegalArgumentException("too few
>> command line arguments ("+args.length+"), minimum needed is 3: \"-e
>> enginename filename\""); } //
>> check whether engine is available, if so, then load it filename=args[2]; //
>> assign filename String
>> errMsg="no \""+args[1]+"\" javax.script engine available"; try {
>> scriptEngineToUse=manager.getEngineByName(args[1]); // fetch script engine }
>> catch (Exception exc) {
>> throw new IllegalArgumentException(errMsg); } if (scriptEngineToUse==null) {
>> throw new
>> IllegalArgumentException(errMsg); } argsStartAt=3; // fourth argument! }
>> else // unknown switch {
>> throw new IllegalArgumentException("unknown switch '"+firstWord+"', must be
>> followed by one of '-h',
>> '-i', '-t', or '-e'"); } } else // a filename in hand, check whether we have
>> a suitable engine
>> available { // - check whether suitable engine is available, if not raise an
>> exception
>> filename=args[0]; // assign filename int lastIdx=filename.lastIndexOf('.');
>> if (lastIdx==0) { throw
>> new IllegalArgumentException("filename \"filename\" does not have an
>> extension, cannot determine
>> scripting engine"); } String errMsg="cannot determine scripting engine from
>> the filename extension
>> in \""+filename+"\""; try { String extension=filename.substring(lastIdx+1);
>> // get extension
>> scriptEngineToUse=manager.getEngineByExtension(extension); // fetch script
>> engine } catch (Exception
>> exc) // if substring() causes an exception { throw new
>> IllegalArgumentException(errMsg); } if
>> (scriptEngineToUse==null) // no scripting engine found { throw new
>> IllegalArgumentException(errMsg);
>> } argsStartAt=1; // second argument! } } // now setup the remainder and
>> eval() the "filename" with
>> the script engine // - check whether file exists, if not raise an exception
>> File f=null; try { f=new
>> File (filename); } catch (Exception exc) { throw new
>> IllegalArgumentException(exc); } if
>> (f.exists()==false) { throw new IllegalArgumentException("filename
>> \""+filename+"\" does not
>> exist"); } // - supply filename ScriptContext
>> sc=scriptEngineToUse.getContext(); // get the default
>> context sc.setAttribute(ScriptEngine.FILENAME, filename,
>> ScriptContext.ENGINE_SCOPE); // - if
>> arguments, setup ARGV in ENGINE_SCOPE if (args.length>argsStartAt) // do we
>> have command line
>> arguments to supply? { String argArr []=new String
>> [args.length-argsStartAt]; // determine array
>> size int k=0; for (int i=argsStartAt; i<args.length; i++, k++) {
>> argArr[k]=args[i]; }
>> sc.setAttribute(ScriptEngine.ARGV, argArr, ScriptContext.ENGINE_SCOPE); } //
>> - eval the script try {
>> scriptEngineToUse.eval(new FileReader(f)); } catch (Exception exc) { throw
>> new
>> IllegalArgumentException(exc); } } // show information about the script
>> engine static void
>> showEngineProperties(String name, ScriptEngineFactory sef) {
>> System.out.println(name);
>> System.out.print ("\tgetEngineName() : "); try {
>> System.out.println(sef.getEngineName() ); } catch
>> (Exception e) { System.out.println("--> FAILED!"); } System.out.print
>> ("\tgetEngineVersion() : ");
>> try { System.out.println(sef.getEngineVersion() ); } catch (Exception e) {
>> System.out.println("-->
>> FAILED!"); } System.out.print ("\tgetExtensions() : "); try {
>> System.out.println(sef.getExtensions
>> ()); } catch (Exception e) { System.out.println("--> FAILED!"); }
>> System.out.print
>> ("\tgetLanguageName() : "); try { System.out.println(sef.getLanguageName ()
>> ); } catch (Exception e)
>> { System.out.println("--> FAILED!"); } System.out.print
>> ("\tgetLanguageVersion() : "); try {
>> System.out.println(sef.getLanguageVersion()); } catch (Exception e) {
>> System.out.println("-->
>> FAILED!"); } System.out.print ("\tgetMimeTypes() : "); try {
>> System.out.println(sef.getMimeTypes
>> ()); } catch (Exception e) { System.out.println("--> FAILED!"); }
>> System.out.print ("\tgetNames() :
>> "); try { System.out.println(sef.getNames() ); } catch (Exception e) {
>> System.out.println("-->
>> FAILED!"); } System.out.print ("\tgetParameter(\"THREADING\"): "); try {
>> System.out.println(sef.getParameter("THREADING")); } catch (Exception e) {
>> System.out.println("-->
>> FAILED!"); } } // create an output statement and execute output statement
>> for each available script
>> engine static void testEngine(String name, ScriptEngineFactory sef,
>> ScriptEngine se) {
>> System.out.println("---> language ["+name+"]:
>> ---------------------------------------->\n"); String
>> text="hello world, this is \""+name+"\" speaking! "; String
>> code=sef.getOutputStatement(text);
>> System.out.println("\t1) output statement to process: "+text+"\n");
>> System.out.print("\t--> testing
>> getOutputStatement(String)"); System.out.println(", produced the following
>> ["+name+"] output
>> statement \n\n"+code+"\n"); System.out.println("\t... now running
>> \"eval(code)\" using the scripting
>> engine ["+name+"]: \n\n"); try { se.eval(code); System.out.println("\n"); }
>> catch (ScriptException
>> sexc) { System.err.println(sexc+" while eval() the code: "+code+"\n"); }
>> System.out.print("\t2)
>> testing getMethodCallSyntax(obj, meth, arg...)"); String
>> methCode=sef.getMethodCallSyntax("object",
>> "method", "arg1", "arg2"); System.out.println(", produced the following
>> ["+name+"] method call
>> statement: \n\n"+methCode+"\n"); System.out.print("\t3) testing
>> getProgram(String...)"); String
>> programCode=sef.getProgram(code, methCode); System.out.println(" produced
>> the following ["+name+"]
>> program: \n\n"+programCode+"\n"); System.out.println("<--- end of testing
>> language ["+name+"].
>> <----------------------------------------\n"); } // allow us to call this
>> from different parts
>> static void showHelp() { System.out.println("usage: java RunScript [{-i | -t
>> | -e enginename
>> filename [args...] | filename [args...]}]\n"); System.out.println(" ... no
>> arguments lists the
>> available javax.script engines"); System.out.println(" -h ... 'help', gives
>> this usage text");
>> System.out.println(" -i ... lists the available javax.script engines and
>> informs about their
>> properties"); System.out.println(" -t ... lists the available javax.script
>> engines and tests
>> evaluating their \"getOutputStatement(String)\" method");
>> System.out.println(" -e enginename
>> filename [args...] ... uses \"enginename\" to evaluate \"filename\"
>> supplying the arguments
>> \"args...\""); System.out.println(" filename [args...] ... the \"filename\"
>> extension determines the
>> script engine to evaluate it, supplying the arguments \"args...\""); return;
>> } } ------------------
>> cut here ------------------
>>
>>
