001 /*****************************************************************************
002 * *
003 * This file is part of the BeanShell Java Scripting distribution. *
004 * Documentation and updates may be found at http://www.beanshell.org/ *
005 * *
006 * Sun Public License Notice: *
007 * *
008 * The contents of this file are subject to the Sun Public License Version *
009 * 1.0 (the "License"); you may not use this file except in compliance with *
010 * the License. A copy of the License is available at http://www.sun.com *
011 * *
012 * The Original Code is BeanShell. The Initial Developer of the Original *
013 * Code is Pat Niemeyer. Portions created by Pat Niemeyer are Copyright *
014 * (C) 2000. All Rights Reserved. *
015 * *
016 * GNU Public License Notice: *
017 * *
018 * Alternatively, the contents of this file may be used under the terms of *
019 * the GNU Lesser General Public License (the "LGPL"), in which case the *
020 * provisions of LGPL are applicable instead of those above. If you wish to *
021 * allow use of your version of this file only under the terms of the LGPL *
022 * and not to allow others to use your version of this file under the SPL, *
023 * indicate your decision by deleting the provisions above and replace *
024 * them with the notice and other provisions required by the LGPL. If you *
025 * do not delete the provisions above, a recipient may use your version of *
026 * this file under either the SPL or the LGPL. *
027 * *
028 * Patrick Niemeyer (pat@pat.net) *
029 * Author of Learning Java, O'Reilly & Associates *
030 * http://www.pat.net/~pat/ *
031 * *
032 *****************************************************************************/
033
034 package bsh;
035
036 import java.util.Vector;
037 import java.io.*;
038 import java.lang.reflect.Method;
039 import java.lang.reflect.InvocationTargetException;
040
041 /**
042 The BeanShell script interpreter.
043
044 An instance of Interpreter can be used to source scripts and evaluate
045 statements or expressions.
046 <p>
047 Here are some examples:
048
049 <p><blockquote><pre>
050 Interpeter bsh = new Interpreter();
051
052 // Evaluate statements and expressions
053 bsh.eval("foo=Math.sin(0.5)");
054 bsh.eval("bar=foo*5; bar=Math.cos(bar);");
055 bsh.eval("for(i=0; i<10; i++) { print(\"hello\"); }");
056 // same as above using java syntax and apis only
057 bsh.eval("for(int i=0; i<10; i++) { System.out.println(\"hello\"); }");
058
059 // Source from files or streams
060 bsh.source("myscript.bsh"); // or bsh.eval("source(\"myscript.bsh\")");
061
062 // Use set() and get() to pass objects in and out of variables
063 bsh.set( "date", new Date() );
064 Date date = (Date)bsh.get( "date" );
065 // This would also work:
066 Date date = (Date)bsh.eval( "date" );
067
068 bsh.eval("year = date.getYear()");
069 Integer year = (Integer)bsh.get("year"); // primitives use wrappers
070
071 // With Java1.3+ scripts can implement arbitrary interfaces...
072 // Script an awt event handler (or source it from a file, more likely)
073 bsh.eval( "actionPerformed( e ) { print( e ); }");
074 // Get a reference to the script object (implementing the interface)
075 ActionListener scriptedHandler =
076 (ActionListener)bsh.eval("return (ActionListener)this");
077 // Use the scripted event handler normally...
078 new JButton.addActionListener( script );
079 </pre></blockquote>
080 <p>
081
082 In the above examples we showed a single interpreter instance, however
083 you may wish to use many instances, depending on the application and how
084 you structure your scripts. Interpreter instances are very light weight
085 to create, however if you are going to execute the same script repeatedly
086 and require maximum performance you should consider scripting the code as
087 a method and invoking the scripted method each time on the same interpreter
088 instance (using eval()).
089 <p>
090
091 See the BeanShell User's Manual for more information.
092 */
093 public class Interpreter
094 implements Runnable, ConsoleInterface,Serializable
095 {
096 /* --- Begin static members --- */
097
098 public static final String VERSION = "2.0b4";
099 /*
100 Debug utils are static so that they are reachable by code that doesn't
101 necessarily have an interpreter reference (e.g. tracing in utils).
102 In the future we may want to allow debug/trace to be turned on on
103 a per interpreter basis, in which case we'll need to use the parent
104 reference in some way to determine the scope of the command that
105 turns it on or off.
106 */
107 public static boolean DEBUG, TRACE, LOCALSCOPING;
108
109 // This should be per instance
110 transient static PrintStream debug;
111 static String systemLineSeparator = "\n"; // default
112
113 static {
114 staticInit();
115 }
116
117 /** Shared system object visible under bsh.system */
118 static This sharedObject;
119
120 /**
121 Strict Java mode
122 @see #setStrictJava( boolean )
123 */
124 private boolean strictJava = false;
125
126 /* --- End static members --- */
127
128 /* --- Instance data --- */
129
130 transient Parser parser;
131 NameSpace globalNameSpace;
132 transient Reader in;
133 transient PrintStream out;
134 transient PrintStream err;
135 ConsoleInterface console;
136
137 /** If this interpeter is a child of another, the parent */
138 Interpreter parent;
139
140 /** The name of the file or other source that this interpreter is reading */
141 String sourceFileInfo;
142
143 /** by default in interactive mode System.exit() on EOF */
144 private boolean exitOnEOF = true;
145
146 protected boolean
147 evalOnly, // Interpreter has no input stream, use eval() only
148 interactive; // Interpreter has a user, print prompts, etc.
149
150 /** Control the verbose printing of results for the show() command. */
151 private boolean showResults;
152
153 /* --- End instance data --- */
154
155 /**
156 The main constructor.
157 All constructors should now pass through here.
158
159 @param namespace If namespace is non-null then this interpreter's
160 root namespace will be set to the one provided. If it is null a new
161 one will be created for it.
162 @param parent The parent interpreter if this interpreter is a child
163 of another. May be null. Children share a BshClassManager with
164 their parent instance.
165 @param sourceFileInfo An informative string holding the filename
166 or other description of the source from which this interpreter is
167 reading... used for debugging. May be null.
168 */
169 public Interpreter(
170 Reader in, PrintStream out, PrintStream err,
171 boolean interactive, NameSpace namespace,
172 Interpreter parent, String sourceFileInfo )
173 {
174 //System.out.println("New Interpreter: "+this +", sourcefile = "+sourceFileInfo );
175 parser = new Parser( in );
176 long t1=System.currentTimeMillis();
177 this.in = in;
178 this.out = out;
179 this.err = err;
180 this.interactive = interactive;
181 debug = err;
182 this.parent = parent;
183 if ( parent != null )
184 setStrictJava( parent.getStrictJava() );
185 this.sourceFileInfo = sourceFileInfo;
186
187 BshClassManager bcm = BshClassManager.createClassManager( this );
188 if ( namespace == null )
189 this.globalNameSpace = new NameSpace( bcm, "global");
190 else
191 this.globalNameSpace = namespace;
192
193 // now done in NameSpace automatically when root
194 // The classes which are imported by default
195 //globalNameSpace.loadDefaultImports();
196
197 /*
198 Create the root "bsh" system object if it doesn't exist.
199 */
200 if ( ! ( getu("bsh") instanceof bsh.This ) )
201 initRootSystemObject();
202
203 if ( interactive )
204 loadRCFiles();
205
206 long t2=System.currentTimeMillis();
207 if ( Interpreter.DEBUG )
208 Interpreter.debug("Time to initialize interpreter: "+(t2-t1));
209 }
210
211 public Interpreter(
212 Reader in, PrintStream out, PrintStream err,
213 boolean interactive, NameSpace namespace)
214 {
215 this( in, out, err, interactive, namespace, null, null );
216 }
217
218 public Interpreter(
219 Reader in, PrintStream out, PrintStream err, boolean interactive)
220 {
221 this(in, out, err, interactive, null);
222 }
223
224 /**
225 Construct a new interactive interpreter attached to the specified
226 console using the specified parent namespace.
227 */
228 public Interpreter(ConsoleInterface console, NameSpace globalNameSpace) {
229
230 this( console.getIn(), console.getOut(), console.getErr(),
231 true, globalNameSpace );
232
233 setConsole( console );
234 }
235
236 /**
237 Construct a new interactive interpreter attached to the specified
238 console.
239 */
240 public Interpreter(ConsoleInterface console) {
241 this(console, null);
242 }
243
244 /**
245 Create an interpreter for evaluation only.
246 */
247 public Interpreter()
248 {
249 this( new StringReader(""),
250 System.out, System.err, false, null );
251 evalOnly = true;
252 setu( "bsh.evalOnly", new Primitive(true) );
253 }
254
255 // End constructors
256
257 /**
258 Attach a console
259 Note: this method is incomplete.
260 */
261 public void setConsole( ConsoleInterface console ) {
262 this.console = console;
263 setu( "bsh.console", console );
264 // redundant with constructor
265 setOut( console.getOut() );
266 setErr( console.getErr() );
267 // need to set the input stream - reinit the parser?
268 }
269
270 private void initRootSystemObject()
271 {
272 BshClassManager bcm = getClassManager();
273 // bsh
274 setu("bsh", new NameSpace( bcm, "Bsh Object" ).getThis( this ) );
275
276 // init the static shared sharedObject if it's not there yet
277 if ( sharedObject == null )
278 sharedObject = new NameSpace(
279 bcm, "Bsh Shared System Object" ).getThis( this );
280 // bsh.system
281 setu( "bsh.system", sharedObject );
282 setu( "bsh.shared", sharedObject ); // alias
283
284 // bsh.help
285 This helpText = new NameSpace(
286 bcm, "Bsh Command Help Text" ).getThis( this );
287 setu( "bsh.help", helpText );
288
289 // bsh.cwd
290 try {
291 setu( "bsh.cwd", System.getProperty("user.dir") );
292 } catch ( SecurityException e ) {
293 // applets can't see sys props
294 setu( "bsh.cwd", "." );
295 }
296
297 // bsh.interactive
298 setu( "bsh.interactive", new Primitive(interactive) );
299 // bsh.evalOnly
300 setu( "bsh.evalOnly", new Primitive(evalOnly) );
301 }
302
303 /**
304 Set the global namespace for this interpreter.
305 <p>
306
307 Note: This is here for completeness. If you're using this a lot
308 it may be an indication that you are doing more work than you have
309 to. For example, caching the interpreter instance rather than the
310 namespace should not add a significant overhead. No state other
311 than the debug status is stored in the interpreter.
312 <p>
313
314 All features of the namespace can also be accessed using the
315 interpreter via eval() and the script variable 'this.namespace'
316 (or global.namespace as necessary).
317 */
318 public void setNameSpace( NameSpace globalNameSpace ) {
319 this.globalNameSpace = globalNameSpace;
320 }
321
322 /**
323 Get the global namespace of this interpreter.
324 <p>
325
326 Note: This is here for completeness. If you're using this a lot
327 it may be an indication that you are doing more work than you have
328 to. For example, caching the interpreter instance rather than the
329 namespace should not add a significant overhead. No state other than
330 the debug status is stored in the interpreter.
331 <p>
332
333 All features of the namespace can also be accessed using the
334 interpreter via eval() and the script variable 'this.namespace'
335 (or global.namespace as necessary).
336 */
337 public NameSpace getNameSpace() {
338 return globalNameSpace;
339 }
340
341 /**
342 Run the text only interpreter on the command line or specify a file.
343 */
344 public static void main( String [] args )
345 {
346 if ( args.length > 0 ) {
347 String filename = args[0];
348
349 String [] bshArgs;
350 if ( args.length > 1 ) {
351 bshArgs = new String [ args.length -1 ];
352 System.arraycopy( args, 1, bshArgs, 0, args.length-1 );
353 } else
354 bshArgs = new String [0];
355
356 Interpreter interpreter = new Interpreter();
357 //System.out.println("run i = "+interpreter);
358 interpreter.setu( "bsh.args", bshArgs );
359 try {
360 Object result =
361 interpreter.source( filename, interpreter.globalNameSpace );
362 if ( result instanceof Class )
363 try {
364 invokeMain( (Class)result, bshArgs );
365 } catch ( Exception e )
366 {
367 Object o = e;
368 if ( e instanceof InvocationTargetException )
369 o = ((InvocationTargetException)e)
370 .getTargetException();
371 System.err.println(
372 "Class: "+result+" main method threw exception:"+o);
373 }
374 } catch ( FileNotFoundException e ) {
375 System.out.println("File not found: "+e);
376 } catch ( TargetError e ) {
377 System.out.println("Script threw exception: "+e);
378 if ( e.inNativeCode() )
379 e.printStackTrace( DEBUG, System.err );
380 } catch ( EvalError e ) {
381 System.out.println("Evaluation Error: "+e);
382 } catch ( IOException e ) {
383 System.out.println("I/O Error: "+e);
384 }
385 } else
386 {
387 // Workaround for JDK bug 4071281, where system.in.available()
388 // returns too large a value. This bug has been fixed in JDK 1.2.
389 InputStream src;
390 if ( System.getProperty("os.name").startsWith("Windows")
391 && System.getProperty("java.version").startsWith("1.1."))
392 {
393 src = new FilterInputStream(System.in) {
394 public int available() throws IOException {
395 return 0;
396 }
397 };
398 }
399 else
400 src = System.in;
401
402 Reader in = new CommandLineReader( new InputStreamReader(src));
403 Interpreter interpreter =
404 new Interpreter( in, System.out, System.err, true );
405 interpreter.run();
406 }
407 }
408
409 public static void invokeMain( Class clas, String [] args )
410 throws Exception
411 {
412 Method main = Reflect.resolveJavaMethod(
413 null/*BshClassManager*/, clas, "main",
414 new Class [] { String [].class }, true/*onlyStatic*/ );
415 if ( main != null )
416 main.invoke( null, new Object [] { args } );
417 }
418
419 /**
420 Run interactively. (printing prompts, etc.)
421 */
422 public void run()
423 {
424 if(evalOnly)
425 throw new RuntimeException("bsh Interpreter: No stream");
426
427 /*
428 We'll print our banner using eval(String) in order to
429 exercise the parser and get the basic expression classes loaded...
430 This ameliorates the delay after typing the first statement.
431 */
432 if ( interactive )
433 try {
434 eval("printBanner();");
435 } catch ( EvalError e ) {
436 println(
437 "BeanShell "+VERSION+" - by Pat Niemeyer (pat@pat.net)");
438 }
439
440 // init the callstack.
441 CallStack callstack = new CallStack( globalNameSpace );
442
443 boolean eof = false;
444 while( !eof )
445 {
446 try
447 {
448 // try to sync up the console
449 System.out.flush();
450 System.err.flush();
451 Thread.yield(); // this helps a little
452
453 if ( interactive )
454 print( getBshPrompt() );
455
456 eof = Line();
457
458 if( get_jjtree().nodeArity() > 0 ) // number of child nodes
459 {
460 SimpleNode node = (SimpleNode)(get_jjtree().rootNode());
461
462 if(DEBUG)
463 node.dump(">");
464
465 Object ret = node.eval( callstack, this );
466
467 // sanity check during development
468 if ( callstack.depth() > 1 )
469 throw new InterpreterError(
470 "Callstack growing: "+callstack);
471
472 if(ret instanceof ReturnControl)
473 ret = ((ReturnControl)ret).value;
474
475 if( ret != Primitive.VOID )
476 {
477 setu("$_", ret);
478 if ( showResults )
479 println("<" + ret + ">");
480 }
481 }
482 }
483 catch(ParseException e)
484 {
485 error("Parser Error: " + e.getMessage(DEBUG));
486 if ( DEBUG )
487 e.printStackTrace();
488 if(!interactive)
489 eof = true;
490
491 parser.reInitInput(in);
492 }
493 catch(InterpreterError e)
494 {
495 error("Internal Error: " + e.getMessage());
496 e.printStackTrace();
497 if(!interactive)
498 eof = true;
499 }
500 catch(TargetError e)
501 {
502 error("// Uncaught Exception: " + e );
503 if ( e.inNativeCode() )
504 e.printStackTrace( DEBUG, err );
505 if(!interactive)
506 eof = true;
507 setu("$_e", e.getTarget());
508 }
509 catch (EvalError e)
510 {
511 if ( interactive )
512 error( "EvalError: "+e.toString() );
513 else
514 error( "EvalError: "+e.getMessage() );
515
516 if(DEBUG)
517 e.printStackTrace();
518
519 if(!interactive)
520 eof = true;
521 }
522 catch(Exception e)
523 {
524 error("Unknown error: " + e);
525 if ( DEBUG )
526 e.printStackTrace();
527 if(!interactive)
528 eof = true;
529 }
530 catch(TokenMgrError e)
531 {
532 error("Error parsing input: " + e);
533
534 /*
535 We get stuck in infinite loops here when unicode escapes
536 fail. Must re-init the char stream reader
537 (ASCII_UCodeESC_CharStream.java)
538 */
539 parser.reInitTokenInput( in );
540
541 if(!interactive)
542 eof = true;
543 }
544 finally
545 {
546 get_jjtree().reset();
547 // reinit the callstack
548 if ( callstack.depth() > 1 ) {
549 callstack.clear();
550 callstack.push( globalNameSpace );
551 }
552 }
553 }
554
555 if ( interactive && exitOnEOF )
556 System.exit(0);
557 }
558
559 // begin source and eval
560
561 /**
562 Read text from fileName and eval it.
563 */
564 public Object source( String filename, NameSpace nameSpace )
565 throws FileNotFoundException, IOException, EvalError
566 {
567 File file = pathToFile( filename );
568 if ( Interpreter.DEBUG ) debug("Sourcing file: "+file);
569 Reader sourceIn = new BufferedReader( new FileReader(file) );
570 try {
571 return eval( sourceIn, nameSpace, filename );
572 } finally {
573 sourceIn.close();
574 }
575 }
576
577 /**
578 Read text from fileName and eval it.
579 Convenience method. Use the global namespace.
580 */
581 public Object source( String filename )
582 throws FileNotFoundException, IOException, EvalError
583 {
584 return source( filename, globalNameSpace );
585 }
586
587 /**
588 Spawn a non-interactive local interpreter to evaluate text in the
589 specified namespace.
590
591 Return value is the evaluated object (or corresponding primitive
592 wrapper).
593
594 @param sourceFileInfo is for information purposes only. It is used to
595 display error messages (and in the future may be made available to
596 the script).
597 @throws EvalError on script problems
598 @throws TargetError on unhandled exceptions from the script
599 */
600 /*
601 Note: we need a form of eval that passes the callstack through...
602 */
603 /*
604 Can't this be combined with run() ?
605 run seems to have stuff in it for interactive vs. non-interactive...
606 compare them side by side and see what they do differently, aside from the
607 exception handling.
608 */
609
610 public Object eval(
611 Reader in, NameSpace nameSpace, String sourceFileInfo
612 /*, CallStack callstack */ )
613 throws EvalError
614 {
615 Object retVal = null;
616 if ( Interpreter.DEBUG ) debug("eval: nameSpace = "+nameSpace);
617
618 /*
619 Create non-interactive local interpreter for this namespace
620 with source from the input stream and out/err same as
621 this interpreter.
622 */
623 Interpreter localInterpreter =
624 new Interpreter(
625 in, out, err, false, nameSpace, this, sourceFileInfo );
626
627 CallStack callstack = new CallStack( nameSpace );
628
629 boolean eof = false;
630 while(!eof)
631 {
632 SimpleNode node = null;
633 try
634 {
635 eof = localInterpreter.Line();
636 if (localInterpreter.get_jjtree().nodeArity() > 0)
637 {
638 node = (SimpleNode)localInterpreter.get_jjtree().rootNode();
639 // nodes remember from where they were sourced
640 node.setSourceFile( sourceFileInfo );
641
642 if ( TRACE )
643 println( "// " +node.getText() );
644
645 retVal = node.eval( callstack, localInterpreter );
646
647 // sanity check during development
648 if ( callstack.depth() > 1 )
649 throw new InterpreterError(
650 "Callstack growing: "+callstack);
651
652 if ( retVal instanceof ReturnControl ) {
653 retVal = ((ReturnControl)retVal).value;
654 break; // non-interactive, return control now
655 }
656
657 if ( localInterpreter.showResults
658 && retVal != Primitive.VOID )
659 println("<" + retVal + ">");
660 }
661 } catch(ParseException e) {
662 /*
663 throw new EvalError(
664 "Sourced file: "+sourceFileInfo+" parser Error: "
665 + e.getMessage( DEBUG ), node, callstack );
666 */
667 if ( DEBUG )
668 // show extra "expecting..." info
669 error( e.getMessage(DEBUG) );
670
671 // add the source file info and throw again
672 e.setErrorSourceFile( sourceFileInfo );
673 throw e;
674
675 } catch ( InterpreterError e ) {
676 e.printStackTrace();
677 throw new EvalError(
678 "Sourced file: "+sourceFileInfo+" internal Error: "
679 + e.getMessage(), node, callstack);
680 } catch ( TargetError e ) {
681 // failsafe, set the Line as the origin of the error.
682 if ( e.getNode()==null )
683 e.setNode( node );
684 e.reThrow("Sourced file: "+sourceFileInfo);
685 } catch ( EvalError e) {
686 if ( DEBUG)
687 e.printStackTrace();
688 // failsafe, set the Line as the origin of the error.
689 if ( e.getNode()==null )
690 e.setNode( node );
691 e.reThrow( "Sourced file: "+sourceFileInfo );
692 } catch ( Exception e) {
693 if ( DEBUG)
694 e.printStackTrace();
695 throw new EvalError(
696 "Sourced file: "+sourceFileInfo+" unknown error: "
697 + e.getMessage(), node, callstack);
698 } catch(TokenMgrError e) {
699 throw new EvalError(
700 "Sourced file: "+sourceFileInfo+" Token Parsing Error: "
701 + e.getMessage(), node, callstack );
702 } finally {
703 localInterpreter.get_jjtree().reset();
704
705 // reinit the callstack
706 if ( callstack.depth() > 1 ) {
707 callstack.clear();
708 callstack.push( nameSpace );
709 }
710 }
711 }
712 return Primitive.unwrap( retVal );
713 }
714
715 /**
716 Evaluate the inputstream in this interpreter's global namespace.
717 */
718 public Object eval( Reader in ) throws EvalError
719 {
720 return eval( in, globalNameSpace, "eval stream" );
721 }
722
723 /**
724 Evaluate the string in this interpreter's global namespace.
725 */
726 public Object eval( String statements ) throws EvalError {
727 if ( Interpreter.DEBUG ) debug("eval(String): "+statements);
728 return eval(statements, globalNameSpace);
729 }
730
731 /**
732 Evaluate the string in the specified namespace.
733 */
734 public Object eval( String statements, NameSpace nameSpace )
735 throws EvalError
736 {
737
738 String s = ( statements.endsWith(";") ? statements : statements+";" );
739 return eval(
740 new StringReader(s), nameSpace,
741 "inline evaluation of: ``"+ showEvalString(s)+"''" );
742 }
743
744 private String showEvalString( String s ) {
745 s = s.replace('\n', ' ');
746 s = s.replace('\r', ' ');
747 if ( s.length() > 80 )
748 s = s.substring( 0, 80 ) + " . . . ";
749 return s;
750 }
751
752 // end source and eval
753
754 /**
755 Print an error message in a standard format on the output stream
756 associated with this interpreter. On the GUI console this will appear
757 in red, etc.
758 */
759 public final void error( Object o ) {
760 if ( console != null )
761 console.error( "// Error: " + o +"\n" );
762 else {
763 err.println("// Error: " + o );
764 err.flush();
765 }
766 }
767
768 // ConsoleInterface
769 // The interpreter reflexively implements the console interface that it
770 // uses. Should clean this up by using an inner class to implement the
771 // console for us.
772
773 /**
774 Get the input stream associated with this interpreter.
775 This may be be stdin or the GUI console.
776 */
777 public Reader getIn() { return in; }
778
779 /**
780 Get the outptut stream associated with this interpreter.
781 This may be be stdout or the GUI console.
782 */
783 public PrintStream getOut() { return out; }
784
785 /**
786 Get the error output stream associated with this interpreter.
787 This may be be stderr or the GUI console.
788 */
789 public PrintStream getErr() { return err; }
790
791 public final void println( Object o )
792 {
793 print( String.valueOf(o) + systemLineSeparator );
794 }
795
796 public final void print( Object o )
797 {
798 if (console != null) {
799 console.print(o);
800 } else {
801 out.print(o);
802 out.flush();
803 }
804 }
805
806 // End ConsoleInterface
807
808 /**
809 Print a debug message on debug stream associated with this interpreter
810 only if debugging is turned on.
811 */
812 public final static void debug(String s)
813 {
814 if ( DEBUG )
815 debug.println("// Debug: " + s);
816 }
817
818 /*
819 Primary interpreter set and get variable methods
820 Note: These are squeltching errors... should they?
821 */
822
823 /**
824 Get the value of the name.
825 name may be any value. e.g. a variable or field
826 */
827 public Object get( String name ) throws EvalError {
828 try {
829 Object ret = globalNameSpace.get( name, this );
830 return Primitive.unwrap( ret );
831 } catch ( UtilEvalError e ) {
832 throw e.toEvalError( SimpleNode.JAVACODE, new CallStack() );
833 }
834 }
835
836 /**
837 Unchecked get for internal use
838 */
839 Object getu( String name ) {
840 try {
841 return get( name );
842 } catch ( EvalError e ) {
843 throw new InterpreterError("set: "+e);
844 }
845 }
846
847 /**
848 Assign the value to the name.
849 name may evaluate to anything assignable. e.g. a variable or field.
850 */
851 public void set( String name, Object value )
852 throws EvalError
853 {
854 // map null to Primtive.NULL coming in...
855 if ( value == null )
856 value = Primitive.NULL;
857
858 CallStack callstack = new CallStack();
859 try {
860 if ( Name.isCompound( name ) )
861 {
862 LHS lhs = globalNameSpace.getNameResolver( name ).toLHS(
863 callstack, this );
864 lhs.assign( value, false );
865 } else // optimization for common case
866 globalNameSpace.setVariable( name, value, false );
867 } catch ( UtilEvalError e ) {
868 throw e.toEvalError( SimpleNode.JAVACODE, callstack );
869 }
870 }
871
872 /**
873 Unchecked set for internal use
874 */
875 void setu(String name, Object value) {
876 try {
877 set(name, value);
878 } catch ( EvalError e ) {
879 throw new InterpreterError("set: "+e);
880 }
881 }
882
883 public void set(String name, long value) throws EvalError {
884 set(name, new Primitive(value));
885 }
886 public void set(String name, int value) throws EvalError {
887 set(name, new Primitive(value));
888 }
889 public void set(String name, double value) throws EvalError {
890 set(name, new Primitive(value));
891 }
892 public void set(String name, float value) throws EvalError {
893 set(name, new Primitive(value));
894 }
895 public void set(String name, boolean value) throws EvalError {
896 set(name, new Primitive(value));
897 }
898
899 /**
900 Unassign the variable name.
901 Name should evaluate to a variable.
902 */
903 public void unset( String name )
904 throws EvalError
905 {
906 /*
907 We jump through some hoops here to handle arbitrary cases like
908 unset("bsh.foo");
909 */
910 CallStack callstack = new CallStack();
911 try {
912 LHS lhs = globalNameSpace.getNameResolver( name ).toLHS(
913 callstack, this );
914
915 if ( lhs.type != LHS.VARIABLE )
916 throw new EvalError("Can't unset, not a variable: "+name,
917 SimpleNode.JAVACODE, new CallStack() );
918
919 //lhs.assign( null, false );
920 lhs.nameSpace.unsetVariable( name );
921 } catch ( UtilEvalError e ) {
922 throw new EvalError( e.getMessage(),
923 SimpleNode.JAVACODE, new CallStack() );
924 }
925 }
926
927 // end primary set and get methods
928
929 /**
930 Get a reference to the interpreter (global namespace), cast
931 to the specified interface type. Assuming the appropriate
932 methods of the interface are defined in the interpreter, then you may
933 use this interface from Java, just like any other Java object.
934 <p>
935
936 For example:
937 <pre>
938 Interpreter interpreter = new Interpreter();
939 // define a method called run()
940 interpreter.eval("run() { ... }");
941
942 // Fetch a reference to the interpreter as a Runnable
943 Runnable runnable =
944 (Runnable)interpreter.getInterface( Runnable.class );
945 </pre>
946 <p>
947
948 Note that the interpreter does *not* require that any or all of the
949 methods of the interface be defined at the time the interface is
950 generated. However if you attempt to invoke one that is not defined
951 you will get a runtime exception.
952 <p>
953
954 Note also that this convenience method has exactly the same effect as
955 evaluating the script:
956 <pre>
957 (Type)this;
958 </pre>
959 <p>
960
961 For example, the following is identical to the previous example:
962 <p>
963
964 <pre>
965 // Fetch a reference to the interpreter as a Runnable
966 Runnable runnable =
967 (Runnable)interpreter.eval( "(Runnable)this" );
968 </pre>
969 <p>
970
971 <em>Version requirement</em> Although standard Java interface types
972 are always available, to be used with arbitrary interfaces this
973 feature requires that you are using Java 1.3 or greater.
974 <p>
975
976 @throws EvalError if the interface cannot be generated because the
977 version of Java does not support the proxy mechanism.
978 */
979 public Object getInterface( Class interf ) throws EvalError
980 {
981 try {
982 return globalNameSpace.getThis( this ).getInterface( interf );
983 } catch ( UtilEvalError e ) {
984 throw e.toEvalError( SimpleNode.JAVACODE, new CallStack() );
985 }
986 }
987
988 /* Methods for interacting with Parser */
989
990 private JJTParserState get_jjtree() {
991 return parser.jjtree;
992 }
993
994 private JavaCharStream get_jj_input_stream() {
995 return parser.jj_input_stream;
996 }
997
998 private boolean Line() throws ParseException {
999 return parser.Line();
1000 }
1001
1002 /* End methods for interacting with Parser */
1003
1004 void loadRCFiles() {
1005 try {
1006 String rcfile =
1007 // Default is c:\windows under win98, $HOME under Unix
1008 System.getProperty("user.home") + File.separator + ".bshrc";
1009 source( rcfile, globalNameSpace );
1010 } catch ( Exception e ) {
1011 // squeltch security exception, filenotfoundexception
1012 if ( Interpreter.DEBUG ) debug("Could not find rc file: "+e);
1013 }
1014 }
1015
1016 /**
1017 Localize a path to the file name based on the bsh.cwd interpreter
1018 working directory.
1019 */
1020 public File pathToFile( String fileName )
1021 throws IOException
1022 {
1023 File file = new File( fileName );
1024
1025 // if relative, fix up to bsh.cwd
1026 if ( !file.isAbsolute() ) {
1027 String cwd = (String)getu("bsh.cwd");
1028 file = new File( cwd + File.separator + fileName );
1029 }
1030
1031 // The canonical file name is also absolute.
1032 // No need for getAbsolutePath() here...
1033 return new File( file.getCanonicalPath() );
1034 }
1035
1036 public static void redirectOutputToFile( String filename )
1037 {
1038 try {
1039 PrintStream pout = new PrintStream(
1040 new FileOutputStream( filename ) );
1041 System.setOut( pout );
1042 System.setErr( pout );
1043 } catch ( IOException e ) {
1044 System.err.println("Can't redirect output to file: "+filename );
1045 }
1046 }
1047
1048 /**
1049 Set an external class loader to be used as the base classloader
1050 for BeanShell. The base classloader is used for all classloading
1051 unless/until the addClasspath()/setClasspath()/reloadClasses()
1052 commands are called to modify the interpreter's classpath. At that
1053 time the new paths /updated paths are added on top of the base
1054 classloader.
1055 <p>
1056
1057 BeanShell will use this at the same point it would otherwise use the
1058 plain Class.forName().
1059 i.e. if no explicit classpath management is done from the script
1060 (addClassPath(), setClassPath(), reloadClasses()) then BeanShell will
1061 only use the supplied classloader. If additional classpath management
1062 is done then BeanShell will perform that in addition to the supplied
1063 external classloader.
1064 However BeanShell is not currently able to reload
1065 classes supplied through the external classloader.
1066 <p>
1067
1068 @see BshClassManager#setClassLoader( ClassLoader )
1069 */
1070 public void setClassLoader( ClassLoader externalCL ) {
1071 getClassManager().setClassLoader( externalCL );
1072 }
1073
1074 /**
1075 Get the class manager associated with this interpreter
1076 (the BshClassManager of this interpreter's global namespace).
1077 This is primarily a convenience method.
1078 */
1079 public BshClassManager getClassManager()
1080 {
1081 return getNameSpace().getClassManager();
1082 }
1083
1084 /**
1085 Set strict Java mode on or off.
1086 This mode attempts to make BeanShell syntax behave as Java
1087 syntax, eliminating conveniences like loose variables, etc.
1088 When enabled, variables are required to be declared or initialized
1089 before use and method arguments are reqired to have types.
1090 <p>
1091
1092 This mode will become more strict in a future release when
1093 classes are interpreted and there is an alternative to scripting
1094 objects as method closures.
1095 */
1096 public void setStrictJava( boolean b ) {
1097 this.strictJava = b;
1098 }
1099
1100 /**
1101 @see #setStrictJava( boolean )
1102 */
1103 public boolean getStrictJava() {
1104 return this.strictJava;
1105 }
1106
1107 static void staticInit()
1108 {
1109 /*
1110 Apparently in some environments you can't catch the security exception
1111 at all... e.g. as an applet in IE ... will probably have to work
1112 around
1113 */
1114 try {
1115 systemLineSeparator = System.getProperty("line.separator");
1116 debug = System.err;
1117 DEBUG = Boolean.getBoolean("debug");
1118 TRACE = Boolean.getBoolean("trace");
1119 LOCALSCOPING = Boolean.getBoolean("localscoping");
1120 String outfilename = System.getProperty("outfile");
1121 if ( outfilename != null )
1122 redirectOutputToFile( outfilename );
1123 } catch ( SecurityException e ) {
1124 System.err.println("Could not init static:"+e);
1125 } catch ( Exception e ) {
1126 System.err.println("Could not init static(2):"+e);
1127 } catch ( Throwable e ) {
1128 System.err.println("Could not init static(3):"+e);
1129 }
1130 }
1131
1132 /**
1133 Specify the source of the text from which this interpreter is reading.
1134 Note: there is a difference between what file the interrpeter is
1135 sourcing and from what file a method was originally parsed. One
1136 file may call a method sourced from another file. See SimpleNode
1137 for origination file info.
1138 @see bsh.SimpleNode#getSourceFile()
1139 */
1140 public String getSourceFileInfo() {
1141 if ( sourceFileInfo != null )
1142 return sourceFileInfo;
1143 else
1144 return "<unknown source>";
1145 }
1146
1147 /**
1148 Get the parent Interpreter of this interpreter, if any.
1149 Currently this relationship implies the following:
1150 1) Parent and child share a BshClassManager
1151 2) Children indicate the parent's source file information in error
1152 reporting.
1153 When created as part of a source() / eval() the child also shares
1154 the parent's namespace. But that is not necessary in general.
1155 */
1156 public Interpreter getParent() {
1157 return parent;
1158 }
1159
1160 public void setOut( PrintStream out ) {
1161 this.out = out;
1162 }
1163 public void setErr( PrintStream err ) {
1164 this.err = err;
1165 }
1166
1167 /**
1168 De-serialization setup.
1169 Default out and err streams to stdout, stderr if they are null.
1170 */
1171 private void readObject(ObjectInputStream stream)
1172 throws java.io.IOException, ClassNotFoundException
1173 {
1174 stream.defaultReadObject();
1175
1176 // set transient fields
1177 if ( console != null ) {
1178 setOut( console.getOut() );
1179 setErr( console.getErr() );
1180 } else {
1181 setOut( System.out );
1182 setErr( System.err );
1183 }
1184 }
1185
1186 /**
1187 Get the prompt string defined by the getBshPrompt() method in the
1188 global namespace. This may be from the getBshPrompt() command or may
1189 be defined by the user as with any other method.
1190 Defaults to "bsh % " if the method is not defined or there is an error.
1191 */
1192 private String getBshPrompt()
1193 {
1194 try {
1195 return (String)eval("getBshPrompt()");
1196 } catch ( Exception e ) {
1197 return "bsh % ";
1198 }
1199 }
1200
1201 /**
1202 Specify whether, in interactive mode, the interpreter exits Java upon
1203 end of input. If true, when in interactive mode the interpreter will
1204 issue a System.exit(0) upon eof. If false the interpreter no
1205 System.exit() will be done.
1206 <p/>
1207 Note: if you wish to cause an EOF externally you can try closing the
1208 input stream. This is not guaranteed to work in older versions of Java
1209 due to Java limitations, but should work in newer JDK/JREs. (That was
1210 the motivation for the Java NIO package).
1211 */
1212 public void setExitOnEOF( boolean value ) {
1213 exitOnEOF = value; // ug
1214 }
1215
1216 /**
1217 Turn on/off the verbose printing of results as for the show()
1218 command.
1219 If this interpreter has a parent the call is delegated.
1220 See the BeanShell show() command.
1221 */
1222 public void setShowResults( boolean showResults ) {
1223 this.showResults = showResults;
1224 }
1225 /**
1226 Show on/off verbose printing status for the show() command.
1227 See the BeanShell show() command.
1228 If this interpreter has a parent the call is delegated.
1229 */
1230 public boolean getShowResults() {
1231 return showResults;
1232 }
1233 }
1234