Documentation/java.txt

Chinese translated version of Documentation/java.txt

If you have any comment or update to the content, please contact the
original document maintainer directly.  However, if you have a problem
communicating in English you can also ask the Chinese maintainer for
help.  Contact the Chinese maintainer if this translation is outdated
or if there is a problem with the translation.

Chinese maintainer: 秦芹 [e-mail]
---------------------------------------------------------------------
Documentation/java.txt的中文翻译

如果想评论或更新本文的内容，请直接联系原文档的维护者。如果你使用英文
交流有困难的话，也可以向中文版维护者求助。如果本翻译更新不及时或者翻
译存在问题，请联系中文版维护者。

中文版维护者： 秦芹 [e-mail]
中文版翻译者：秦芹 [e-mail]

以下为正文

---------------------------------------------------------------------

 Documentation/java.txt
 Java(tm) Binary Kernel Support for Linux v1.03
 Java（TM）二进制内核支持Linux V1.03
 ----------------------------------------------
 
   Linux beats them ALL! While all other OS's are TALKING about direct
   support of Java Binaries in the OS, Linux is doing it!
   Linux击败了所以其他系统！当所有其他操作系统正在讨论在操作系统上

   直接支持Java二进制时，Linux正在付诸于实践。
   You can execute Java applications and Java Applets just like any
   other program after you have done the following:
   你在像其他程序一样执行Java应用程序和Java小程序之前，你必须先完成如下步骤：
 1) You MUST FIRST install the Java Developers Kit for Linux.
    The Java on Linux HOWTO gives the details on getting and
    installing this. This HOWTO can be found at:
    你必须先安装Java开发工具包用于Linux。在Linux HOWTO上，

     Java给予获取和安装HOWTO的细节。HOWTO在如下地址可以找到：   

      ftp://sunsite.unc.edu/pub/Linux/docs/HOWTO/Java-HOWTO
 
    You should also set up a reasonable CLASSPATH environment
    variable to use Java applications that make use of any
    nonstandard classes (not included in the same directory
    as the application itself).
    你也应该设置一个合理的CLASSPATH环境变量来充分利用任何非标准类

    的Java应用程序（不包括跟应用程序自己的相同目录）。
 2) You have to compile BINFMT_MISC either as a module or into
    the kernel (CONFIG_BINFMT_MISC) and set it up properly.
    If you choose to compile it as a module, you will have
    to insert it manually with modprobe/insmod, as kmod
    cannot easily be supported with binfmt_misc.
    Read the file 'binfmt_misc.txt' in this directory to know
    more about the configuration process.
    你必须编译BINFMT_MISC生成一个模块或者直接编译进入内核（CONFIG_BINFMT_MISC），

    并且正确的设置它。如果你选择把他编译成一个模块，你将必须手动插入‘modprobe/insmod’命令，

    因为binfmt_misc不容易支持kmod。在这个目录下，阅读‘binfmt_misc.txt’文件来了解更多关于配置的过程。
 3) Add the following configuration items to binfmt_misc
    (you should really have read binfmt_misc.txt now):
 添加如下配置项到binfmt_misc文件（你目前本应该已经阅读了binfmt_misc.txt文件）：
    support for Java applications:
    支持Java应用程序的配置项: ':Java:M::\xca\xfe\xba\xbe::/usr/local/bin/javawrapper:'
    support for executable Jar files:
    支持可执行的Jar文件配置项： ':ExecutableJAR:E::jar::/usr/local/bin/jarwrapper:'
    support for Java Applets:
    支持Java小应用程序配置项 ':Applet:E::html::/usr/bin/appletviewer:'
    or the following, if you want to be more selective:
    或者如果你想有更多的选择性，添加如下配置项： ':Applet:M::<!--applet::/usr/bin/appletviewer:'
 
    Of course you have to fix the path names. The path/file names given in this
    document match the Debian 2.1 system. (i.e. jdk installed in /usr,
    custom wrappers from this document in /usr/local)
    当然，你必须确定路径名。路径或者文件名将在与Debian2.1系统匹配的文件中给出。

  （如：在/usr目录下安装jdk，在/usr/local下的文件为普通包装类）
    Note, that for the more selective applet support you have to modify
    existing html-files to contain <!--applet--> in the first line
    ('<' has to be the first character!) to let this work!
     请注意，为了使更多选择性的小应用程序能够起作用，你必须修改存在的html文件，

     使html文件的第一行包含<!--applet-->（第一个字符必须是'<'）！
    For the compiled Java programs you need a wrapper script like the
    following (this is because Java is broken in case of the filename
    handling), again fix the path names, both in the script and in the
    above given configuration string.
      无论是在脚本还是已经给出的配置字符串，为了编译Java程序，

      你都需要封装script脚本，如：在文件名毁坏情况下的处理，重新修复路径名。
    You, too, need the little program after the script. Compile like
    gcc -O2 -o javaclassname javaclassname.c
    and stick it to /usr/local/bin.
    执行脚本后，你也需要小程序。通过‘gcc -O2 -o javaclassname javaclassname.c’

    命令编译javaclassname.c文件，并且将其附加到/usr/local/bin目录下。
    Both the javawrapper shellscript and the javaclassname program
    were supplied by Colin J. Watson <[e-mail]>.
     javawrapper shell脚本和javaclassname程序都是由J.沃森<[e-mail]>提供
 ===================== 如下为javawrapper的内容 ===================
 #!/bin/bash
 # /usr/local/bin/javawrapper - the wrapper for binfmt_misc/java
 
 if [ -z "$1" ]; then
         exec 1>&2
         echo Usage: $0 class-file
         exit 1
 fi
 
 CLASS=$1
 FQCLASS=`/usr/local/bin/javaclassname $1`
 FQCLASSN=`echo $FQCLASS | sed -e 's/^.*\.\([^.]*\)$/\1/'`
 FQCLASSP=`echo $FQCLASS | sed -e 's-\.-/-g' -e 's-^[^/]*$--' -e 's-/[^/]*$--'`
 
 # for example:
 # CLASS=Test.class
 # FQCLASS=foo.bar.Test
 # FQCLASSN=Test
 # FQCLASSP=foo/bar
 
 unset CLASSBASE
 
 declare -i LINKLEVEL=0
 
 while :; do
         if [ "`basename $CLASS .class`" == "$FQCLASSN" ]; then
                 # See if this directory works straight off
                 cd -L `dirname $CLASS`
                 CLASSDIR=$PWD
                 cd $OLDPWD
                 if echo $CLASSDIR | grep -q "$FQCLASSP$"; then
                         CLASSBASE=`echo $CLASSDIR | sed -e "s.$FQCLASSP$.."`
                         break;
                 fi
                 # Try dereferencing the directory name
                 cd -P `dirname $CLASS`
                 CLASSDIR=$PWD
                 cd $OLDPWD
                 if echo $CLASSDIR | grep -q "$FQCLASSP$"; then
                         CLASSBASE=`echo $CLASSDIR | sed -e "s.$FQCLASSP$.."`
                         break;
                 fi
                 # If no other possible filename exists
                 if [ ! -L $CLASS ]; then
                         exec 1>&2
                         echo $0:
                         echo "  $CLASS should be in a" \
                              "directory tree called $FQCLASSP"
                         exit 1
                 fi
         fi
         if [ ! -L $CLASS ]; then break; fi
         # Go down one more level of symbolic links
         let LINKLEVEL+=1
         if [ $LINKLEVEL -gt 5 ]; then
                 exec 1>&2
                 echo $0:
                 echo "  Too many symbolic links encountered"
                 exit 1
         fi
         CLASS=`ls --color=no -l $CLASS | sed -e 's/^.* \([^ ]*\)$/\1/'`
 done
 
 if [ -z "$CLASSBASE" ]; then
         if [ -z "$FQCLASSP" ]; then
                 GOODNAME=$FQCLASSN.class
         else
                 GOODNAME=$FQCLASSP/$FQCLASSN.class
         fi
         exec 1>&2
         echo $0:
         echo "  $FQCLASS should be in a file called $GOODNAME"
         exit 1
 fi
 
 if ! echo $CLASSPATH | grep -q "^\(.*:\)*$CLASSBASE\(:.*\)*"; then
         # class is not in CLASSPATH, so prepend dir of class to CLASSPATH
         if [ -z "${CLASSPATH}" ] ; then
                 export CLASSPATH=$CLASSBASE
         else
                 export CLASSPATH=$CLASSBASE:$CLASSPATH
        fi
 fi
 
 shift
 /usr/bin/java $FQCLASS "$@"
 
 ====================== 如下为javaclassname.c文件内容 ===================
 /* javaclassname.c
  *
  * Extracts the class name from a Java class file; intended for use in a Java
  * wrapper of the type supported by the binfmt_misc option in the Linux kernel.
  * 从一个Java类文件提取类名；目的为用于Java类型的包装类，该类型由在内核中的binfmt_misc选** 项支持。
  * Copyright (C) 1999 Colin J. Watson <[e-mail]>.
  * 版权(C) 1991 科林.J.沃森<[e-mail]>.
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  * 这个程序是免费软件；在由免费软件基金会发表的GNU通用公共许可证的条款下，

  * 你可以重新分配或者修改它；许可证为第二版本或者任何其他最新版本（由你决定）。
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  * 这个程序使分布式的，希望它将是有用的，但是没有任何的担保；

  * 甚至没有隐含的适销性保证或特定用途的适用性。
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  * 你应该已经收到一份伴随这个程序的GNU通用公共许可证的复印件；如果没有收到，

  * 请写信给免费基金会，地址：Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
 #include <sys/types.h>
 
 /* From Sun's Java VM Specification, as tag entries in the constant pool. */
  /*  Sun公司的Java虚拟机的规范，就像在常量池中的标签实体。*/
 #define CP_UTF8 1
 #define CP_INTEGER 3
 #define CP_FLOAT 4
 #define CP_LONG 5
 #define CP_DOUBLE 6
 #define CP_CLASS 7
 #define CP_STRING 8
 #define CP_FIELDREF 9
 #define CP_METHODREF 10
 #define CP_INTERFACEMETHODREF 11
 #define CP_NAMEANDTYPE 12
 
 /* Define some commonly used error messages */
 /* 定义一些常用的错误信息*/
 #define seek_error() error("%s: Cannot seek\n", program)
 #define corrupt_error() error("%s: Class file corrupt\n", program)
 #define eof_error() error("%s: Unexpected end of file\n", program)
 #define utf8_error() error("%s: Only ASCII 1-255 supported\n", program);
 
 char *program;
 
 long *pool;
 
 u_int8_t read_8(FILE *classfile);
 u_int16_t read_16(FILE *classfile);
 void skip_constant(FILE *classfile, u_int16_t *cur);
 void error(const char *format, ...);
 int main(int argc, char **argv);
 
 /* Reads in an unsigned 8-bit integer. */
 /* 读取一个8位无符号整数。*/
 u_int8_t read_8(FILE *classfile)
 {
         int b = fgetc(classfile);
         if(b == EOF)
                 eof_error();
         return (u_int8_t)b;
 }
 
 /* Reads in an unsigned 16-bit integer. */
 /* 读取一个16位无符号整数。*/
 u_int16_t read_16(FILE *classfile)
 {
         int b1, b2;
         b1 = fgetc(classfile);
         if(b1 == EOF)
                 eof_error();
         b2 = fgetc(classfile);
         if(b2 == EOF)
                 eof_error();
         return (u_int16_t)((b1 << 8) | b2);
 }
 
 /* Reads in a value from the constant pool. */
 /* 从常量池中读取一个值*/
 void skip_constant(FILE *classfile, u_int16_t *cur)
 {
         u_int16_t len;
         int seekerr = 1;
         pool[*cur] = ftell(classfile);
         switch(read_8(classfile))
         {
         case CP_UTF8:
                 len = read_16(classfile);
                 seekerr = fseek(classfile, len, SEEK_CUR);
                 break;
         case CP_CLASS:
         case CP_STRING:
                 seekerr = fseek(classfile, 2, SEEK_CUR);
                 break;
         case CP_INTEGER:
         case CP_FLOAT:
         case CP_FIELDREF:
         case CP_METHODREF:
         case CP_INTERFACEMETHODREF:
         case CP_NAMEANDTYPE:
                 seekerr = fseek(classfile, 4, SEEK_CUR);
                 break;
         case CP_LONG:
         case CP_DOUBLE:
                 seekerr = fseek(classfile, 8, SEEK_CUR);
                 ++(*cur);
                 break;
         default:
                 corrupt_error();
         }
         if(seekerr)
                 seek_error();
 }
 
 void error(const char *format, ...)
 {
         va_list ap;
         va_start(ap, format);
         vfprintf(stderr, format, ap);
         va_end(ap);
         exit(1);
 }
 
 int main(int argc, char **argv)
 {
         FILE *classfile;
         u_int16_t cp_count, i, this_class, classinfo_ptr;
         u_int8_t length;
 
         program = argv[0];
 
         if(!argv[1])
                 error("%s: Missing input file\n", program);
         classfile = fopen(argv[1], "rb");
         if(!classfile)
                 error("%s: Error opening %s\n", program, argv[1]);
 
         if(fseek(classfile, 8, SEEK_SET))  /* skip magic and version numbers */
                 seek_error();
         cp_count = read_16(classfile);
         pool = calloc(cp_count, sizeof(long));
         if(!pool)
                 error("%s: Out of memory for constant pool\n", program);
 
         for(i = 1; i < cp_count; ++i)
                 skip_constant(classfile, &i);
         if(fseek(classfile, 2, SEEK_CUR))       /* skip access flags */
                 seek_error();
 
         this_class = read_16(classfile);
         if(this_class < 1 || this_class >= cp_count)
                 corrupt_error();
         if(!pool[this_class] || pool[this_class] == -1)
                 corrupt_error();
         if(fseek(classfile, pool[this_class] + 1, SEEK_SET))
                 seek_error();
 
         classinfo_ptr = read_16(classfile);
         if(classinfo_ptr < 1 || classinfo_ptr >= cp_count)
                 corrupt_error();
         if(!pool[classinfo_ptr] || pool[classinfo_ptr] == -1)
                 corrupt_error();
         if(fseek(classfile, pool[classinfo_ptr] + 1, SEEK_SET))
                 seek_error();
 
         length = read_16(classfile);
         for(i = 0; i < length; ++i)
         {
                 u_int8_t x = read_8(classfile);
                 if((x & 0x80) || !x)
                 {
                         if((x & 0xE0) == 0xC0)
                         {
                                 u_int8_t y = read_8(classfile);
                                 if((y & 0xC0) == 0x80)
                                 {
                                         int c = ((x & 0x1f) << 6) + (y & 0x3f);
                                         if(c) putchar(c);
                                         else utf8_error();
                                 }
                                 else utf8_error();
                         }
                         else utf8_error();
                 }
                 else if(x == '/') putchar('.');
                 else putchar(x);
         }
         putchar('\n');
         free(pool);
         fclose(classfile);
         return 0;
 }
 ====================== 如下为jarwrapper文件  ===================
 #!/bin/bash
 # /usr/local/java/bin/jarwrapper - the wrapper for binfmt_misc/jar
 
 java -jar $1
 ====================== Cut here ===================
 Now simply chmod +x the .class, .jar and/or .html files you want to execute.
 To add a Java program to your path best put a symbolic link to the main
 .class file into /usr/bin (or another place you like) omitting the .class
 extension. The directory containing the original .class file will be
 added to your CLASSPATH during execution.
 现在，简单的将你想要执行的.class,.jar或者.html文件通过chmod+x方式赋予权限。

 为了添加一个Java程序到你的路径中，最好将主类的.class文件与/usr/bin（或者另一个你想放的地方）

  目录下忽略的.class扩展名通过符号链接联系在一起。在执行期间，

  包含原始.class文件的目录将被添加到你的CLASSPATH路径下。
 
 To test your new setup, enter in the following simple Java app, and name
 it "HelloWorld.java":
 为了测试新的设置，输入下面的简单Java应用程序，并且将其命名为“HelloWorld.java”：
         class HelloWorld {
                 public static void main(String args[]) {
                         System.out.println("Hello World!");
                 }
         }
 
 Now compile the application with:
 现在通过如下命令编译该应用程序：
         javac HelloWorld.java
 
 Set the executable permissions of the binary file, with:
 设置二进制文件的可执行权限：
         chmod 755 HelloWorld.class
 
 And then execute it:
 执行应用程序：
         ./HelloWorld.class
 
 
 To execute Java Jar files, simple chmod the *.jar files to include
 the execution bit, then just do
 为了执行Java中的Jar文件，仅仅修改*.jar文件，使其包含执行位，然后执行：
        ./Application.jar
 
 
 To execute Java Applets, simple chmod the *.html files to include
 the execution bit, then just do
 为了执行Java中的小应用程序，仅仅修改*.html文件，使其包含执行位，然后执行：
         ./Applet.html
 
 originally by Brian A. Lantz, [e-mail]
 heavily edited for binfmt_misc by Richard Günther
 new scripts by Colin J. Watson <[e-mail]>
 added executable Jar file support by Kurt Huwig <[e-mail]>
 最初由Brian A.兰兹[e-mail]
 大量编辑Richard Günther的binfmt_misc文件，
 科林J.沃森<[e-mail]>的新脚本
 增加了可执行的由库尔特Huwig<[e-mail]>支持的JAR文件。