Note: Before using this information and the product it supports, be sure to read the general information under Notices.
This edition of the README applies to the IBM zSeries Developer Kit for Linux, Java 2 Technology Edition, and to all subsequent releases and modifications until otherwise indicated in new editions.
(c) Copyright Sun Microsystems, Inc. 1997, 2002, 901 San Antonio Rd., Palo Alto, CA 94303 USA. All rights reserved.
(c) Copyright International Business Machines Corporation, 1999, 2002. All rights reserved.
U.S. Government Users Restricted Rights - Use, duplication or disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
This README file provides information about the IBM(R) zSeries Developer Kit for Linux, Java(TM) 2 Technology Edition, (Developer Kit for Linux) at the Sun 1.3.1 SDK level.
The Developer Kit for Linux enables you to write and then run Java applications and applets. Note that the Runtime Environment for Linux is a subset of this Developer Kit and enables you only to run Java applications. If you have installed the Developer Kit for Linux, you do not need the Runtime Environment.
For the list of distributions against which the Developer Kit for Linux has been tested, see:
http://www-106.ibm.com/developerworks/java/jdk/linux/tested.html
The Developer Kit for Linux is a development environment for writing applets and applications that conform to Sun's Java 1.3.1 Core Application Programming Interface (API).
Applets that depend on Sun's Java 1.3.1 APIs work only on browsers that support Java 1.3.1 APIs.
To see the document on compatibility select the link and follow the steps below:
X11R6 3.3.x, provided by XFree86 | Currently included in all of the supported products |
C Runtime Library (libc) version 2.1.3-176 or later | Currently included in all of the supported products
If you do not have the C Runtime Library (libc) version 2.1.3-176 or later, you must upgrade before using the Developer Kit for Linux. To determine the level of glibc on your system, type the following from within any shell: rpm -q libc Newer versions of libc can be compiled to provide "floating stacks" support. This version of Java will not run when floating stacks support is enabled. |
Linux kernel 2.2.16 The 2.4 kernel has not been tested. |
2.2.16 currently included in all of the supported products. |
The following list describes the contents of the Developer Kit package.
Compiles programs written in the Java programming language into bytecodes (compiled Java code).
Executes Java bytecodes. The Java Interpreter runs programs written in the Java programming language.
Use for testing and running applets.
Helps debug your Java programs.
Disassembles compiled files and prints a representation of the bytecodes.
Parses the declarations and documentation comments in a set of source files and produces a set of HTML pages describing the public and protected classes, interfaces, constructors, methods, and fields. Also produces a class hierarchy and an index of all members.
Attaches native methods to code written in the Java programming language.
Generates signatures for Java Archive (JAR) files, and verifies the signatures of signed JAR files.
Manages entities, including their keys, certificates, and the trust associated with them.
Manages a keystore (database) of private keys and their associated X.509 certificate chains authenticating the corresponding public keys.
Creates and modifies the external policy configuration files that define your installation's Java security policy.
Converts a native encoding file to an ASCII file that includes the \udddd Unicode notation.
Generates objects from the names of compiled classes that contain remote object implementations. Includes RMI over Internet Inter-ORB Protocol (IIOP), or RMI-IIOP, support.
Starts the activation system daemon so that objects can be registered and activated in a Java virtual machine (JVM).
Compiles Object Management Group (OMG) Interface Definition Language (IDL) files to Java code.
Starts the CORBA transient naming service.
Creates and starts a remote object registry on the specified port of the current host.
Returns the serialVersionUID for one or more classes in a form that is suitable for copying into an evolving class.
Detects version conflicts between a target jar file and currently installed extension jar files.
This file.
Copyright notice for the Developer Kit for Linux software.
The LICENSE_xx.html file contains the license agreement for the Developer Kit for Linux software. (xx is an abbreviation for the language.)
To view or print the license agreement, open the file in a Web browser.
A text file that describes any defects fixed after the initial release of this version.
Note: This README file and the accompanying license, copyright files, and demo directory are the only documentation included in this Developer Kit for Linux. You can view Sun's software documentation by visiting the Sun Web site, or you can download Sun's Software documentation package from the following Sun Web site:
The documentation package is designed to be extracted into the Developer Kit for Linux software installation directory. If you download the zip file archive version, be sure to preserve the file path names when you extract the files from the archive. If you use pkunzip, specify the -d option.
The Developer Kit for Linux includes the IBM just-in-time (JIT) compiler (libjitc.so). The JIT compiler generates machine code dynamically for frequently used bytecode sequences in a Java application or applet while it is running.
All Developer Kit for Linux tools can disable the JIT to isolate a problem with a Java application, an applet, or the compiler itself. To disable the JIT, type the following at a shell prompt.
export JAVA_COMPILER=NONE
To enable the JIT, type the following at a shell prompt:
export JAVA_COMPILER=jitc
To determine if the JIT is enabled, type the following at a shell prompt:
java -version
If a JIT is enabled, one of the following messages is displayed:
(JIT enabled: jitc)
compiler = enabled: jitc
If a JIT is not enabled, one of the following messages is displayed:
(JIT disabled)
compiler = disabled
After you install the Developer Kit for Linux, edit your shell script and add the directory where you installed the Developer Kit to your PATH statement. For more information about the PATH statement, see PATH considerations.
The Developer Kit For Linux can display all Unicode characters, but most versions of Linux install only the fonts needed to show your language. You can download fonts from IBM that let you to see the complete Unicode character set. These fonts are not included in the Runtime Environment for Linux package because they are large and not needed by all users. IBM supplies two Unicode fonts, and each of them is customized by country. Users in China and Korea should use the country-specific versions, and all others should use the Japanese version of these fonts.
If you did not download fonts, you can get them from the DeveloperWorks Web site at http://www.ibm.com/developer/java/ associated with the IBM Developer Kit for Linux(R), Java(TM) 2 Technology Edition, Version 1.3.1. Descriptions of the fonts are provided to help you decide which fonts to download.
To install a font, put the file in the /opt/IBMJava2-s390-131/jre/lib/fonts directory.
If you download fonts in parts, you must first put the fonts back together into one file. To put the file back together, be sure it is in the /opt/IBMJava2-s390-131/jre/lib/fonts directory and use the cat command.
For example, if you downloaded the Times New Roman WorldType (for Japan and other countries) font in parts, type the following command to put it back together:
cat tmrmtwt_j.t01 tmrmtwt_j.t02 > tmrmtwt_j.ttf
When you are installing on a Red Hat system, to allow the font server to find the Java TrueType fonts, run:
You must do this at install time and you must be root
to run the command.
If you intend to use the BEA Weblogic server, when you install the Developer Kit for Linux packages you must unselect the JAAS optional installation. The BEA Weblogic server contains its own implementation of JAAS.
The process you use to remove the Developer Kit for Linux depends on whether you installed the installable Red Hat Package Manager (RPM) package or the compressed Tape Archive (TAR) package. See Uninstalling the installable Red Hat Package Manager (RPM) package or Uninstalling the compressed TAR package for instructions.
To uninstall the Developer Kit for Linux if you installed the installable RPM package:
rpm -qa | grep IBMThe name of the package is displayed.
rpm -e pkgnamewhere pkgname is the name of the package that was displayed.
To uninstall the Developer Kit for Linux if you installed the compressed TAR package:
The Java tools are programs that are run from a shell prompt; they do not have a Graphical User Interface (GUI).
The following sections give information on using the Developer Kit for Linux.
After installing the Developer Kit for Linux, you can run a tool by typing its name at a shell prompt with a filename as an argument.
You can specify the path to a tool by typing the path before the name of the tool each time. For example, if the Developer Kit for Linux software is installed in /opt/IBMJava2-s390-131/bin, you can compile a file named myfile.java by typing the following at a shell prompt:
/opt/IBMJava2-s390-131/bin/javac myfile.java
To avoid typing the full path each time:
javac myfile.java
The PATH environment variable enables Linux to find executable files, such as javac, java, and javadoc, from any current directory. To display the current value of your PATH, type the following at a shell prompt:
echo $PATH
To change the PATH environment variable:
The CLASSPATH tells the Developer Kit for Linux tools, such as java, javac, and javadoc, where to find the Java class libraries. If you keep the bin and lib directories under the same parent directory level, the executable files can find the classes.
You need to explicitly set the CLASSPATH only if one of the following applies:
To display the current value of your CLASSPATH, type the following at a shell prompt:
echo $CLASSPATH
If you plan to develop and run applications using different runtime environments, including other versions that you have installed separately, you need to set the CLASSPATH (and PATH) explicitly for each application. If you plan to run multiple applications simultaneously using different runtime environments, be sure each application is run in its own shell.
If you want to run only one version of Java at a time, you can use a shell script to switch between the different runtime environments.
With the Applet Viewer, you can run one or more applets that are called by reference in a Web page (HTML file) using the APPLET tag. The Applet Viewer finds the APPLET tags in the HTML file and runs the applets, in separate windows.
Because the Applet Viewer is for viewing applets, it cannot display an entire Web page that contains numerous HTML tags. It parses only the APPLET tag and no other HTML on the Web page.
To run an applet with the Applet Viewer, type the following at a shell prompt:
appletviewer name
where name is one of the following:
For example, to invoke the Applet Viewer on an HTML file that calls an applet, type the following at a shell prompt:
appletviewer $HOME/filename.htmlwhere filename is the name of the HTML file.
For example, http://java.sun.com/applets/NervousText/example1.html
is the URL of
a Web page that calls an applet. To invoke the Applet Viewer on this Web page,
type the following at a shell prompt:
appletviewer http://java.sun.com/applets/NervousText/example1.html
You can debug applets using the -debug option of Applet Viewer. When debugging applets, it is best to invoke Applet Viewer from the directory that contains the HTML file that calls the applet. For example:
cd demo/TicTacToe ../../bin/appletviewer -debug example1.html
You might find documentation on the debugger and its API at the following Sun Web site (see http://java.sun.com for any legal statements regarding this information):
To obtain the IBM build and version number, type the following at a shell prompt:
java -version
On a non-floating stack Linux system, regardless of what is set for -Xss, a minimum native stack size of 256KB for each thread is provided. On a floating stack Linux system, the -Xss values are honored. Thus, if you are migrating from a non-floating stack Linux system, you must ensure that any -Xss values are large enough and are not relying on a minimum of 256KB.
To debug Java programs, you can use the Java Debugger (JDB) application. This debugger communicates with the Java Platform Debugger Architecture (JPDA) provided by the Developer Kit for Linux. For native JNI binary programs, you can still use gdb for debugging.
The JPDA classes are included in the tools.jar file, which must be included in the CLASSPATH when running Java programs that use the JPDA (for example, JDB). Only socket communication is supported on Linux.
A new JDB application is included in the Developer Kit for Linux. The JDB application runs the class com.sun.tools.example.debug.tty.TTY. The Java Virtual Machine Debugging Interface (JVMDI) is now fully supported. The jdb tool included in earlier versions is now included as oldjdb.
The new JDB application uses the JPDA and enables the jdb example tool to attach to a listening Virtual Machine (VM) or to start a new debug session. It is invoked by the jdb command and can be used in the same way as the oldjdb.
You can use the JDB application to debug remote Java applications, including Java applications running on remote machines over a TCP/IP link. To debug a remote Java program,start the java program as follows:
java-Xdebug-Xnoagent-Xrunjdwp:transport=dt_socket,server=y,suspend=y -Djava.compiler=NONE <other args> <myapp> <myapp class args>
The port on which the JPDA is listening is displayed. At the remote debugging machine, type:
jdb -attach <machine name or ip address>:<port>
When you launch a debug session using the dt_socket transport, be sure that the specified ports are actually free to use.
On double-byte character set (DBCS) systems, if you want to switch the input method, you must set an environment variable that represents the keycode you use for switching. Optionally, you can set another environment variable that represents the modifiers of the keycode.
To specify the keycode to use for switching, set the IBMJAVA_INPUTMETHOD_SWITCHKEY environment variable to a keycode definition in the java.awt.event.KeyEvent class, for example, VK_F4.
Optionally, specify modifiers of the keycode. To specify modifiers of the keycode, set the IBMJAVA_INPUTMETHOD_SWITCHKEY_MODIFIERS environment variable to any combination of the following three mask definitions in the java.awt.event.InputEvent class:
Separate the masks by commas.
For example, you might set the IBMJAVA_INPUTMETHOD_SWITCHKEY_MODIFIERS environment variable to ALT_MASK, CTRL_MASK.
During Java initialization, the two environment variables are stored. To be sure you have set the environment variables correctly, press a key and check it with the key combination you specified. If it matches, a Java pop-up menu with selectable input methods is displayed.
This Developer Kit does not ship Devanagari fonts (Devamt.ttf and Devamtb.ttf) in the jre/lib/fonts directory. Instead, where appropriate, Java uses the Monotype Unicode fonts (Times New Roman WorldType and Sans Monospace WorldType) shipped with the IBM platform or IBM software product to support Devanagari (Hindi) fonts.
The IBM Runtime Environment for Linux, Java 2 Technology Edition, V1.3.1 introduces the -Xgcpolicy JVM runtime option for specifying garbage collection policy.
-Xgcpolicy takes two values, optthruput (the default) and optavgpause. The option controls garbage collector behavior, making tradeoffs between throughput of the application and overall system and the pause times caused by garbage collection.
The format of the option and its values is:
-Xgcpolicy:optthruputand
-Xgcpolicy:optavgpause
When an application's attempt to create an object cannot be satisfied immediately from the available space in the heap, the garbage collector is responsible for identifying unreferenced objects (garbage), deleting them, and returning the heap to a state in which the immediate and subsequent allocation requests can be satisfied quickly. Such garbage collection cycles introduce occasional unexpected pauses in the execution of application code. As applications grow in size and complexity, and heaps become correspondingly larger, this garbage collection pause time tends to grow in size and significance. The default garbage collection value, optthruput, delivers very high throughput to applications, but at the cost of these occasional pauses, which can vary from a few milliseconds to many seconds, depending on the size of the heap and the quantity of garbage.
The optavgpause value substantially reduces the time spent in these garbage collection pauses, as well as limiting the effect of increasing heap size on the length of the garbage collection pause. This is particularly relevant to configurations with large heaps. (Consider a heap as large when it is at least 1 GB.) The pause times are reduced by overlapping garbage collection activities with normal program execution. This overlapping results in a small reduction to application throughput.
If the Java heap becomes nearly full, and there is very little garbage to be reclaimed, requests for new objects might not be satisfied quickly because there is no space immediately available. If the heap is operated at near-full capacity, application performance might suffer regardless of which of the above options is used; and, if requests for more heap space continue to be made, the application receives an Out of Memory exception, which results in JVM termination if the exception is not caught and handled. In these situations, you are recommended either to increase the heap size using the -Xmx option or to reduce the number of application objects in use.
For information on heap size tuning and the implications of garbage collection for application performance, see:
IBM Developer Kit for Windows, Java 2 Technology Edition, Version 1.3.1, 32-bit version adds support for these CORBA specifications:
This Developer Kit supports all versions of GIOP, as defined by chapters 13 and 15 of the CORBA 2.3.1 specification, OMG document formal/99-10-07, which you can obtain from:
http://cgi.omg.org/cgi-bin/doc?formal/99-10-07
Bi-directional GIOP is not supported.
This Developer Kit supports Portable Interceptors, as defined by the OMG in the document formal/01-09-58, which you can obtain from:
http://cgi.omg.org/cgi-bin/doc?formal/01-09-58
Portable Interceptors are hooks into the ORB through which ORB services can intercept the normal flow of execution of the ORB.
Several new classes are introduced in the API to support Portable Interceptors. These are:
These classes are not part of the Sun Java 1.3 Core API, and could change in future versions of the IBM Developer Kit.
This Developer Kit has added support for the Interoperable Naming Service, as defined by the OMG in the document ptc/00-08-07, which you can obtain from:
http://cgi.omg.org/cgi-bin/doc?ptc/00-08-07
The default port used by the Transient Name Server (the tnameserv
command), when no ORBInitialPort parameter is given, has changed from 900 to 2809, which is the port number registered with the IANA (Internet Assigned Number Authority) for a CORBA Naming Service. Programs that depend on this default might have to be updated to work with this version.
Several new classes are introduced in the API to support the Interoperable Naming Service:
These classes are not part of the Sun Java 1.3 Core API, and could change in future versions of the IBM Developer Kit.
The initial context returned from the Transient Name Server is now an org.omg.CosNaming.NamingContextExt
. Existing programs that narrow the reference to an org.omg.CosNaming.NamingContext
will still work, and do not need to be recompiled.
The ORB supports the -ORBInitRef and -ORBDefaultInitRef parameters defined by the Interoperable Naming Service specification, and the ORB::string_to_object operation now supports the ObjectURL string formats (corbaloc: and corbaname:) defined by the Interoperable Naming Service specification.
The OMG specifies a method ORB::register_initial_reference to register a service with the Interoperable Naming Service. However this method is not available in the Sun Java Core API at version 1.3.1. Programs that need to register a service in the current version must invoke this method on the IBM internal ORB implementation class. For example, to register a service "MyService":
where orb
is an instance of org.omg.CORBA.ORB
, returned from ORB.init()
, and serviceRef
is a CORBA Object, connected to the ORB.
This mechanism is an interim one, and is not compatible with future versions or portable to non-IBM ORBs.
A new runtime debug feature provides improved serviceability. You might find it useful for problem diagnosis or it might be requested by IBM service personnel. Tracing is controlled by three system properties. Set com.ibm.CORBA.Debug=true
to turn on tracing. To format and add to the trace GIOP messages sent and received, set com.ibm.CORBA.CommTrace=true
. By default, ORB tracing goes to the standard error stream, java.lang.System.err
. To direct it to a file, set com.ibm.CORBA.Debug.Output
. For example, to trace events and formatted GIOP messages to a file:
The trace will be sent to the files orbtrc.DDMMYYYY.HHmm.SS.txt and orbmsg.DDMMYYYY.HHmm.SS.txt.
Do not turn on tracing for normal operation, because it might cause performance degradation.
The content and format of the trace output could vary from version to version.
The following properties help you to tune the ORB:
The default fragment size is 1024 bytes. You can turn off fragmentation by setting the fragment size to 0.
By default, the ORB waits indefinitely for a response. Do not set the timeout too low, or connections might be ended unnecessarily.
If this property is set, the ORB starts listening as soon as it is initialized. Otherwise, it starts listening only when required.
When running with a Java 2 SecurityManager, invocation of some methods in the CORBA API classes might cause permission checks to be made, which could result in a SecurityException. Affected methods include the following:
Class/Interface |
Method |
Required permission |
---|---|---|
org.omg.CORBA.ORB |
init |
java.net.SocketPermission resolve |
org.omg.CORBA.ORB |
connect |
java.net.SocketPermission listen |
org.omg.CORBA.ORB |
resolve_initial_references |
java.net.SocketPermission connect |
org.omg.CORBA.portable.ObjectImpl |
_is_a |
java.net.SocketPermission connect |
org.omg.CORBA.portable.ObjectImpl |
_non_existent |
java.net.SocketPermission connect |
org.omg.CORBA.portable.ObjectImpl |
OutputStream _request (String, boolean) |
java.net.SocketPermission connect |
org.omg.CORBA.portable.ObjectImpl |
_get_interface_def |
java.net.SocketPermission connect |
org.omg.CORBA.Request |
invoke |
java.net.SocketPermission connect |
org.omg.CORBA.Request |
send_deferred |
java.net.SocketPermission connect |
org.omg.CORBA.Request |
send_oneway |
java.net.SocketPermission connect |
javax.rmi.PortableRemoteObject |
narrow |
java.net.SocketPermission connect |
If your program uses any of these methods, ensure that it is granted the necessary permissions.
The ORB implementation classes in this release are:
These are the default values, and you are advised not to set these properties or refer to the implementation classes directly. For portability, make references only to the CORBA API classes, and not to the implementation. Theses values might be changed in future releases.
Java Remote Method Invocation (RMI) provides a simple mechanism to do distributed Java programming. RMI over IIOP (RMI-IIOP) extends the base Java RMI to perform communication using the Common Object Request Broker Architecture (CORBA) standard Internet Inter-ORB Protocol (IIOP protocol). This allows direct interaction with any other CORBA Object Request Brokers (ORBs), whether they were implemented in Java or another programming language.
For information about IBM and RMI-IIOP, see this IBM Web site:
http://www.ibm.com/developerworks/java/rmi-iiop
The following documentation is available:
The Runtime Environment includes an enhanced BigDecimal class (com.ibm.math.BigDecimal) for Java programming. It is provided (with its supporting class MathContext) as an alternative to the java.math.BigDecimal class.
If you are using the java.math.BigDecimal class in a Java program, and you want to access the class, you must change the import statement in your source code as shown:
Change import java.math.*;
to import com.ibm.math.*;
You do not need to change any other code.
A Java application, unlike a Java applet, cannot rely on a Web browser for installation and runtime services. When you ship a Java application, your software package probably consists of the following parts:
To run your application, a user needs the Runtime Environment for Linux. The Developer Kit for Linux software contains a runtime environment. However, you cannot assume that your users have the Developer Kit for Linux software installed.
Your Developer Kit for Linux software license does not allow you to redistribute the Developer Kit for Linux software files. You should ensure that a licensed version of the Developer Kit for Linux is installed on the target machine.
If you encounter a problem after you install the Developer Kit for Linux, check the following list:
If you use the Applet Viewer to run an applet that is in the CLASSPATH, you might get an AccessControlException in Swing.
To work around this problem, be sure of the following:
Unable to load libjava.so library
message.
If you receive a message indicating that the libjava.so library could not be loaded because of a symbol not found, you might have a down-level version of the C Runtime Library, libc, installed. The Developer Kit for Linux thread implementation requires libc version 2.1.3-176 or later.
If the Applet Viewer does not load applets, type the following at a shell prompt:
java -verbose sun.applet.AppletViewer
This command lists the classes that are being loaded. From this output, you can determine which class the Applet Viewer is trying to load and where it is trying to load it from. Check to make sure that the class exists and is not damaged.
If you are writing a Java application, particularly a Java Native Interface (JNI) application, be sure that the application handles the EINTR return code correctly; otherwise the application will fail.
The following sections explain known limitations of the Developer Kit for Linux.
The maximum number of threads available is determined by the minimum of:
However, you might run out of virtual storage prior to reaching the maximum number of threads. Select the link and follow the steps below to possibly obtain additional information on adjusting these limits:
public interface interface java.lang.Runnable extends java.lang.Object...
On the Linux X Window System, the keymap is set to: 64 0xffe9 (Alt_L) 0xffe7 (Meta_L), and 113 0xffea (Alt_R) 0xffe8 (Meta_R). You can check this by typing the following at a shell prompt:
xmodmap -pk
This is why the Developer Kit for Linux considers that Meta is being pressed together with Alt. As a workaround, you can remove the Meta_x mapping by typing the following at a shell prompt:
xmodmap -e "keysym Alt_L = Alt_L" -e "keysym Alt_R = Alt_R"
Note: This workaround might affect other X-Windows applications running on the same display if they use the Meta-key that was removed.
Java applications that use many threads can exceed the systems memory capacity. Use the following formula to estimate the maximum number of threads a Java application can use:
heap_size(MB) + 2*thread_count < 910 (approximately)
When memory is exhausted, the JVM or the JIT will report an error condition similar to one of the following:
Exception in thread "main" java.lang.OutOfMemoryError at java.lang.Thread.start(Native Method) at serling.main(serling.java:29) COMPILER ERROR: java/io/ObjectStreamClass.compareClassNames - JIT: Out of memory, emitcode
It is the "out of memory" indication that is significant, not the specific files or methods that are named. It is also possible that other error messages may follow the above which do not indicate additional errors, but instead indicate secondary effects of the out of memory condition.
This release supports only US English and Japanese. Japanese language support was tested only with TurboLinux Server 6.1 for zSeries and S/390, and not tested with SuSE Linux 7.0. This was because, at present, only TurboLinux Server 6.1 for zSeries and S/390 supports Japanese.
Swing components can display Japanese fonts by installing the Japanese WorldType fonts. (See the section on Installing additional fonts). Installing Japanese WorldType fonts does not affect AWT components nor IM switching panels. To avoid this problem, additional Japanese TrueType fonts need to be installed.
TurboLinux Japan have made the Japanese TrueType fonts available from their website - http://www.turbolinux.co.jp (Search word : truetype)
S/390 does not have any natively attached graphical displays. Therefore a remote system, which has a graphical display, is required. There are two ways to display X applications on the remote systems.
TurboLinux Server 6.1 for zSeries and S/390 does not have any IM (Input Method) interface such as kinput2. As a result only the second option above has been tested for this release.
The following environments have been tested :
System | OS | Language | Window Manager | Host Attached Input Method Engine |
Java System | TurboLinux for S/390 | Japanese (EUC) | FVWM2 lesstif-mwm, twm (no kinput2) |
Canna 3.5 (no kinput2) |
Graphic Client | TurboLinux Server J6.5 | Japanese (EUC) | Sawfish1 with GNOME | Canna 3.5 with kinput2 FreeWnn with kinput2 |
On Japanese versions of Linux, you can use a Japanese input method such as Canna, ATOK12(TM) SE, Wnn4(TM), or Wnn6. Use the following sections to avoid problems when using these Japanese input methods.
To bring another window to the top, do one of the following:
If you are entitled to services for the Program code pursuant to the IBM Solutions Developer Program, contact the IBM Solutions Developer Program through your normal method of access or on the Web at http://www.developer.ibm.com.
If you have purchased a service contract (that is, IBM's Personal Systems Support Line or equivalent service by country), the terms and conditions of that service contract will determine what services, if any, you are entitled to receive with respect to the Program.
This information was developed for products and services offered in the U.S.A.
IBM may not offer the products, services, or features discussed in this document in other countries. Consult your local IBM representative for information on the products and services currently available in your area. Any reference to an IBM product, program, or service is not intended to state or imply that only that IBM product, program, or service may be used. Any functionally equivalent product, program, or service that does not infringe any IBM intellectual property right may be used instead. However, it is the user's responsibility to evaluate and verify the operation of any non-IBM product, program, or service.
IBM may have patents or pending patent applications covering subject matter in this document. The furnishing of this document does not give you any license to these patents. You can send license inquiries, in writing, to:
For license inquiries regarding double-byte (DBCS) information, contact the IBM Intellectual Property Department in your country or send inquiries, in writing, to:
The following paragraph does not apply to the United Kingdom or any other country where such provisions are inconsistent with local law:
INTERNATIONAL BUSINESS MACHINES CORPORATION PROVIDES THIS PUBLICATION "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Some states do not allow disclaimer of express or implied warranties in certain transactions, therefore, this statement may not apply to you.
This information could include technical inaccuracies or typographical errors. Changes are periodically made to the information herein; these changes will be incorporated in new editions of the information. IBM may make improvements and/or changes in the product(s) and/or the program(s) described in this information at any time without notice.
Any references in this information to non-IBM Web sites are provided for convenience only and do not in any manner serve as an endorsement of those Web sites. The materials at those Web sites are not part of the materials for this IBM product and use of those Web sites is at your own risk.
IBM may use or distribute any of the information you supply in any way it believes appropriate without incurring any obligation to you.
Licensees of this program who wish to have information about it for the purpose of enabling (i) the exchange of information between independently created programs and other programs (including this one) and (ii) the mutual use of the information which has been exchanged, should contact:
Such information may be available, subject to appropriate terms and conditions, including in some cases, payment of a fee.
The licensed program described in this document and all licensed material available for it are provided by IBM under terms of the IBM Customer Agreement, IBM International Program License Agreement or any equivalent agreement between us.
Any performance data contained herein was determined in a controlled environment. Therefore, the results obtained in other operating environments may vary significantly. Some measurements may have been made on development-level systems and there is no guarantee that these measurements will be the same on generally available systems. Furthermore, some measurement may have been estimated through extrapolation. Actual results may vary. Users of this document should verify the applicable data for their specific environment.
Information concerning non-IBM products was obtained from the suppliers of those products, their published announcements or other publicly available sources. IBM has not tested those products and cannot confirm the accuracy of performance, compatibility or any other claims related to non-IBM products. Questions on the capabilities of non-IBM products should be addressed to the suppliers of those products.
IBM is a trademark of International Business Machines Corporation in the United States, or other countries, or both.
Java and all Java-based trademarks and logos are trademarks or registered trademarks of Sun Microsystems, Inc. in the United States, other countries, or both. The Java technology is owned and exclusively licensed by Sun Microsystems, Inc.
Other company, product, and service names may be trademarks or service marks of others.
This product is also based in part on the work of the FreeType Project. For more information about FreeType see http://www.freetype.org.