CN1242086A - 用微控制器使用高级程序设计语言 - Google Patents

Abstract

一种用于终端的集成电路卡。集成电路卡包括一个存储器,存储器存储解释程序和具有高级程序设计语言格式的应用程序。卡的处理器被配置成用解释程序来解释执行应用程序并用卡的通信器来与终端通信。

Description

用微控制器使用高级程序设计语言

本专利文件的部分内容含有受版权保护的材料。版权所有人不反对任何人按美国专利和商标局的文件或记录的形式原样复制该专利文件，但是保留所有的版权权利。

根据35 U.S.C.§119(e)，本申请要求在先的美国临时申请系列号60/029,057(1996年10月25日提交)的权益。

本发明总的来说涉及程序设计领域，更具体来说涉及用智能卡或微控制器来使用高级程序设计语言。

用JAVA高级程序设计语言编写的软件应用程序是这样设计的，即用JAVA编写的应用程序能不加改变地在许多不同的计算机品牌或计算机平台上运行。这是通过以下步骤实现的。在编写JAVA应用程序时，它被编译成含有字节代码的“类”文件，字节代码是称为JAVA虚拟机的假想计算机的指令。这个虚拟机的实现要为每个被支持的平台编写。当某个用户希望在选定平台上运行特定JAVA应用程序时，从所要求的应用程序编译成的类文件就被加载到选定平台上。选定平台的JAVA虚拟机被运行，解释类文件中的字节代码，这样实际就是在运行JAVA应用程序。

以下参考文献描述了JAVA，本文引用它们作为参考：(1)Arnold、Ken和Jame Gosling的《The Java Programming Language》(Addison-Wesley出版，1996年)；(2)Jame Gosling、Bill Joy和Guy Steele的《The Java Language Specification》(SunMicorsystems出版，1996年，web网址：http：∥java.sun.com/doc/language_environment/)；(3)JameGosling和Henry McGilton的《The Java Language Environment：A White Paper》(Sun Micorsystems出版，1995年，web网址：http：∥java.sun.com/doc/language_environment/)；(4)TimLindholm和Frank Yellin的《The Java Virtual MachineSpecification》(Addison-Wesley出版，1997年)。这些文章和其它文章都描述了如何用JAVA编写程序。

为了让JAVA应用程序能在特定平台上运行，要编写一个在该平台的限制条件内运行的JAVA虚拟机实现，还必须提供一个用于将所要求的JAVA应用程序加载到该平台的机构，并且还是保持在该平台的限制条件内。

常规的支持JAVA的平台通常是基于微处理器的计算机，能访问相对大量的内存和硬盘存储空间。这种微处理器实现经常用在桌面电脑和个人电脑中。然而，在智能卡通常使用的微控制器中却没有常规的JAVA实现。

微控制器与微处理器的差别有许多方面。例如，微处理器一般有一个中央处理单元，它要求一定的外部部件(例如存储器、输入控制和输出控制)要功能正常。典型的微处理器可以访问从Mb级到Gb级容量的存储器，用一条指令就能处理16、32或64位或更大的数据。与微处理器不同，微控制器包括的中央处理单元、存储器和其它功能单元都在一个半导体基片或集成电路(例如“芯片”)上。与微处理器访问的相对较大的外部存储器相比，典型的微控制器访问的存储器容量小得多。典型的微控制器能访问1到64Kb的内置存储器，16Kb则非常普遍。

一般来说有三种不同类型的存储器被使用：随机存取存储器(RAM)、只读存储器(ROM)、电可擦除可编程只读存储器(EEPROM)。在微控制器中，每一种存储器的可用容量受到集成电路上用于每一种存储器的空间的限制。通常，RAM占用的空间最多，处于短缺状态；ROM占用空间最少，处于充足状态；EEPROM比RAM更充足，但不及ROM。

每一种存储器适合于不同的用途。尽管ROM最价廉，但它只适用于没有变化的数据，诸如操作系统的代码。EEPROM用于存储断电时必须保留的数据，但是写的速度极慢。RAM可以高速读写，但是价格高，断电时数据丢失。

微处理器系统通常有较小的ROM和EEPROM，有1-128Mb的RAM-这是因为不受在单个集成电路设备上要受到的约束，经常能访问外部磁盘存储器系统，后者作为大型可写、非易失性存储区，费用比EEPROM更低。然而，微控制器通常有个0.1～2.0K的小RAM、2K～8K的EEPROM、8K～56K的ROM。

由于所需的外部部件数量少，体积小，微控制器经常用于集成电路卡，诸如智能卡。这种智能卡有各种形式，包括基于接触的卡和无接触的卡，前者必须插入读卡机才能使用，后者则不必插入。事实上，以无接触方式通讯的微控制器通常被嵌入特殊造型中，例如手表和戒指中，实际上以符合人机工程学的引人入胜方式集成了智能卡的功能。

由于环境要求的限制，用于智能卡的应用程序通常是用低级程序设计语言(例如汇编语言)编写的，以节约存储空间。

集成电路卡是一种安全、耐用、抗干扰、便于携带的数据存储设备。集成电路卡是最个人化的个人电脑，因为其体积小，因为其具有集成电路卡所独有的硬件和软件数据安全特点。

集成电路卡和卡上的微控制器的主要任务是保护存储在卡上的数据。因此，自1974发明以来，出于这些相同的安全原因，智能卡技术受到严密的保护。智能卡首先由法国的银行作为信用卡使用。在这种应用中，在基于信用卡的金融交易被认可之前，信用卡用户除了拥有其持的卡外还必须表明其知道一个4位数的个人标识号(PIN)。任何可能导致发现遗失或被偷信用卡上的个人标识号的信息都被堵塞在公共传播之外。事实上，由于在这一方面没有人能分辨哪些信息可能有用，几乎所有有关集成电路卡的信息都被隐瞒起来。

出于保密性考虑，为集成电路卡编写的应用程序具有独特的性质。例如，每个应用程序通常只以某特定所有人或身份来标识。由于应用程序通常是用低级程序设计语言诸如汇编语言编写的，所以应用程序是为特定类型的微控制器编写的。由于低级程序设计语言的性质，未经认可的应用程序可以访问集成电路卡上的数据。为特定集成电路卡编写的程序要用特定本体来标识，使得如果两个本体想要执行同一个编程功能，集成电路卡的微控制器上应用程序的有些部分必须有两份拷贝。

集成电路卡系统历史上一直是封闭的系统。集成电路卡含有为了与特定终端应用共同工作而设计的专有应用程序。集成电路卡使用时的安全检查的内容，主要是确认卡应用程序与终端应用程序是匹配的一对，卡上的数据是有效数据。

随着集成电路卡流行程度的提高，集成电路卡用户显然会不愿意携带适合各个集成电路卡应用的不同集成电路卡。因此开始在一个提供商的集成电路卡上提供多个合作应用。于是，例如一个自动柜员机(ATM)访问卡和一个借方卡可以共存于单一的集成电路卡平台上。不过，这仍然是一种封闭系统，因为终端和卡中的所有应用都是由一个清楚地了解其它提供商的提供商建立的。

有关集成电路卡的信息—特别是有关如何与它们通讯以及如何为它们编写程序的信息—的缺乏，已经阻碍了集成电路卡的普遍应用。然而，公用数字网络(例如因特网和万维网)的出现已经为集成电路卡的应用开放了新的领域。特别地，这已经导致需要在卡上装入不是清楚地了解其它提供商的新的应用程序，但是不可能破坏卡的保密性。然而，对于用低级程序设计语言编制的常规卡来说，这种做法是不切实际的。

总之，作为本发明特点的一个方面是一种用于终端的集成电路卡。集成电路卡包括一个存储解释程序和具有高级程序设计语言格式的应用程序的存储器。卡的处理器被配置为用解释程序解释执行该应用程序，并用卡的通信器与终端通信。

以下是本发明的其中一些优点。新的应用程序可以下载到智能卡，而不破坏智能卡的安全性。这些应用程序可以是由不同的公司提供的，可以用不同的终端在不同的时间加载。安全性之所以不受破坏，是因为应用程序受到防止未授权访问任何应用程序代码或数据的保护，这种保护是由JAVA虚拟机提供的安全特点决定的。智能卡应用程序可以采用功能强大的主流程序开发工具、以诸如JAVA和Eiffel的高级语言进行编制。新的应用程序能在数小时内迅速成型并下载到智能卡，无须借助软屏蔽。采用微控制器的嵌入式系统通过使用本发明，也能获得许多这些优点，来下载新的应用程序、进行高级语言程序开发和快速成型。

本发明的实现包括以下若干内容。应用程序的高级程序设计语言格式可能有类文件格式，可能有JAVA程序设计语言格式。处理器可以是微控制器。存储器至少有一部分可能位于处理器中。

该应用程序可以是从有一个字符串的第二应用程序已经处理过，该字符串可以在第一应用程序中用一个标识符(例如整数)来代表。

处理器也可以被配置成接收来自某请求者(例如处理器或终端)的要求访问卡的某单元(例如存储器中存储的应用程序、存储器中存储的数据、通信器)的请求，接收请求后，与请求者交互作用，以验证请求者的身份，根据该身份，有选择地授予对该单元的访问权。

存储器也可以存储该单元的访问控制清单。访问控制清单设有标志，指示要授予该身份的访问权的类型，根据访问控制清单，处理器选择性地将特定类型的访问(例如读数据、写数据、追加数据、创建数据、删除数据或者执行应用程序)授予请求者。

应用程序可以是存储器中存储的若干应用程序的其中之一。处理器也可以被进一步配置成接收来自某请求者的要求访问这多个应用程序中之一的请求；接收请求后，判断所述多个应用程序之一是否符合预定的规则集；根据这个判断，选择性地授予请求者对所述多个应用程序之一的访问权。预定的规则为判断所述多个应用程序之一是否访问存储器预定区域提供了指南。处理器可以被进一步配置成能验证请求者的身份，并根据该身份，授予对所述多个应用程序之一的访问权。

处理器也可以被配置成能通过通信器与终端进行交互作用来验证请求者的身份；能判断身份是否已经验证；能根据该判断，选择性地允许终端与集成电路卡之间进行通信。

通信器和终端可以通过通信通道进行通信。处理器也可以被配置成能在处理器允许终端与集成电路卡之间进行通信时将通信通道之一分配给该身份。处理器也可以被配置成能将对话关键码分派给所分配的通信通道并在处理器与终端通过所分配的通信通道进行通信时使用该对话关键码。

终端可以有一个读卡机，通信器可以包括一个用于与读卡机通信的触点。终端可以包括一个无线通信设备，通信器可以包括一个用于与该无线通信设备通信的无线收发机。终端可以有一个无线通信设备，通信器可以包括一个用于与该无线通信设备通信的无线发射机。

概括来说，本发明具有的特点的另一个方面是，一种用于集成电路卡和终端的方法。该方法包括在集成电路卡存储器中存储一个解释程序和至少一个具有高级程序设计语言格式的应用程序。集成电路卡的处理器用解释程序来解释执行该至少一个应用程序，当处理器与终端之间进行通信时，处理器使用该卡的一个通信器。

概括来说，本发明具有的特点的另一个方面是一种智能卡。该智能卡包括一个存储JAVA解释程序的存储器和一个被配置成能用解释程序解释执行JAVA应用程序的处理器。

概括来说，本发明具有的特点的另一个方面是一种具有半导体衬底和位于衬底的存储器的微控制器。一个程序设计语言解释程序存储在存储器中并被配置成能执行安全检查。一个中央处理单元位于衬底中并与存储器相连。

本发明的实现可以包括以下若干内容。解释程序可以是JAVA字节代码解释程序。安全检查可以包括建立防火墙并且包括实施一个砂箱安全模型(sandbox security model)。

概括来说，本发明具有的特点的另一个方面是一种具有在卡的存储器中存储的程序设计语言解释程序的智能卡。解释程序被配置成能执行安全检查。卡的中央处理单元与存储器相连。

概括来说，本发明具有的特点的另一个方面是一种用于终端的集成电路卡。该卡包括一个通信器和一个存储解释程序和第一应用程序的第一指令的存储器。第一应用程序的第一指令是从第二应用程序的第二指令转换的。集成电路卡包括一个处理器，处理器与存储器相连，并被配置成能利用解释程序执行第一指令以及通过通信器与终端进行通信。

本发明的实现包括以下若干内容。第一和/或第二应用程序可以具有类文件格式。第一和/或第二应用程序可以包括字节代码，诸如JAVA字节代码。第一指令可以是第二指令的综合版本或重新编号的版本。第二指令可以包括常量引用，第一指令可以包括替代第二指令的常量引用的常量。第二指令可以包括引用，引用在第二指令向第一指令的转换期间可以移动位置。移动之后，第一指令可以重新连接到该引用。第一指令可以包括用于第一类虚拟机的字节代码，第二指令可以包括用于第二类虚拟机的字节代码。第一类与第二类不同。

概括来说，本发明具有的特点的另一个方面是一种用于集成电路卡的方法。该方法包括将第二应用程序的第二指令转换成第一应用程序的第一指令，将第一指令存储到集成电路卡的存储器中，用集成电路卡的解释程序执行第一指令。

概括来说，本发明具有的特点的另一个方面是一种用于终端的集成电路卡。该集成电路卡有一个通信器和一个存储器，通信器被配置成能与终端通信，存储器存储已从具有一个字符串的第二应用程序处理形成的第一应用程序，该字符串在第一应用程序中用一个标识符来代表。集成电路卡包括一个与存储器相连的处理器。处理器被配置成用解释程序去解释执行第一应用程序，用通信器去与终端通信。

概括来说，本发明具有的特点的另一个方面是一种用于集成电路卡和终端的方法。该方法包括处理第二应用程序以创建第一应用程序。第二应用程序有一个字符串，该字符串在第一应用程序中用一个标识符来代表。集成电路卡的存储器中存储一个解释程序和第一应用程序。处理器用解释程序去解释执行第一应用程序。

概括来说，本发明具有的特点的另一个方面是一种包括一个存储应用程序和解释程序的存储器的微控制器。应用程序有一个类文件格式。微控制器的处理器连接存储器并被配置成用解释程序来解释执行应用程序。

在本发明的实现中，微控制器也可以包括一个配置成与终端通信的通信器。

概括来说，本发明具有的特点的另一个方面是一种用于集成电路卡的方法。该方法包括在集成电路卡的存储器中存储第一应用程序，在集成电路卡的存储器中存储第二应用程序，建立一个隔离第一应用程序与第二应用程序的防火墙，使得第二应用程序既不能访问与第一应用程序，也不能访问与第一应用程序关联的数据。

概括来说，本发明具有的特点的另一个方面是一种用于终端的集成电路卡。该集成电路卡包括一个配置成与终端通信的通信器、一个存储器和一个处理器。存储器存储应用程序，每个应用程序都有高级程序设计语言格式。存储器也存储一个解释程序。处理器与存储器连接，并被配置成：a)用解释程序来解释执行应用程序，b)用解释程序建立一个将应用程序互相隔离的防火墙，c)用通信器与终端通信。

阅读以下说明和权利要求，其它优点和特点将是显而易见的。

图1是一个集成电路卡系统的框图。

图2是表示对要下载到集成电路卡的JAVA应用程序进行准备的流图。

图3是由卡类文件转换器使用并生成的文件的框图。

图4是表示应用程序类文件变换成卡类文件的框图。

图5是表示类文件转换器的工作的流图。

图6是表示字节代码的修改的流图。

图7是表示专用字节代码变换成通用字节代码的框图。

图8是表示用常量替换常量引用的框图。

图9是表示将引用用它们的更新值进行替换的框图。

图10是表示对原始字节代码重新编号的框图。

图11是表示为不同的虚拟机结构翻译原始字节代码的框图。

图12是表示将应用程序加载到集成电路卡的框图。

图13是表示在集成电路卡中执行应用程序的框图。

图14是表示ROM、RAM和EEPROM的存储器组织结构的示意图。

图15是表示卡JAVA虚拟机的总体体系结构的流图。

图16是表示在带有安全检查的卡JAVA虚拟机中的过程执行的流图。

图17是表示卡JAVA虚拟机中的字节代码执行的流图。

图18是表示在没有安全检查的卡JAVA虚拟机中的过程执行的流图。

图19是表示卡应用程序与身份之间的关联性的框图。

图20是表示专用运行应用程序的访问权的框图。

图21是智能卡上的微控制器的透视图。

图22是电话上的微控制器的透视图。

图23是钥匙环上的微控制器的透视图。

图24是戒指上的微控制器的透视图。

图25是汽车电路卡上的微控制器的透视图。

参见图1，构造一个集成电路卡10(例如智能卡)来提供一个高级的、基于JAVA的多应用程序编程和执行环境。集成电路卡10有一个通信器12a，它被配置成与终端14的终端通信器12b进行通信。在有些实施例中，集成电路卡10是一个智能卡，带有8位的微控制器、512字节的RAM、4K字节的EEPROM和20K字节的ROM；终端通信器12b是常规的接触式智能卡读卡机；终端14是运行Windows NT操作系统的常规个人电脑，该操作系统支持个人电脑智能卡(PC/SC)标准并提供JAVA开发支持。

在有些实施例中，微控制器、存储器和通信器内置于与通常的信用卡尺寸几乎相同的塑料卡中。在另一些实施例中，微控制器、存储器和通信器安装在塑料卡以外的基体中，诸如首饰(例如手表、戒指或项链)、汽车设备、电信设备(例如用户身份模块(SIM)卡)、安全设备(例如加密模块)和家用电器中。

终端14准备JAVA应用程序并用终端通信器12b将JAVA应用程序加载到集成电路卡10。终端通信器12b是一种能在集成电路卡10与终端14之间建立通信通道的通信设备。有些通信选择包括接触式读卡机、通过无线频率或红外技术的无线通信，串行通信协议、分组通讯协议、ISO 7816通讯协议，等等。

终端14也能与集成电路卡10中运行的应用程序交互作用。在有些情况下，可以用不同的终端来实现这种目的。例如，可以用一种终端来准备应用程序，用不同的终端来下载应用程序，用另外其它终端来运行各种应用程序。终端可以是自动柜员机(ATM)、销售点终端、防盗门系统、付费系统、存取控制系统、或者任何其它与集成电路卡或微控制器通信的系统。

集成电路卡10含有卡JAVA虚拟机(卡JVM)16，它被用于解释卡10上含有的应用程序。

参见图2，JAVA应用程序20包括三个JAVA源代码文件A.java20a、B.java 20b和C.java 20c。这些源代码文件是在JAVA应用程序开发环境22中被准备和编译的。当JAVA应用程序20被开发环境22编译时，就产生了应用程序类文件24，其中这些类文件A.class24a、B.class 24b和C.class 24c分别对应它们各自的类JAVA源代码20a、20b和20c。应用程序类文件24符合《JAVA虚拟机规范》第4章记载的标准类文件格式(《JAVA虚拟机规范》为Tim Lindholm和Frank Yellin所著，1996年Addison-Wesley公司出版)。这些类文件24被馈送到卡类文件转换器26，后者将文件合并、压缩，生成单一的卡类文件27。用常规的卡加载器28将卡类文件27装入集成电路卡10。

参见图3，卡类文件转换器26是一个处理一组按标准JAVA类文件格式编码的类文件24的类文件后处理器，它可选择采用一种串到ID输入映射文件30来生成某种卡类文件格式的JAVA卡类文件27。附录A描述了一个这种卡类文件格式，本文引为参考。此外，在有些实施例中，卡类文件转换器26产生一个串到ID输出映射文件32，用作卡类文件转换器的后继执行的输入。

在有些实施例中，为了使串到ID映射与以前生成的卡类文件一致(在有多个类文件引用相同的串的情况下)，卡类文件转换器26能从串到ID输入映射文件30接受以前定义的串到ID映射。如果没有这一个文件，各ID就由卡类文件转换器26生成。本文引为参考的附录B描述了实现并产生串到ID输入映射文件30和串到ID输出映射文件32的一种可能方法，并举例说明了这种映射表。

参见图4，典型的应用程序类文件24a包括类文件数据41，类常量池42，类、域创建的、界面引用的和过程数据43，以及各种属性数据44，它们在前文所述的《JAVA虚拟机规范》中有详细说明。注意，属性数据44中许多对于本实施例来说并不需要，因此被卡类文件转换器26剔除45。剔除的属性包括SourceFile、ConstantValue、Exceptions、LineNumberTable、LocalVariableTable以及任何可选择的售主属性。如附录A中所述的典型卡类文件27是按下列方式从应用程序类文件24导出的。卡类文件数据46是从所有应用程序类文件24a、24b、24c的合计类文件数据41导出的。卡类文件常量池47是从所有应用程序类文件24a、24b、24c的合计类常量池42导出的。卡类、域创建的、界面引用的和过程数据48是从所有应用程序类文件24a、24b、24c的合计类、域创建的、界面引用的和过程数据43导出的。本实施例中的卡属性数据49仅仅是从所有应用程序类文件24a、24b、24c的合计属性数据44的代码属性导出的。

为了避免在卡中进行动态链接，在构成应用程序24的若干JAVA类文件24a、24b、24c之间分配的所有数据被图5中流图中所示的进程合并成一个卡类文件27。在51a，选择要处理的第一类文件。在51b以下述方式压缩常量池42。JAVA类文件24a中引用的所有对象、类、域、过程都被用类文件24a的常量池42中的串来标识。卡类文件转换器26将在JAVA类文件24a中发现的常量池42压缩成一个优化版本。这种压缩是通过将类文件常量池42中发现的所有串映射成整数而完成的(其大小依微控制器的体系结构而定)。这些整数也被称作ID。每个ID唯一地标识应用程序20中的某特定对象、类、域或过程。因此，卡类文件转换器26将JAVA类文件常量池42中的串替换为其对应的唯一ID。附录B显示一例应用程序HelloSmartCard.java，位于附录下部的表说明的是与该应用程序的类文件的常量池中发现的串对应的ID。本例中所用的ID都是16位无符号整数。

下一步，在51c卡类文件转换器26在输入JAVA类文件24a的代码属性中检查不受支持的特征码。卡JVM16只支持全部JAVA字节代码的一个子集，具体如本文引为参考的附录C中所述。因此，卡类文件转换器26在JAVA类文件24a的代码属性中检查不受支持的字节代码。如果在52发现任何不受支持的字节代码，卡类文件转换器设立一个错误标志并停止转换53。附录D中作“A”标记的程序代码片断显示了这些寄生字节代码是如何被理解的。通过要求标准JAVA开发环境22编译带“-g”标志的应用程序22可以进行另一个层次的检查。根据上述JAVA虚拟机规范，该选项要求JAVA编译器将关于JAVA应用程序20中所使用变量的数据放置到类文件24a的LocalVariableTable属性中。卡类文件转换器26利用这个数据来检查JAVA类文件24a是否引用不被JAVA卡支持的数据类型。

下一步，卡类文件转换器26丢弃进行解释时不要求的、JAVA类文件24a中的所有不需要的部分。JAVA类文件24a存储与在JAVA类文件的属性节44中的类文件中的字节代码有关的数据。在45卡JVM16进行解释时所不要求的属性，诸如SourceFile、ConstantValue、Exceptions、LineNumberTable、LocalVariableTable可以安全地丢弃。唯一被保留的属性是代码属性。代码属性含有对应于JAVA类文件24a中过程的字节代码。

修改字节代码54涉及到检查类文件中每个过程的代码属性数据44，以及修改引用JAVA类文件常量池42的条目的字节代码的操作数以反映卡类文件常量池47中的条目。在有些实施例中，字节代码也被修改，如下文所述。

修改字节代码54涉及五遍(两遍是可选择的)，如图6中的流图所述。原始字节代码60被发现在正被处理的JAVA类文件24a的代码属性44中。第一遍61记录所有跳转及其在源字节代码中的目的地。在以后进行的字节代码翻译中，有些单字节代码可能被翻译成2个或3个字节。图7所示的例子中，字节代码ILOAD_0被用两个字节代替：字节代码ILOAD和参数0。这一步完成后，代码大小发生变化，这就要求对受其影响的任何跳转目的地进行调整。因此，在完成这些转换之前，要分析原始字节代码60，找出任何跳转字节代码，记下它们的位置和当前目的地。附录D中作“B”标记的程序代码片断显示了如何记录这些跳转指令。附录D被本文引为参考。

一旦记录了跳转指令，如果不是正在进行可选择的字节代码翻译62，卡类文件转换器26就可以进行第三遍64。

否则，卡类文件转换器就将专用字节代码转换成通用字节代码。通常，翻译出的字节代码不在卡JVM16中被解释，但是却得到支持，因为能将该字节代码转换成能被卡JVM16解释的等价字节代码(见图7)。字节代码70可以替换为语义上等价的另一个不同字节代码72。这通常导致将诸如ILOAD_0的专用短单字节代码翻译成更通用的形式。例如，ILOAD_0可以被带参数0的字节代码ILOAD代替。进行这种翻译，目的是减少由卡JVM 16翻译的字节代码的数量，由此减少对卡JVM 16的复杂程度和代码空间的要求。附录D中作“C”标记的程序代码片断显示了这种翻译是如何完成的。注意，这种翻译增加了结果字节代码的大小，必须对任何受影响的跳转指令进行重新计算。

在第三遍64中，卡类文件转换器重建常量引用，方法是剔除用于表示这些常量的串。图8表示的例子中，引用通过JAVA类文件24a的常量池42中的索引发现的常量“18”的字节代码LDC 80可以被翻译成BIPUSH字节代码82。在这遍中，卡类文件转换器26修改引用JAVA类文件常量池42的条目的所有字节代码的操作数以反映它们在卡类文件常量池47中的新位置。图9表示的例子中，一个字节代码的参数INVOKESTATIC 90引用JAVA类文件常量池42的某个条目，该条目被修改以反映该条目在卡类文件常量池47中的新位置。修改后的操作数94表示这种转换。附录D中作“D”标记的程序代码片断显示了这种修改是如何完成的。

一旦常量引用被再链接后，如果不是正在进行可选择的字节代码修改，卡类文件转换器就继续到第五个也是最后一遍67。

否则，卡类文件转换器就将原始字节代码修改成由正使用的特定卡JVM 16支持的某个不同的字节代码集合。一种可能的修改是将原始字节代码60重新编号变成卡JVM 16的字节代码(见图10)。这种重新编号方式导致原始字节代码60中的字节代码100被修改成重新编号后的字节代码102。由值21识别的字节代码ILOAD可以被重新编号变成由值50来识别。可以用这种修改来优化卡JVM 16中的类型测试(在现有技术中也称为第三遍检查)。附录D中作“E”标记的程序代码片断显示了这个实施例的一个实现。为了减少卡JVM 16解释字节代码所需的程序空间可以进行这种修改。这种修改的实质是将字节代码重组成卡JVM 16字节代码，使得具有类似操作数和结果的字节代码被组合在一起，卡JVM 16的字节代码之间没有空隙。这就使得卡JVM 16能在其执行时高效地检查卡JVM 16字节代码并确认类型。

在有些实施例中，卡类文件转换器将原始字节代码60修改成旨在用于不同虚拟机体系结构的不同字节代码集合，如图11中所示。旨在在字堆栈114上使用的JAVA字节代码ILOAD 112可以被要在字节堆栈118上使用的卡JVM 16的字节代码ILOAD_B 116替换。字堆栈114中的一个单元要求分配4个字节的堆栈空间，而字堆栈118中的一个单元仅要求1个字节的堆栈空间。尽管这种选择有助于提高执行速度，其风险是丧失原始字节代码所具有的安全特性。

因为前面的步骤63、64或66都可能会改变字节代码60的大小，在67所以卡类文件转换器26只好再链接任何已经受影响的跳转指令。由于跳转指令已经在卡类文件转换器26的第一个步骤61被记录，所以进行这种调整的方法是将跳转目的地确定为适当的值。附录D中作“F”标记的程序代码片断显示了这些跳转是如何确定的。

卡类文件转换器现在已经修改与待命加载的原始字节代码60等价的字节代码68。从JAVA类文件24a到卡类文件27的转换现在完成。

参见图5，如果在55还有类文件24等待处理，则对其余的每个类文件重复执行前面的步骤51a、51b、51c、52、54。在56卡类文件转换器26收集已处理过的类24的映射和修改后的字节代码，在57将它们合并放置并生成卡类文件27。如果需要的话，卡类文件转换器26就生成一个串到ID输出映射文件32，它含有为翻译期间在JAVA类文件24的常量池42中遇到的串所分配的所有新ID的清单。

参见图12，终端14内的卡加载器28用标准ISO 7816命令将卡类文件发送到集成电路卡中的加载与执行控件120。加载与执行控件120有一个卡操作系统122，卡操作系统提供必要的系统资源，包括支持卡文件系统124，卡文件系统可用于存储几个卡应用程序126。有许多常规的卡加载器是用由卡操作系统122支持的低级语言编写的。在优选实施例中，引导程序加载器是用JAVA编写的，集成电路卡10包括运行这个应用程序的JAVA虚拟机。在本文引为参考的附录E中表示了加载与执行控件120的一个Java实现。加载与执行控件120接收卡类文件26，生成在集成电路卡10的EEPROM中卡文件系统126中存储的JAVA卡应用程序126x。多个JAVA卡应用程序126x、126y和126z都能以这种方式存储在单一的卡中。加载与执行控件120支持终端能用来选择哪一个Java卡应用程序立即或在下一次卡复位时运行的命令。

参见图13，当接收到来自加载与执行控件120的一个复位或执行命令时，卡JAVA虚拟机(卡JVM)16开始在所选JAVA卡应用程序126z中所选类的某个预定过程(例如主过程)执行。卡JVM 16提供JAVA卡应用程序126z访问基础卡操作系统122，操作系统用本机JAVA过程来提供诸如I/O、EEPROM支持、文件系统、存取控制以及其它系统功能。所用本机JAVA过程如本文引为参考的附录F中所示。

所选的JAVA卡应用程序126z用通信器12a与终端14中的适当应用程序通信，以便建立通向终端14的通信通道。从通信器12a到终端14的数据经过终端中的通信驱动程序132，通信驱动程序是专门为处理通信器12a所用的通讯协议而编写的。数据然后传送到集成电路卡驱动程序134，集成电路卡驱动程序是专门为访问正被使用的特定集成电路卡10的能力而编写的，它向终端应用程序136提供高级软件服务。在优选实施例中，这个驱动程序是合适的PC/SC智能卡服务提供商(SSP-Smartcard Service Provider)软件。数据然后传送到终端应用程序136，后者必须处理由正在运行的特定卡应用程序126z所提供的能力。命令和响应就这样在终端应用程序136和选定的卡应用程序126z之间来回传送。终端应用程序与用户交互作用，接收来自用户的命令—其中有些命令被传送到选定的JAVA卡应用程序126z，接收来自选定的JAVA卡应用程序126z的响应—这些响应经处理后被传送回用户。

参见图14，卡JVM 16是一个解释卡应用程序126x的解释器。微控制器中影响卡JVM 16的存储器资源是卡ROM 140、卡RAM 141和卡EEPROM 142。卡ROM 140用于存储卡JVM 16和卡操作系统122。卡ROM 140也可用于存储固定的卡应用程序140a和类库140b。可加载的应用程序141a、141b和库141c也可以存储在卡RAM 141中。卡JVM 16解释卡应用程序141a、141b或140a。卡JVM 16用卡RAM来存储VM堆栈144a和系统状态变量144b。卡JVM 16通过VM堆栈144a来跟踪所进行的操作。由卡JVM 16创建的对象或者存储在RAM堆144c中，或者存储在EEPROM堆146a中，或者存储在文件系统147中。

所有由卡JVM 16操纵的堆都可以作为RAM堆144c存储在卡RAM141中，也可以作为EEPROM堆分布到卡EEPROM142。卡RAM141也用于记录用微控制器的本机代码编写的例程所用的系统堆栈148的状态。卡JVM 16用卡EEPROM 142来把应用程序数据存储在EEPROM堆146a或文件系统147中。存储在文件中的应用程序数据可以通过到卡操作系统122的接口来操纵。这种接口由卡ROM 140中存储的类库140b提供，由卡EEPROM 142中存储的可加载类库141c提供。附录F中描述了一个这样的接口。卡中的应用程序和数据被防火墙机构149隔离。

为了适应微控制器上所能得到的有限资源，卡JVM 16执行JAVA程序设计语言的一个严格的子集。结果，JAVA应用程序20编译成一个含有JAVA字节代码的一个严格子集的类文件。这就使应用程序设计者能以这个JAVA的严格子集编写程序并仍然保持与现有JAVA虚拟机的兼容。由卡JVM 16解释的JAVA字节代码的语义在前面所述的《JAVA虚拟机规范》中有描述。附录C中有由卡JVM 16解释的字节代码子集。卡类文件转换器26检查JAVA应用程序20以确保只使用这个子集中可用的特征，并将应用程序转换成能被卡JVM 16理解和解释的形式。

在其它实施例中，卡JVM 16被设计成能解释字节代码116的一个不同集合或增广集合。尽管不同的字节代码集合可能导致某些性能上的提高，从原始JAVA字节代码具有的安全性或者从与主流JAVA开发工具的兼容性角度来说，偏离严格的JAVA子集可能并不可取。

所有卡JVM 16应用程序126都有一个定义好的入口点，入口点由某个类和该类中的某个过程指示。这种入口点在串到ID输入映射30中映射，并由卡类文件转换器26分配。JAVA应用程序20中的类、过程和域是由卡类文件转换器26分配ID的。例如，对应主应用程序类的ID可被定义为F001，对应其主过程诸如“main()V”的ID可被定义为F002。

图15中的流图描述了卡JVM的总体执行体系。卡JVM 16的执行从执行控件120开始，执行控件选择一个要执行的卡应用程序126z。它接着就寻找并分配卡应用程序中的一个入口点152(某过程)供卡JVM 16去解释。卡JVM 16解释该过程153。如果解释进行得成功154，卡JVM 16就报告成功155，将控制返还给执行控件120。如果在进行解释的过程中153，卡JVM 16遇到未处理的错误或异常(通常是资源限制或安全侵犯)，则卡JVM 16就停止156并将适当的错误报告给终端14。

卡JVM 16的核心部分是一个处理字节代码的执行的子例程。图16中的流图描述了这个子例程。该流图假定一个过程160，该子例程执行该过程中的字节代码。子例程的开始是准备该过程的参数161。这涉及到设置VM堆栈144a指针、VM堆栈144a帧限制，以及将程序计数器设置到过程的第一个字节代码。

下一步检查过程各标志162。如果过程被标志为本地的，则过程实际上是一个对本机过程代码(用微控制器的本地处理器代码编写的子例程)的调用。在这种情况下，卡JVM 16为有效调用进行准备163并返回到本机代码例程。参数可以在VM堆栈144a上或通过系统堆栈148传送给本机过程。在进行适当的安全检查后本机过程子例程被调用。返回时，本机过程子例程的结果(如果有结果的话)被置于VM堆栈144a上，以便能被下一个要执行的字节代码来存取。

然后就进入了卡JVM 16的调度循环164。字节代码调度循环负责每个字节代码的准备、执行和退役。循环结束的条件是，循环结束了对过程160中字节代码的解释，或者卡JVM 16遇到资源限制或安全侵犯。

如果上一个字节代码导致要转移165，则卡JVM 16准备转移165a。提取下一个字节代码165b。为了保持以低代价处理每个字节代码，要尽可能提取并存储常用的单元，诸如字节代码参数、长度、类型。

为了提供程序设计语言的安全模型具有的安全性，要检验类文件中字节代码，判断是否符合该模型。这种检查在现有技术中通常是由一个称为字节代码检验器的程序执行的，按照《JAVA虚拟机规范》，字节代码检验器进行四遍操作。为了提供由字节代码检验器保障的运行时的安全性，卡JVM 16必须进行与检验器的第三、第四遍相关的检查。这种检查可以被卡JVM 16省略，条件是由卡JVM 16解释的字节代码60的安全性能得到保证(这几乎不可能做到)。至少，只要对象引用不可能是假造的、VM堆栈144a和本地变量界限得到遵守，代码安全性就可能得到保持。这就要求针对正在执行的字节代码检查VM堆栈144a的状态。

为了实施程序设计语言的安全模型，要创建一个256字节的表，如本文引为参考的附录G所示。该表由字节代码的编号标引。该表含有与索引字节代码关联的类型和长度数据。其编码方式是前5位代表类型，后3位代表长度。字节代码的类型和长度是直接从该表由字节代码编号索引的。这种类型和长度然后被用于进行由本文引为参考的附录H所示的检查。附录H中，这种检查始于从本文引为参考的附录G的表中解码长度和类型。长度用于递增程序计数器。类型首先用于执行前的检查，以保证在VM堆栈144a上的数据类型对于要执行的字节代码来说是正确的。用256个字节的ROM存储该表，使得原始Java字节代码能在卡JVM 16中运行并使对要加载到卡的JAVA类文件所需的改变最少。其它JAVA字节代码可以容易地被支持，因为更新适当的表条目是相对容易的事情。

在其它实施例中，如图10所示，过程中JAVA字节代码是这样重新编号的，即要使得存储在附录H的表中的字节代码类型和长度数据在重定序中是隐含的。附录H被本文引为参考。于是，必须对VM堆栈144a的状态和正在处理的字节代码进行的检查并不涉及对表的查找。通过执行本文引为参考的附录I中所示的几个简单比较就能进行检查。当ROM空间非常宝贵时，最好采用这个实施例，因为它去除了一个256字节的表。然而要向被支持字节代码的集合添加新字节代码，必须仔细地设计周到，因为新字节代码必须适合被支持字节代码的隐含编号方案。

在另一个实施例中，卡JVM 16为了卡JVM 16的执行速度而选择不进行任何安全检查。这在图18的流图中表示。图18的流图与去掉安全检查后的图16的流图相同。从安全的观点来说，这种选择是不可取的，除非能保证字节代码是安全的。

卡JVM 16也能实施其它安全检查。如果字节代码可以引用局部变量，卡JVM 16就检查这种引用是否有效，如果无效，就发出出错信号。如果引用有效，卡JVM 16就将该局部变量的类型存储起来用于将来的检查。要检查VM堆栈144a指针，看其是否仍然处于有效区间。如果不在有效区间，就发出异常信号。要检查字节代码编号，如果不受支持，就发出异常信号。

最后，字节代码本身被调度165d。由卡JVM 16翻译的字节代码清单列举在附录C中。前述的《JAVA虚拟机规范》中有针对字节代码调度之前和之后VM堆栈144a的状态对字节代码的语义的描述。注意，有些字节代码(字节代码INVOKESTATIC、INVOKESPECIAL、INVOKENONVIRTUAL和INVOKEVIRTUAL)可能导致重新进入卡JVM 16，要求在子例程161的入口处开始处理。图17表示字节代码执行例程的流图。该例程被赋予一个要执行的字节代码171。卡JVM 16执行该字节代码所要求的指令172。如果在执行的过程中，卡JVM 16遇到某资源限制173，它就返回一个错误156。这个错误被卡JVM 16返回给终端16。如果字节代码执行成功，它就返回一个成功信号175。

执行之后，结果的类型被用于正确地设置VM堆栈144a(165e)，适当地在VM堆栈144a上设置数据类型标志。上一次从字节代码信息表收集(165b)的字节代码数据被用于按照刚刚执行的字节代码来设置VM堆栈144a的状态。

在其它实施例中，针对被执行的字节代码来设置VM堆栈144a的输出状态在字节代码是重新编号过的情况下被简化。这种简化在本文引为参考的附录I中表示。

在另一个实施例中，卡JVM 16为了卡JVM 16的执行速度，可能省略对VM堆栈144a的输出状态的设置。从安全的观点来说，这种选择并不可取—除非能保证字节代码是安全的。

在字节代码已经执行后，字节代码被退役(165f)。这涉及到使参数从VM堆栈144a出栈。一旦字节代码的处理完成，循环164就对过程的下一个字节代码重复。

一旦调度循环164终止，VM堆栈144a就被清空(166)。这就防止有任何对象引用渗漏到其它卡JVM 16调用，破坏卡JVM 16的安全。字节代码调度循环164的停止167，标志卡JVM 16已经完成了对所请求过程的执行。

为了将集成电路卡10中的数据和应用程序互相隔离，集成电路卡10要依靠由卡JVM 16提供的防火墙机构149。因为卡JVM实施标准的第3和第4遍的检验器检查，它能检测到某应用程序引用另一个应用程序所用数据或代码空间的任何企图并发出安全错误信号(156)。例如，常规低级应用程序能将非引用数据类型变造成引用，由此使得能访问未经授权的存储空间，侵犯安全。如果采用本发明，则要是卡应用程序126z企图用一个非引用数据类型作为引用的话，就会触发一个安全侵犯错误(156)。在常规JAVA中，这种受保护的应用程序环境被称为沙箱应用程序-解释环境。

然而，这些防火墙设施并不是独立工作的。实际上，这些设施是与下表所示的常规存取控制列表和加密机构重叠并互相加强的：

	存取控制列表	虚拟机	加密
				数据保护	操作前的存取控制	只访问自己的名字空间	去向另一个程序的数据被加密
程序保护	执行前的存取控制	只对正确的类型执行	数据在程序的名字空间中加密
				通信保护	通道上的存取控制	在自己的名字空间中的通道控制	只有互相验证的各方才能通信

这些设施结合在一起，隔离集成电路卡10上的数据和应用程序，保证每个卡应用程序126只能访问集成电路卡10的授权资源。

参见图19，当卡应用程序126执行时，卡应用程序126x、126y、126z能被赋予特别的特权。这些特权例如确定，卡应用程序126能访问哪些数据文件，卡应用程序126在文件系统147上能执行哪些操作。授予卡应用程序126的特权一般是在特定的卡应用程序126z被用户通常从终端14启动时设置的。

集成电路卡10用加密验证过程来将某身份190(例如身份190a、190b和190c)并因此将一组特权关联到卡应用程序126的执行。特定身份190c与卡应用程序126z的关联是在卡应用程序126z开始执行时作出的，因此而创建一个特定的运行应用程序200，如图20所示。身份190是一种独特可识别的文字，与某身份标志可靠关联。身份标志(例如个人身份证号(PIN)或RSA私人密钥)是一种密钥。

参见图20，为了运行特定的卡应用程序126z，必须验证卡应用程序126z的身份190c。身份190c是通过展示知道与身份190c关联的身份标志而验证的。因此，为了运行卡应用程序126z，代理(例如持卡者或希望运行该应用程序的另一个应用程序)必须显示其拥有或知道该应用程序的定义身份的密钥。

展示拥有密钥的一种方式是简单地展示该钥本身。PIN验证就是这种验证形式的一个例子。另一种不展示密钥本身就能显示拥有密钥的方式是，展示有能力以该密钥来加密或解密普通文字。

因此，集成电路卡10上特定的运行应用程序200包括一个卡应用程序126z和一个验证过的身份190c。没有这两个单元的就位，任何卡应用程序126都不能运行。卡应用程序126z定义要执行的数据处理操作，验证过的身份190c确定这些操作可以在什么计算对象上执行。例如，某特定应用程序126z只能访问文件系统147中与该特定身份190c关联的该身份C的文件202，该特定卡应用程序126z不能访问与该特定身份190c以外的身份关联的其它文件204。

集成电路卡10可以采取其它步骤来保证应用程序和数据的隔离。集成电路卡10具有三个软件部件集：验证过的身份的存取控制列表、基于JAVA的虚拟机、分别保护数据文件、应用程序执行和通信通道的一次性会话密钥。这些部件集联合起来用于一个实施例时，能为一个实施例提供应用程序防火墙149。下面讨论每个软件部件集，然后展示这三个集是如何共同工作来保证在集成电路卡10上隔离应用程序和数据的。

集成电路卡10上每一个受保护的—即对其的访问要受控制的—计算对象(例如数据文件或通信通道)都有一个关联的存取控制列表(ACL)。(特定计算对象的)ACL上的条目的数据格式称为e-tuple：

type(类型)：identity(身份)：permissions(允许)

type域指示后面的(identity域中的)身份—例如某用户(例如“John Smith”)或某小组—的类型。permissions域指示能由该身份对计算对象进行的操作(例如读、追加数据和更新)的一个列表。

例如，假定某数据文件有ACL条目：

USER：AcmeAirlines：RAU，

则任何身份是“AcmeAirlines”的应用程序都能对该数据文件进行读(“R”)、追加数据(“A”)和更新(“U”)。此外，该ACL可以选择性地用于允许创建和删除数据文件。此外，该ACL可以选择性地用于允许执行一个应用程序。

每当某计算对象被运行应用程序200访问时，访问都被卡JVM 16截获并传送到卡操作系统122，后者判断是否有ACL与该对象关联。如果有关联的ACL，则与运行应用程序200关联的身份190c在该ACL上被匹配。如果该身份不存在，或者不允许该身份进行正在请求的类型的访问，则访问被拒绝。否则，就允许进行访问。

参见图13，为了防止由于集成电路卡10与终端14之间只有单一的数据通路而可能产生的问题，要完成通信通道的隔离，方法是在身份验证进程中增加在卡应用程序126z与终端应用程序136之间交换一次性会话密钥209。密钥209然后被用于加密随后在验证终端应用程序136与验证过的卡应用程序126z之间的通信。有了一次性会话密钥209后，无赖终端应用程序既不能“收听”在终端14与集成电路卡10之间的验证过的通信，也不能“电子欺骗”卡应用程序去代表无赖终端应用程序进行没有验证的操作。

卡-终端通信的加密解密，既可以由卡操作系统122处理，也可以有卡应用程序本身126z处理。在前一种情况下，与终端14的通信是对应用程序透明地进行加密的，信息通信解密后到达应用程序的数据空间。在后一种情况下，卡应用程序126z选择进行加密和解密来提供一个额外的安全层，这是因为应用程序能在数据一旦创建时就加密数据，在数据要使用时就解密数据。否则，数据就用会话密钥209保持在加密状态。

所以，应用程序防火墙包括三个互相加强的软件集。数据文件受到验证过的身份存取控制列表的保护。应用程序执行空间受卡JVM 16的保护。通信通道用一次性会话密钥209保护。

在其它实施例中，上述用于微控制器(诸如处理器12)的技术可以控制集成电路卡以外的设备(例如汽车发动机的一部分)。在这些应用中，微控制器提供一个小平台(即一个中央处理单元和一个存储器，二者都位于一个半导体衬底上)来存储和执行高级程序设计语言。多数采用微控制器的现有设备和新设计都能用本发明来提供用高级语言为微控制器编程的能力，特别是包括了本发明对这类设备的应用。

应用程序这个用语包括任何诸如JAVA应用程序、JAVA小应用程序、JAVA aglets、JAVA小服务程序(servlets)、JAVA小通信程序(commlets)、JAVA部件程序，以及其它能产生如下所述的类文件的非JAVA程序。

类文件可以具有一个不是JAVA程序文件的源。有一些非JAVA的程序设计语言也有用于从各自的源文件生成类文件的编译程序或汇编程序。例如，程序设计语言Eiffel可用于用Pirmin Kalberer的“J-Eiffel”来生成类文件。 “J-Eiffel”是具有JVM字节代码生成功能的Eiffel编译程序(web网址：http：∥www.spin.ch/～kalberer/jive/index.htm)。在以下的(本文引为参考的)参考文献中描述了一种将Ada 95到JAVA字节代码的翻译器：《用Ada 95编写因特网程序》(原文标题为“Programming the Internet in Ada95”，作者taft，S.Tucker，1996年发表于’96欧洲Ada学会会刊)。Jasmin是一种JAVA字节代码汇编程序，能用于生成类文件，方法如以下的(本文引为参考的)参考文献中所描述：《JAVA虚拟机》(原文标题为“JAVA Virtual Machine”作者Meyer、Jon和Troy Downing，1997年O’Reilly出版)。不管类文件的源是什么，上述描述可应用于JAVA以外的语言以生成要被解释的代码。

图21表示一种集成电路卡或智能卡，它包括的微控制器210安装在塑料卡212上。塑料卡212具有与典型的信用卡大致相同的形式因素。通信器12a能用接触焊点(contact pad)214来建立通信通道，通信器12a或者也能采用无线通信系统。

在其它实施例中，微控制器210被安装在移动式或固定的电话220中，实际上向电话添加了智能卡的功能，如图22所示。在这些实施例中，微控制器210被安装在能插入电话220或从电话中摘除的模块(诸如用户身份模块(SIM-Subscribe Identity Module))中。

在其它实施例中，微控制器210被加到钥匙环230上，如图23所示。这可用于保护安装有识别与钥匙环230上微控制器210相关联的身份的装备的汽车的出入。

诸如手表或戒指240等贵重物品上也能以符合人机工程学的方式安装微控制器210，如图24所示。这种实施例通常用无线通信系统来建立通信通道，是一种对用户妨碍最小的存取控制的实现方式。

图25表示一个在汽车254的电子子系统252中安装的微控制器210。在这个实施例中，微控制器被用于各种用途，诸如控制进出汽车(例如检查身份或驾车人是否清醒后才启动汽车的点火系统)、通过无线通信来付路桥费、或者与全球定位系统(GPS)交互作用来追踪汽车的位置，如此等等。

本文描述了本发明的特定实施例，但本领域的熟练人员通过阅读本说明书显然知道存在各种修改和替代方案。这种修改和替代并不超出本发明的范围，被包含在后附的诸项权利要求内。

附录A

优选实施例的卡类文件格式

介绍

该卡类文件是原始类文件的一种压缩形式。卡类文件只含有解释从原始类文件来的JAVA程序所需的语文数据。原始类文件中的间接引用被替换为直接引用，结果产生一种紧凑的表示。

卡类文件的格式基于下列原则：

贴近标准类文件格式。卡类文件格式应当尽可能地接近标准类文件格式。类文件中的JAVA字节代码保持不变。不改变字节代码，保证了对它们的结构和静态约束依然可以验证是完好无缺的。

容易实现。卡类文件格式应当足够简单，以吸引JAVA虚拟机的实现者。它必须允许不同形式但行为相当的实现。

可行性。卡类文件格式必须紧凑，以便能与智能卡技术结合。必须既符合当今技术条件，又不失对明日创新的远见。

本文件基于题为《JAVATM虚拟机规范》[1]一书中的第4章“类文件格式”，此后称该书为红皮书。由于本文件基于红皮书中说明的标准类文件格式，我们只展示不同的数据。任何澄清都要以红皮书为最终权威依据。

与标准类文件格式的主要不同之处是：

常量池被优化成只含有16位的标识符，在可能的地方，间接引用被替换成直接引用。

原始类文件中的属性被剔除或重新分组。

JAVA卡类文件格式

本节描述JAVA卡类文件格式。每个卡类文件含有一个或许多JAVA类型，其中的类型可以是类或界面。

卡类文件由8位字节的流组成。所有16位、32位和64位数都是通过分别读取两个、四个和八个连续的8位字节而构造的。多字节的数据项总是以大结尾顺序(big-endian order)存储的，其中高位字节位于前面。在JAVA语言中，这种格式受界面java.io.DataInput和java.io.DataOutput以及诸如java.io.DataInputStream和java.io.DataOutputStream的类的支持。

我们定义并使用相同的数据类型集表示Java类文件数据：类型u1、u2和u4分别代表无符号的1字节、2字节或4字节数。在JAVA语言中，这些类型可以被诸如界面java.io.DataInput的readUnsignedByte、readUnsignedShort和readInt的过程读取。卡类文件格式采用用与C语言相象的结构记号编写的伪结构来表示。为了避免与JAVA卡虚拟机类和类实例的域混淆，描述卡类文件格式的结构的内容被称为项。与C结构的域不同，连续的项被顺序存储在卡类文件中，没有填充或对齐。由可变长项组成的可变长表在几个类文件结构中被使用。尽管将用类似C的数组语法来引用表项，但事实上表是可变长度结构的流，这就意味着不可能直接将表索引翻译成表内字节位移地址。

当我们称某数据为数组时，它实际就是一个数组。

为了区别卡类文件结构与标准类文件结构，我们增加了大写表示法。例如我们将原始类文件中的field_info重新命名为卡类文件中的FieldInfo。

卡类文件

卡类文件含有一个单一的CardClassFile结构：

CardClassFile{

u1 major_version；

u1 minor_version；

u2 name_index；

u2 const_size；

u2 max_class；

Cpinfo constant_pool[const_size]；

ClassInfo class[max_class]；

}

CardClassFile结构中的项如下：

minor_version，major_version

minor_version和major_version项的值是产生该卡类文件的卡外JAVA卡虚拟机的低和高版本号。JAVA卡虚拟机的实现一般支持具有给定高版本号和0到某特定minor_version的低版本号的卡类文件。

只有Java卡论坛(Java Card Forum)才可以定义卡类文件版本号的意思。

name_index

name_index的值必须代表一个有效的Java类名。由name_index代表的Java类名必须与要在卡中运行的主应用程序对应的Java类名严格相同。卡类文件含有若干类或界面，是它们构成了在卡中运行的应用程序。由于Java允许每个类都含有一个主过程，必须有方法来区别含有与卡应用程序对应的主过程的类文件。

const_size

const_size的值给出在卡类文件常量池中条目的数量。constant_pool下标如果大于等于0并且小于const_size时才被视为有效。

max_class

该值指的是卡类文件中出现的类的数目。由于Java卡中的名字归结和链接都是由卡外Java虚拟机完成的，所以应用程序所需的所有类文件或类都被一起放置在一个卡类文件中。

constant_pool[]

constant_pool是一个可变长度结构的表()，代表各种串常量、类名、域名和其它在CardClassFile结构和其子结构内被引用的常量。

卡类文件中的第一个条目是constant_pool[0]。

下标在0到const_size的constant_pool表的每个条目都是一个可变长度的结构()。

class[]

该类是构成加载到卡上的应用程序的max_class个类的一个表。

constant_pool

所有constant_pool表条目都具有以下的通用格式：

CpInfo{

u1 tag；

u1 info[]；

}

constant_pool表中的每项都必须以标志cp_info条目的种类的1字节的标签开始。该info数组的内容随标签的值而变化。有效标签以及它们的值与红皮书中规定的一样。

每个标签字节后必须跟随两个或更多给出有关特定常量的数据的字节。额外数据的格式随标签值而变。

当前要包括的标签只有CONSTANT_Class、CONSTANT_FiledRef、CONSTANT_MethodRef和CONSTANT_InterfaceRef。也可以增加对其它标签的支持，因为它们包含在规范中。

CONSTANT_Class

CONSTANT_Class_info结构用于代表一个类或一个界面：

CONSTANT_Classinfo{

u1 tag；

u2 name_index；

}

CONSTANT_Class_info结构的诸项如下所述：

tag

tag项具有值CONSTANT_Class(7)。

name_index

name_index的值必须代表一个有效的Java类名。由name_index代表的Java类名必须是与由原始类文件的constant_pool中对应的CONSTANT_Class条目所描述的完全相同的Java类名。

CONSTANT_Fieldref、CONSTANT_Methodref和CONSTANT_InterfaceMethodref域、过程和界面过程由类似结构代表：

CONSTANT_FieldrefInfo{

u1 tag；

u2 class_index；

u2 name_sig_index；

}

CONSTANT_MethodrefInfo{

u1 tag；

u2 class_index；

u2 name_sig_index；

}

CONSTANT_InterfaceMethodrefInfo{

u1 tag；

u2 class_index；

u2 name_sig_index；

}

这些结构的诸项如下所述：

tag

CONSTANT_FieldrefInfo结构的tag项具有值CONSTANT_Fieldref(9)。

CONSTANT_MethodrefInfo结构的tag项具有值CONSTANT_Methodref(10)。

CONSTANT_InterfaceMethodrefInfo结构的tag项具有值CONSTANT_InterfaceMethodref(11)。

CLass_index

class_index项的值必须代表一个有效的Java类或界面名。由class_index代表的名必须是与由原始类文件的constant_pool中对应的CONSTANT_Class_info条目所描述的完全相同的名。

name_sig_index

name_sig_index的值必须代表一个有效的Java名和类型。由name_sig_index代表的名和类型必须是与由原始类文件的constant_pool结构中的CONSTANT_NameAndType_info条目所描述的完全相同的名和类型。

Class

每个Class都由一个定长的ClassInfo结构来描述。这种结构的格式是：

ClassInfo{

u2 name_index；

u1 max_field；

u1 max_sfield；

u1 max_method；

u1 max_interface；

u2 superclass；

u2 access_flags

FieldInfo field[max_field+max_sfield]；

InterfaceInfo interface[max_interface]；

MethodInfo method[max_method]；

}

ClassInfo结构的诸项如下所述：

name_index

name_index项的值必须代表一个有效的Java类名。由name_index代表的Java类名必须是与由原始类文件的对应ClassFile结构所描述的完全相同的Java类名。

max_field

max_field项的值给出域表中代表由该类或界面类型说明的实例变量的FieldInfo()结构的数目。这个值指的是卡类文件中非静态域的数目。如果类代表一个结构则max_field的值为0。

max_sfield

max_sfield项的值给出域表中代表由该类或界面类型说明的类变量的FieldInfo结构的数目。这个值指的是卡类文件中静态域的数目。

max_method

max_method项的值给出过程表中MethodInfo()结构的数目。

max_interface

max_interface项的值给出该类或界面类型的直接超界面的数目。

superclass

对于一个类来说，superclass项的值必须代表一个有效的Java类名。由superclass代表的Java类名必须是与由原始类文件的对应ClassFile结构所描述的完全相同的Java类名。无论该superclass还是其任何超类都不以是一个最后类。

如果superclass的值是0，则该类必须代表类java.lang.Object，这是唯一没有超类的类或界面。

对于界面来说，superclass的值总是代表Java类java.lang.Object。

access_flags

access_flags项的值是用在类和界面说明中的修改符的一个屏蔽。这些access_flags修改符和它们的值是与原始类文件的对应ClassFile结构中的完全相同的access_flags修改符。

field[]

field表中的每个值都必须是一个定长的FieldInfo()结构，能全面描述类或界面类型中的一个域。field表仅包括那些由该类或界面说明过的域。它不包括代表从超类或超界面继承的域的项。

interface[]

interface数组中每个值都必须代表一个有效的界面名。由每个条目代表的界面名必须是与由原始类文件的对应界面数组所描述的完全相同的界面名。

method[]

method表中的每个值都必须是一个可变长的MethodInfo()结构，能全面描述类或界面中某过程的Java虚拟机代码。

MethodInfo结构代表由该类或界面类型所说明的所有过程，包括实例过程和-对于类来说-类(静态)过程。该method表只包括由该类所显式说明的那些过程。界面只有一个过程<clinit>，即界面初始化过程。说method表不包括表示从超类或超界面所继承的过程的那些项。

Fields

每个field都由一个定长的field_info结构来描述。这种结构的格式是：

FieldInfo{

u2 name_index；

u2 signature_index；

u2 access_flags；

}

FieldInfo结构的诸项如下所述：

name_index

name_index项的值必须代表一个有效的Java域名。由name_index代表的Java域名必须是与由原始类文件的对应field_info结构所描述的完全相同的Java域名。

signature_index

signature_index项的值必须代表一个有效的Java域描述符。由name_index代表的Java域描述符必须是与由原始类文件的对应field_info结构所描述的完全相同的Java域描述符。

access_flags

access_flags项的值是用于描述对域的访问许可和域的特性的修改符的一个屏蔽。这些access_flags修改符和它们的值是与原始类文件的对应field_info结构中的完全相同的access_flags修改符。

methods

每个method(过程)都由一个变长的MethodInfo结构来描述。MethodInfo结构是一个变长的结构，含有用于一个单一Java过程、实例初始化过程、或类或界面初始化过程的Java虚拟机指令和辅助信息。该结构具有以下的格式：

MethodInfo{

u2 name_index；

u2 signature_index；

u1 max_local；

u1 max_arg；

u1 max_stack；

ul access_flags；

u2 code_length

u2 exception_length；

u1 code[code_length]；

{u2 start_pc；

u2 end_pc；

u2 handler_pc；

u2 catch_type；

}einfo[exception_length]；

}

MethodInfo结构的诸项如下所述：

name_index

name_index项的值必须要么代表一个特殊内部过程名-<init>或者<clinit>，要么代表一个有效的Java过程名。由name_index代表的Java过程名必须是与由原始类文件的对应method_info结构所描述的完全相同的Java过程名。

signature_index

signature_index项的值必须代表一个有效的Java过程描述符。由signature_index代表的Java过程描述符必须是与由原始类文件的对应method_info结构所描述的完全相同的Java过程描述符。

max_local

max_local项的值给出该过程所用的局部变量的数目，不包括调用时传递给过程的参数。第一个局部变量的变址值是0。对于一个单字值最大的局部变量变址量是max_locals-1。

max_arg

max_arg项的值规定向该过程传递的参数的最大数目。

max_stack

max_stack项的值规定在执行该过程期间的任何时刻操作数堆栈上的最多字数。

access_flags

access_flags项的值是用于描述对过程或实例初始化过程的访问许可和过程的特性的修改符的一个屏蔽。这些access_flags修改符和它们的值是与原始类文件的对应method_info结构中的完全相同的access_flags修改符。

code_length

code_length项的值给出该过程的代码数组中的字节数。code_length的值必须大于0，代码数组不得为空数组。

exception_length

exception_length项的值给出exception_info表中的条目数。

code[]

code(代码)数组给出实现该过程的Java虚拟机代码的实际字节。当代码数组被读入字节可寻址机器上的存储器中时，如果数组的第一个字节是在4字节边界上对齐的，则表切换(tableswitch)和查找切换(lookupswitch)的32位位移地址是4字节对齐的；关于代码数组对齐的重要性可参阅对这些指令的说明以了解更多情况。对代码数组内容的具体限制很广泛，与《Java虚拟机规范》一文中所述的相同。

einfo[]

einfo数组中的每个条目都描述代码数组中的一个异常处理程序。每个einfo条目都含有以下各项：

start_pc、end_pc

start_pc、end_pc这两项的值表示代码数组中异常处理程序活动时所处的范围。

start_pc的值必须是一个在某指令的操作码的代码数组内的有效变址量。end_pc的值要么必须是在某指令的操作码的代码数组内的有效变址量，要么必须等于code_length即代码数组的长度。start_pc的值必须小于end_pc的值。

start_pc是包含的，end_pc是排除的，就是说，当程序计数器位于区间[start_pc，end_pc]内时，异常处理程序必须是活动的。

handler_pc

handler_pc项的值指示异常处理程序的开始。该项的值必须是代码数组内的一个有效变址，必须是某指令的操作码的变址，必须小于code_length项的值。

catch_type

如果catch_type项的值是非零的，它必须代表一个有效的Java类类型。由catch_type代表的Java类类型必须是与由原始类文件的对应method_info结构中的catch_type所描述的完全相同的Java类类型。该类必须是类Throwable或者它的其中一个子类。异常处理程序仅当被抛出的异常是给定类或者它的其中一个子类的一个实例时才被调用。

如果catch_type项的值为零，则该异常处理程序就对所有异常而被调用。这被用于最终的执行。

Attributes

原始类文件中使用的属性要么被剔除，要么被重组，目的是为了紧凑。

可以将预先定义的属性SourceFile、ConstantValue、Exception、LineNumberTable和Local-VariableTable剔除，而不牺牲Java字节代码解释所需的任何信息。

预先定义的含有特定过程的所有字节代码的属性Code，在对应的MethodInfo结构中被移动。

对Java卡虚拟机代码的限制

过程、实例初始化过程、或者类或界面初始化过程的Java卡虚拟机代码被存储在卡类文件的MethodInfo结构的数组代码中。对这个代码数组的静态的和结构性的两种限制都与红皮书中所述的相同。

Java卡虚拟机和Java卡类文件格式的限制

该版本的《Java卡虚拟机规范》在Java卡虚拟机中施加以下限制：

每个卡的类文件常量池由CardClassFile结构()的16位const_size域限制在65535个条目。这作为对一个单一卡类文件的总体复杂程度的内部限制。这个计数也包括对应卡中应用程序可用的类层次的常量池的条目。

每个过程的代码量由MethodInfo结构中的变址量大小限制在65535个字节。

过程中的局部变量个数由MethodInfo结构()的max_local项的大小限制在255。

类的域的个数由ClassInfo结构()的max_field和max_sfield项的大小限制在510。

类的过程个数由ClassInfo结构()的max_method项的大小限制在255。

操作数堆栈的大小由MethodInfo结构()的Max_stack域限制到255个字。

参考文献

[1]Tim Linfholm and Frank Yellin，The Java Virtual MachineSpeicification，Addison-Wesley，1996.

附录B

串到ID输入和输出

为了卡JVM的正确操作，很重要的一点是对所说明和生成的各ID加以正确的管理。这种管理由串到ID输入文件String-ID INMap中的定义来控制。这个文本文件的基础如以下所示，它说明名字的哪些地方可以用于什么用途。这个映射的一种可能安排可以保留一些ID供卡JVM解释器作内部使用，其余的被分配给卡JVM应用程序。##String-ID INMap文件##  4000-7FFF可供应用程序所用#  F000-FFFE保留供卡JVM作内部使用#constantBase F000    #从F000到FFFF的区域保留

                 #供卡JVM作内部使用

                 #MainApplication      #F000-Startup类的名字

                 #(随各应用程序而变)main()V              #F001-Startup过程的名字

                 #(可以随应用程序而变)java/lang/Object     #F002java/lang/String     #F003<init>()V            #F004<clinit>()V          #F005[L                   #F006[I                   #F007[C                   #F008[B                   #F009[S                   #F000A#constantBase FFF0    #本区保留用于简单返回类型L                    #FFF0V                    #FFF1I                    #FFF2S                    #FFF3C                    #FFF4B                    #FFF5Z                    #FFF6#constantBase 4000    #此处开始的该空间依应用程序而定。实际上，所有要被加载进智能卡中的应用程序都在OX 4000-OX7FFF之间被分配一个它们自己的ID。对于每一个应用程序，这一空间是空闲的，因为不允许所加载的应用程序访问其它应用程序。

一定要注意管理预加载的类库的ID。通过串到ID输出文件String-IDOUTMap文件的生成(可选)可有助于这些ID的管理。这种映射是以新String-ID绑定扩充的String-ID INMap。这些绑定可以是在卡类文件转换器应用程序终止时产生。产生String-ID OUTMap用于在卡上加载的支持库和OS接口。该映射可用作使用加载在该卡上的支持库和OS接口的智能卡应用程序的String-ID INMap。作为一个例子，考虑下面的Java程序，Hello Smart Card.Java。在对其编译时，产生一个类文件Hello Smart Card.Class。该类文件已嵌入表示该类名、过程和类型信息的串中。根据上述的String-ID INMap，卡类文件转换器产生一个卡类文件，该文件用卡类文件转换器分配的ID替换该类文件中的串。表1列出了在Hello Smare Card。Class的常量池中发现的串，这些串具有各自的卡类文件转换器分配的ID。注：一些串(象“Java/Lang/Object”)具有预先分配的值(F002)，一些串(象“()V”)获得一个新值(4004)。Program：HelloSmartCard.javapublic class HelloSmartCard{public byte aVariable；public static void main(){HelloSmartCard h＝new HelloSmartCard()；h.aVariable＝(byte)13；}}String-ID OUT Map的相关条目  附录C由优选实施例中的卡JVM支持的字节代码AALOAD             AASTORE           ACONST_NULLALOAD              ALOAD_0           ALOAD_1ALOAD_2            ALOAD_3           ARETURNARRAYLENGTH        ASTORE            ASTORE_0ASTORE_1           ASTORE_2          ASTORE_3ATHROW             BALOAD            BASTORECHECKCAST          DUP               DUP2DUP2_X1            DUP2_X2           DUP_X1DUP_X2             GETFIELD          GETSTATICGOTO               IADD              IALOADIAND               IASTORE           ICONST_0ICONST_1           ICONST_2          ICONST_3ICONST_4           ICONST_5          ICONST_M1IDIV               IFEQ              IFGEIFGT               IFLE              IFLTIFNE               IFNONNULL         IFNULLIF_ACMPEQ          IF_ACMPNE         IF_ICMPEQIF_ICMPGE          IF_ICMPGT         IF_ICMPLEIF_ICMPLT          IF_ICMPNE         IINCILOAD              ILOAD_0           ILOAD_1ILOAD_2            ILOAD_3           IMULINEG               INSTANCEOF        INT2BYTEINT2CHAR           INT2SHORT         INVOKEINTERFACEINVOKENONVIRTUAL   INVOKESTATIC      INVOKEVIRTUALIOR                IREM              IRETURNISHL               ISHR              ISTOREISTORE_0           ISTORE_1          ISTORE_2ISTORE_3           ISUB              IUSHRIXOR               JSR               LDC1LDC2               LOOKUPSWITCH      NEWNEWARRAY           NOP               POPPOP2               PUTFIELD          PUTSTATICRET                RETURN            SALOADSASTORE            SIPUSH            SWAPTABLESWITCH        BIPUSH优选实施例中支持的字节代码的标准Java字节代码号package util；

/*
* 由该JVM处理的实际Java字节代码的列表
* 参见Lindohlm和Yellin的文章。
*
* 版权属于美国的Schlumberger Austin Products Center，
*           Schlumberger，Austin，Texas，1996。
*/
public interface BytecodeDefn {
  public static final byte j_NOP＝(byte)0；
  public static final byte ACONST_NULL＝(byte)1；
  public static final byte ICONST_M1＝(byte)2；
  public static final byte ICONST_0＝(byte)3；
  public static final byte ICONST_1＝(byte)4；
  public static final byte ICONST_2＝(byte)5；
  public static final byte ICONST_3＝(byte)6；
  public static final byte ICONST_4＝(byte)7；
  public static final byte ICONST_5＝(byte)8；
  public static final byte BIPUSH＝(byte)16；
  public static final byte SIPUSH＝(byte)17；
  public static final byte LDC1＝(byte)18；
  public static final byte LDC2＝(byte)19；
  public static final byte ILOAD＝(byte)21；
  public static final byte ALOAD＝(byte)25；
  public static final byte ILOAD_0＝(byte)26；
  public static final byte ILOAD_1＝(byte)27；
  public static final byte ILOAD_2＝(byte)28；
  public static final byte ILOAD_3＝(byte)29；
  public static final byte ALOAD_0＝(byte)42；
  public static final byte ALOAD_1＝(byte)43；
				
				<dp n="d39"/>
  public static final byte ALOAD_2＝(byte)44；
  public static final byte ALOAD_3＝(byte)45；
  public static final byte IALOAD＝(byte)46；
  public static final byte AALOAD＝(byte)50；
  public static final byte BALOAD＝(byte)51；
  public static final byte CALOAD＝(byte)52；
  public static final byte ISTORE＝(byte)54；
  public static final byte ASTORE＝(byte)58；
  public static final byte ISTORE_0＝(byte)59；
  public static final byte ISTORE_1＝(byte)60；
  public static final byte ISTORE_2＝(byte)61；
  public static final byte ISTORE_3＝(byte)62；
  public static final byte ASTORE_0＝(byte)75；
  public static final byte ASTORE_1＝(byte)76；
  public static final byte ASTORE_2＝(byte)77；
  public static final byte ASTORE_3＝(byte)78；
  public static final byte IASTORE＝(byte)79；
  public static final byte AASTORE＝(byte)83；
  public static final byte BASTORE＝(byte)84；
  public static final byte CASTORE＝(byte)85；
  public static final byte POP＝(byte)87；
  public static final byte POP2＝(byte)88；
  public static final byte DUP＝(byte)89；
  public static final byte DUP_X1＝(byte)90；
  public static final byte DUP_X2＝(byte)91；
  public static final byte DUP2＝(byte)92；
  public static final byte DUP2_X1＝(byte)93；
  public static final byte DUP2_X2＝(byte)94；
  public static final byte SWAP＝(byte)95；
  public static final byte IADD＝(byte)96；
  public static final byte ISUB＝(byte)100；
  public static final byte IMUL＝(byte)104；
  public static final byte IDIV＝(byte)108；
  public static final byte IREM＝(byte)112；
  public static final byte INEG＝(byte)116；
				
				<dp n="d40"/>
  public static final byte ISHL＝(byte)120；
  public static final byte ISHR＝(byte)122；
  public static final byte IUSHR＝(byte)124；
  public static final byte lAND＝(byte)126；
  public static final byte IOR＝(byte)128；
  public static final byte IXOR＝(byte)130；
  public static final byte IINC＝(byte)132；
  public static final byte INT2BYTE＝(byte)145；
  public static final byte INT2CHAR＝(byte)146；
  public static final byte INT2SHORT＝(byte)147；
  public static final byte IFEQ＝(byte)153；
  public static final byte IFNE＝(byte)154；
  public static final byte IFLT＝(byte)155；
  public static final byte IFGE＝(byte)156；
  public static final byte IFGT＝(byte)157；
  public static final byte IFLE＝(byte)158；
  public static final byte IF_ICMPEQ＝(byte)159；
  public static final byte IF_ICMPNE＝(byte)160；
  public static final byte IF_ICMPLT＝(byte)161；
  public static final byte IF_ICMPGE＝(byte)162；
  public static final byte IF_ICMPGT＝(byte)163；
  public static final byte IF_ICMPLE＝(byte)164；
  public static final byte IF_ACMPEQ＝(byte)165；
  public static final byte IF_ACMPNE＝(byte)166；
  public static final byte GOTO＝(byte)167；
  public static final byte j_JSR＝(byte)168；
  public static final byte RET＝(byte)169；
  public static final byte TABLESWITCH＝(byte)170；
  public static final byte LOOKUPSWITCH＝(byte)171；
  public static final byte IRETURN＝(byte)172；
  public static final byte ARETURN＝(byte)176；
  public static final byte RETURN＝(byte)177；
  public static final byte GETSTATIC＝(byte)178；
  public static final byte PUTSTATIC＝(byte)179；
  public static final byte GETFIELD＝(byte)180；
				
				<dp n="d41"/>
  public static final byte PUTFIELD＝(byte)181；
  public static final byte INVOKEVIRTUAL＝(byte)182；
  public static final byte INVOKENONVIRTUAL＝(byte)183；
  public static final byte INVOKESTATIC＝(byte)184；
  pubiic static final byte INVOKEINTERFACE＝(byte)185；
  public static final byte NEW＝(byte)187；
  public static final byte NEWARRAY＝(byte)188；
  public static final byte ARRAYLENGTH＝(byte)190；
  public static final byte ATHROW＝(byte)191；
  public static final byte CHECKCAST＝(byte)192；
  public static final byte INSTANCEOF＝(byte)193；
  public static final byte IFNULL＝(byte)198；
  public static final byte IFNONNULL＝(byte)199；

附录D

卡类文件转换程序的字节代码转换过程

/*
* 再处理代码块
*/
static
void
reprocessMethod(iMethod*imeth)
{
 int pc；
 int npc；
 int align；
 bytecode*code；
 int codelen；
 int i；
 int opad；
 int npad；
 int apc；
 int high；
 int low；
/*Codeinfo表跟踪有效Java字节代码及其对应
 *   的翻译
 */
  code＝imeth-＞external-＞code；
  codelen＝imeth-＞external-＞code_length；
  jumpPos＝0；
  align＝0；
  /*   扫描不支持的操作码         */
  for(pc＝0；pc＜codelen；pc＝npc){
   if(codeinfo[code[pc]].valid＝＝0){

     error(″Unsupported opcode％d″，code[pc])；
				
				<dp n="d43"/>
 }
 npc＝nextPC(pc，code)；
}
/*       扫描跳转指令并插入跳转表             */
for(pc＝0；pc＜codelen；pc＝npc){
 npc＝nextPC(pc，code)；
 if(codeinfo[code[pc]].valid＝＝3){
   insertJump(pc+1，pc，(int16)((code[pc+1]＜＜8)|code[pc+2]))；
 }
 eise if(codeinfo[code[pc]].valid＝＝4){
  apc＝pc&amp;-4；
  low＝(code[apc+8]＜＜24)|(code[apc+9]＜＜16)

     |(code[apc+10]＜＜8)|code[apc+11]；
  high＝(code[apc+12]＜＜24)|(code[apc+13]＜＜16)

     |(code[apc+14]＜＜8)|code[apc+15]；
  for(i＝0；i＜high-low+1；i++){
   insertJump(apc+(i*4)+18，pc，

　　      (int16)((code[apc+(i*4)+18]＜＜8)|code[apc+(i*4)+19]))；
  }
  insertJump(apc+6，pc，(int16)((code[apc+6]＜＜8)|code[apc+7]))；
 }
 else if(codeinfo[code[pc]].valid＝＝5){
  apc＝pc&amp;-4；
  low＝(code[apc+8]＜＜24)|(code[apc+9]＜＜16)

　　 |(code[apc+10]＜＜8)|code[apc+11]；
  for(i＝0；i＜low；i++){
   insertJump(apc+(i*8)+8，pc，

　　      (int16)((code[apc+(i*8)+18]＜＜8)|code[apc+(i*8)+19]))；
  }
  insertJump(apc+6，pc，(int16)((code[apc+6]＜＜8)|code[apc+7]))；
 }
}
				
				<dp n="d44"/>
#ifdef TRANSLATE_BYTECODE
 /*     翻译专用操作的以生成通用操作码    */
 for(pc＝0；pc＜codelen；pc＝npc){
  /*   这是一个翻译代码   */
  if(codeinfo[code[pc]].valid＝＝2){
　　switch(code[pc]){

　　case ILOAD_0：

　　case ILOAD_1：

　　case ILOAD_2：

　　case ILOAD_3：

　　 insertSpace(code，&amp;codelen，pc，1)；

　　 align+＝1；

　　 code[pc+1]＝code[pc]-ILOAD_0；

　　 code[pc+0]＝ILOAD；

　　 break；

　　case ALOAD_0：

　　case ALOAD_1：

　　case ALOAD_2：

　　case ALOAD_3：

　　 insertSpace(code，&amp;codelen，pc，1)；

　　 align+＝1；

　　 code[pc+1]＝code[pc]-ALOAD_0；

　　 code[pc+0]＝ALOAD；

　　 break；

　　case ISTORE_0：

　　case ISTORE_1：

　　case ISTORE_2：

　　case ISTORE_3：

　　 insertSpace(code，&amp;codelen，pc，1)；

　　 align+＝1；

　　 code[pc+1]＝code[pc]-ISTORE_0；

　　 code[pc+0]＝ISTORE；
				
				<dp n="d45"/>
　　 break；

　　case ASTORE_0：

　　case ASTORE_1：

　　case ASTORE_2：

　　case ASTORE_3：

　　 insertSpace(code，&amp;codelen，pc，1)；

　　 align+＝1；

　　 code[pc+1]＝code[pc]-ASTORE_0；

　　 code[pc+0]＝ASTORE；

　　 break；

　　case ICONST_M1：

　　 insertSpace(code，&amp;codelen，pc，2)；

　　 align+＝2；

　　 code[pc+2]＝255；
　　 code[pc+1]＝255；

　　 code[pc+0]＝SIPUSH；

　　 break；

　　case ICONST_0：

　　case ICONST_1：

　　case ICONST_2：

　　case ICONST_3：

　　case ICONST_4：

　　case ICONST_5：

　　 insertSpace(code，&amp;codelen，pc，2)；

　　 align+＝2；

　　 code[pc+2]＝code[pc]-ICONST_0；

　　 code[pc+1]＝0；

　　 code[pc+0]＝SIPUSH；

　　 break；

　　case LDC1：

　　 insertSpace(code，&amp;codelen，pc，1)；
				
				<dp n="d46"/>
　　 align+＝1；

　　 code[pc+1]＝0；

　　 code[pc+0]＝LDC2；

　　 break；
				
				<dp n="d47"/>
  case BIPUSH：

   insertSpace(code，&amp;codelen，pc，1)；

   align+＝1；

   if((int8)code[pc+2]＞＝0){

    code[pc+1]＝0；

   }

   else{

    code[pc+1]＝255；

   }

   code[pc+0]＝SIPUSH；

   break；

  case INT2SHORT：

   removeSpace(code，&amp;codelen，pc，1)；

   align-＝1；

   npc＝pc；

   continue；

  }

}

else if (codeinfo[code[pc]].valid＝＝4||codeinfo[code[pc]].valid＝＝5){

/* 切换被对齐到4字节的边界。由于我们在插入，删除字节代码，

*  这会改变切换指令的对齐。

*  因此我们必须重新调整切换中的填充来加以补偿。

*/

opad＝(4-(((pc+1)-align)％4))％4；/*当前切换填充   */

npad＝(4-((pc+1)％4))％4；/*新切换填充    /*

if(npad＞opad){

 insertSpace(code，&amp;codelen，pc+1，npad-opad)；

 align+＝(npad-opad)；

}

else if(npad＜opad){

 removeSpace(code，&amp;codelen，pc+1，opad-npad)；

 align-＝(opad-npad)；

}
				
				<dp n="d48"/>
  }

  npc＝nextPC(pc，code)；

 }

#endif

/*  重链接常量    */

for(pc＝0；pc＜codelen；pc＝npc){

 npc＝nextPC(pc，code)；

 i＝(uint16)((code[pc+1]＜＜8)+code[pc+2])；

 switch(code[pc]){

 case LDC2：

 /*′i′＝＝通用变址 */

 switch(cltem(i).type){

 case CONSTANNT_Integer：

  i＝cltem(i).v.tint；

  code[pc]＝SIPUSH；

  break；

 case CONSTANT_String：

  i＝buildStringindex(i)；

  break；

 default：

  error(″Unsupported loading of constant type″)；

  break；

 }

 break；

case NEW：

case INSTANCEOF：

case CHECKCAST：

 /*′i′＝＝类变址 */
				
				<dp n="d49"/>
   i＝buildClassIndex(i)；

   break；

  case GETFIELD：

  case PUTFIELD：

   /*′i′＝＝域变址   */

   /*i＝buildFieldSignaturelndex(i)；*/

   i＝buildStaticFieldSignaturelndex(i)；

   break；

  case GETSTATIC：

  case PUTSTATIC：

   /*′i′＝＝域变址  */

   i＝buildStaticFieldSignaturelndex(i)；

   break；

  case INVOKEVIRTUAL：

  case INVOKENONVIRTUAL

  case INVOKESTATIC：

  case INVOKEINTERFACE：

   /*′i′＝＝过程签名变址        */

   i＝buildSignaturelndex(i)；

   break；

  }
  /*插入应用程序的常量引用              */

  code[pc+1]＝(i＞＞8)&amp;0×FF；

  code[pc+2]＝i &amp;0×FF；

 }

#ifdef MODIFY_BYTECODE

 /*翻译代码   */

 for(pc＝0；pc＜codelen；pc＝npc){

  npc＝nextPC(pc，code)；
				
				<dp n="d50"/>
  code[pc]＝codeinfo[code[pc]].translation；
 }

#endif

 /* 重链接跳转*/

 for(i＝0；i＜jumpPos；i++){

  apc＝jumpTable[i]at；

  pc＝jumpTable[i].from；

  npc＝jumpTable[i].to-pc；

  code[apc+0]＝(npc＞＞8)&amp;0×FF；

  code[apc+1]＝npc&amp;0×FF；

 }

  /*固定长度*/

  imeth-＞external-＞code_length＝codelen；

  imeth-＞esize＝(SIZEOFMETHOD+codelen+3)&amp;-4；

 }

附录E

加载和执行控制程序举例

public class Bootstrap{
 ∥ 整个程序所使用的常量
 static final byte BUFFER_LENGTH           ＝32；
 static final byte ACK_SIZE           ＝(byte)1；
 static final byte ACK_CODE            ＝(byte)0；
 static final byte OS_HEADER_SIZE          ＝(byte)0×10；
 static final byte GPOS_CREATE_FILE         ＝(byte)0×E0；
 static final byte ST_INVALID_CLASS        ＝(byte)0×C0；
 static final byte ST_INVALID_PARAMETER      ＝(byte)0×A0；
 static final byte ST_INS_NOT_SUPPORTED       ＝(byte)0×B0；
 static final byte ST_SUCCESS      ＝(byte)0×00；
 static final byte ISO_COMMAND_LENGTH      ＝(byte)5；
 static final byte ISO_READ_BINARY    ＝(byte)0×B0；
 static final byte ISO_UPDATE_BINARY   ＝(byte)0×D6；
 static final byte ISO_INIT_APPLICATION＝(byte)0×F2；
 static final byte ISO_VERIFY_KEY    ＝(byte)0×2A；
 static final byte ISO_SELECT_FILE   ＝(byte)0×A4；
 static final byte ISO_CLASS     ＝(byte)0×C0；
 static final byte ISO_APP_CLASS     ＝(byte)0×F0；
 public static void main () {
  byte pbuffer[]＝new byte[ISO_COMMAND_LENGTH]；
  byte dbuffer[]＝new byte[BUFFER_LENGTH]；
  byte ackByte[]＝new byte[ACK_SIZE]；
  ∥short fileld；
  short offset；
				
				<dp n="d52"/>
byte bReturnStatus；

∥初始化通信

_OS.SendATR()；

do{

 ∥提取命令首部

 _OS.GetMessage(pbuffer，ISO_COMMAND_LENGTH，ACK_CODE)；

 ∥检验报文的类-仅ISO和应用程序

 if((pbuffer[0]！＝ISO_APP_CLASS)

  &amp;&amp;(pbuffer[0]！＝ISO_CLASS)){

   _OS.SendStatus(ST_INVALID_CLASS)；

 }

 else{

 ∥通过切换

 ∥发送应答代码

 ∥检验数据长度是否太大
 if(pbuffer[4]＞BUFFER_LENGTH){

  bReturnStatus＝ST_INVALID_PARAMETER；

 }

 else

 {

  switch(pbuffer[1]){

  case ISO_SELECT_FILE：

    ∥假定长度总是2

    if(pbuffer[4]！＝2){

       bReturnStatus＝ST_INVALID_PARAMETER；

    }

    else

    {

      ∥读取数据缓冲器中的field(offset)

      _OS.GetMessage(dbuffer，(byte)2，pbuffer[1])；

      ∥将dbuffer[0..1]变换成短整数
				
				<dp n="d53"/>
　　offset＝(short)((dbuffer[0]＜＜8)|(dbuffer[1]&amp; 0×00FF))；

　　bReturnStatus＝_OS.SelectFile(offset)；
  }
  break；
case ISO_VERIFY_KEY：
  ∥从终端取得密钥
  _OS.GetMessage(dbuffer，pbuffer[4]，pbuffer[1])；
  bReturnStatus＝_OS.VerifyKey(pbuffer[3]，

　　              dbuffer，

　　              pbuffer[4])；
  break；
case ISO_INIT_APPLICATION：
  ∥应发送有效程序文件的ID
  _OS.GetMessage(dbuffer，(byte)1，pbuffer[1])；
  ∥通过变换从pbuffer[2..3]计算fileld(offset)
  offset＝(short)((pbuffer[2]＜＜8)|(pbuffer[3]&amp; 0×00FF))；
  bReturnStatus＝_OS.Execute(offset，

　　             dbuffer[0])；
  break；
case GPOS_CREATE_FILE：
  if(pbuffer[4]！＝OS_HEADER_SIZE){

　　 bReturnStatus＝ST_INVALID_PARAMETER；

　　 break；
  }
  ∥接收数据
  _OS.GetMessage(dbuffer，pbuffer[4]，pbuffer[1])；
  bReturStatus＝_OS.CreateFile(dbuffer)；  
  break；
case ISO_UPDATE_BINARY：
  _OS.GetMessage(dbuffer，pbuffer[4]，pbuffer[1])；
  ∥通过变换从pbuffer[2..3]计算偏移
				
				<dp n="d54"/>
　　   offset＝(short)((pbuffer[2]＜＜8)|(pbuffer[3]&amp;0×00FF))；

　　   ∥假定有文件已被选择

　　   bReturnStatus＝_OS.WriteBinaryFile(offset，

　　                       pbuffer[4]，

　　                       dbuffer)；

　　   break；

　　 case ISO_READ_BINARY：

　　   ∥通过变换从pbuffer[2..3]计算偏移

　　   offset＝(short)((pbuffer[2]＜＜8)|(pbuffer[3]&amp;0×00FF))；

　　   ∥假定某文件已经被选择

　　   bReturnStatus＝_OS.ReadBinaryFile(offset，

　　                      pbuffer[4]，

　　                      dbuffer)；

　　   ∥如果成功则发送数据

　　   ackByte[0]＝pbuffer[1]；

　　   if(bReturnStatus＝＝ST_SUCCESS){

　　      _OS.SendMessage(ackByte，ACK_SIZE)；

　　      _OS.SendMessage(dbuffer，pbuffer[4])；

　　    }

　　    break；

　　  default：

　　    bReturnStatus＝ST_INS_NOT_SUPPORTED；

　　  }

　　 }

　　_OS.SendStatus(bReturnStatus)；
   }
  }
  while(true)；
 }
}

附录F

优选实施例中访问卡操作系统功能的过程

pubiic class_OS{
 static native byte    SelectFile    (short file_id)；
 static native byte    SelectParent   ()；
 static native byte    SelectCD      ()；
 static native byte    SelectRoot    ()；
 static native byte    CreateFile    (byte file_hdr[])；
 static native byte    DeleteFile    (short file_id)；
 ∥一般文件操作
 static native byte    ResetFile     ()；
 static native byte    ReadByte      (byte offset)；
 static native short   ReadVVord     (byte offset)；
 ∥首部操作
 static native byte    GetFilelnfo   (byte file_hdr[])；
 ∥二进制文件支持
 static native byte    ReadBinaryFile (short offset，

　　                          byte data_length，

　　                          byte buffer[])；
 static native byte    WriteBinaryFile (short offset，

　　                          byte data_length，

　　                          byte buffer[])；
 ∥记录文件支持
 static native byte    SelectRecord    (byte record_nb，

　　                          byte mode)；
 static native byte    NextRecord     ()；
 static native byte    PreviousRecord    ()；
				
				<dp n="d56"/>
 static native byte    ReadRecord     (byte record_data[]，

　　                        byte record_nb，

　　                        byte offset，

　　                        byte length)；
 static native byte    WriteRecord     (byte buffer[]，

　　                        byte record_nb，

　　                        byte offset，

　　                        byte length)；
 ∥循环文件支持
 static native byte   LastUpdatedRec   ()；
 ∥报文传递功能
 static native byte   GetMessage      (byte buffer[]，

　　                        byte expected_length，

　　                        byte ack_code)；
 static native byte   SendMessage     (byte buffer[]，

　　                        byte data_length)；
 static native byte   SetSpeed       (byte speed)；
 ∥身份管理
 static native byte   CheckAccess     (byte ac_action)；
 static native byte   VerifyKey     (byte key_number，

　　                         byte key_buffer[]，

　　                         byte key_length)；
 static native byte   VerifyCHV       (byte CHV_number，

　　                         byte CHV_bufferr[]，

　　                         byte unblock_flag)；
 static native byte   ModifyCHV       (byte CHV_number，

　　                         byte old_CHV_buffer[]，

　　                         byte new_CHV_buffer[]，

　　                         byte unblock_flag)；
				
				<dp n="d57"/>
 static native byte    GetFileStatus  ()；
 static native byte    SetFileStatus  (byte file_status)；
 static native byte    GrantSupervisorMode()；
 static native byte    RevokeSupervisorMode()；
 static native byte    SetFileACL      (byte file_acl[])；
 static native byte    GetFileACL      (byte file_acl[])；
 ∥文件上下文操作
 static native void    InitFileStatus()；
 static native void    BackupFileStatus()；
 static native void    RestoreFileStatus()；
 ∥实用程序
 static native byte    CompareBuffer   (byte patterm_length，

　　                         byte buffer_1[]，

　　                         byte buffer_2[])；
 static native short   AvailableMemory  ()；
 static native void    ResetCard    (byte mode)；
 static native byte    SendATR      ()；
 static native byte    SetDefaultATR  (byte buffer□，

　　                          byte length)；
 static native byte    Execute     (short file_id，

　　                          byte flag)；
 ∥全局状态变量函数
 static native byte     Getldentity  ()；
 static native byte     GetRecordNb    ()；
 static native short    GetApplicationld  ()；
 static native byte     GetRecordLength  ()；
 static native byte     GetFileType   ()；
 static native short    GetFileLength    ()；
 static native void    SendStatus      (byte status)；
				
				<dp n="d58"/>
}

附录G

字节代码属性表

划分Java字节代码成类型组

每个字节代码都被分配一个与之关联的5位类型。它用于将

代码划分为行为相似的各个集合。一般来说，这种行为反

映的是各类型的字节代码是如何在堆栈上操作的；但是，

类型0、13、14和15反映的是特殊种类的指令，如注解

栏所注明。

下表表示在每类指令被执行前后堆栈的状态。

类型       执行前             执行后             注解

0                                               非法指令

1   stk0＝＝int stk1＝＝int   pop(1)

2   stk0＝＝int               pop(1)

3   stk0＝＝int stk1＝＝int   pop(2)

4

5   push(1)

6   stk0＝＝int stk1＝＝int   pop(3)

7   stk0＝＝int               pop(1)

8   stk0＝＝ref               pop(1)

9   stk0＝＝int               pop(1)

10  push(1)                   stk0＜-int

11  push(1)                   stk0＜-ref

12  stk0＝＝ref               stk0＜-int

13                                             DUPs，SWAP指令

14                                             INVOKE指令

15                                             FIELDS指令

16                           stk0＜-ref

使用标准Java字节代码(设有重新排序)-属性查找表

　　/*

　　*字节代码译码信息表。该表内容是字节代码类型和

　　*字节代码长度。当前支持代码0-201的所有

　　*标准字节代码(共202个代码)

　　*/

　　#define    T_   0

　　#define    T3   1

　　#define    T6   2

　　#define    T1   3

　　#define    T2   4

　　#define    T7   5

　　#define    T9   6

　　#define    T8   7

　　#define    T12  8

　　#define    T10  9

　　#define    T5   10

　　#define    T11  11

　　#define    T16  12

　　#define    T4   13

　　#define    T13  14

　　#define    T14  15

　　#define    T15  16

　　#define    D(T，L)

　　_BUILD_ITYPE_AND_ILENGTH(T，L)

　　#define   _BUILD_ITYPE_AND_ILENGTH(T，L)

　　(_BUILD_ITYPE(T)I_BUILD_ILENGTH(L))

　　#define   _BUILD_ITYPE(T)          ((T)＜＜3)

　　#define   _BUILD_ILENGTH(L)               (L)

　　#define   _GET_ITYPE(I)                   ((I)&0×F8)

　　#define   _GET_ILENGTH(I)          ((I)&0×07)
				
				<dp n="d61"/>
const uint8_SCODE_decodeinfo[256]＝{

　　  D(T4，1)，     /* NOP         */

　　  D(T11，1)，    /* ACONST_NULL */

　　  D(T10，1)，    /* ICONST_M1   */

　　  D(T10，1)，    /* ICONST_0    */

　　  D(T10，1)，    /* ICONST_1    */

　　  D(T10，1)，    /* ICONST_2    */

　　  D(T10，1)，    /* ICONST_3    */

　　  D(T10，1)，    /* ICONST_4    */

　　  D(T10，1)，    /* ICONST_5    */

　　  D(T_，1)，

　　  D(T_，1)，

　　  D(T_，1)，

　　  D(T_，1)，

　　  D(T_，1)，

　　  D(T_，1)，

　　  D(T_，1)，

　　  D(T10，2)，    /* BIPUSH */

　　  D(T10，3)，    /* SIPUSH */

　　  D(T_，2)，     /* LDC1        */

　　  D(T11，3)，    /* LDC2        */

　　  D(T_，3)，

　　  D(T5，2)，     /*ILOAD   */

　　  D(T_，2)，

　　  D(T_，2)，

　　  D(T_，2)，

　　  D(T5，2)，     /*ALOAD   */

　　  D(T5，1)，     /*ILOAD_0 */

　　  D(T5，1)，     /*ILOAD_1 */

　　  D(T5，1)，     /*ILOAD_2 */

　　  D(T5，1)，     /*ILOAD_3 */

　　  D(T_，1)，

　　  D(T_，1)，

　　  D(T_，1)，

　　  D(T_，1)，
				
				<dp n="d62"/>
  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T5，1)，      /*ALOAD_0  */

  D(T5，1)，      /*ALOAD_1  */

  D(T5，1)，      /*ALOAD_2  */
  D(T5，1)，      /*ALOAD_3  */

  D(T_，1)，      /*IALOAD   */

  D(T_，1)，

  D(T_，1)，
  D(T_，1)，

  D(T_，1)，      /*AALOAD   */

  D(T7，1)，      /*BALOAD   */

  D(T_，1)，      /*CALOAD   */

  D(T7，1)，      /*SALOAD   */

  D(T2，2)，      /*ISTORE   */

  D(T_，2)，

  D(T_，2)，

  D(T_，2)，

  D(T8，2)，      /*ASTORE   */

  D(T2，1)，      /*ISTORE_0      */

  D(T2，1)，      /*ISTORE_1      */

  D(T2，1)，      /*ISTORE_2      */

  D(T2，1)，      /*ISTORE_3      */

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，
				
				<dp n="d63"/>
  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T8，1)，      /*ASTORE_0     */

  D(T8，1)，      /*ASTORE_1     */

  D(T8，1)，      /*ASTORE_2     */

  D(T8，1)，      /*ASTORE_3     */

  D(T_，1)，      /*IASTORE */

  D(T_，1)，

  D(T_，1)，
  D(T_，1)，

  D(T_，1)，      /*AASTORE      */

  D(T6，1)，      /*BASTORE      */

  D(T_，1)，      /*CASTORE      */

  D(T6，1)，      /*SASTORE      */

  D(T2，1)，      /*POP          */

  D(T3，1)，      /*POP2         */

  D(T13，1)，     /*DUP          */

  D(T13，1)，     /*DUP_X1  */

  D(T13，1)，     /*DUP_X2  */

  D(T13，1)，     /*DUP2         */

  D(T13，1)，     /*DUP2_X1 */

  D(T13，1)，     /*DUP2_X2 */

  D(T13，1)，     /*SWAP         */

  D(T1，1)，      /*IADD         */

  D(T_，1)，

  D(T_，1)，

  D(T1，1)，

  D(T_，1)，      /*ISUB         */

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，
				
				<dp n="d64"/>
  D(T1，1)，     /*IMUL        */

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T1，1)，     /*IDIV        */

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T1，1)，     /*IREM        */

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T9，1)，     /* INEG       */

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T1，1)，     /* ISHL       */

  D(T_，1)，

  D(T1，1)，     /*ISHR        */

  D(T_，1)，

  D(T1，1)，     /*IUSHR       */

  D(T_，1)，

  D(T1，1)，     /*IAND        */

  D(T_，1)，

  D(T1，1)，     /*IOR         */

  D(T_，1)，

  D(T1，1)，     /*IXOR        */

  D(T_，1)，

  D(T4，3)，     /* IINC       */

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，
				
				<dp n="d65"/>
  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T9，1)，     /*INT2BYTE    */

  D(T9，1)，     /*INT2CHAR    */

  D(T_，1)，     /*INT2SHORT   */

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T2，3)，     /*IFEQ        */

  D(T2，3)，     /*IFNE        */

  D(T2，3)，     /*IFLT        */

  D(T2，3)，     /*IFGE        */

  D(T2，3)，     /*IFGT        */

  D(T2，3)，     /*IFLT        */

  D(T3，3)，     /*IF_ICMPEQ   */

  D(T3，3)，     /*IF_ICMPNE   */

  D(T3，3)，     /*IF_ICMPLT   */

  D(T3，3)，     /*IF_ICMPGE   */

  D(T3，3)，     /*IF_ICMPGT   */

  D(T3，3)，     /*IF_ICMPLE   */

  D(T3，3)，     /*IF_ACMPEQ   */

  D(T3，3)，     /*IF_ACMPNE   */

  D(T4，3)，     /*GOTO        */

  D(T_，3)，     /*JSR         */

  D(T_，2)，     /*RET         */

  D(T2，0)，     /*TABLESWITCH */

  D(T2，0)，     /*LOOKUPSWITCH*/

  D(T2，1)，     /*IRETURN */

  D(T_，1)，
				
				<dp n="d66"/>
  D(T_，1)，

  D(T_，1)，

  D(T8，1)，      /* ARETURN      */

  D(T4，1)，      /*RETURN        */

  D(T15，3)，     /*GETSTATIC     */

  D(T15，3)，     /*PUTSTATIC     */

  D(T15，3)，     /*GETFIELD      */

  D(T15，3)，     /*PUTFIELD      */

  D(T14，3)，     /*INVOKEVIRTUAL */

  D(T14，3)，     /*INVOKESPECIAL */

  D(T14，3)，     /*INVOKESTATIC */

  D(T14，5)，     /*INVOKEINTERFACE */

  D(T_，1)，

  D(T11，3)，     /* NEW         */

  D(T16，2)，     /* NEWARRAY    */

  D(T_，3)，

  D(T12，1)，     /*ARRAYLENGTH  */

  D(T8，1)，      /* ATHROW      */

  D(T16，3)，     /* CHECKCAST   */

  D(T12，3)，     /* INSTANCEOF  */

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，4)，

  D(T8，3)，      /*IFNULL    */

  D(T8，3)，      /*IFNONNULL    */

  D(T_，5)，

  D(T_，5)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，
  D(T_，1)，

  D(T_，1)，
				
				<dp n="d67"/>
  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，
  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，
  D(T_，1)，
				
				<dp n="d68"/>
  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，

  D(T_，1)，
}；

附录H

通过类型对Java字节代码进行的检查

将指令解码，得出要生成下一个PC的长度、以及指令类型：

     pcarg1＝_GET_ILENGTH(_decodeinfo[insn])；

　     itype＝_GET_ITYPE(_decodeinfo[insn])；

　　   根据以下内容进行一些执行前检查：

　　   /*    根据指令类型来检查输入堆栈类型    */

　　   if(itype＜＝ITYPE9){

　　         if(itype＜＝ITYPE1){

　　               check_stack_int(1)；

　　         }

　　         check_stack_int(0)；

　　   }

　　   else if(itype＜＝ITYPE12){

　　        check_stack_ref(0)；

　　   }

　　   else if(itype＜ITYPE11){

　　        push(1)；

　　   }

　　 最后，进行一些执行后的检查：

　　   /*  设置输出状态  */

　　   if(itype＜＝ITYPE8){

　　         if(itype＜＝ITYPE6){

　　               if (itype＞＝ITYPE6){

　　                      pop(1)；

　　               }
				
				<dp n="d70"/>
　　     pop(1)；

　　 }

　　 pop(1)；
}
else if(itype＜＝ITYPE10){

　　 set_stack_int(0)；
}
else if(itype＞＝ITYPE11 &amp;&amp; itype＜＝ITYPE16){

　　 set_stack_ref(0)；
}

附录I

对重编号的Java字节代码进行的检查

取指令。指令的数字值隐含地包括指令类型：

insn＝getpc(-1)；根据以下内容进行一些执行前检查：

  /*

       *检查输入堆栈状态。通过对字节代码重新编号，

　　   *如果字节代码的值(因此字节代码)属于正确的

　　   *组，则能通过测试而进行必需的安全检查。

　　   */

　　   if(insn＜＝TYPE9_END){

　　    if(insn＜＝TYPE1_END){

　　      check_stack_int(1)；

　　    }

　　    check_stack_int(0)；

　　   }

　　   else if(insn＜＝TYPE12_END){

　　    check_stack_ref(0)；

　　   }

　　   else if(insn＜＝TYPE11_END){

　　     push(1)

　　   }

　　最后，进行一些执行后检查：

　　  /*
				
				<dp n="d72"/>
*设置输出堆栈状态。
*/
if(insn＜＝TYPE8_END){
 if(insn＜＝TYPE6_END){
  if(insn＞＝TYPE6_START){

　　pop(1)；
   }
   pop(1)；
  }
  pop(1)；
 }
 else if(insn＜＝TYPE10_END){
  set_stack_int(0)；
 }
 else if(insn＞＝TYPE11_START &amp;&amp; insn＜＝TYPE16_END){
  set_stack_ref(0)；
 }
				
				<dp n="d73"/>
按类型来对所支持的Java字节代码进行重定序
/*类型3*/
#define s_POP2       0
#define s_IF_ICMPEQ  1
#define s_IF_ICMPNE  2
#define s_IF_ICMPLT  3
#define s_IF_ICMPGE  4
#define s_IF_ICMPGT  5
#define s_IF_ICMPLE  6
#define s_IF_ACMPEQ  7
#define s_IF_ACMPNE  8
/*类型6*/
#define TYPE6_START  9 
#define s_SASTORE    9
#define s_AASTORE    10
#define s_BASTORE    11
#define TYPE6_END    12
/*类型1*/
#define s_IADD       13
#define s_ISUB       14
#define s_IMUL       15
#define s_IDIV       16
#define s_IREM       17
#define s_ISHL       18
#define s_ISHR       19
#define s_IUSHR      20
#define s_IAND       21
				
				<dp n="d74"/>
#define s_IOR           22
#define s_IXOR          23
#define TYPE1_END       23
/*类型2*/
#define s_ISTORE        24
#define s_POP           25
#define s_IFEQ          26
#define s_IFNE          27
#define s_IFLT          28
#define s_IFGE          29
#define s_IFGT          30
#define s_IFLE          31
#define s_TABLESWITCH   32
#define s_LOOKUPSWITCH  33
#define s_IRETURN       34
/*类型7*/
#define s_SALOAD        35
#define s_AALOAD        36
#define s_BALOAD        37
/*类型9*/
#define s_INEG          39
#define s_INT2BYTE      40
#define s_INT2CHAR      41
#define TYPE9_END       41
/*类型8*/
				
				<dp n="d75"/>
#define s_ASTORE       42
#define s_ARETURN      43
#define s_ATHROW       44
#define s_IFNULL       45
#define s_IFNONNULL    46
#define TYPE8_END      46
/*类型12*/
#define s_ARRAYLENGTH  47
#define s_INSTANCEOF   48
#define TYPE12_END     48
/*类型10*/
#define s_SIPUSH       49
#define TYPE10_END     49
/*类型5*/
#define s_ILOAD        50
#define s_ALOAD        51
/*类型11*/
#define TYPE11_START   52
#define s_ACONST_NULL  52
#define s_LDC2         53
#define s_JSR          54
#define s_NEW          55
				
				<dp n="d76"/>
#define TYPE11_END     55
/*类型16*/
#define s_NEWARRAY     56
#define s_CHECKCAST    57
#define TYPE16_END     57
/*类型13*/
#define s_DUP          58
#define s_DUP_X1       59
#define s_DUP_X2       60
#define s_DUP2         61
#define s_DUP2_X1      62
#define s_DUP2_X2      63
#define s_SWAP         64
/*类型14*/
#define s_INVOKEVIRTUAL  65/*01000001*/
#define s_INVOKENONVIRTUAL 66/*01000010*/
#define s_INVOKESTATIC  67/*01000011*/
#define s_INVOKEINTERFACE  68/*01000100*/
/*类型15*/
#define s_GETSTATIC   69
#define s_PUTSTATIC   70
#define s_GETFIELD    71
#define s_PUTFIELD    72
/*类型4*/
				
				<dp n="d77"/>
#define s_NOP      73
#define s_IINC     74
#define s_GOTO     75
#define s_RET      76
#define s_RETURN   77

Claims (105)

1.一种用于终端的集成电路卡，包含：

一个配置成能与该终端通信的通信器；

一个存储一个具有高级程序设计语言格式的应用程序和一个解释程序的存储器；

一个与该存储器相连的处理器，该处理器被配置成能用该解释程序来解释执行该应用程序并用该通信器与该终端通信。

2.权利要求1的集成电路卡，其中，该高级程序设计语言包含一个类文件格式。

3.权利要求1的集成电路卡，其中，该处理器包含一个微控制器

4.权利要求1的集成电路卡，其中，该存储器至少有一部分位于该处理器中。

5.权利要求1的集成电路卡，其中，该高级程序设计语言格式包含Java程序设计语言格式。

6.权利要求1的集成电路卡，其中，该应用程序已经被有一个字符串的第二应用程序处理过，该字符串在第一应用程序中用一个标识符来代表。

7.权利要求6的集成电路卡，其中，该标识符包含一个整数。

8.权利要求1的集成电路卡，其中，该处理器被进一步配置成：

从某个请求者接收要求访问该卡的某个单元的请求；

接收该请求后，与该请求者交互作用以验证该请求者的身份；

根据该身份，有选择地授予对该单元的访问权。

9.权利要求8的集成电路卡，其中，该请求者包含该处理器。

10.权利要求8的集成电路卡，其中，该请求者包含该终端。

11.权利要求8的集成电路卡，其中，该单元包含在该存储器中存储的该应用程序，并且一旦访问被允许时，该请求者被配置成能使用该应用程序。

12.权利要求8的集成电路卡，其中，该单元包含另一个在该存储器中存储的应用程序。

13.权利要求8的集成电路卡，其中，该单元包含在存储器中存储的数据。

14.权利要求8的集成电路卡，其中，该单元包含该通信器。

15.权利要求8的集成电路卡，其中，该存储器也为该单元存储一个存取控制列表，该存取控制列表中有一个表示要授予该身份的访问的类型的标志，该处理器进一步被配置成能根据该存取控制列表有选择地将特定的访问类型授权给该请求者。

16.权利要求15的集成电路卡，其中，该访问的类型包括读数据。

17.权利要求15的集成电路卡，其中，该访问的类型包括写数据。

18.权利要求15的集成电路卡，其中，该访问的类型包括追加数据。

19.权利要求15的集成电路卡，其中，该访问的类型包括创建数据。

20.权利要求15的集成电路卡，其中，该访问的类型包括删除数据。

21.权利要求15的集成电路卡，其中，该访问的类型包括执行某应用程序。

22.权利要求1的集成电路卡，其中，该应用程序是该存储器中存储的多个应用程序的其中之一，该处理器进一步被配置成：

接收来自一个请求者要求访问多个应用程序的其中之一的请求；

接收该请求后，判定多个应用程序的该其中之一是否与一个预定的规则集相符；

根据该判定，有选择地授予该请求者对多个应用程序的所述一个的访问权。

23.权利要求22的集成电路卡，其中，该预定的规则为决定多个应用程序的所述一个是否访问存储器的某预定区域提供指引。

24.权利要求22的集成电路卡，其中，该处理器进一步被配置成：

验证该请求者的一个身份；

根据该身份，授予对多个应用程序的所述一个的访问权。

25.权利要求1的集成电路卡，其中，该处理器进一步被配置成：

通过该通信器与该终端进行交互作用以验证某个身份；

判断该身份是否已经被验证；

根据该判断，有选择地允许该终端与该集成电路卡之间的通信。

26.权利要求25的集成电路卡，其中，该通信器与该终端通过通信通道进行通信，该处理器进一步被配置成当该处理器允许在终端与该集成电路卡之间通信时，将其中一个通信通道分配给该身份。

27.权利要求26的集成电路卡，其中，该处理器进一步被配置成

向该其中一个通信通道分配一个会话密钥；

当该处理器与该终端通过该其中之一通信通道进行通讯时，使用该会话密钥。

28.权利要求1的集成电路卡，其中，该终端具有一个读卡机，该通信器包含一个用于与该读卡机通信的触点。

29.权利要求1的集成电路卡，其中，该终端有一个无线通信设备，该通信器有一个用于与该无线通信设备通信的无线收发机。

30.权利要求1的集成电路卡，其中，该终端有一个无线通信设备，该通信器包含一个用于与该无线通信设备通信的无线发射机。

31.一种用于集成电路卡和终端的方法，包含：

在该集成电路卡的存储器中存储一个解释程序和一个具有高级程序设计语言格式的应用程序；

用该集成电路卡的处理器来用该解释程序去解释执行该应用程序；

当该处理器与该终端之间进行通信时，使用该卡的通信器。

32.权利要求31的方法，其中，该高级程序设计语言包含一个类文件格式。

33.权利要求31的方法，其中，该处理器包含一个微控制器

34.权利要求31的方法，其中，该存储器至少有一部分位于该处理器中。

35.权利要求31的方法，其中，该高级程序设计语言格式包含Java程序设计语言格式。

36.权利要求31的方法，其中，

该应用程序已经被有一个字符串的第二应用程序处理过，进一步包含：

在第一应用程序中用一个标识符来代表该字符串。

37.权利要求36的方法，其中，该标识符包含一个整数。

38.权利要求31的方法，进一步包含：

从某个请求者接收要求访问该卡的某个单元的请求；

接收该请求后，与该请求者交互作用以验证该请求者的身份；

根据该身份，有选择地授予对该单元的访问权。

39.权利要求38的方法，其中，该请求者包含该处理器。

40.权利要求38的方法，其中，该请求者包含该终端。

41.权利要求38的方法，其中，该单元包含在该存储器中存储的该应用程序，进一步包含：一旦访问被允许时，以该请求者来使用该应用程序。

42.权利要求38的方法，其中，该单元包含另一个在该存储器中存储的应用程序。

43.权利要求38的方法，其中，该单元包含在该存储器中存储的数据。

44.权利要求38的方法，其中，该单元包含该通信器。

45.权利要求38的方法，其中，存储器也为该单元存储一个存取控制列表，该存取控制列表中有一个表示要授予该身份的访问的类型的标志，进一步包含：

根据该存取控制列表，用该处理器来有选择地将特定的访问类型授权给该请求者。

46.权利要求45的方法，其中，该访问的类型包括读数据。

47.权利要求45的方法，其中，该访问的类型包括写数据。

48.权利要求45的方法，其中，该访问的类型包括追加数据。

49.权利要求45的方法，其中，该访问的类型包括创建数据。

50.权利要求45的方法，其中，该访问的类型包括删除数据。

51.权利要求45的方法，其中，该访问的类型包括执行某应用程序。

52.权利要求31的方法，其中，该应用程序是存储器中存储的多个应用程序的其中之一，进一步包含：

接收来自请求者要求访问存储在该存储器中的该多个应用程序的其中之一的请求；

接收该请求后，判定该多个应用程序的所述一个是否与预定的规则集相符；

根据该判定，有选择地授予该请求者对该多个应用程序的所述一个的访问权。

53.权利要求52的方法，其中，该预定的规则为决定该多个应用程序的所述一个是否访问该存储器的某预定区域提供指南。

54.权利要求52的方法，进一步包含：

验证该请求者的一个身份；

根据该身份，授予对该多个应用程序的所述一个的访问权。

55.权利要求31的方法，进一步包含：

通过与该终端的通信来验证某个身份；

判断该身份是否已经被验证；

根据该判断，有选择地允许该终端与该集成电路卡之间的通信。

56.权利要求55的方法，进一步包含：

该终端与该处理器通过通信通道进行通信；

当允许该读卡机与该集成电路卡之间通信时，将其中一个通信通道分配给该身份。

57.权利要求56的方法，进一步包含：

向该其中一个通信通道分配会话密钥；

当该处理器与该终端通过该其中之一通信通道进行通信时，使用该会话密钥。

58.一种智能卡，包含：

一个存储一个Java解释程序的存储器；

一个配置成用该解释程序来解释执行Java应用程序的处理器。

59.一种微控制器，包含：

一个半导体衬底；

一个位于该半导体衬底的存储器；

一个在该存储器中存储并配置成能执行安全检查的程序设计语言解释程序；

一个位于该衬底并与该存储器相连的中央处理单元。

60.权利要求59的微控制器，其中，该解释程序包含Java字节代码解释程序。

61.权利要求59的微控制器，其中，该安全检查包含建立防火墙。

62.权利要求59的微控制器，其中，该安全检查包含实行沙箱安全模型。

63.一种智能卡，包含：

一个存储器；

一个在该存储器中存储并配置能执行安全检查的程序设计语言解释程序；

一个与该存储器相连的中央处理单元。

64.权利要求63的智能卡，其中，该解释程序包含Java字节代码解释程序。

65.权利要求63的智能卡，其中，该安全检查包含建立防火墙。

66.权利要求63的智能卡，其中，该安全检查包含实行沙箱安全模型。

67.一种用于终端的集成电路卡，包含：

一个通信器；

一个存储器，该存储器存储一个解释程序和第一应用程序的第一指令，该第一指令是从第二应用程序的第二指令转换的；

一个处理器，该处理器与该存储器相连并被配置成能用该解释程序来执行该第一指令以及通过该通信器与该终端进行通信。

68.权利要求67的集成电路卡，其中，该第一应用程序有一种类文件格式。

69.权利要求67的集成电路卡，其中，该第二应用程序有一种类文件格式。

70.权利要求67的集成电路卡，其中，该第一指令包含字节代码。

71.权利要求67的集成电路卡，其中，该第二指令包含字节代码。

72.权利要求67的集成电路卡，其中，该第一指令包含Java字节代码。

73.权利要求67的集成电路卡，其中，该第二指令包含Java字节代码。

74.权利要求67的集成电路卡，其中，该第一指令包含第二指令的通用化版本。

75.权利要求67的集成电路卡，其中，该第一指令包含第二指令的重编号版本。

76.权利要求67的集成电路卡，其中，

第二指令包括常量引用；

该第一指令包括替代该第二指令的该常量引用的常量。

77.权利要求67的集成电路卡，其中，

该第二指令包括引用，这些引用在该第二指令向该第一指令转换期间移动位置；

该第一指令被重新链接到移位后的该引用。

78.权利要求67的集成电路卡，其中，

该第一指令包含用于第一类虚拟机的字节代码；

该第二指令包含用于第二类虚拟机的字节代码，该第一类与该第二类不同。

79.一种用于集成电路卡的方法，包含：

将第二应用程序的第二指令转换成第一应用程序的第一指令；

该将第一指令存储到该集成电路卡的存储器中；

用该集成电路卡的解释程序来执行该第一指令。

80.权利要求79的方法，其中，该第一应用程序有一种类文件格式。

81.权利要求79的方法，其中，该第二应用程序有一种类文件格式。

82.权利要求79的方法，其中，该第一指令包含字节代码。

83.权利要求79的方法，其中，该第二指令包含字节代码。

84.权利要求79的方法，其中，该第一指令包含Java字节代码。

85.权利要求79的方法，其中，该第二指令包含Java字节代码。

86.权利要求79的方法，其中，该第一指令是该第二指令的通用化版本。

87.权利要求79的方法，其中，该转换包括将该第二指令重编号后形成第一指令。

88.权利要求79的方法，其中，该第二指令包括常量引用，该转换包括用常量来替代该第二指令的该常量引用。

89.权利要求79的方法，其中，该第二指令包括引用，该转换包括将该引用移动位置，进一步包含：

将该第一指令重新链接到转换后的该引用。

90.权利要求79的方法，其中，该第一指令包含用于第一类虚拟机的字节代码，该第二指令包含用于第二类虚拟机的字节代码，该第一类与该第二类不同。

91.一种用于终端的集成电路卡，包含：

一个配置成与该终端通信的通信器；

一个存储器，该存储器存储一个已经被有一个字符串的第二应用程序处理过的第一应用程序，该字符串在该第一应用程序中用一个标识符来代表；

一个与该存储器相连的处理器，该处理器被配置成用该解释程序来解释执行该第一应用程序，用该通信器来与该终端通信。

92.权利要求91的集成电路卡，其中，该标识符包含一个整数。

93.一种用于集成电路卡和终端的方法，包含：

处理第二应用程序以创建第一应用程序，该第二应用程序有一个字符串；

在该第二应用程序中用一个标识符来代表该第一应用程序的字符串；

在该集成电路卡的存储器中存储解释程序和该第一应用程序；

用该集成电路卡的处理器来用解释程序解释执行该第一应用程序。

94.权利要求93的方法，其中，该标识符包括一个整数。

95.一种微控制器，包含：

一个存储具有一个类文件格式的应用程序和一个解释程序的存储器；

一个与该存储器相连的处理器，该处理器被配置成用该解释程序解释执行该应用程序。

96.权利要求95的微控制器，进一步包含：

一个配置成与该终端通信的通信器。

97.权利要求96的微控制器，其中，该终端有一个读卡机，该通信器包含一个用于与该读卡机通信的触点。

98.权利要求96的微控制器，其中，该终端有一个无线通信设备，该通信器有一个用于与该无线通信设备通信的无线收发机。

99.权利要求96的微控制器，其中，该终端有一个无线通信设备，该通信器包含一个用于与该无线通信设备通信的无线发射机。

100.权利要求95的微控制器，其中，该类文件格式包含一个Java类文件格式。

101.一种用于集成电路卡和终端的方法，包含：

在该集成电路卡的存储器中存储第一应用程序；

在该集成电路卡的存储器中存储第二应用程序；

建立一个将该第一和该第二应用程序隔离的防火墙，使得该第二应用程序既不能访问该第一应用程序也不能访问与该第一应用程序关联的数据。

102.权利要求101的方法，其中，该第一和该第二应用程序包含Java字节代码。

103.权利要求101的方法，其中，建立防火墙包括使用一个Java解释程序。

104.权利要求101的方法，其中，该第一应用程序的存储是与该集成电路卡的制造结合进行的；

该第二应用程序的存储是在完成制造之后的晚些时间进行的。

105.一种用于终端的集成电路卡，包含：

一个配置成与该终端通信的通信器；

一个存储应用程序和一个解释程序的存储器，每个应用程序都有一种高级程序设计语言格式；

一个与该存储器相连的处理器，该处理器被配置成：

a)用该解释程序来解释执行该应用程序；

b)用该解释程序来建立一个使该应用程序彼此隔离的防火墙；

c)用该通信器来与该终端通信。

Images