CN101458633A

CN101458633A - 通过脚本程序访问宿主程序的方法及其系统和装置

Info

Publication number: CN101458633A
Application number: CNA2007101948783A
Authority: CN
Inventors: 杨锋镝
Original assignee: Huawei Technologies Co Ltd
Current assignee: Huawei Technologies Co Ltd; Huawei Software Technologies Co Ltd
Priority date: 2007-12-13
Filing date: 2007-12-13
Publication date: 2009-06-17
Anticipated expiration: 2027-12-13
Also published as: CN101458633B

Abstract

本发明公开了一种通过脚本程序访问宿主程序的方法及其系统和装置，本发明方法包括：为宿主程序中的共享类创建对应的共享类适配器；当执行脚本程序中访问宿主程序的共享类的语句时，调用与所述共享类对应的共享类适配器，并通过所述共享类适配器访问对应的共享类。采用本发明，可解除虚拟机与共享类的紧耦合，提高虚拟机的可重用性，进而提高访问共享类的灵活性，简化代码维护工作。

Description

通过脚本程序访问宿主程序的方法及其系统和装置

技术领域

本发明涉及通信领域的计算机技术，尤其涉及一种通过脚本程序访问宿主程序的方法及其系统，以及预编译器。

背景技术

随着市场竞争的加剧和软件技术的发展，客户对应用系统的灵活性提出了很高的要求，要求能够在不修改程序的情况下，通过调整系统参数、修改业务脚本的方式，迅速适应市场的变化，实现新的业务需求。

在应用系统中嵌入业务脚本语言编译器是目前常用的加强系统灵活性的方法，图1给出了嵌入业务脚本语言编译器的应用程序总体结构示意图。图1中的业务脚本编译器和虚拟机，与应用程序编译在同一进程内，应用程序中包含了业务脚本语言的编译和执行环境，应用程序成为业务脚本程序的宿主程序。业务脚本编译器负责将业务脚本程序代码编译成某种中间代码(如三地址码)；虚拟机是业务脚本的执行环境，能够执行由脚本编译器生成的中间代码；共享类和私有类都是由在应用程序中用原生编程语言(如：C++语言)实现的领域类，对业务脚本程序而言，共享类和私有类都是宿主程序中的类。共享类是指能够在业务脚本程序中直接访问的类，私有类是不能在业务脚本程序中直接访问的类。

业务脚本程序在应用程序中被处理和执行的过程可如图2所示。从图2可以看出，业务脚本程序代码通过与脚本编译器编译为中间代码，中间代码在虚拟机中执行，虚拟机在执行过程中需要根据预先定义的共享类代码创建相应的共享类对象，并调用共享类对象提供的方法。

在实际应用中，通常会将系统中最容易发生变化的业务逻辑采用业务脚本来描述。在业务脚本中，借助脚本语言丰富的表达能力，通过对共享类的操作，实现复杂的业务逻辑。在业务逻辑发生变化的情况下，只要不是必须修改宿主程序中的类，通常只需要修改业务脚本就可以实现新的业务逻辑。

图3是一个通过业务脚本程序访问宿主程序中的共享类来实现复杂的业务逻辑的例子。图3中的业务脚本中分别创建了共享类_A、共享类_B和共享类_C的实例化对象：对象_A、对象_B和对象_C，并通过业务脚本分别调用了对象_A的方法_X，对象_C的方法_Z等各种方法。在执行所调用的共享类的方法的过程中，将有可能调用其它一些共享类或私有类的方法。如图3所示，执行共享类_A的方法X过程中，将调用共享类_B的方法，共享类_B的方法将调用私有类_A的方法；执行共享类_B的方法W过程中，将调用私有类_A的方法。通过对共享类的各种方法的组合调用，可以完成复杂的业务逻辑。

在上述方案中，建立一条方便的在业务脚本语言中访问共享类的途径是影响业务脚本语言表达能力的关键。如果在业务脚本中能够访问的共享类比较少，则业务脚本的表达能力弱，如果业务脚本中能够访问宿主程序中的所有关键领域类，则业务脚本的表达能力很强，系统整体的灵活性很高。

由于业务脚本最终将被编译成中间代码，而中间代码是在虚拟机上执行的，因此，在业务脚本中访问共享类，本质上是通过虚拟机访问共享类。在虚拟机中硬编码对共享类的访问，即，在虚拟机中直接访问共享类，是目前一种常见的实现方案。

例如，以下为一段业务脚本代码：

1int iParam＝1；//定义整型参数iParam

2String sParam＝＂test＂；//定义字符型参数sParam

3int iResult；//定义整型参数iResult

4ShareClass obj＝new ShareClass()；//实例化共享类ShareClass的对象obj，其中ShareClass为共享类的类名

5iResult＝obj.Fun(iParam，sParam)；//调用共享对象obj的函数Fun，其中Fun为ShareClass中的函数名

经过脚本编译器编译后，得到中间代码序列。业务脚本中实例化共享对象的操作被编译成CREATE指令，函数调用被编译成一系列的动作：将函数的各个参数压栈，将共享对象的地址压栈，调用CALL指令。以下为业务脚本第4、5条脚本代码对应的中间代码，其中，第4条脚本代码对应以下第1、2、3、4条中间代码，第5行脚本代码对应以下第5、6、7、8、9、10条中间代码：

1CREATE ShareClass//创建ShareClass对象，并将创建的对象压栈

2POP //将栈顶弹出，弹出的指针保存到寄存器REG_A中

3ALLOC obj_addr//申请一块内存空间，其地址表示为obj_addr

4MOV REG_Aobj_addr//将REG_A中的内容复制到obj_add

5PUSH iParam_addr//将第一个参数iParam的地址压栈

6PUSH sParam_addr//将第二个参数sParam的地址压栈

7PUSH obj_addr//将参与函数调用的对象obj的地址压栈

8CALL ShareClass Fun//调用ShareClass的函数Fun，函数返回值地址将压栈

9POP //将栈顶弹出，弹出的指针保存到寄存器REG_A中

10MOV REG_AiResult_addr//将REG_A中的内容复制到iResult_add

当虚拟机执行CREATE指令时，先检查指令的第一个操作数ShareClass，这个操作数是待实例化的类名，虚拟机通过这个类名找到对应的共享类，调用共享类的构造函数，并将新创建的共享对象的指针压栈保存；当虚拟机执行CALL指令时，先检查指令的第一个操作数ShareClass，这个操作数是类名，虚拟机通过类名找到其对应的共享类，然后检查指令的第二个操作数Fun，这个操作数是函数名，虚拟机通过函数名找到共享类对应的函数，然后依次从调用栈中弹出共享对象的指针，以及函数各参数的指针，用这些参数调用相应共享对象的相应函数。

从上面的例子中可以看出，虚拟机中硬编码了对所有共享类的访问代码，随着共享类的增多，将造成虚拟机异常臃肿，虚拟机的代码量大，因而容易出错。另外，虚拟机与共享类之间存在不恰当的耦合，虚拟机是应用框架中的一部分，应该是高度可重用的，而共享类属于业务范畴，二者之间的强耦合将会降低虚拟机的可重用性，一旦共享类中的函数原型有变化，需要同步修改虚拟机的代码。在实际应用中，共享类的修改是比较频繁的，在目前的这种方案下，由于需要同步修改虚拟机代码，代码维护的工作量较大。

发明内容

本发明的实施例揭示了一种通过脚本程序访问宿主程序的方法及其系统和装置，以解除虚拟机与宿主程序共享类的紧耦合关系。

本发明实施例揭示的通过脚本程序访问宿主程序的方法，包括步骤：

为宿主程序中的共享类创建对应的共享类适配器；

当执行脚本程序中访问宿主程序的共享类的语句时，调用与所述共享类对应的共享类适配器，并通过所述共享类适配器访问对应的共享类。

本发明实施例揭示的通过脚本程序访问宿主程序的实现系统，包括：

共享类适配器创建模块，用于为宿主程序中的共享类创建共享类适配器；

脚本执行模块，用于根据脚本程序中访问宿主程序的共享类的语句，调用与所述共享类对应的共享类适配器，并通过所述共享类适配器访问对应的共享类。

本发明实施例揭示的预编译器，包括：

文件分析模块，用于分析共享类的头文件，并得到共享类的结构；

代码生成模块，用于根据所述文件分析模块得到的共享类的结构，并根据共享类的结构生成所述共享类对应的共享类适配器。

本发明的上述实施例，通过为宿主程序中的共享类创建对应的共享类适配器，并在脚本程序访问宿主程序中的共享类时，通过调用与共享类对应的共享类适配器访问共享类。通常情况下，脚本程序访问宿主程序由虚拟机实现，因而本发明的上述实施例与现有技术相比，解除了虚拟机与共享类的紧耦合，提高了虚拟机的可重用性，进而提高了访问共享类的灵活性，简化了代码维护工作。

附图说明

图1为现有技术中嵌入业务脚本语言编译器的应用程序总体结构示意图；

图2为现有技术中业务脚本在应用程序中被处理和执行的过程的示意图；

图3为现有技术中通过业务脚本实现业务逻辑的示意图；

图4为本发明实施例中通过共享类适配器访问共享类的结构示意图；

图5为本发明实施例中创建共享对象的时序图；

图6为本发明实施例中调用共享对象的方法时序图；

图7为本发明实施例中共享类与共享类适配器的映射关系示意图；

图8为本发明实施例中预编译器的结构及其工作原理示意图；

图9为本发明实施例中经预编译器分析得到的共享类结构示意图；

图10为本发明实施例中通过脚本程序访问宿主程序的实现系统的示意图；

图11为本发明实施例中产品的集成过程示意图。

具体实施方式

下面结合附图对本发明的实施例进行详细描述。

本发明实施例采用共享类适配器的方法来解除虚拟机与共享类之间的耦合。首先分别为宿主程序中的每个共享类创建对应的共享类适配器，当执行脚本程序中访问宿主程序的共享类的语句时，调用与所访问的共享类对应的共享类适配器，并通过该共享类适配器访问该共享类。

参见图4，为本发明实施例中通过共享类适配器访问共享类的结构示意图，其中，共享对象访问接口和共享类适配器是预先定义好的类：

共享对象访问接口是一个抽象类，其中定义了虚拟机访问共享对象的两个方法：对象创建接口和方法调用接口。对共享类的任何操作，都通过调用这两个接口(即接口函数，也称接口模块)完成；

共享类适配器是共享对象访问接口的子类，与共享对象访问接口一样，也定义了两个方法：对象创建接口和方法调用接口。对于宿主程序中的每一个共享类，都定义一个与之对应的共享类适配器。图4中，对应于宿主程序中的共享类_A、共享类_B和共享类_C，分别定义了共享类适配器_A、共享类适配器_B和共享类适配器_C。

下面以通过业务脚本程序访问宿主程序中的共享类_A为例，对通过脚本程序访问宿主程序的过程进行描述。业务脚本程序代码中包含有实例化共享类_A的对象，以及调用共享类_A的函数的语句，如脚本程序中包含以下语句：

ShareClass obj＝new ShareClass()；//实例化共享对象obj，其中ShareClass表示为共享类名称，本实施例中表示共享类_A

iResult＝obj.Fun(iParam，sParam)；//调用共享对象obj的函数Fun，其中Fun为ShareClass中的函数名

当执行该业务脚本程序时，脚本编译器将该业务脚本代码编译为中间代码。在编译业务脚本代码的过程中，业务脚本代码中实例化共享对象的语句被编译成CREATE指令；函数调用语句被编译成一系列的动作，包括将函数的各个参数压栈，将共享对象的地址压栈，调用CALL指令。例如，中间代码包含以下语句：

CREATE ShareClass//创建ShareClass(即共享类_A)对象，并将创建的对象压栈

POP//将栈顶弹出，弹出的指针保存到寄存器REG_A中

ALLOC obj_addr//申请一块内存空间，其地址表示为obj_addr

MOV REG_A obj_addr//将REG_A中的内容复制到obj_add

PUSH iParam_addr//将第一个参数iParam的地址压栈

PUSH sParam_add//将第二个参数sParam的地址压栈

PUSH obj_addr//将参与函数调用的对象obj的地址压栈

CALL ShareClass Fun//调用ShareClass(即共享类_A)的函数Fun，函数返回值地址将压栈

POP//将栈顶弹出，弹出的指针保存到寄存器REG_A中

MOV REG_A iResult_addr//将REG_A中的内容复制到iResult_add，iResult_add表示调用共享类_A的方法Fun所得到的结果值iResult的存储单元。

虚拟机执行中间代码，在此过程中，实例化共享对象obj的时序图可如图5所示。当虚拟机执行CREATE指令时，首先根据该指令的第一个操作数所指示的共享类名，创建该共享类的共享类适配器的实例(即实例化共享类适配器对象)，然后调用该共享类适配器的对象创建接口。图5中的间接调用表示在业务脚本语言中对共享对象的调用，虚线表示表示对调用的返回。实例化共享对象的实现过程可以为：

1 AdapterInterface*adapter＝

AdapterFactory.CreateAdapater(statement.getArgument_1())；

2 adapter.CreateShareObject(stack)；

......

其中，语句1是创建共享类适配器，根据CREATE指令的第一个操作数得到共享类的类名(由statement.getArgument_1()语句得到)，通过调用工厂对象AdapterFactory中的创建共享类适配器方法CreateAdapater来创建共享类适配器adapter(即共享类A的适配器)的实例；语句2是调用共享类适配器adapter的对象创建接口CreateShareObject。

在执行语句2的过程中，共享类适配器adapter的对象创建接口CreateShareObject调用共享类_A的构造函数，通过执行该构造函数创建共享对象obj，并将共享对象obj的指针压栈保存，完成共享对象的实例化，其实现过程可以为：

//调用共享类_A的适配器的创建对象接口

void AdapterClassA::CreateShareObject(Stack stack){

//执行共享类_A的构造函数，创建共享类_A的共享对象

ClassA*obj＝new ClassA()；

stack.push(obj)；//将共享对象的指针压栈

}

虚拟机执行中间代码的过程中，调用共享对象obj的函数的时序图可如图6所示。当虚拟机执行CALL指令时，首先根据该指令的第一个操作数所指示的共享类名，创建该共享类的共享类适配器的实例(即实例化共享类适配器对象)，然后调用该共享类适配器的方法调用接口，方法调用接口根据CALL指令的第二个操作数所指示的函数名调用共享类中的相应方法函数。图6中的间接调用表示在业务脚本语言中对共享对象方法的调用，虚线表示表示对调用的返回。调用共享对象的函数实现过程可以为：

......

1 AdapterInterface*adapter＝

AdapterFactory.CreateAdapater(statement.getArgument_1())；

2 void*obj＝stack.pop()；

3 adapter.MethodCall(statement.getArgument_2()，stack，obj)；

......

其中，语句1是创建共享类适配器，根据CALL指令的第一个操作数得到共享类的类名(由statement.getArgument_1()语句得到)，通过调用工厂对象AdapterFactory中的创建共享类适配器方法CreateAdapater来创建共享类适配器adapter(即共享类A的适配器)的实例；语句2是从栈顶获得共享对象obj(即共享类_A的实例化对象)的指针；语句3是调用共享类适配器adapter的方法调用接口MethodCall。

在执行语句3的过程中，共享类适配器adapter的方法调用接口MethodCall根据CALL指令的第二个操作数(由statement.getArgument_2()得到，操作数为共享类_A的中函数名Fun)，从共享对象obj的栈中得到相应的函数名及所有的参数，并使用这些参数调用该函数，其实现过程可以为：

//以下为方法调用接口的实现

void AdapterClassA::MethodCall(string MethedName，

Stack stack，void*object){

ClassA*objA＝(ClassA*)object；

if(MethodName＝＝＂Method_A＂){

//以下为从栈顶获得第一个参数iparam的指针(int型)

int*iparam＝(int*)(stack.pop())；

//以下为正式调用函数

int iResult＝objA->Method_A(*iparam)；

//以下为将函数返回值iResult压栈

stack.push(iResult)；

}

在以上两个虚拟机指令(CREATE和CALL)的实现代码中都使用了适配器工厂(AdapterFactory)来创建共享类适配器的实例，适配器工厂的CreateAdapter方法能够根据送入的共享类名参数创建相应的共享类适配器的实例，如，若送入的共享类名是ClassA，则创建的共享类适配器是与之对应的AdapterClassA，这里采用了成熟的设计模式，其实现机理在此不再赘述。

综上，引入共享类适配器之后，虚拟机就可以通过调用共享对象访问接口来实现对共享类的访问，从而实现了虚拟机与共享类的解耦。如果需要添加新的共享类，只需要定义相应的共享类适配器即可。如果共享类中的函数原型发生变化，只需要修改相应的共享类适配器，虚拟机不需要做任何修改。较之现有技术方案，使得程序设计得到了极大的简化。

共享类适配器解除了虚拟机与共享类之间的耦合关系，但是，共享类适配器与相应的共享类之间是紧密耦合的，只要共享类中的函数原型发生变化，共享类适配器的代码要做相应的修改。共享类适配器的代码可以手工编写和维护，但工作量较大，而且容易出错。本发明实施例提供了一种自动定义共享类适配器，即自动生成共享类适配器代码的方法，即，引入预编译器，由其自动生成共享类适配器的代码。

分析共享类适配器的实现，可以发现，从共享类的结构到共享类适配器的实现存在简单的映射关系。从共享类的构造函数可以得到共享类适配器的对象创建接口，从共享类的各公有函数(即public函数)可以得到共享类适配器的方法调用接口，其映射关系可如图7所示。

在C++编程语言中，类的结构可以完整地从类的头文件中得到，因此，可以通过分析共享类的头文件得到共享类的结构，再从共享类的结构自动生成共享类适配器的源代码。在本发明实施例中，通过预先编写的预编译器程序，实现自动生成共享类适配器的源代码，预编译器的结构及其工作原理可如图8所示。

图8所示的预编译器主要由两个功能模块组成：文件分析模块和代码生成模块。其工作原理为：将共享类的头文件输入到预编译器的文件分析模块，由其通过分析共享类的头文件得到共享类的结构；代码生成模块根据文件分析模块分析得到的共享类结构生成共享类适配器源代码。

以下面所示的共享类头文件为例，描述从共享类头文生成共享类适配器源代码的过程。共享类的头文件为：

#ifndef__ClassA_H__

#define__ClassA_H__

#include＂stdio.h＂

#include＂headfile.h＂

class ClassA:public BaseClass

{

public:

ClassA()；

int MethodA(int iParam，string sParam)；

string MethodB(int iParam)；

void MethodC(string sParam 1，string sParam2，int iParam)；

private:

int PrivateMethodA()；

string PrivateMethodB(int iParam)；

}；

#endif

从以上代码可以看出，共享类名为ClassA，ClassA有3个公有函数MethodA、MethodB、MethodC，还有2个私有函数PrivateMethodA、PrivateMethodB。其中MethodA有整型参数iParam和字符型参数sParam，MethodB有整型参数iParam，MethodC有字符型参数sParam1、sParam2和整型参数sParam。

将上述头文件代码输入到预编译器的文件分析模块，该模块分析得到如图9所示的共享类的结构。图9所示的共享类结构中记录了上述头文件中的共享类类名，以及共享类中所有的公有函数的函数名、返回值，以及公有函数的参数名称和类型。

如果共享类是由C++语言编写的，由C++的语法标准可知，C++头文件的语法结构中不包含递归，因此，对共享类头文件只需要进行简单的词法分析就可以得到共享类的结构，由于采用的是成熟的词法分析算法，其实现机理在此不再赘述。

在实际应用中，还可进一步从头文件中收集一些更细节的信息，如参数是否有const修饰，方法是否有static修饰等，并将这些信息反映在共享类结构以及生成的共享类适配器源代码中。

预编译器的代码生成模块，通过遍历上述共享类结构，结合前面所述的共享类适配器的实现方法，生成共享类适配器的代码。

以下是共享类适配器头文件的代码，其中包含了共享类的定义以及对象创建接口和方法调用接口的定义(省略了部分细节)：

#include＂ShareClassAdapter.h＂

class AdapterClassA:public ShareClassAdapter //定义共享类适配器

{

public:

//定义对象创建接口

void CreateShareObject(Stack stack)；

//定义方法调用接口

void MethodCall(string MethedName，Stack stack，void*object)

}；

以下是共享类适配器CPP文件的代码，其中包含对象创建接口和函数调用接口的实现(省略了部分细节)：

//以下是对象创建接口的实现

void AdapterClassA::CreateShareObject(Stack stack){

ClassA*obj＝new ClassA()；

stack.push(obj)；

}

//以下是方法调用接口的实现

void AdapterClassA::MethodCall(string MethedName，

Stack stack，

void*object){

ClassA*objA＝(ClassA*)object；

if(MethodName＝＝＂MethodA＂){

//从栈顶获得第一个参数的指针(int型)

int*iparam＝(int*)(stack.pop())；

//从栈顶获得第二个参数的指针(string型)

String*sparam＝(string*)(stack.pop())；

//正式调用函数

int iResult＝objA->MethodA(*iparam，*sparam)；

//将函数返回值压栈

stack.push(iResult)；

}

本发明实施例还提供了一种通过脚本程序访问宿主程序的实现系统，以实现上述通过业务脚本程序访问宿主程序的共享类的流程。如图10所示，该系统包括：共享类适配器创建模块和脚本执行模块，还可包括脚本编译模块，其中

脚本编译模块，用于将业务脚本程序编译为中间代码；脚本编译模块可由脚本编译器程序实现；

脚本执行模块，用于根据由脚本程序中访问宿主程序的共享类的语句，调用与该共享类对应的共享类适配器，并通过该共享类适配器访问相应的共享类。脚本执行模块可由虚拟机程序实现，该虚拟机执行脚本编译模块编译得到的中间代码。

共享类适配器包括对象创建接口模块和方法调用接口模块，相应地，脚本执行模块包括对象创建子模块和方法调用子模块，其中

对象创建子模块，用于根据脚本程序中创建共享类的对象的语句，调用与该共享类对应的共享类适配器的对象创建接口模块，并通过该接口模块调用该共享类中的构造函数，生成该共享类的对象；

方法调用子模块，用于根据脚本程序中调用共享类的方法的语句，调用与该共享类对应的共享类适配器的方法调用接口模块，并通过该接口模块调用该共享类中的相应方法函数。

上述系统中的共享类适配器创建模块可由预编译器代码实现，该预编译器的结构可如图8所示。该预编译器根据共享类的头文件自动生成共享类的共享类适配器代码。

基于上述通过共享类适配器访问宿主程序中的共享类的方法，以及共享类适配器代码的自动生成方法，产品的开发与集成过程可如11所示。在图11所示的产品集成过程中，业务开发人员无需考虑领域类与业务脚本的交互问题，在产品开发完成之后，先将所有需要在业务脚本中访问的领域类挑选出来，将其作为共享类(如图11中的共享类A源代码和共享类B源代码)，并将共享类的头文件输入预编译器进行预编译，生成相应的共享类适配器源代码(如图11中的共享类适配器A源代码和共享类适配器B源代码)，然后将所有领域类源代码、生成的共享类适配器源代码、业务脚本编译器源代码，以及虚拟机源代码，还有私有类源代码一起进行编译、链接，得到最终产品。

综上所述，本发明的上述实施例提供了一种在C++中通过脚本程序访问宿主程序中的共享类的方法，借助预编译器，可以在几乎不需要增加额外工作量的情况下实现业务脚本程序对宿主程序中的共享类的访问，方便了应用程序的编写，并且实现了虚拟机和共享类之间的解耦，实现了虚拟机的高内聚，提高了虚拟机代码的可重用性，业务脚本编译器和虚拟机可以作为完全独立的模块编译到各种应用系统中。应用本发明实施例所提供的方法，业务开发人员只无需关心业务脚本编译器与虚拟机的实现细节，不需要关心共享类适配器的编写，只需要把精力集中在领域对象的设计与实现，从而简化了代码维护工作。

显然，本领域的技术人员可以对本发明进行各种改动和变型而不脱离本发明的精神和范围。这样，倘若本发明的这些修改和变型属于本发明权利要求及其等同技术的范围之内，则本发明也意图包含这些改动和变型在内。

Claims

1、一种通过脚本程序访问宿主程序的方法，其特征在于，包括：

为宿主程序中的共享类创建对应的共享类适配器；

2、如权利要求1所述的方法，其特征在于，所述共享类适配器包括对象创建接口模块和方法调用接口模块；

所述通过共享类适配器访问对应的共享类，具体为：

当执行所述脚本程序中创建共享类的共享对象的语句时，调用与所述共享类对应的共享类适配器的对象创建接口模块，并通过该接口模块调用所述共享类中的构造函数，生成所述共享类的共享对象；

当执行所述脚本程序中调用共享类的方法的语句时，调用与所述共享类对应的共享类适配器的方法调用接口模块，并通过该接口模块调用所述共享类中的相应方法函数。

3、如权利要求2所述的方法，其特征在于，所述调用与共享类对应的共享类适配器的对象创建接口模块，并通过该接口模块调用所述共享类中的构造函数的过程，具体为：

根据共享类的类名实例化对应的共享类适配器，得到与所述共享类对应的共享类适配器对象；

调用所述共享类适配器对象的对象创建接口模块；

所述对象创建接口模块调用所述共享类中的构造函数。

4、如权利要求2所述的方法，其特征在于，所述调用与共享类对应的共享类适配器的方法调用接口模块，并通过该接口模块调用所述共享类中的相应方法函数的过程，具体为：

调用所述共享类适配器对象的方法调用接口模块；

所述方法调用接口模块根据所述脚本程序中指示调用的方法函数名称，调用所述共享类中的相应方法函数。

5、如权利要求1所述的方法，其特征在于，当执行脚本程序中访问宿主程序的共享类的语句时，包括步骤：

将所述脚本程序编译为中间代码；

执行所述中间代码，并在执行过程中，调用与所述共享类对应的共享类适配器，通过所述共享类适配器访问对应的共享类。

6、如权利要求1所述的方法，其特征在于，所述为宿主程序中的共享类创建对应的共享类适配器，具体为：

通过预编译器，根据共享类的头文件得到共享类的结构，并根据共享类的结构生成共享类适配器的源代码。

7、如权利要求6所述的方法，其特征在于，所述通过预编译器，根据共享类的头文件得到共享类的结构，具体为：通过预编译器，根据共享类的头文件得到共享类名称、公有函数名称和函数返回值名称、公有函数参数名称和参数类型；

所述根据共享类的结构生成共享类适配器的源代码，具体为：通过预编译器，根据所述共享类名称、公有函数名称和函数返回值名称、公有函数参数名称和参数类型，定义所述共享类适配器的对象创建接口模块和方法调用接口模块。

8、一种通过脚本程序访问宿主程序的实现系统，其特征在于，包括：

9、如权利要求8所述的系统，其特征在于，所述共享类适配器包括对象创建接口模块和方法调用接口模块，所述脚本执行模块包括：

对象创建子模块，用于根据所述脚本程序中创建共享类的对象的语句，调用与所述共享类对应的共享类适配器的对象创建接口模块，并通过该接口模块调用所述共享类中的构造函数，生成所述共享类的对象；

方法调用子模块，用于根据所述脚本程序中调用共享类的方法的语句，调用与所述共享类对应的共享类适配器的方法调用接口模块，并通过该接口模块调用所述共享类中的相应方法函数。

10、如权利要求8所述的系统，其特征在于，所述系统还包括：

脚本编译模块，用于将所述脚本程序编译为中间代码；

所述脚本执行模块为虚拟机，所述虚拟机用于根据所述中间代码，调用与所述共享类对应的共享类适配器，并通过所述共享类适配器访问对应的共享类。

11、如权利要求8所述的系统，其特征在于，所述共享类适配器创建模块为预编译器，所述预编译器用于根据所述共享类的头文件创建所述共享类的共享类适配器。

12、一种预编译器，其特征在于，包括：

13、如权利要求12所述的预编译器，其特征在于，所述文件分析模块进一步用于，根据共享类的头文件得到共享类名称、公有函数名称和函数返回值名称、公有函数参数名称和参数类型；

所述代码生成模块进一步用于，根据所述共享类名称、公有函数名称和函数返回值名称、公有函数参数名称和参数类型，定义所述共享类适配器的对象创建接口模块和方法调用接口模块。