Source code: java/lang/Runtime.java
1 /* Runtime.java -- access to the VM process
2 Copyright (C) 1998, 2002, 2003, 2004, 2005 Free Software Foundation
3
4 This file is part of GNU Classpath.
5
6 GNU Classpath is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
9 any later version.
10
11 GNU Classpath is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GNU Classpath; see the file COPYING. If not, write to the
18 Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
19 02110-1301 USA.
20
21 Linking this library statically or dynamically with other modules is
22 making a combined work based on this library. Thus, the terms and
23 conditions of the GNU General Public License cover the whole
24 combination.
25
26 As a special exception, the copyright holders of this library give you
27 permission to link this library with independent modules to produce an
28 executable, regardless of the license terms of these independent
29 modules, and to copy and distribute the resulting executable under
30 terms of your choice, provided that you also meet, for each linked
31 independent module, the terms and conditions of the license of that
32 module. An independent module is a module which is not derived from
33 or based on this library. If you modify this library, you may extend
34 this exception to your version of the library, but you are not
35 obligated to do so. If you do not wish to do so, delete this
36 exception statement from your version. */
37
38
39 package java.lang;
40
41 import gnu.classpath.SystemProperties;
42 import gnu.classpath.VMStackWalker;
43
44 import java.io.File;
45 import java.io.IOException;
46 import java.io.InputStream;
47 import java.io.OutputStream;
48 import java.util.HashSet;
49 import java.util.Iterator;
50 import java.util.Set;
51 import java.util.StringTokenizer;
52
53 /**
54 * Runtime represents the Virtual Machine.
55 *
56 * @author John Keiser
57 * @author Eric Blake (ebb9@email.byu.edu)
58 * @author Jeroen Frijters
59 */
60 // No idea why this class isn't final, since you can't build a subclass!
61 public class Runtime
62 {
63 /**
64 * The library path, to search when loading libraries. We can also safely use
65 * this as a lock for synchronization.
66 */
67 private final String[] libpath;
68
69 /**
70 * The thread that started the exit sequence. Access to this field must
71 * be thread-safe; lock on libpath to avoid deadlock with user code.
72 * <code>runFinalization()</code> may want to look at this to see if ALL
73 * finalizers should be run, because the virtual machine is about to halt.
74 */
75 private Thread exitSequence;
76
77 /**
78 * All shutdown hooks. This is initialized lazily, and set to null once all
79 * shutdown hooks have run. Access to this field must be thread-safe; lock
80 * on libpath to avoid deadlock with user code.
81 */
82 private Set shutdownHooks;
83
84 /**
85 * The one and only runtime instance.
86 */
87 private static final Runtime current = new Runtime();
88
89 /**
90 * Not instantiable by a user, this should only create one instance.
91 */
92 private Runtime()
93 {
94 if (current != null)
95 throw new InternalError("Attempt to recreate Runtime");
96
97 // If used by underlying VM this contains the directories where Classpath's own
98 // native libraries are located.
99 String bootPath = SystemProperties.getProperty("gnu.classpath.boot.library.path", "");
100
101 // If properly set by the user this contains the directories where the application's
102 // native libraries are located. On operating systems where a LD_LIBRARY_PATH environment
103 // variable is available a VM should preset java.library.path with value of this
104 // variable.
105 String path = SystemProperties.getProperty("java.library.path", ".");
106 String pathSep = SystemProperties.getProperty("path.separator", ":");
107 String fileSep = SystemProperties.getProperty("file.separator", "/");
108
109 StringTokenizer t1 = new StringTokenizer(bootPath, pathSep);
110 StringTokenizer t2 = new StringTokenizer(path, pathSep);
111 libpath = new String[t1.countTokens() + t2.countTokens()];
112
113 int i = 0;
114 while(t1.hasMoreTokens()) {
115 String prefix = t1.nextToken();
116 if (! prefix.endsWith(fileSep))
117 prefix += fileSep;
118
119 libpath[i] = prefix;
120 i++;
121 }
122
123 while(t2.hasMoreTokens()) {
124 String prefix = t2.nextToken();
125 if (! prefix.endsWith(fileSep))
126 prefix += fileSep;
127
128 libpath[i] = prefix;
129 i++;
130 }
131 }
132
133 /**
134 * Get the current Runtime object for this JVM. This is necessary to access
135 * the many instance methods of this class.
136 *
137 * @return the current Runtime object
138 */
139 public static Runtime getRuntime()
140 {
141 return current;
142 }
143
144 /**
145 * Exit the Java runtime. This method will either throw a SecurityException
146 * or it will never return. The status code is returned to the system; often
147 * a non-zero status code indicates an abnormal exit. Of course, there is a
148 * security check, <code>checkExit(status)</code>.
149 *
150 * <p>First, all shutdown hooks are run, in unspecified order, and
151 * concurrently. Next, if finalization on exit has been enabled, all pending
152 * finalizers are run. Finally, the system calls <code>halt</code>.</p>
153 *
154 * <p>If this is run a second time after shutdown has already started, there
155 * are two actions. If shutdown hooks are still executing, it blocks
156 * indefinitely. Otherwise, if the status is nonzero it halts immediately;
157 * if it is zero, it blocks indefinitely. This is typically called by
158 * <code>System.exit</code>.</p>
159 *
160 * @param status the status to exit with
161 * @throws SecurityException if permission is denied
162 * @see #addShutdownHook(Thread)
163 * @see #runFinalizersOnExit(boolean)
164 * @see #runFinalization()
165 * @see #halt(int)
166 */
167 public void exit(int status)
168 {
169 SecurityManager sm = SecurityManager.current; // Be thread-safe!
170 if (sm != null)
171 sm.checkExit(status);
172
173 if (runShutdownHooks())
174 halt(status);
175
176 // Someone else already called runShutdownHooks().
177 // Make sure we are not/no longer in the shutdownHooks set.
178 // And wait till the thread that is calling runShutdownHooks() finishes.
179 synchronized (libpath)
180 {
181 if (shutdownHooks != null)
182 {
183 shutdownHooks.remove(Thread.currentThread());
184 // Interrupt the exit sequence thread, in case it was waiting
185 // inside a join on our thread.
186 exitSequence.interrupt();
187 // Shutdown hooks are still running, so we clear status to
188 // make sure we don't halt.
189 status = 0;
190 }
191 }
192
193 // If exit() is called again after the shutdown hooks have run, but
194 // while finalization for exit is going on and the status is non-zero
195 // we halt immediately.
196 if (status != 0)
197 halt(status);
198
199 while (true)
200 try
201 {
202 exitSequence.join();
203 }
204 catch (InterruptedException e)
205 {
206 // Ignore, we've suspended indefinitely to let all shutdown
207 // hooks complete, and to let any non-zero exits through, because
208 // this is a duplicate call to exit(0).
209 }
210 }
211
212 /**
213 * On first invocation, run all the shutdown hooks and return true.
214 * Any subsequent invocations will simply return false.
215 * Note that it is package accessible so that VMRuntime can call it
216 * when VM exit is not triggered by a call to Runtime.exit().
217 *
218 * @return was the current thread the first one to call this method?
219 */
220 boolean runShutdownHooks()
221 {
222 boolean first = false;
223 synchronized (libpath) // Synch on libpath, not this, to avoid deadlock.
224 {
225 if (exitSequence == null)
226 {
227 first = true;
228 exitSequence = Thread.currentThread();
229 if (shutdownHooks != null)
230 {
231 Iterator i = shutdownHooks.iterator();
232 while (i.hasNext()) // Start all shutdown hooks.
233 try
234 {
235 ((Thread) i.next()).start();
236 }
237 catch (IllegalThreadStateException e)
238 {
239 i.remove();
240 }
241 }
242 }
243 }
244 if (first)
245 {
246 if (shutdownHooks != null)
247 {
248 // Check progress of all shutdown hooks. As a hook completes,
249 // remove it from the set. If a hook calls exit, it removes
250 // itself from the set, then waits indefinitely on the
251 // exitSequence thread. Once the set is empty, set it to null to
252 // signal all finalizer threads that halt may be called.
253 while (true)
254 {
255 Thread[] hooks;
256 synchronized (libpath)
257 {
258 hooks = new Thread[shutdownHooks.size()];
259 shutdownHooks.toArray(hooks);
260 }
261 if (hooks.length == 0)
262 break;
263 for (int i = 0; i < hooks.length; i++)
264 {
265 try
266 {
267 synchronized (libpath)
268 {
269 if (!shutdownHooks.contains(hooks[i]))
270 continue;
271 }
272 hooks[i].join();
273 synchronized (libpath)
274 {
275 shutdownHooks.remove(hooks[i]);
276 }
277 }
278 catch (InterruptedException x)
279 {
280 // continue waiting on the next thread
281 }
282 }
283 }
284 synchronized (libpath)
285 {
286 shutdownHooks = null;
287 }
288 }
289 // Run finalization on all finalizable objects (even if they are
290 // still reachable).
291 VMRuntime.runFinalizationForExit();
292 }
293 return first;
294 }
295
296 /**
297 * Register a new shutdown hook. This is invoked when the program exits
298 * normally (because all non-daemon threads ended, or because
299 * <code>System.exit</code> was invoked), or when the user terminates
300 * the virtual machine (such as by typing ^C, or logging off). There is
301 * a security check to add hooks,
302 * <code>RuntimePermission("shutdownHooks")</code>.
303 *
304 * <p>The hook must be an initialized, but unstarted Thread. The threads
305 * are run concurrently, and started in an arbitrary order; and user
306 * threads or daemons may still be running. Once shutdown hooks have
307 * started, they must all complete, or else you must use <code>halt</code>,
308 * to actually finish the shutdown sequence. Attempts to modify hooks
309 * after shutdown has started result in IllegalStateExceptions.</p>
310 *
311 * <p>It is imperative that you code shutdown hooks defensively, as you
312 * do not want to deadlock, and have no idea what other hooks will be
313 * running concurrently. It is also a good idea to finish quickly, as the
314 * virtual machine really wants to shut down!</p>
315 *
316 * <p>There are no guarantees that such hooks will run, as there are ways
317 * to forcibly kill a process. But in such a drastic case, shutdown hooks
318 * would do little for you in the first place.</p>
319 *
320 * @param hook an initialized, unstarted Thread
321 * @throws IllegalArgumentException if the hook is already registered or run
322 * @throws IllegalStateException if the virtual machine is already in
323 * the shutdown sequence
324 * @throws SecurityException if permission is denied
325 * @since 1.3
326 * @see #removeShutdownHook(Thread)
327 * @see #exit(int)
328 * @see #halt(int)
329 */
330 public void addShutdownHook(Thread hook)
331 {
332 SecurityManager sm = SecurityManager.current; // Be thread-safe!
333 if (sm != null)
334 sm.checkPermission(new RuntimePermission("shutdownHooks"));
335 if (hook.isAlive() || hook.getThreadGroup() == null)
336 throw new IllegalArgumentException("The hook thread " + hook + " must not have been already run or started");
337 synchronized (libpath)
338 {
339 if (exitSequence != null)
340 throw new IllegalStateException("The Virtual Machine is exiting. It is not possible anymore to add any hooks");
341 if (shutdownHooks == null)
342 {
343 VMRuntime.enableShutdownHooks();
344 shutdownHooks = new HashSet(); // Lazy initialization.
345 }
346 if (! shutdownHooks.add(hook))
347 throw new IllegalArgumentException(hook.toString() + " had already been inserted");
348 }
349 }
350
351 /**
352 * De-register a shutdown hook. As when you registered it, there is a
353 * security check to remove hooks,
354 * <code>RuntimePermission("shutdownHooks")</code>.
355 *
356 * @param hook the hook to remove
357 * @return true if the hook was successfully removed, false if it was not
358 * registered in the first place
359 * @throws IllegalStateException if the virtual machine is already in
360 * the shutdown sequence
361 * @throws SecurityException if permission is denied
362 * @since 1.3
363 * @see #addShutdownHook(Thread)
364 * @see #exit(int)
365 * @see #halt(int)
366 */
367 public boolean removeShutdownHook(Thread hook)
368 {
369 SecurityManager sm = SecurityManager.current; // Be thread-safe!
370 if (sm != null)
371 sm.checkPermission(new RuntimePermission("shutdownHooks"));
372 synchronized (libpath)
373 {
374 if (exitSequence != null)
375 throw new IllegalStateException();
376 if (shutdownHooks != null)
377 return shutdownHooks.remove(hook);
378 }
379 return false;
380 }
381
382 /**
383 * Forcibly terminate the virtual machine. This call never returns. It is
384 * much more severe than <code>exit</code>, as it bypasses all shutdown
385 * hooks and initializers. Use caution in calling this! Of course, there is
386 * a security check, <code>checkExit(status)</code>.
387 *
388 * @param status the status to exit with
389 * @throws SecurityException if permission is denied
390 * @since 1.3
391 * @see #exit(int)
392 * @see #addShutdownHook(Thread)
393 */
394 public void halt(int status)
395 {
396 SecurityManager sm = SecurityManager.current; // Be thread-safe!
397 if (sm != null)
398 sm.checkExit(status);
399 VMRuntime.exit(status);
400 }
401
402 /**
403 * Tell the VM to run the finalize() method on every single Object before
404 * it exits. Note that the JVM may still exit abnormally and not perform
405 * this, so you still don't have a guarantee. And besides that, this is
406 * inherently unsafe in multi-threaded code, as it may result in deadlock
407 * as multiple threads compete to manipulate objects. This value defaults to
408 * <code>false</code>. There is a security check, <code>checkExit(0)</code>.
409 *
410 * @param finalizeOnExit whether to finalize all Objects on exit
411 * @throws SecurityException if permission is denied
412 * @see #exit(int)
413 * @see #gc()
414 * @since 1.1
415 * @deprecated never rely on finalizers to do a clean, thread-safe,
416 * mop-up from your code
417 */
418 public static void runFinalizersOnExit(boolean finalizeOnExit)
419 {
420 SecurityManager sm = SecurityManager.current; // Be thread-safe!
421 if (sm != null)
422 sm.checkExit(0);
423 VMRuntime.runFinalizersOnExit(finalizeOnExit);
424 }
425
426 /**
427 * Create a new subprocess with the specified command line. Calls
428 * <code>exec(cmdline, null, null)</code>. A security check is performed,
429 * <code>checkExec</code>.
430 *
431 * @param cmdline the command to call
432 * @return the Process object
433 * @throws SecurityException if permission is denied
434 * @throws IOException if an I/O error occurs
435 * @throws NullPointerException if cmdline is null
436 * @throws IndexOutOfBoundsException if cmdline is ""
437 */
438 public Process exec(String cmdline) throws IOException
439 {
440 return exec(cmdline, null, null);
441 }
442
443 /**
444 * Create a new subprocess with the specified command line and environment.
445 * If the environment is null, the process inherits the environment of
446 * this process. Calls <code>exec(cmdline, env, null)</code>. A security
447 * check is performed, <code>checkExec</code>.
448 *
449 * @param cmdline the command to call
450 * @param env the environment to use, in the format name=value
451 * @return the Process object
452 * @throws SecurityException if permission is denied
453 * @throws IOException if an I/O error occurs
454 * @throws NullPointerException if cmdline is null, or env has null entries
455 * @throws IndexOutOfBoundsException if cmdline is ""
456 */
457 public Process exec(String cmdline, String[] env) throws IOException
458 {
459 return exec(cmdline, env, null);
460 }
461
462 /**
463 * Create a new subprocess with the specified command line, environment, and
464 * working directory. If the environment is null, the process inherits the
465 * environment of this process. If the directory is null, the process uses
466 * the current working directory. This splits cmdline into an array, using
467 * the default StringTokenizer, then calls
468 * <code>exec(cmdArray, env, dir)</code>. A security check is performed,
469 * <code>checkExec</code>.
470 *
471 * @param cmdline the command to call
472 * @param env the environment to use, in the format name=value
473 * @param dir the working directory to use
474 * @return the Process object
475 * @throws SecurityException if permission is denied
476 * @throws IOException if an I/O error occurs
477 * @throws NullPointerException if cmdline is null, or env has null entries
478 * @throws IndexOutOfBoundsException if cmdline is ""
479 * @since 1.3
480 */
481 public Process exec(String cmdline, String[] env, File dir)
482 throws IOException
483 {
484 StringTokenizer t = new StringTokenizer(cmdline);
485 String[] cmd = new String[t.countTokens()];
486 for (int i = 0; i < cmd.length; i++)
487 cmd[i] = t.nextToken();
488 return exec(cmd, env, dir);
489 }
490
491 /**
492 * Create a new subprocess with the specified command line, already
493 * tokenized. Calls <code>exec(cmd, null, null)</code>. A security check
494 * is performed, <code>checkExec</code>.
495 *
496 * @param cmd the command to call
497 * @return the Process object
498 * @throws SecurityException if permission is denied
499 * @throws IOException if an I/O error occurs
500 * @throws NullPointerException if cmd is null, or has null entries
501 * @throws IndexOutOfBoundsException if cmd is length 0
502 */
503 public Process exec(String[] cmd) throws IOException
504 {
505 return exec(cmd, null, null);
506 }
507
508 /**
509 * Create a new subprocess with the specified command line, already
510 * tokenized, and specified environment. If the environment is null, the
511 * process inherits the environment of this process. Calls
512 * <code>exec(cmd, env, null)</code>. A security check is performed,
513 * <code>checkExec</code>.
514 *
515 * @param cmd the command to call
516 * @param env the environment to use, in the format name=value
517 * @return the Process object
518 * @throws SecurityException if permission is denied
519 * @throws IOException if an I/O error occurs
520 * @throws NullPointerException if cmd is null, or cmd or env has null
521 * entries
522 * @throws IndexOutOfBoundsException if cmd is length 0
523 */
524 public Process exec(String[] cmd, String[] env) throws IOException
525 {
526 return exec(cmd, env, null);
527 }
528
529 /**
530 * Create a new subprocess with the specified command line, already
531 * tokenized, and the specified environment and working directory. If the
532 * environment is null, the process inherits the environment of this
533 * process. If the directory is null, the process uses the current working
534 * directory. A security check is performed, <code>checkExec</code>.
535 *
536 * @param cmd the command to call
537 * @param env the environment to use, in the format name=value
538 * @param dir the working directory to use
539 * @return the Process object
540 * @throws SecurityException if permission is denied
541 * @throws IOException if an I/O error occurs
542 * @throws NullPointerException if cmd is null, or cmd or env has null
543 * entries
544 * @throws IndexOutOfBoundsException if cmd is length 0
545 * @since 1.3
546 */
547 public Process exec(String[] cmd, String[] env, File dir)
548 throws IOException
549 {
550 SecurityManager sm = SecurityManager.current; // Be thread-safe!
551 if (sm != null)
552 sm.checkExec(cmd[0]);
553 return VMRuntime.exec(cmd, env, dir);
554 }
555
556 /**
557 * Returns the number of available processors currently available to the
558 * virtual machine. This number may change over time; so a multi-processor
559 * program want to poll this to determine maximal resource usage.
560 *
561 * @return the number of processors available, at least 1
562 */
563 public int availableProcessors()
564 {
565 return VMRuntime.availableProcessors();
566 }
567
568 /**
569 * Find out how much memory is still free for allocating Objects on the heap.
570 *
571 * @return the number of bytes of free memory for more Objects
572 */
573 public long freeMemory()
574 {
575 return VMRuntime.freeMemory();
576 }
577
578 /**
579 * Find out how much memory total is available on the heap for allocating
580 * Objects.
581 *
582 * @return the total number of bytes of memory for Objects
583 */
584 public long totalMemory()
585 {
586 return VMRuntime.totalMemory();
587 }
588
589 /**
590 * Returns the maximum amount of memory the virtual machine can attempt to
591 * use. This may be <code>Long.MAX_VALUE</code> if there is no inherent
592 * limit (or if you really do have a 8 exabyte memory!).
593 *
594 * @return the maximum number of bytes the virtual machine will attempt
595 * to allocate
596 */
597 public long maxMemory()
598 {
599 return VMRuntime.maxMemory();
600 }
601
602 /**
603 * Run the garbage collector. This method is more of a suggestion than
604 * anything. All this method guarantees is that the garbage collector will
605 * have "done its best" by the time it returns. Notice that garbage
606 * collection takes place even without calling this method.
607 */
608 public void gc()
609 {
610 VMRuntime.gc();
611 }
612
613 /**
614 * Run finalization on all Objects that are waiting to be finalized. Again,
615 * a suggestion, though a stronger one than {@link #gc()}. This calls the
616 * <code>finalize</code> method of all objects waiting to be collected.
617 *
618 * @see #finalize()
619 */
620 public void runFinalization()
621 {
622 VMRuntime.runFinalization();
623 }
624
625 /**
626 * Tell the VM to trace every bytecode instruction that executes (print out
627 * a trace of it). No guarantees are made as to where it will be printed,
628 * and the VM is allowed to ignore this request.
629 *
630 * @param on whether to turn instruction tracing on
631 */
632 public void traceInstructions(boolean on)
633 {
634 VMRuntime.traceInstructions(on);
635 }
636
637 /**
638 * Tell the VM to trace every method call that executes (print out a trace
639 * of it). No guarantees are made as to where it will be printed, and the
640 * VM is allowed to ignore this request.
641 *
642 * @param on whether to turn method tracing on
643 */
644 public void traceMethodCalls(boolean on)
645 {
646 VMRuntime.traceMethodCalls(on);
647 }
648
649 /**
650 * Load a native library using the system-dependent filename. This is similar
651 * to loadLibrary, except the only name mangling done is inserting "_g"
652 * before the final ".so" if the VM was invoked by the name "java_g". There
653 * may be a security check, of <code>checkLink</code>.
654 *
655 * <p>
656 * The library is loaded using the class loader associated with the
657 * class associated with the invoking method.
658 *
659 * @param filename the file to load
660 * @throws SecurityException if permission is denied
661 * @throws UnsatisfiedLinkError if the library is not found
662 */
663 public void load(String filename)
664 {
665 load(filename, VMStackWalker.getCallingClassLoader());
666 }
667
668 /**
669 * Same as <code>load(String)</code> but using the given loader.
670 *
671 * @param filename the file to load
672 * @param loader class loader, or <code>null</code> for the boot loader
673 * @throws SecurityException if permission is denied
674 * @throws UnsatisfiedLinkError if the library is not found
675 */
676 void load(String filename, ClassLoader loader)
677 {
678 SecurityManager sm = SecurityManager.current; // Be thread-safe!
679 if (sm != null)
680 sm.checkLink(filename);
681 if (loadLib(filename, loader) == 0)
682 throw new UnsatisfiedLinkError("Could not load library " + filename);
683 }
684
685 /**
686 * Do a security check on the filename and then load the native library.
687 *
688 * @param filename the file to load
689 * @param loader class loader, or <code>null</code> for the boot loader
690 * @return 0 on failure, nonzero on success
691 * @throws SecurityException if file read permission is denied
692 */
693 private static int loadLib(String filename, ClassLoader loader)
694 {
695 SecurityManager sm = SecurityManager.current; // Be thread-safe!
696 if (sm != null)
697 sm.checkRead(filename);
698 return VMRuntime.nativeLoad(filename, loader);
699 }
700
701 /**
702 * Load a native library using a system-independent "short name" for the
703 * library. It will be transformed to a correct filename in a
704 * system-dependent manner (for example, in Windows, "mylib" will be turned
705 * into "mylib.dll"). This is done as follows: if the context that called
706 * load has a ClassLoader cl, then <code>cl.findLibrary(libpath)</code> is
707 * used to convert the name. If that result was null, or there was no class
708 * loader, this searches each directory of the system property
709 * <code>java.library.path</code> for a file named
710 * <code>System.mapLibraryName(libname)</code>. There may be a security
711 * check, of <code>checkLink</code>.
712 *
713 * <p>Note: Besides <code>java.library.path</code> a VM may chose to search
714 * for native libraries in a path that is specified by the
715 * <code>gnu.classpath.boot.library.path</code> system property. However
716 * this is for internal usage or development of GNU Classpath only.
717 * <b>A Java application must not load a non-system library by changing
718 * this property otherwise it will break compatibility.</b></p>
719 *
720 * <p>
721 * The library is loaded using the class loader associated with the
722 * class associated with the invoking method.
723 *
724 * @param libname the library to load
725 *
726 * @throws SecurityException if permission is denied
727 * @throws UnsatisfiedLinkError if the library is not found
728 *
729 * @see System#mapLibraryName(String)
730 * @see ClassLoader#findLibrary(String)
731 */
732 public void loadLibrary(String libname)
733 {
734 loadLibrary(libname, VMStackWalker.getCallingClassLoader());
735 }
736
737 /**
738 * Same as <code>loadLibrary(String)</code> but using the given loader.
739 *
740 * @param libname the library to load
741 * @param loader class loader, or <code>null</code> for the boot loader
742 * @throws SecurityException if permission is denied
743 * @throws UnsatisfiedLinkError if the library is not found
744 */
745 void loadLibrary(String libname, ClassLoader loader)
746 {
747 SecurityManager sm = SecurityManager.current; // Be thread-safe!
748 if (sm != null)
749 sm.checkLink(libname);
750 String filename;
751 if (loader != null && (filename = loader.findLibrary(libname)) != null)
752 {
753 if (loadLib(filename, loader) != 0)
754 return;
755 }
756 else
757 {
758 filename = VMRuntime.mapLibraryName(libname);
759 for (int i = 0; i < libpath.length; i++)
760 if (loadLib(libpath[i] + filename, loader) != 0)
761 return;
762 }
763 throw new UnsatisfiedLinkError("Native library `" + libname
764 + "' not found (as file `" + filename + "') in gnu.classpath.boot.library.path and java.library.path");
765 }
766
767 /**
768 * Return a localized version of this InputStream, meaning all characters
769 * are localized before they come out the other end.
770 *
771 * @param in the stream to localize
772 * @return the localized stream
773 * @deprecated <code>InputStreamReader</code> is the preferred way to read
774 * local encodings
775 * @XXX This implementation does not localize, yet.
776 */
777 public InputStream getLocalizedInputStream(InputStream in)
778 {
779 return in;
780 }
781
782 /**
783 * Return a localized version of this OutputStream, meaning all characters
784 * are localized before they are sent to the other end.
785 *
786 * @param out the stream to localize
787 * @return the localized stream
788 * @deprecated <code>OutputStreamWriter</code> is the preferred way to write
789 * local encodings
790 * @XXX This implementation does not localize, yet.
791 */
792 public OutputStream getLocalizedOutputStream(OutputStream out)
793 {
794 return out;
795 }
796 } // class Runtime