1 /*
2 * Copyright (c) 2005, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 /**
27 * jrunscript JavaScript built-in functions and objects.
28 */
29
30 /**
31 * Creates an object that delegates all method calls on
32 * it to the 'invoke' method on the given delegate object.<br>
33 *
34 * Example:
35 * <pre>
36 * <code>
37 * var x = { invoke: function(name, args) { //code...}
38 * var y = new JSInvoker(x);
39 * y.func(3, 3); // calls x.invoke('func', args); where args is array of arguments
40 * </code>
41 * </pre>
42 * @param obj object to be wrapped by JSInvoker
43 * @constructor
44 */
45 function JSInvoker(obj) {
46 return new JSAdapter({
47 __get__ : function(name) {
48 return function() {
49 return obj.invoke(name, arguments);
50 }
51 }
52 });
53 }
54
55 /**
56 * This variable represents OS environment. Environment
57 * variables can be accessed as fields of this object. For
58 * example, env.PATH will return PATH value configured.
59 */
60 var env = new JSAdapter({
61 __get__ : function (name) {
62 return java.lang.System.getenv(name);
63 },
64 __has__ : function (name) {
65 return java.lang.System.getenv().containsKey(name);
66 },
67 __getIds__ : function() {
68 return java.lang.System.getenv().keySet().toArray();
69 },
70 __delete__ : function(name) {
71 println("can't delete env item");
72 },
73 __put__ : function (name, value) {
74 println("can't change env item");
75 },
76 toString: function() {
77 return java.lang.System.getenv().toString();
78 }
79 });
80
81 /**
82 * Creates a convenient script object to deal with java.util.Map instances.
83 * The result script object's field names are keys of the Map. For example,
84 * scriptObj.keyName can be used to access value associated with given key.<br>
85 * Example:
86 * <pre>
87 * <code>
88 * var x = java.lang.SystemProperties();
89 * var y = jmap(x);
90 * println(y['java.class.path']); // prints java.class.path System property
91 * delete y['java.class.path']; // remove java.class.path System property
92 * </code>
93 * </pre>
94 *
95 * @param map java.util.Map instance that will be wrapped
96 * @constructor
97 */
98 function jmap(map) {
99 return new JSAdapter({
100 __get__ : function(name) {
101 if (map.containsKey(name)) {
102 return map.get(name);
103 } else {
104 return undefined;
105 }
106 },
107 __has__ : function(name) {
108 return map.containsKey(name);
109 },
110
111 __delete__ : function (name) {
112 return map.remove(name);
113 },
114 __put__ : function(name, value) {
115 map.put(name, value);
116 },
117 __getIds__ : function() {
118 return map.keySet().toArray();
119 },
120 toString: function() {
121 return map.toString();
122 }
123 });
124 }
125
126 /**
127 * Creates a convenient script object to deal with java.util.List instances.
128 * The result script object behaves like an array. For example,
129 * scriptObj[index] syntax can be used to access values in the List instance.
130 * 'length' field gives size of the List. <br>
131 *
132 * Example:
133 * <pre>
134 * <code>
135 * var x = new java.util.ArrayList(4);
136 * x.add('Java');
137 * x.add('JavaScript');
138 * x.add('SQL');
139 * x.add('XML');
140 *
141 * var y = jlist(x);
142 * println(y[2]); // prints third element of list
143 * println(y.length); // prints size of the list
144 *
145 * @param map java.util.List instance that will be wrapped
146 * @constructor
147 */
148 function jlist(list) {
149 function isValid(index) {
150 return typeof(index) == 'number' &&
151 index > -1 && index < list.size();
152 }
153 return new JSAdapter({
154 __get__ : function(name) {
155 if (isValid(name)) {
156 return list.get(name);
157 } else if (name == 'length') {
158 return list.size();
159 } else {
160 return undefined;
161 }
162 },
163 __has__ : function (name) {
164 return isValid(name) || name == 'length';
165 },
166 __delete__ : function(name) {
167 if (isValid(name)) {
168 list.remove(name);
169 }
170 },
171 __put__ : function(name, value) {
172 if (isValid(name)) {
173 list.set(name, value);
174 }
175 },
176 __getIds__: function() {
177 var res = new Array(list.size());
178 for (var i = 0; i < res.length; i++) {
179 res[i] = i;
180 }
181 return res;
182 },
183 toString: function() {
184 return list.toString();
185 }
186 });
187 }
188
189 /**
190 * This is java.lang.System properties wrapped by JSAdapter.
191 * For eg. to access java.class.path property, you can use
192 * the syntax sysProps["java.class.path"]
193 */
194 var sysProps = new JSAdapter({
195 __get__ : function (name) {
196 return java.lang.System.getProperty(name);
197 },
198 __has__ : function (name) {
199 return java.lang.System.getProperty(name) != null;
200 },
201 __getIds__ : function() {
202 return java.lang.System.getProperties().keySet().toArray();
203 },
204 __delete__ : function(name) {
205 java.lang.System.clearProperty(name);
206 return true;
207 },
208 __put__ : function (name, value) {
209 java.lang.System.setProperty(name, value);
210 },
211 toString: function() {
212 return "<system properties>";
213 }
214 });
215
216 // stdout, stderr & stdin
217 var out = java.lang.System.out;
218 var err = java.lang.System.err;
219 // can't use 'in' because it is a JavaScript keyword :-(
220 var inp = java.lang.System["in"];
221
222 var BufferedInputStream = java.io.BufferedInputStream;
223 var BufferedOutputStream = java.io.BufferedOutputStream;
224 var BufferedReader = java.io.BufferedReader;
225 var DataInputStream = java.io.DataInputStream;
226 var File = java.io.File;
227 var FileInputStream = java.io.FileInputStream;
228 var FileOutputStream = java.io.FileOutputStream;
229 var InputStream = java.io.InputStream;
230 var InputStreamReader = java.io.InputStreamReader;
231 var OutputStream = java.io.OutputStream;
232 var Reader = java.io.Reader;
233 var URL = java.net.URL;
234
235 /**
236 * Generic any object to input stream mapper
237 * @param str input file name, URL or InputStream
238 * @return InputStream object
239 * @private
240 */
241 function inStream(str) {
242 if (typeof(str) == "string") {
243 // '-' means standard input
244 if (str == '-') {
245 return java.lang.System["in"];
246 }
247 // try file first
248 var file = null;
249 try {
250 file = pathToFile(str);
251 } catch (e) {
252 }
253 if (file && file.exists()) {
254 return new FileInputStream(file);
255 } else {
256 try {
257 // treat the string as URL
258 return new URL(str).openStream();
259 } catch (e) {
260 throw 'file or URL ' + str + ' not found';
261 }
262 }
263 } else {
264 if (str instanceof InputStream) {
265 return str;
266 } else if (str instanceof URL) {
267 return str.openStream();
268 } else if (str instanceof File) {
269 return new FileInputStream(str);
270 }
271 }
272 // everything failed, just give input stream
273 return java.lang.System["in"];
274 }
275
276 /**
277 * Generic any object to output stream mapper
278 *
279 * @param out output file name or stream
280 * @return OutputStream object
281 * @private
282 */
283 function outStream(out) {
284 if (typeof(out) == "string") {
285 if (out == '>') {
286 return java.lang.System.out;
287 } else {
288 // treat it as file
289 return new FileOutputStream(pathToFile(out));
290 }
291 } else {
292 if (out instanceof OutputStream) {
293 return out;
294 } else if (out instanceof File) {
295 return new FileOutputStream(out);
296 }
297 }
298
299 // everything failed, just return System.out
300 return java.lang.System.out;
301 }
302
303 /**
304 * stream close takes care not to close stdin, out & err.
305 * @private
306 */
307 function streamClose(stream) {
308 if (stream) {
309 if (stream != java.lang.System["in"] &&
310 stream != java.lang.System.out &&
311 stream != java.lang.System.err) {
312 try {
313 stream.close();
314 } catch (e) {
315 println(e);
316 }
317 }
318 }
319 }
320
321 /**
322 * Loads and evaluates JavaScript code from a stream or file or URL<br>
323 *
324 * Examples:
325 * <pre>
326 * <code>
327 * load('test.js'); // load script file 'test.js'
328 * load('http://java.sun.com/foo.js'); // load from a URL
329 * </code>
330 * </pre>
331 *
332 * @param str input from which script is loaded and evaluated
333 */
334 if (typeof(load) == 'undefined') {
335 this.load = function(str) {
336 var stream = inStream(str);
337 var bstream = new BufferedInputStream(stream);
338 var reader = new BufferedReader(new InputStreamReader(bstream));
339 var oldFilename = engine.get(engine.FILENAME);
340 engine.put(engine.FILENAME, str);
341 try {
342 engine.eval(reader);
343 } finally {
344 engine.put(engine.FILENAME, oldFilename);
345 streamClose(stream);
346 }
347 }
348 }
349
350 // file system utilities
351
352 /**
353 * Creates a Java byte[] of given length
354 * @param len size of the array to create
355 * @private
356 */
357 function javaByteArray(len) {
358 return java.lang.reflect.Array.newInstance(java.lang.Byte.TYPE, len);
359 }
360
361 var curDir = new File('.');
362
363 /**
364 * Print present working directory
365 */
366 function pwd() {
367 println(curDir.getAbsolutePath());
368 }
369
370 /**
371 * Changes present working directory to given directory
372 * @param target directory to change to. optional, defaults to user's HOME
373 */
374 function cd(target) {
375 if (target == undefined) {
376 target = sysProps["user.home"];
377 }
378 if (!(target instanceof File)) {
379 target = pathToFile(target);
380 }
381 if (target.exists() && target.isDirectory()) {
382 curDir = target;
383 } else {
384 println(target + " is not a directory");
385 }
386 }
387
388 /**
389 * Converts path to java.io.File taking care of shell present working dir
390 *
391 * @param pathname file path to be converted
392 * @private
393 */
394 function pathToFile(pathname) {
395 var tmp = pathname;
396 if (!(tmp instanceof File)) {
397 tmp = new File(tmp);
398 }
399 if (!tmp.isAbsolute()) {
400 return new File(curDir, pathname);
401 } else {
402 return tmp;
403 }
404 }
405
406 /**
407 * Copies a file or URL or stream to another file or stream
408 *
409 * @param from input file or URL or stream
410 * @param to output stream or file
411 */
412 function cp(from, to) {
413 if (from == to) {
414 println("file " + from + " cannot be copied onto itself!");
415 return;
416 }
417 var inp = inStream(from);
418 var out = outStream(to);
419 var binp = new BufferedInputStream(inp);
420 var bout = new BufferedOutputStream(out);
421 var buff = javaByteArray(1024);
422 var len;
423 while ((len = binp.read(buff)) > 0 )
424 bout.write(buff, 0, len);
425
426 bout.flush();
427 streamClose(inp);
428 streamClose(out);
429 }
430
431 /**
432 * Shows the content of a file or URL or any InputStream<br>
433 * Examples:
434 * <pre>
435 * <code>
436 * cat('test.txt'); // show test.txt file contents
437 * cat('http://java.net'); // show the contents from the URL http://java.net
438 * </code>
439 * </pre>
440 * @param obj input to show
441 * @param pattern optional. show only the lines matching the pattern
442 */
443 function cat(obj, pattern) {
444 if (obj instanceof File && obj.isDirectory()) {
445 ls(obj);
446 return;
447 }
448
449 var inp = null;
450 if (!(obj instanceof Reader)) {
451 inp = inStream(obj);
452 obj = new BufferedReader(new InputStreamReader(inp));
453 }
454 var line;
455 if (pattern) {
456 var count = 1;
457 while ((line=obj.readLine()) != null) {
458 if (line.match(pattern)) {
459 println(count + "\t: " + line);
460 }
461 count++;
462 }
463 } else {
464 while ((line=obj.readLine()) != null) {
465 println(line);
466 }
467 }
468 }
469
470 /**
471 * Returns directory part of a filename
472 *
473 * @param pathname input path name
474 * @return directory part of the given file name
475 */
476 function dirname(pathname) {
477 var dirName = ".";
478 // Normalize '/' to local file separator before work.
479 var i = pathname.replace('/', File.separatorChar ).lastIndexOf(
480 File.separator );
481 if ( i != -1 )
482 dirName = pathname.substring(0, i);
483 return dirName;
484 }
485
486 /**
487 * Creates a new dir of given name
488 *
489 * @param dir name of the new directory
490 */
491 function mkdir(dir) {
492 dir = pathToFile(dir);
493 println(dir.mkdir()? "created" : "can not create dir");
494 }
495
496 /**
497 * Creates the directory named by given pathname, including
498 * any necessary but nonexistent parent directories.
499 *
500 * @param dir input path name
501 */
502 function mkdirs(dir) {
503 dir = pathToFile(dir);
504 println(dir.mkdirs()? "created" : "can not create dirs");
505 }
506
507 /**
508 * Removes a given file
509 *
510 * @param pathname name of the file
511 */
512 function rm(pathname) {
513 var file = pathToFile(pathname);
514 if (!file.exists()) {
515 println("file not found: " + pathname);
516 return false;
517 }
518 // note that delete is a keyword in JavaScript!
519 println(file["delete"]()? "deleted" : "can not delete");
520 }
521
522 /**
523 * Removes a given directory
524 *
525 * @param pathname name of the directory
526 */
527 function rmdir(pathname) {
528 rm(pathname);
529 }
530
531 /**
532 * Synonym for 'rm'
533 */
534 function del(pathname) {
535 rm(pathname);
536 }
537
538 /**
539 * Moves a file to another
540 *
541 * @param from original name of the file
542 * @param to new name for the file
543 */
544 function mv(from, to) {
545 println(pathToFile(from).renameTo(pathToFile(to))?
546 "moved" : "can not move");
547 }
548
549 /**
550 * Synonym for 'mv'.
551 */
552 function ren(from, to) {
553 mv(from, to);
554 }
555
556 var months = [ "Jan", "Feb", "Mar", "Apr", "May", "Jun",
557 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ];
558
559 /**
560 * Helper function called by ls
561 * @private
562 */
563 function printFile(f) {
564 var sb = new java.lang.StringBuffer();
565 sb.append(f.isDirectory()? "d" : "-");
566 sb.append(f.canRead() ? "r": "-" );
567 sb.append(f.canWrite() ? "w": "-" );
568 sb.append(" ");
569
570 var d = new java.util.Date(f.lastModified());
571 var c = new java.util.GregorianCalendar();
572 c.setTime(d);
573 var day = c.get(java.util.Calendar.DAY_OF_MONTH);
574 sb.append(months[c.get(java.util.Calendar.MONTH)]
575 + " " + day );
576 if (day < 10) {
577 sb.append(" ");
578 }
579
580 // to get fixed length 'length' field
581 var fieldlen = 8;
582 var len = new java.lang.StringBuffer();
583 for(var j=0; j<fieldlen; j++)
584 len.append(" ");
585 len.insert(0, java.lang.Long.toString(f.length()));
586 len.setLength(fieldlen);
587 // move the spaces to the front
588 var si = len.toString().indexOf(" ");
589 if ( si != -1 ) {
590 var pad = len.toString().substring(si);
591 len.setLength(si);
592 len.insert(0, pad);
593 }
594 sb.append(len.toString());
595 sb.append(" ");
596 sb.append(f.getName());
597 if (f.isDirectory()) {
598 sb.append('/');
599 }
600 println(sb.toString());
601 }
602
603 /**
604 * Lists the files in a directory
605 *
606 * @param dir directory from which to list the files. optional, default to pwd
607 * @param filter pattern to filter the files listed. optional, default is '.'.
608 */
609 function ls(dir, filter) {
610 if (dir) {
611 dir = pathToFile(dir);
612 } else {
613 dir = curDir;
614 }
615 if (dir.isDirectory()) {
616 var files = dir.listFiles();
617 for (var i in files) {
618 var f = files[i];
619 if (filter) {
620 if(!f.getName().match(filter)) {
621 continue;
622 }
623 }
624 printFile(f);
625 }
626 } else {
627 printFile(dir);
628 }
629 }
630
631 /**
632 * Synonym for 'ls'.
633 */
634 function dir(d, filter) {
635 ls(d, filter);
636 }
637
638 /**
639 * Unix-like grep, but accepts JavaScript regex patterns
640 *
641 * @param pattern to search in files
642 * @param files one or more files
643 */
644 function grep(pattern, files /*, one or more files */) {
645 if (arguments.length < 2) return;
646 for (var i = 1; i < arguments.length; i++) {
647 println(arguments[i] + ":");
648 cat(arguments[i], pattern);
649 }
650 }
651
652 /**
653 * Find in files. Calls arbitrary callback function
654 * for each matching file.<br>
655 *
656 * Examples:
657 * <pre>
658 * <code>
659 * find('.')
660 * find('.', '.*\.class', rm); // remove all .class files
661 * find('.', '.*\.java'); // print fullpath of each .java file
662 * find('.', '.*\.java', cat); // print all .java files
663 * </code>
664 * </pre>
665 *
666 * @param dir directory to search files
667 * @param pattern to search in the files
668 * @param callback function to call for matching files
669 */
670 function find(dir, pattern, callback) {
671 dir = pathToFile(dir);
672 if (!callback) callback = print;
673 var files = dir.listFiles();
674 for (var f in files) {
675 var file = files[f];
676 if (file.isDirectory()) {
677 find(file, pattern, callback);
678 } else {
679 if (pattern) {
680 if (file.getName().match(pattern)) {
681 callback(file);
682 }
683 } else {
684 callback(file);
685 }
686 }
687 }
688 }
689
690 // process utilities
691
692 /**
693 * Exec's a child process, waits for completion & returns exit code
694 *
695 * @param cmd command to execute in child process
696 */
697 function exec(cmd) {
698 var process = java.lang.Runtime.getRuntime().exec(cmd);
699 var inp = new DataInputStream(process.getInputStream());
700 var line = null;
701 while ((line = inp.readLine()) != null) {
702 println(line);
703 }
704 process.waitFor();
705 $exit = process.exitValue();
706 }
707
708 if (typeof(exit) == 'undefined') {
709 /**
710 * Exit the shell program.
711 *
712 * @param exitCode integer code returned to OS shell.
713 * optional, defaults to 0
714 */
715 this.exit = function (code) {
716 if (code) {
717 java.lang.System.exit(code + 0);
718 } else {
719 java.lang.System.exit(0);
720 }
721 }
722 }
723
724 if (typeof(quit) == 'undefined') {
725 /**
726 * synonym for exit
727 */
728 this.quit = function (code) {
729 exit(code);
730 }
731 }
732
733 // XML utilities
734
735 /**
736 * Converts input to DOM Document object
737 *
738 * @param inp file or reader. optional, without this param,
739 * this function returns a new DOM Document.
740 * @return returns a DOM Document object
741 */
742 function XMLDocument(inp) {
743 var factory = javax.xml.parsers.DocumentBuilderFactory.newInstance();
744 var builder = factory.newDocumentBuilder();
745 if (inp) {
746 if (typeof(inp) == "string") {
747 return builder.parse(pathToFile(inp));
748 } else {
749 return builder.parse(inp);
750 }
751 } else {
752 return builder.newDocument();
753 }
754 }
755
756 /**
757 * Converts arbitrary stream, file, URL to XMLSource
758 *
759 * @param inp input stream or file or URL
760 * @return XMLSource object
761 */
762 function XMLSource(inp) {
763 if (inp instanceof javax.xml.transform.Source) {
764 return inp;
765 } else if (inp instanceof Packages.org.w3c.dom.Document) {
766 return new javax.xml.transform.dom.DOMSource(inp);
767 } else {
768 inp = new BufferedInputStream(inStream(inp));
769 return new javax.xml.transform.stream.StreamSource(inp);
770 }
771 }
772
773 /**
774 * Converts arbitrary stream, file to XMLResult
775 *
776 * @param inp output stream or file
777 * @return XMLResult object
778 */
779 function XMLResult(out) {
780 if (out instanceof javax.xml.transform.Result) {
781 return out;
782 } else if (out instanceof Packages.org.w3c.dom.Document) {
783 return new javax.xml.transform.dom.DOMResult(out);
784 } else {
785 out = new BufferedOutputStream(outStream(out));
786 return new javax.xml.transform.stream.StreamResult(out);
787 }
788 }
789
790 /**
791 * Perform XSLT transform
792 *
793 * @param inp Input XML to transform (URL, File or InputStream)
794 * @param style XSL Stylesheet to be used (URL, File or InputStream). optional.
795 * @param out Output XML (File or OutputStream
796 */
797 function XSLTransform(inp, style, out) {
798 switch (arguments.length) {
799 case 2:
800 inp = arguments[0];
801 out = arguments[1];
802 break;
803 case 3:
804 inp = arguments[0];
805 style = arguments[1];
806 out = arguments[2];
807 break;
808 default:
809 println("XSL transform requires 2 or 3 arguments");
810 return;
811 }
812
813 var factory = javax.xml.transform.TransformerFactory.newInstance();
814 var transformer;
815 if (style) {
816 transformer = factory.newTransformer(XMLSource(style));
817 } else {
818 transformer = factory.newTransformer();
819 }
820 var source = XMLSource(inp);
821 var result = XMLResult(out);
822 transformer.transform(source, result);
823 if (source.getInputStream) {
824 streamClose(source.getInputStream());
825 }
826 if (result.getOutputStream) {
827 streamClose(result.getOutputStream());
828 }
829 }
830
831 // miscellaneous utilities
832
833 /**
834 * Prints which command is selected from PATH
835 *
836 * @param cmd name of the command searched from PATH
837 */
838 function which(cmd) {
839 var st = new java.util.StringTokenizer(env.PATH, File.pathSeparator);
840 while (st.hasMoreTokens()) {
841 var file = new File(st.nextToken(), cmd);
842 if (file.exists()) {
843 println(file.getAbsolutePath());
844 return;
845 }
846 }
847 }
848
849 /**
850 * Prints IP addresses of given domain name
851 *
852 * @param name domain name
853 */
854 function ip(name) {
855 var addrs = InetAddress.getAllByName(name);
856 for (var i in addrs) {
857 println(addrs[i]);
858 }
859 }
860
861 /**
862 * Prints current date in current locale
863 */
864 function date() {
865 println(new Date().toLocaleString());
866 }
867
868 /**
869 * Echoes the given string arguments
870 */
871 function echo(x) {
872 for (var i = 0; i < arguments.length; i++) {
873 println(arguments[i]);
874 }
875 }
876
877 if (typeof(printf) == 'undefined') {
878 /**
879 * This is C-like printf
880 *
881 * @param format string to format the rest of the print items
882 * @param args variadic argument list
883 */
884 this.printf = function (format, args/*, more args*/) {
885 var array = java.lang.reflect.Array.newInstance(java.lang.Object,
886 arguments.length - 1);
887 for (var i = 0; i < array.length; i++) {
888 array[i] = arguments[i+1];
889 }
890 java.lang.System.out.printf(format, array);
891 }
892 }
893
894 /**
895 * Reads one or more lines from stdin after printing prompt
896 *
897 * @param prompt optional, default is '>'
898 * @param multiline to tell whether to read single line or multiple lines
899 */
900 function read(prompt, multiline) {
901 if (!prompt) {
902 prompt = '>';
903 }
904 var inp = java.lang.System["in"];
905 var reader = new BufferedReader(new InputStreamReader(inp));
906 if (multiline) {
907 var line = '';
908 while (true) {
909 java.lang.System.err.print(prompt);
910 java.lang.System.err.flush();
911 var tmp = reader.readLine();
912 if (tmp == '' || tmp == null) break;
913 line += tmp + '\n';
914 }
915 return line;
916 } else {
917 java.lang.System.err.print(prompt);
918 java.lang.System.err.flush();
919 return reader.readLine();
920 }
921 }
922
923 if (typeof(println) == 'undefined') {
924 // just synonym to print
925 this.println = print;
926 }
927