CN101401075B - 程序调测系统中的映射方法和程序调测系统 - Google Patents

Abstract

一种用于软件调测的映射方法以及使用该方法的程序调测系统。所述程序调测系统包括测试测试主机(1)和目标机(2)，所述测试主机(1)对所述目标机(2)中的程序进行调测，所述目标机(2)中包含映射支持模块(2112)，所述方法包括：1)所述映射支持模块(2112)根据被调测程序被编译后的调测数据库产生所述被测试程序的符号表和类型表；2)所述映射支持模块(2112)将所述类型表、符号表中的变量和函数都映射至变量容器中，生成由宿主脚本系统可操作的映射变量和映射函数，其中，所述变量容器是脚本TContainer类的类对象。被测目标机(2)还可以有选择地驻留一个异构脚本系统以增强调测能力。异构脚本系统中变量、函数可以映射到宿主脚本系统中成为映射变量与映射函数，使宿主脚本系统具备跨语言调用测试服务能力。

Description

程序调测系统中的映射方法和程序调测系统

技术领域

本发明涉及软件调试与测试领域，特别涉及针对C/C++语言开发环境的软件调试与测试的调测系统及方法。

背景技术

在软件开发领域，支持VxWorks实时操作系统开发的Tornado编程环境是众多嵌入式编程语言中调测性能表现最佳的编程环境之一。Tornado测试命令解释模块工具支持脚本化的被测变量读写与被测函数调用，功能比较强大。关于Tornado的详细说明，可参见Wind River Systems，Inc.出版的“Tornado User’s Guide(Windows Version)”，V2.0Edition 1。

尽管Tornado测试命令解释模块功能强大，但由于使用两种解释器即C解释器和TCL解释器，并且由于驻留在目标机服务器中的只有符号表，没有类型表，因而使它的调测能力受到不少限制，主要包括：

1)由于变量与函数的类型表未驻留，难以支持针对复合类型的操作；

2)用于调测控制的C解释器与TCL解释器驻留于测试主机端，导致调测控制与被测代码有紧耦合交互的情况下无法支持调测；

3)变量读写与函数调用与if、else等控制分别在两个脚本语言内实现。因此，在测试命令解释模块运行调测指令时，经常要在C解释器与TCL解释器之间切换，很烦琐。尽管C解释器可内嵌一个API来调用TCL脚本，TCL脚本也可内嵌C解释器，但在使用上仍然不便，而且运行效率低。

4)而且，由于上述3)的原因，C解释器与TCL解释器属两套系统，难以在语法和语义级别进行融合，增加了使用者的学习负担，也不利于调测功能的扩展。

第4代白盒测试方法综合了软件白盒测试的最佳实践，反映了现今白盒测试的发展方向。为了符合第4代白盒测试方法的要求，需要对基于Tornado技术的调测体系做如下改进：

1、引入一种支持即时调测的体系，测试控制与被测代码应处于同一个执行体内。

2、使用一种脚本语言，既描述针对被测C/C++变量与函数的控制(类似于Tornado Shell中的C解释器)，也描述测试控制(类似于Tornado Shell中的TCL解释器)，使这两类描述维持近似的语言风格。

发明内容

本发明为了改善当前软件开发中普遍存在的调测能力不足及测试效率欠佳的问题，并满足第4代白盒测试方法的要求，将相关的测试方法论应用到C/C++语言开发领域，而提出一套编程语言映射技术，即：将C/C++语言的变量操作、函数操作映射到一个脚本语言系统，将该脚本语言系统驻留于被测系统中，使这些脚本语言既实现脚本化的测试描述，又能直接操控被测系统中的变量、函数等，并使这种测试描述与C/C++的语法规则尽可能保持一致。

另外，对于大型软件测试，经常需要借助一个功能强大的脚本语言(如Python、Ruby、TCL等)，本发明的映射技术同样能够以尽可能近似的语法规则(近似Python，或Ruby，或TCL)描述这种脚本语言提供的功能接口，在调测中直接调用。

并且，本发明还引入一种支持即时调测的体系，使测试控制与被测代码同处于一个执行体内。本发明使用一种脚本语言既描述针对被测C/C++语言的变量与函数的控制，也描述测试控制，并保持这两类描述具有相同风格。

根据本发明，提供了一种程序调测系统，包括测试主机和目标机，所述测试主机对所述目标机的程序进行调测。其中，所述目标机中包括映射支持模块，所述映射支持模块包含变量容器；所述变量容器是脚本的TContainer类的类对象，所述被调测的C/C++目标程序系统中的变量和函数被映射成所述变量容器中的映射变量和映射函数，当宿主脚本语言中描述映射变量或映射函数的操作时，所述映射变量与所述映射函数与被测试程序的变量和函数具有相似的表达；通过所述变量容器，利用所述宿主脚本语言对所述映射变量的操作被转向到所述被调测的C/C++目标程序系统中相应变量的操作，所述宿主脚本语言对所述映射函数的操作转向到所述被调测的C/C++目标程序系统中相应函数的操作。

根据本发明的另一方面，提供一种应用于程序调测系统中的映射方法。所述程序调测系统包括测试主机和目标机，所述测试主机对所述目标机中的程序进行调测，在所述目标机中包含映射支持模块，所述方法包括：1)所述映射支持模块根据被调测程序被编译后的调试数据库产生所述被测试程序的符号表和类型表；2)所述映射支持模块将所述类型表、符号表中的变量和函数都映射至变量容器中，生成由宿主脚本系统可操作的映射变量和映射函数，其中，所述变量容器是脚本TContainer类的类对象。

通过本发明的系统和方法，可以将对软件调测的运算处理分配到测试主机和目标机。由测试主机处理被测程序的测试例的脚本编写、脚本下发(下发至目标机的宿主脚本系统)以及测试中的输出信息显示。驻留在目标机的脚本系统完成对被测端C/C++语言变量以及函数的映射和控制，即，将C/C++语言的变量操作、函数操作映射到一个脚本语言系统(即宿主脚本系统)，使这个驻留于被测系统中的脚本语言，既实现脚本化的测试描述，又能直接操控被测系统中的变量、函数等。

本发明的映射技术有效地提升了软件产品的调试能力与白盒测试能力。与Tornado测试命令解释模块相比，本发明通过在测试代理的脚本系统中包含了调测模块和映射模块，使得测试控制与被测代码都在一个系统中。调测控制与被测代码耦合更紧密。紧耦合交互不会有两个系统因通信连接带来的时延，并且测试控制过程的复杂性也被降低了。

综上所述，本发明的优点在于：通过采用一种映射技术，使调测脚本可以直接控制被测系统的行为。由于脚本的在线定义、在线执行的特性，大大提高了调测脚本的开发效率，有力保证了第4代白盒测试方法要求的在线测试与灰盒调测的工具化实现。相对于Tornado测试命令解释模块，调测效率得到提高。另外，测试脚本不必经常在两种脚本语言之间切换，数据传递与控制传递更加自由。而如上所述，Tornado系统中C解释器与TCL解释器难以在语法语义级别融合。

同时，本发明的方法还能够保证测试描述尽可能地与C/C++的语法规则保持一致。另外，对于大型软件测试，经常需要借助一个功能强大的脚本语言(如Python、Ruby、TCL等)，本发明的方法同样尽可能以近似的语法规则(近似Python，或Ruby，或TCL)描述这种脚本语言提供的功能接口，在调测中直接调用。

因此，本发明可提升嵌入式软件的调测能力，降低测试表述的学习门槛，并大幅提升调测脚本的开发效率。

附图说明

图1显示了现有的Tornado技术的逻辑结构；

图2显示了本发明的程序调测系统的逻辑结构；

图3显示了本发明的程序调测系统的组成框架；

图4是本发明中测试代理的层次结构；

图5是映射支持模块的初始化过程；

图6是映射实例生成过程；

图7示例性地显示了一个映射实例的TData与TType对应关系；

图8示例性地显示了根据本发明的映射实例的属性。

具体实施方式

下面将结合附图详细说明用于软件调测的程序语言映射方法及应用该方法的程序调测系统。虽然以下将以C语言为例进行说明，但本发明的构思与方案也可以用于其它语言的程序，例如C++语言。

本发明中，将被映射的脚本语言称为“异构脚本语言”，将映射后的映射变量与映射函数所在的脚本语言称为“宿主脚本语言”。即，宿主脚本语言是本系统环境下正常调测所使用的主脚本语言。凡是与当前宿主脚本语言不同、并驻留到被测系统中服务于调测的脚本语言都是异构脚本语言。因为异构，才有跨语言实施操作映射的需求。

为便于清楚地理解本发明相对于Tornado的技术演进，以下将在逻辑上分析这两种技术方案，然后比较两者的差异。如图1与图2所示，本发明中的映射宿主脚本解释器相当于Tornado中的C解释器，本发明中提供调测基础库的脚本解释器(如Python，或Ruby，或TCL)相当于Tornado中的TCL解释器。在Tornado技术体系中，针对C/C++的变量脚本化读写与函数脚本化调用(即映射操作)是由Tornado Shell、Target Server，以及目标机中的Agent共同完成的，而在本发明中，是在目标机中实现三者的功能，使得测试控制与被测代码处于一个执行体内。

本发明中，用于实现映射的映射实体(包括映射变量与映射函数)存在于宿主脚本语言中。宿主脚本语言可以是CSE语言，但不限于此。本发明的映射技术既支持针对C/C++中变量与函数的映射，也支持针对提供调测基础库的异构脚本语言的映射。这种映射主要集中在用于宿主脚本调用其它基础库(如Python、Ruby、TCL等)的功能接口，这些功能接口服务于调测目的。例如，还可以在目标机中驻留一个异构脚本语言Python。借助Python提供的数据库接口、文件操作接口、XML解析服务等功能，可以大大增强系统调测能力。因为异构脚本语言中的各种模块经映射后可被宿主脚本语言直接调用，从而可以实现跨语言服务调用。

本发明的映射支持模块可应用于由C/C++语言开发生成的目标系统，将该系统中的C/C++变量与函数映射到宿主脚本系统中，生成与C/C++变量与函数同名的映射变量与映射函数，然后以脚本方式操作映射变量，从而可以实现如下功能：

1.读变量

2.写变量

3.将某类型的映射变量转化成另一类型的映射变量，即强制类型转换以脚本方式操作映射函数，可以实现如下功能：

1.按cdecl方式调用函数

2.按stdcall方式调用函数

3.按C/C++函数原型方式调用函数

4.支持对C/C++函数打桩，以一个脚本函数替代原C/C++函数执行。

实现从C/C++语言向脚本语言的映射后，就能在调测脚本中直接读写被测的变量，也能用脚本发起函数调用了。通过映射实体(包括映射变量与映射函数)，本发明用脚本实现了与写C/C++代码等效的调测模式。

针对异构脚本语言的映射，与上述针对C/C++的映射类似，也包括异构脚本系统中的变量与函数，映射到宿主脚本系统中成为映射变量与映射函数，同样实现包括读变量、写变量、调用函数在内的映射操作。

在本发明的映射方法中，提出了“变量容器”的概念，以下将对变量容器及其相关内容在本发明中的应用进行具体说明。

1.变量容器

1.1变量容器的功能

变量容器本质上是宿主脚本系统中的一个类对象，存在于宿主脚本系统中的映射支持模块中。在宿主脚本系统中定义一个变量容器类TContainer，变量容器就是这个TContainer类的实例化对象。但与常规类对象不同，变量容器是一种具备特殊功能的类对象，这些功能主要包括：

1)变量容器可以层层嵌套。因为被映射变量(例如C/C++中的struct定义)是可以层层展开的，形成一种层与层具有归属关系的树状结构。本发明用变量容器树描述这种树状关系，树上的每个节点都是一个变量容器，变量容器下可以再包含一个或多个下一级的变量容器，以此构造层层归属的树状关系。

2)对变量容器的子成员进行操作时具有自动操作转向的功能。例如通过读取变量容器下某个子成员，可以隐式地自动转向到某个函数调用。

3)借助变量容器给映射变量赋值，赋值语句的表达方式可兼容强类型与弱类型两种风格。

4)具有变量容器属性的映射变量在宿主脚本系统中使用时，根据它所处的上下文环境，具有自动的、隐式的转向功能。例如映射变量在数学运算中作为一个算子使用，就自动读取它所代表的数值含义。又如，将映射变量打印输出，则取它的字串化描述。再例如，将映射变量看作一个函数来调用时，它就按特定格式(例如从C/C++映射过来的函数，调用格式就有cdecl、stdcall、thiscall等)实现调用。

5)变量容器代表异构系统(异构C/C++系统或异构脚本系统)中的一个实体(变量或函数)，当它在赋值语句或在函数参数中被传递时，能实现它所代表的被映射实体的生存周期自动管理。

变量容器的上述5项特征中，前4项保证变量容器用于映射表述时，其表达方式接近于被映射语言的语句。例如在映射C/C++的变量与函数时，相关的映射操作(如：读写变量与调用函数)要在表达上接近于C语言风格，而当变量容器用来描述异构脚本语言Python的变量与函数时，读写映射变量与调用映射函数在表达上又要与Python近似。

1.2变量容器树

映射变量与映射函数用TData类实例表示。TData类从TContainer继承而来，所以映射变量与映射函数都具有变量容器属性。

例如，调用宿主脚本系统中MapCString函数来创建C/C++的字串映射变量，调用MapCInt来创建C/C++的int类型映射变量，调用MapCStruct创建C/C++的指定struct类型的映射变量，调用MapPyString创建Python的字串类型映射变量，调用MapPyInt来创建Python的int类型变量。这里举例的5个创建映射变量的函数，最终都生成TData类型的变量容器。TData类继承了TContainer类的所有属性，所以TData类属性具备完整的变量容器的特征。

TData在TContainer定义基础上再附加了表示映射实体特征的几个属性，如该映射实体归属于谁，即TData的Owner属性，又如该映射实体的数据类型，即TData的DataType属性，其值为TType类实例。

TType类定义用来指明映射实体的数据类型。例如创建从C/C++系统映射过来的int变量，指明它的类型是占4字节的整型类型，除了描述int、short、double等基本类型外，TType还描述class、struct、union等复合数据类型。另外，TType也定义函数类型，包括cdecl、stdcall、thiscall等风格的函数原型定义。

除了映射变量与映射函数是变量容器，还有一种用于容纳映射变量与映射函数的集合，也是变量容器，在本发明中称之为“异构集容器”。异构集容器是TDataSet类实例，而TDataSet类从TContainer类继承而来，所以异构集容器也具有变量容器属性。异构集容器用来描述被映射的异构系统(包括异构C/C++系统与异构脚本系统)中的一个抽象集合。TDataSet在继承TContainer所有属性的基础上再附加表示被映射系统特征的几个属性，例如记录被映射的系统是什么(例如是C/C++，还是Python)、以及实施映射所需的相关配置，如：是否将常量也生成映射实体，枚举值按2字节还是按4字节计算等。

将一个异构系统(异构C/C++系统或异构脚本系统)中的变量与函数映射到宿主脚本系统，成为该脚本系统中的一个实体。要求用一个变量容器即异构集容器来容纳所有这些映射过来的实体。

一般情况下，从被映射语言(C/C++或异构脚本语言)映射过来的实体(映射变量或映射函数)，以及动态创建的新的映射变量，应该存放在异构集容器之下。否则，就不能保证针对该映射变量的赋值操作能够保持被映射语言的风格。只有将映射变量作为异构集容器的一个成员进行赋值时，赋值风格才与被映射语言保持一致。

以异构集容器为根节点，其下保存一个或多个映射实体而构成一种树状集合，本发明中称为“变量容器树”。变量容器树可以只有一层，也可以有多层。当异构集容器下只保存基本类型的映射实体时，就只有一层；而当异构集容器下保存复合数据的映射变量(例如C/C++中的class、struct或union数据，或异构脚本系统中的类对象)，就有多层。每一层的每个节点都是TContainer类实例，因而都具有TContainer属性)，而且子节点层数与各层子节点名称与被映射的复合数据保持一致，这使得各层的子成员能准确描述映射过来的变量，逐层读写子成员时，该变量的子节点层数、各层节点包含的子成员、各层子成员的名称与数据类型等在映射前后保持一致。

在变量容器树中，由于容纳映射实体的变量容器必须是异构集容器，所以，异构集容器只能处于变量容器树的根节点。创建一个空的异构集容器可以封装成一个脚本的API(应用程序接口)调用。例如，在宿主脚本系统中定义newVarContainer函数用来创建C/C++系统或Python系统的一个空的异构集容器。

下面以C/C++系统来举例，例如在被测系统中定义如下变量与函数：

    int iValue＝3；

struct MyStruct{

     int member1；

     char member2[12]；

}struValue＝{5，”example”}；

int sum(int i，int j)

{

      return i+j；

}

然后在宿主脚本系统(例如CSE语言系统)中定义如下语句：

vc＝newVarContainer(”C/C++”)；//创建一个C/C++的异构集容器

ScanCMapData(vc)；//扫描当前C/C++系统，生成映射变量与映射函数

                    到vc下

print(vc.iValue)；//值应为3

print(vc.sum(vc.iValue，12))；//结果值应为15

print(vc.struValue.member2)；//值应为“example”

vc.var1＝MapCInt(7)；//创建一个int类型的映射变量，赋初值7

print(vc.var1)；//值应为7

vc.var2＝MapCString(”Another string”)；//创建char[]映射变量

print(vc.var2)；//值应为“Another string”

在上例中，vc是异构集容器。它本身是一种变量容器，其下包含iValue、struValue、sum、var1、var2等映射实体，这些映射实体都是变量容器。由于struValue是struct结构，其下还有member1与member2两个子成员，这两个子成员都是TData对象，也都是变量容器，都挂在struValue这个映射变量之下。这里的“挂”是一种检索指向，表示一种链接指向关系，也隐含一种主从推导关系。表达式“vc.struValue.member2”是取其第二个子成员。可见，上述以vc为根节点的树，是由变量容器的特性支持层层嵌套的。

1.3针对变量容器子成员的操作转向

针对变量容器的子属性的操作可以支持如下3种操作转向：

1)对变量容器的子成员进行读写时，自动实现操作转向

2)对变量容器的数组子成员进行读写时，自动实现操作转向

3)对变量容器的指针指向值进行读写时，自动实现操作转向

按数值方式读写变量容器的子成员时，自动转向到该容器的getValue与setValue方法调用，例如：

vc＝newVarContainer(”C/C++”)；//创建一个C/C++的异构集容器

vc.var1＝MapCInt(7)；//相当于C语言：int var1＝7

vc.var1＝8；//转向到隐式调用vc.setValue(`var1`，8)

print(vc.var1+1)；//打印值应为9

                         //隐式转向为：

print(vc.getValue(`var1`)+1)

上面传递给getValue与setValue的第一个参数若为nil，表示针对该映射变量自身进行读值或赋值；若不为nil，则表示给该映射变量的指定子成员读值或赋值。例如在上例添加语句vc.var1.getValue(nil)，则得到值是8，等同于vc.getValue(`var1`)。

在读写变量容器的数组子成员时，自动转向到该数组成员的getItem与setItem方法调用，例如：

vc＝newVarContainer(”C/C++”)；//创建一个C/C++的异构集容器；

vc.var3＝MapCArray(vt.int，4)；//相当于C语言中的int var3[4]

vc.var3[0]＝1；     //转向到隐式调用vc.var3.setItem(0，1)

print(vc.var3[0])；//转向到隐式调用vc.var3.getItem(0)

读写变量容器的指针指向值时(这里，读写指针与读写指针指向值是两个概念，例如在C语言中定义变量“char*buff”，给指针赋值如：buff＝AnotherVar，而给指针指向值赋值是：*buff＝’A’)，自动转向到该成员的getPoint与setPoint方法调用，例如：

vc＝newVarContainer(”C/C++”)；//创建一个C/C++的异构集容器

vc.var4＝MapCStruct(vt.MyStruct)；//相当于：struct MyStruct var4

vc.var5＝MapCPoint(vt.struct.MyStruct，vc.var4)；//相当于C语言中：

                               struct MyStruct*var5＝&var4；

vc.var5-＞member1＝17；//转向到调用vc.var5.setPoint(`member1`，17)

print(vc.var5-＞member1)；//转向到调用vc.var5.getPoint(`member1`)

由于上述三种针对映射变量子成员的操作能够自动转向成映射实体下特定的方法调用，这就保证映射操作的表达方式尽可能与被映射语言的风格保持一致。因为同一操作(例如读写子成员，存取数组成员)在不同语言中有不同含义，而同一操作在宿主脚本系统中运行时具有明确含义，不能将宿主脚本语言的固有操作方法直接用于映射过来的数据对象。但经隐式转向后，就能在转向函数中提供专用实现。

所谓专用实现是指：例如，宿主脚本语言中的变量赋值不同于C/C++语言中的变量赋值，在宿主脚本系统中用宿主脚本语言描述C/C++的变量赋值，而实际实现赋值要借助转向函数。在转向函数中专门针对C/C++语言规格实现赋值。同样，如果映射变量是从异构脚本系统映射过来的，则在转向函数中专门针对该异构函数的规格实现赋值。

1.4兼容强类型与弱类型的赋值风格

C/C++是强类型风格语言，但宿主脚本语言则与常规脚本语言一样，是一种弱类型风格语言。前者(强类型风格语言)的变量的数据类型是代码编译时就确定的，并且在动态运行过程中，变量的数据类型不会动态变化。而后者是动态数据类型，变量的数据类型在运行过程中随时发生变化。例如在宿主脚本语言(例如CSE语言)中运行下面的语句：

var1＝MapCInt(7)；

var1＝8；

var1＝8.5；

在第一句脚本运行后，var1是映射变量(即TData的类实例)，而第二句运行后，var1就变成宿主脚本语言的int类型变量了，这时var1不再是类实例，也不再是映射变量，而原先的映射变量的值仍是7。当最后第三句运行后，var1又变成宿主脚本语言的float类型变量了。

上述语法用于表达映射操作时，就存在语义的冲突。因为在C语言中，上述第2条语句的原来含义是：将int变量的值从7改成8。这种语义冲突是将强类型语言映射成弱类型语言来表达所固有的。

为解决这个问题，本发明把映射变量置于变量容器下。因为针对变量容器子成员的赋值能转向到setValue方法调用，就能在setValue调用中按C语言风格进行赋值。例如：

vc＝newVarContainer(”C/C++”)；//创建一个C/C++的异构集容器

vc.var1＝MapCInt(7)；//相当于C语言：int var1＝7

vc.var1＝8；//转向到隐式调用vc.setValue(`var1`，8)

这样，把映射变量置于变量容器中，缺省就按C风格进行赋值，而变量容器外的变量赋值仍可保持宿主脚本语言的动态数据类型风格。

另一方面，如果变量容器下的映射变量一直维持强类型赋值风格，也会给调测工作带来不便。例如在第一个测试用例中临时创建了一个指针类型名为var的映射变量，这个映射变量在该用例运行结束就不用了。现在接着设计第二个测试用例，也使用一个名为var的int类型的映射变量。这时，变量容器下名为var的映射变量还存在(是上个用例执行后遗留的指针类型变量)，此时赋值若仍维持强类型风格，就容易产生问题，例如：

//测试用例1中的语句

vc＝newVarContainer(”C/C++”)；//创建一个C/C++的异构集容器

vc.var＝MapCPoint(vt.int)；     //var是“int*”映射变量

//...

//测试用例2中的语句

vc.var＝MapCInt(3)；//这时，vc.var1仍是“int*”类型，指针值是3

//...

期望在第二个用例中“vc.var＝MapCInt(3)”执行后，vc.var是值为3的int类型变量，但实际上这时这个变量却是“int*”类型。

为解决该问题，宿主脚本系统可提供一个API用来删除变量容器下指定的子成员。例如该API可以是deleteVcAttr。上例中若在“vc.var＝MapCInt(3)”语句之前运行“deleteVcAttr(vc，var`)”，则可消除语义冲突。

如果要进一步提高易用性，还可以让宿主脚本语言支持某种特殊的赋值操作。在赋值前先删除已存在的同名子成员，例如：“vc.var：＝MapCInt(3)”。这样，对变量容器下子成员的赋值就形成清晰的规则，缺省“＝”赋值按被映射语言的风格进行，而“：＝”赋值则按宿主语言原有的风格进行。此处“：＝”是CSE语言中的合法操作符，含义为“特殊赋值”。

1.5映射实体按使用环境隐式转向

同一映射实体在不同使用环境下具有不同含义。例如sum是cdecl风格的映射函数，运行如下脚本：

print(vc.sum)；//打印函数原型，即：int_cdecl sum(int，int)

vc.sum(3，5)；//应调用C函数sum，返回值为8

print(vc.sum+1)；//把该映射函数看成数值使用，即：取其地址值

                   再加上1

上面第一行查看映射实体的描述值(通常用于打印输出，让调测者能一眼看出这个实体是什么)，第二行是按C风格进行函数调用，第三行是把映射实体看作数值来使用。

实现上述自动转向功能，首先要求宿主脚本语言内核能识别当前变量容器所处的上下文使用环境。例如把映射实体用在加、减、乘、除运算中，系统就自动调用该映射实体的getValue方法提取它所代表的数值。上例中第三行脚本反映了这种情况。

除了如上所述系统能捕获针对映射实体子成员读写操作外，本发明要求宿主脚本语言还能识别如下4种上下文环境，并实施隐式转向：

1)映射实体出现在数学运算或逻辑运算中作为算子使用时，或者映射实体在映射函数调用中作为参数传入时，该映射实体被看作数值来使用。即：将当前操作隐式转向到本对象的getValue方法调用。

2)如果映射实体直接用作函数调用，则该映射实体将被理解为映射函数，当前操作将隐式转向到本对象的_call_方法调用，在_call_方法中实施被映射语言的相关函数调用。

3)如果映射实体用于取自身描述值，例如在print语句中使用，当前操作将隐式转向到本映射实体的_str_方法调用。

4)如果映射实体用于获取自身表述值，例如在repr函数中调用，则当前操作将隐式转向到本映射实体的_repr_方法调用。

在上述2)中，映射实体用于函数调用时转向到该实体的_call_方法。其中_call_方法实现应能准确地模拟该函数在被映射语言中是如何运行的。首先要识别传入参数，如果传入参数是一个映射实体，则自动取其代表的数值来压栈。在取其数值的过程还应对照函数原型检查传入参数的类型是否匹配，若不匹配应该报告错误。如果被调用的映射实体来源于C++语言，还应注意多态函数的原型申明。因为多个同名函数，参数个数或类型不尽相同。因此，本发明逐一分析传入的参数，参照多个同名函数的原型进行匹配分析。若匹配上了就选择其中匹配的函数来调用，若匹配不上就报告异常。模拟调用时压栈与出栈方式也应与该函数申明的风格(如：cdecl、stdcall、thiscall、fastcall等)保持一致。

另外，在得到该映射函数的调用结果后，如果该函数原型要求的返回类型不为void，还必须将结果值按指定的返回类型映射成映射变量。例如，映射函数从C/C++系统映射而来。在_call_方法中模拟该函数调用后，返回一个数值，该数值在C/C++系统中有准确含义(例如是int值)。但这种返回值不能直接在宿主脚本中使用。按相同的映射方法，把该返回值映射到宿主脚本系统，成为宿主脚本系统中的一个映射变量后才能使用。

在上述3)和4)中，取自身描述值与表述值是不相同的。前者取描述值仅用于调测时浏览查看目的，而后者取表述值是无损失地获得该对象的文本化描述。该种文本化描述经自身脚本语言计算后能生成回与其自身一致的数据。例如，在Python语言中，运行表达式“eval(repr(100))”得到值仍是值为100的int数据，而运行表达式“eval(repr(”100”))”得到值仍是值为“100”的字串数据。因为取表述值可以无损失地进行流式转化，并能方便地转化回来，所以它常用于跨进程或跨机器透传某实体。本发明所述的“取描述值”与Python内嵌函数“str”的含义一致，本发明所述的“取表述值”与Python内嵌函数“repr”的含义一致，本文不再展开详细解释。

映射实体取表述值自动转向到该实体的_repr_方法调用，这项规则只在异构脚本语言映射中支持，C/C++映射不支持，因为C/C++语言中没有对应的“取表述值”的概念。

1.6映射实体的生存周期自动管理

变量生存周期自动管理是脚本语言普遍支持的一种特征。其原理是对每个受管理的数据都记录引用次数。在创建一个对象并首次使用时，引用次数置为1。当该对象传递给其它实体，其它实体也同时使用它时，引用次数将加1。而如果某实体不再使用该对象，则引用次数减去1。如果某对象的引用计次降为0，表示该对象不再被使用，系统会立即释放它所占用的资源。

本发明提供了两类映射支持，其一是从C/C++系统把变量或函数映射到宿主脚本系统，其二是从异构脚本系统把变量或函数映射到宿主脚本系统。在第二种情况下，由于异构脚本系统自身已支持变量生存周期自动管理，映射为宿主脚本系统的实例，按照常规编程方法就自然支持映射实体的生存周期自动管理了。但是对于第一种情况，因C/C++不具备针对所有数据类型提供生存周期自动管理的功能，需要对C/C++中的变量和函数提供专门的映射支持。实现映射后能保证用宿主脚本方式读写C/C++变量与调用C/C++函数。但是，在新创建一个映射变量后，它使用的变量空间(即：对应于C/C++语言变量的空间)不是自动管理的。如果每次调测都手工去释放无疑比较烦琐，会大大降低测试用例的设计效率，以及损失测试用例的代码质量。

为了让从C/C++系统映射过来的变量也能自动管理它的生存周期，本发明中规定每个映射变量所占用的内存块都有它的所有者，即，在TData类设置Owner属性。当同一内存块作为整体，或者取其局部生成其它映射实体时，采用“引用计次”方法记录它的使用状况。当不再有映射实体使用该块内存时，它占用的资源就自行释放。

2.调测系统的实现

图3是根据本发明的脚本解释器驱动测试系统的示意方框图。如图所示，测试主机1包含测试壳(Test Shell)11，用于发起调测命令，以及提供开发、测试的平台。测试主机端可以采用个人桌面系统(如Windows、Linux等)。测试壳11可以是其中的一个可执行程序。

目标机2通常是被测单板，或者是一个仿真程序。目标机2中驻留有测试代理(Test Agent)21。该测试代理21可以是一个脚本语言系统。在本发明中，对脚本语言的种类并没有限定，只要能满足本发明规定的映射规则即可。在目标机2的测试代理21内包含有被测试程序的符号表和类型表。关于符号表和类型表将在后文中说明。

目标机2可以与测试主机1共用同一台设备，例如计算机。在此情况下，被测程序是exe程序，测试主机也是exe程序，两者可以同时运行在一台机器的操作系统(如windows这样的支持多进程的平台)上。

测试主机1的测试外壳11与测试代理21具有通信连接。此连接的通信方式可以是共享内存通信(对于目标机与测试主机共用同一台计算机的情况、TCP/IP通信，或是其它如串口通信等形式。

如图4所示，测试代理21包括脚本系统211和通讯单元212。通讯单元212负责处理测试代理21与测试主机1的测试外壳11的上述通信连接。

脚本系统211包括内嵌调测支持模块2111和映射支持模块2112。内嵌调测支持模块2111是常规的调测应用编程接口(API)的集合，提供诸如复位目标机、启动或停止某任务、设置断点、删除断点等功能。映射支持模块2112用于实现被测系统中的C/C++语言变量与函数向脚本系统映射的功能。在完成映射后，脚本系统211中生成与C/C++语言的变量和函数同名的映射变量与映射函数。

当目标机2执行测试并反馈结果、或在测试过程中发出了打印信息，测试主机1的测试外壳11将会接收该结果或信息并进行处理。

3.C/C++映射

3.1映射支持模块的初始化

参见图5，首先，目标机2要进行初始化处理。当测试主机1启动命令解释模块的程序时，目标机2启动被测程序(S501)。然后，目标机2初始化其中包含的脚本系统211，包括设置测试代理21的相关配置(S502)。在此过程中，测试代理21的表生成单元(未示出)从目标机2被测试的软件在其最后一次编译后生成的GDB或PDB调试数据库中提取与被映射的变量/函数相关的信息，生成符号表和类型表(后文将要说明)，并记录在测试代理21中(S503)。然后，测试代理21的脚本系统211把符号表及类型表映射到一个全局的变量容器(即异构集容器)(S504)。按照预定的脚本把类型表、符号表的符号都映射至变量容器中(S505)。该操作将被测程序中的变量与函数在脚本系统中描述为映射实体(即脚本的TData类对象)。由于转换全部符号会导致CPU与内存资源浪费，因此根据本发明的一个实施方式，不对符号作一次性全部转换，而仅根据测试需要来映射。例如，运行测试脚本时，脚本包含哪些映射的变量与函数，就动态转换那些变量或函数，或者由用户自行确定规则来按需转换，例如所有外部定义的符号都不作映射。

此后，进行被测系统的正常测试(S506)。在测试主机1，用户使用类似C/C++语言的脚本文件对传送来的编码进行操作。测试外壳11中的命令解释模块解释用户的输入，并发出相应的测试指令。该命令被传送到测试目标机2，并在其脚本系统211中运行，从而得到按编码逻辑所得到的测试运行结果。这个测试运行结果可被反馈到测试主机1，并显示给用户。在上述方法中，由于可以在线地编写测试脚本，直观地查看或修改被测变量、调用被测函数，可以马上看到测试结果，也可马上改进测试，从而提高了测试的效率。

因为C/C++语言编码对其数据的结构/类型要求很严格，作为它的映射后的脚本，必须能够支持基本的C/C++编程的功能和要求。

3.2对宿主脚本语言的基本要求

为了实现本发明的目的，本发明中使用的宿主脚本语言需要在表达方式上满足以下描述方式：

1)指针操作与C/C++语言风格保持一致，包括“-＞”操作符使用方法，例如用“pStruct-＞Member1”描述某结构指针指向某成员；也包括指针移动的规则，例如“pInt+2”将int指针向后移动2，实际指向将偏移2*sizeof(int)个字节。

2)存取数组成员的方式与C/C++语言的风格保持一致。使用中括号按下标取子成员，例如用“ArrayVar[2]”表示存取数组变量ArrayVar的第3个子成员。

3)存取struct与union成员的方式与C/C++语言风格保持一致。使用点号区隔struct/union变量与其成员，例如某Struct类型定义了两个子成员Member1与Member2，存取该类型变量StruVar第一个子成员的描述形式为“StruVar.Member1”。

4)支持下列与C/C++语言含义一致的二元操作，操作符表达方式与优先级都一致。

运算类型	操作符
		数学运算	+-*/
关系运算	＝＝！＝＜＞＜＝＞＝
		位域操作	＜＜＞＞&|^
逻辑运算	‖&&

以上涉及取值描述的应同样适用于赋值描述，如“pStruct-＞Member1＝3”、“ArrayVar[2]＝3”、“StruVar.Member1＝3”。

同时，为达到高效率测试及支持必要的扩展能力，驻留在测试代理中宿主脚本语言优选应能满足如下要求：

1)脚本中的所有变量与函数，能实现生存周期自动管理，多数脚本语言都具备本项特性，通常使用引用计次技术实现生存周期自动管理。

2)支持常见的数据类型，如4字节整数、单精度或双精度浮点数、字串、数组序列、字典等。

3)支持if、else、while等基本的分支与循环控制。

4)支持函数定义扩展与模块定义扩展。

5)支持类定义与类继承。这是由于本发明使用的映射规则依赖于特定的类定义格式。因此需要类定义的功能。

6)在不重启脚本系统前提下，可在线增删变量、函数，以及类的定义，现在技术中已有许多脚本语言都能支持这一点。

满足上述要求的脚本系统都是可以从现有技术中得到的，如Python、Ruby等，它们都支持在线增加或删除变量定义或函数定义。

3.3驻留符号表与类型表

为了实现对C/C++语言编码的映射，根据本发明，在目标机2的测试代理21中驻留了被测试程序的符号表和数据类型表。这两个表将直接支持本发明规定的映射规则的实现。本发明的映射方法依赖于对目标机系统的各种符号及其类型信息的收集与分析。调试数据库在编译过程中由编译器产生，例如在Visual C/C++编译过程中，编译器会从源码中提取相关信息生成作为中间格式数据的PDB文件。GCC在编译时也会将中间格式数据的GDB调试信息编译到目标程序中。驻留在目标机的映射支持模块将进一步分析中间格式数据(PDB/GDB)，生成符号表与类型表。

不同的C/C++编译器生成的调试数据库格式并不一样。本发明通过对类型表和符号表的生成达到了对不同格式的统一。类型表记录被测系统定义过的各种类型。这些类型必须包括：主类型信息、子类型信息、以及占用字节数。表1是类型定义格式的示例：

表1：

同时要确保类型表下各栏目具有唯一性，即，由相同的主类型与子类型以及占相同字节数而构成的类型项只能存在一个。

符号表记录变量或函数的地址值及其类型ID。其中符号地址有两种形式，既可以是绝对地址，也可以是相对地址。例如，存取函数内局部变量或传入参数时，则使用相对于当前栈顶位置的偏移值。再如，某变量在另一变量空间下存在，其地址也按该另一变量的地址加上一个偏移来表达。

符号来源有两种方式，一是来源于另一映射实体，二是来源于某绝对地址。后者是描述变量或函数的常规方式，前者常在将同一内存空间看作多种类型的变量进行操作时使用，例如强制类型转换，是将某字串数组的某一偏移看成整数类型变量。

3.4变量与函数的映射

上述类型表和符号表按照特定格式组织，驻留在被测系统中，符号表中各个符号可映射到宿主脚本系统，成为映射实体，也即脚本系统中的TData类实例。为了节省资源开销，本发明的一个方式是按需映射而非一次全部映射，使变量与函数只有在被使用时才映射为脚本对象。

在生成了符号表和类型表之后，为了脚本的操作方便，需要定义与表中数据相应的转化脚本类对象，即TType类对象对应于类型表，TData类对象对应于符号表。在TType类对象定义的实例化数据包含如下信息：该类型唯一的标识，类型主类别信息，类型子类别信息，类型大小。各个符号映射为TData类定义的实例化数据，包含以下信息：该符号对应的类型ID，符号的来源，相对于来源的偏址，是否是自动释放内存。

表格内容的映射过程按图6进行。首先，脚本系统211从符号表里找出需要的符号(变量或函数)信息，如符号名称，符号的类型ID及符号地址(S601)。然后脚本系统211通过该类型ID查找相应的类型是否有生成的TType类对象，若没有则先创建该TType类对象，即通过定义TData或TType类对象，调用类定义的建构函数来创建这个类对象的实例(S602)。最后，根据该符号的来源、所属的TType对象、地址偏移及是否自动释放内存等信息来创建被映射符号的TData类对象(S603)。

在创建的映射实体包括映射变量与映射函数时，首先要有相应的TType对象指明类型信息。当类型表中的各项都转化成TType类实例后，原有类型信息表不再有用，其占用的资源可释放，而用新生成的各个TType类实例组成一个新表，即TType类型表。映射变量与映射函数都是TData类实例。如图7所示，每个TData类实例使用该符号对应的类型ID(Datatype)指示它使用TType类型表中的哪个类型。

需要注意，TType类的对象可能是嵌套引用的。某些复合类型如struct/union/指针等包含了子类型，而且同一子类型可能被多个复合类型引用。所以，在创建每个TType对象时，该类型涉及的其它类型也同时被创建。

3.4映射数据的生存周期的自动管理

由于测试主机和目标机的系统资源是有限的，为了更有效地进行测试，在相应时期对使用资源的处理是十分重要的。根据本发明，为了有效利用系统资源，变量、函数、类对象等在脚本语言中作为一个实体存在，实现了生存周期自动管理。这些实体所占用的资源会自动申请、自动释放。映射数据作为脚本类对象，也支持它所涉及资源的自动申请与释放。

例如，脚本系统21要创建一个映射变量buff，它是一个长度为24字节的字串数组，这时脚本系统21会向目标机2自动申请它占用的内存，包括buff变量作为脚本TData类实例要占用的内存空间，以及字串数组的24字节空间。为描述方便，在本发明中，将前一类空间称为脚本实例空间，将后一类空间称为C/C++实例空间(本说明中简称C实例空间)。当新创建的映射变量的生存周期结束时，这两种空间都将被自动释放。

但是，由于编程的复杂性，脚本实例空间与C实例空间并不总是同时申请或同时释放的。例如对于被测系统的全局变量，其占用空间是静态分配的，全局变量的映射实体在生存周期结束时，应只释放脚本实例空间，而不应释放C实例空间。再如，使用脚本文件中创建一个映射变量a后，这个变量的脚本实例空间与C实例空间应同时申请或释放。但是，如果把这个映射变量a看成另一类型的映射变量b，例如C语言中的强制类型转换时，将同一地址空间下某变量，看成另一类型的变量，则创建变量b时应新申请脚本实例空间，但不应重复申请C实例空间。另外，当变量a或变量b被删除时，不管先删除哪一个，都应保证尚在使用的另一个变量所操作的C实例空间还有效。也即：C实例空间可被多个映射变量共享，只有该C实例空间所全部涉及的映射变量都释放了，这个C实例空间才自动被释放。此外，映射变量使用的C实例空间还需配合测试，必要情况下可修改其中的标志。例如为映射变量设置Autofree属性，该属性为TRUE表示该映射变量的C实例空间是随它的脚本实例空间释放而释放的，否则属性取值为FALSE，表示C实例空间不随脚本实例空间释放而释放。

为实现上述目的，根据本发明的一个实施方式，对映射实体设置了3个属性。图8显示了映射实体的一个示例。如图8所示，该属性包括：是否自动释放内存(Autofree)、符号来源(Owner)、相对于来源的偏移地址(Offset)。其中“是否自动释放内存”的属性用于指示该映射变量的C实例空间是否跟随脚本实例空间一起释放。“符号来源”用于指示该映射实体的归属对象，其取值既可以是某绝对地址值，也可以是另一个映射实体。相对于来源的偏移地址用于指示本映射实体所用C实例空间的起始地址相对于其符号来源指示的空间地址的偏移量是多少。由于脚本语言具备生存周期自动管理特性，所以如果使符号来源属性指示另一映射实例，就实现了同一C实例空间被多个映射实例共用时也能够实现资源的自动管理。

3.5操作转向的实现

综合前文所述，本发明要求实现的操作转向包括下面几项：

1)按数值方式给变量容器的子成员赋值时，自动转向到子成员的setValue方法调用；

2)变量容器作为算子使用时(即：出现在数学运算或逻辑运算中，或者出现在映射函数调用的传入参数中)，隐式转向到本对象的getValue方法调用，来取其数值形式的值；

3)读写变量容器的数组子成员时，分别自动转向到该数组成员的getItem与setItem方法调用；

4)读写变量容器的指针指向值时，分别自动转向到该成员的getPoint与setPoint方法调用；

5)变量容器直接用于函数调用时，隐式转向到本对象的_call_方法调用；

6)变量容器在取自身描述值时(如在print等语句中使用)，隐式转向到本对象的_str_方法调用；

7)变量容器用于获取自身表述值时(如在repr等语句中使用)，隐式转向到本对象的_repr_方法调用。

实现上述七种操作自动转向，依赖于两个条件：

其一，应有一种形式来定义目标转向函数

如前文所述，这些目标转向函数(如getValue、setValue、getItem、setItem、getPoint、setPoint、_call_、_str_、_repr_)都作为TContainer的类方法定义到变量容器中。

目前已有一些脚本语言支持类似的实现，例如Python语言。其中读写类对象成员可分别被定向到_getattr_与_setattr_这两个函数。只须在Python的相关类定义中增加_getattr_与_setattr_这两个类方法，读写类成员就能捕获并自动跳转。类似地，Python也支持把类对象作为数组，读写其子成员时，能自动跳转到该类对象的_getitem_与_setitem_方法。在Python中若为类对象定义_call_方法，则把该对象作为函数来调用时，也自动跳转到_call_方法。取描述值与取表述值也同样，只要分别定义_str_与_repr_方法即可。所以，Python语言已能实现本发明所要求的9种转向中的7种。

其二，宿主解释器在解释运行过程中，应能捕获该进行自动转向的场合，然后触发自动跳转。这一点是对宿主解释器内核的解释执行能力提出的要求。

上述操作自动转向是可实现，现有Python语言已提供我们所要求9种转向中的7种。只剩下读写变量容器的指针指向值(跳转到getPoint与setPoint)未提供，读写指针的“-＞”操作符在Python语言中是非法的。因此，本发明所要求的宿主脚本语言可以仿照Python来开发。因Python是开源产品，依据本领域已有知识，不难实现本专利所要求的映射操作隐式转向的功能。

4.异构脚本语言的映射

借助上文描述的变量容器的特性，还可以实现将异构脚本语言映射到宿主脚本语言。下面的实施例将以Python与CSE语言为例介绍该映射的实现方法，Python(参见www.python.org)用作异构脚本语言，CSE(参见www.cse-soft.org)用作宿主脚本语言。本领域技术人员可以理解，该说明仅为示例，本发明的实施并不限于这两种语言。

4.1映射内容

异构脚本映射通常以脚本模块为单位，涉及被映射的对象也限于被映射语言在模块接口级别所能提供的实体，主要包括：变量(包括类对象)、函数。

异构脚本映射的内容包括三个方面：

1)实现异构脚本系统规定的基本类型数据的映射，支持针对该映射实体的相关操作，包括：创建、释放、读值、赋值、函数调用。

2)实现异构脚本系统中的类实例映射，支持针对该类实例的相关操作，包括：创建、释放、读写成员、调用类方法。

3)把异构脚本系统中的一个模块映射到宿主脚本系统中的一个变量容器中。

以上三个方面涉及异构脚本映射所包含的3种映射实体，即：基本类型数据映射、类实例映射、脚本模块映射。

这三类映射实体都是宿主脚本的TData类对象。同样，该TData类对象中记录TType实例数据，以此指示该映射实体在被映射系统中的数据类型。用于异构脚本映射的TData与TType结构定义应与前文所述的C/C++映射所用的TData与TType维持一致。如果某些属性定义未使用，例如，用于指示映射实例的C实例空间是否跟随脚本实例空间一起释放的属性不再被使用，则保留不用就行了。

4.2基本类型数据映射

常见脚本语言，如Python、Ruby、TCL都有整型(int)、浮点型(float)、字串(string)、函数(function)等基本类型。这些基本类型数据作为存在于异构脚本系统中的特定格式的数据，不能直接用作宿主脚本语言中的变量。否则，数据存取会发生错误。相同类型的数据在两个异构系统中，其内部格式并不相同。基本类型数据映射的目的是要保证相同类型数据在跨语言传递时能自动转换。

被映射的基本类型数据在跨语言存取(例如取值或赋值，或在函数参数或返回值中传递)时要做隐式转换。因此，涉及大数据量传递的类型不宜用作基本类型来映射，如下文所述，而应作为一种类对象形式进行映射。

在此同样是使用TType类实例记录异构脚本系统中各个基本类型的相关信息，包括类型定义，类型长度等。这些信息可以通过异构脚本系统的API函数来获得。例如调用Python的内嵌函数“type(obj)”可以获得指定变量的类型，调用内嵌函数“len(obj)”可以获得指定变量的长度，等等。

同样，在本实施例中，使用TData类表达映射实体。当然，TData类从TContainer继承而来，也属于变量容器。在TData类实例中同样要记录该映射实体的类型(TType的值)、实体对象的地址等信息。

新创建一个映射实体后，异构脚本系统中被映射的对象要增加一次引用计次，这通过调用异构脚本系统提供的API来实现。例如，Python中增加一次引用的API是Py_INCREF，减少一次引用的API是Py_DECREF，如果该映射实体被释放了，相应被映射的对象的引用计次要减1。

如前文所述，针对映射实体的操作通过读写子成员、读写数组成员、调用实体、取自身描述值、以及取自身表述值时的隐式转向功能，在转向目标函数中实现具体的、针对被映射实体的特定操作。具体操作实现通过调用异构脚本系统的API来完成。例如，异构脚本系统若是Python，调用映射函数后隐式转向到_call_方法调用。本发明在_call_方法中调用Python提供的API来调用被映射系统中的相关函数。在Python中调用函数的API是PyObject_CallFunction，调用类方法的API是PyObject_CallMethod。

4.3类实例与脚本模块映射

在许多脚本语言中，基本类型与class类经常没有明确区分，如Python中的字典类型(dict)。尽管是基本类型，但在本发明中稍作封装就完全可以按类实例的方式使用。例如下面的Python代码：

class TDict:

    def_init_(self):

        self._value＝{}

    def setValue(self，key，value):

         self.value[key]＝value；

    def getValue(self，key):

         self.value[key]

ADict＝TDict()；

ADict.setValue(3，”abc”)；#等同于：ADict[3]＝”abc”；

print ADict.getValue(3)；#等同于：print ADict[3]；

因为某些数据类型可能存贮庞大数据，而基本数据在穿越两个异构脚本系统时要做转换，因此不便将涉及庞大数据的数据类型作为基本类型进行跨语言传递，以避免使用效率降低。针对这种类型数据，本发明是将其视为一种类对象。如对于上面举例的Python字典类型，先将其封装成类，然后按类对象的形式实施映射。在这种情况下，尽管dict数据作为整体并不跨越两个异构脚本系统，但dict的组成元素是能正常跨越两个异构脚本系统的。例如：

vc＝newVarContainer(”PYTHON”)；

vc.ADict＝MapPyDict()；

vc.ADict[3]＝”abc”；//隐式转向到调用：vc.ADict.setItem(3，”abc”)；

print(vc.ADict[3])；//隐式转向到调用：print(vc.ADict.getItem(3))；

在转向函数setItem与getItem中，再调用Python提供的API，实现对Python字典数据的读写操作。

对于每个类对象映射实体的类方法调用，同样可以通过动态生成一个类方法的变量容器，然后调用这个变量容器(即类方法映射实体)，就自动转向到该类方法映射实体的_call_方法。在_call_方法中，可通过调用Python的API实现专用的Python类方法调用。例如：

vc＝newVarContainer(”PYTHON”)；

vc.AObj＝MapPyInstace(`AClass`，arg1，arg2)；//创建类实例映射实体

vc.AOBJ.method1(1，2)；//第1步：执行vc.AObj.method1

                    //转向到vc.AObj.getValue(`method1`)

                    //第2步：动态生成一个AObj.method1映射函数

                    //第3步：执行AObj.method1(1，2)

                    //转向到AOBJ.method1._call_(1，2)

对于类对象映射实体，每次调用其方法，都动态生成一个对应的映射函数，然后调用映射函数时，自动转向到该映射函数的_call_方法调用。在_call_方法中再专项实现Python相应类方法的正常调用过程。即，如果异构语言是Python就按Python的格式实现相应调用，如果异构语言是Ruby就按Ruby的格式实现相应调用。当然，调用的结果值也自动装配成映射变量。

针对异构脚本语言的不同，从类定义中搜索它的成员的方法不尽相同。但是，无论异构脚本语言是Python，还是Ruby或TCL，借助该脚本系统提供API及该脚本语言所定义的类型格式，总是可以遍历指定class类下都定义了哪些方法、定义了哪些类成员的。同样，也总是可以遍历指定模块下都定义了哪些对象实体。例如Python语言就提供一个“dir(namespace)”内嵌函数，可以扫描指定域名空间下都定义哪些对象，模块下都定义哪些对象，class类下都定义哪些属性。这些都可以通过调用dir函数来获知。所以，对于类对象映射实体，每次调用其方法都能动态获得相应函数定义，都可以动态地生成一个映射函数。

也可以通过一次扫描异构脚本系统中的模块，在获知该模块下都定义哪些对象后，再将这些对象按其TType的不同生成不同的映射实体，保存到指定的变量容器之下。

因为某些大型脚本语言如Python、Ruby能提供丰富的软件功能，因此本发明采用异构脚本语言映射，可以大幅增强系统的调测能力。将异构脚本映射到宿主脚本语言，一方面能够实现跨语言功能调用，另一方面，也降低了学习门槛，因为映射语法屏蔽了异构语言在表述上的差异。

Claims (17)

1.一种应用于程序调测系统中的映射系统，所述程序调测系统包括测试主机和目标机，所述测试主机对所述目标机中的程序进行调测，在所述目标机中包含映射支持装置，所述映射系统包括：

使所述映射支持装置根据被调测程序被编译后的调试数据库生成所述被测试程序的符号表和类型表的装置；

使所述映射支持装置将所述类型表、符号表中的变量和函数都映射至变量容器中，生成由宿主脚本系统可操作的映射变量和映射函数的装置；

在所述目标机有选择地驻留一个与宿主脚本语言不同的异构脚本系统，使所述异构脚本系统中变量、函数能够映射到宿主脚本系统的变量容器中的装置；

其中，所述变量容器是脚本TContainer类的类对象。

2.根据权利要求1所述的映射系统，其中在所述目标机中还包括异构脚本语言系统，用于提供测试服务的脚本系统。

3.根据权利要求2所述的映射系统，其中所述变量容器层层嵌套构成变量容器树，并且，所述变量容器树中每个节点都具有TContainer属性。

4.根据权利要求3所述的映射系统，其中所述变量容器树的根节点中包括异构集容器，所述异构集容器记录被映射系统的类型以及实施映射所需的相关配置；和

所述映射变量与所述映射函数都是脚本TData类的类对象，所述TData类从TContainer类继承而来，所述映射变量与所述映射函数都记录在所述异构集容器中。

5.根据权利要求2所述的映射系统，其中所述变量容器树中还包含复合数据映射变量，所述复合数据映射变量的层次和子成员从属关系与映射之前保持一致，所述复合数据包括C/C++语言中的class、struct、union，以及所述异构脚本系统中的类定义。

6.根据权利要求1所述的映射系统，其中所述目标机包含宿主脚本解释器，当对所述变量容器中的所述映射变量的赋值操作在所述宿主脚本解释器中用脚本语言表达时，缺省保持所述C/C++目标程序系统的强类型风格，其中：

对所述变量容器下子成员赋值时，在赋值前后子成员的类型不发生变化，只修改该子成员的映射实体所代表的处于被映射系统中的数值；

在所述宿主脚本解释器中使用API能够删除所述变量容器下的指定子成员。

7.根据权利要求6所述的映射系统，其中还允许非缺省的弱类型风格。

8.根据权利要求6所述的映射系统，其中所述宿主脚本解释器与所述变量容器在针对所述映射变量或所述映射函数进行读/写或函数调用时具备自动转向的功能，包括：

由所述宿主脚本解释器捕获对映射变量或映射函数的操作；和

隐式触发与所捕获的相关操作相应的目标转向函数。

9.根据权利要求8所述的映射系统，其中所有所述目标转向函数都作为类方法定义在映射实体中。

10.根据权利要求8所述的映射系统，其中所述宿主脚本解释器捕获对映射变量或映射函数的操作包括：

读取映射实体自身或其子成员的数值；

给映射实体的子成员赋值；

读取数组映射实体的子成员；

给数组映射实体的子成员赋值；

读取映射实体的指针指向值；

给映射实体的指针指向赋值；

调用映射实体；

取映射实体的描述值；

取映射实体的表述值。

11.根据权利要求6所述的映射系统，其中所述宿主脚本解释器自动管理映射实体的资源空间，所述资源空间包括C实例空间和脚本实例空间，所述自动管理包括：

脚本实例空间与C实例空间同时申请与释放；

全局变量的资源空间自动管理：所述C实例空间不随所述脚本实例空间一起申请和释放；

由一个映射变量生成另一个映射变量时的资源空间自动管理：所述C实例空间随第一个映射变量的脚本实例空间申请而申请，并随最后一个共用所述C实例空间的映射变量的脚本实例空间的释放而释放；以及

支持手工修改映射变量的标志，对所述C实例空间是否随变量的脚本实例空间的释放而释放进行控制。

12.根据权利要求4所述的映射系统，其中所述TData对象包括如下属性：

用于指示所述映射实例的数据类型的属性；

用于指示所述映射实例的C实例空间是否跟随脚本实例空间一起释放的属性；

用于指示所述映射实例的C实例空间的归属对象的属性；和

用于指示所述映射实例使用的C实例空间相对其归属对象的偏移的属性。

13.一种应用于程序调测系统中的映射方法，所述程序调测系统包括测试主机和目标机，所述测试主机对所述目标机中的程序进行调测，在所述目标机中包含映射支持模块，所述方法包括：

1)所述映射支持模块根据被调测程序被编译后的调试数据库产生所述被测试程序的符号表和类型表；

2)所述映射支持模块将所述类型表、符号表中的变量和函数都映射至变量容器中，生成由宿主脚本系统可操作的映射变量和映射函数；

3)在所述目标机有选择地驻留一个与宿主脚本语言不同的异构脚本系统，所述异构脚本系统中变量、函数能够映射到宿主脚本系统的变量容器中；

其中，所述变量容器是脚本TContainer类的类对象。

14.根据权利要求13所述的方法，其中在所述变量容器中对所述C/C++目标程序系统的映射变量赋值的操作在所述宿主脚本系统的宿主脚本解释器中用脚本语言表达时，按如下方式缺省保持被映射系统的强类型风格：

对所述变量容器下子成员赋值时，在赋值前后子成员的类型不发生变化，只修改该子成员映射实体所代表的处于被映射系统中的数值；

在所述宿主脚本解释器使用一个API删除所述变量容器下指定子成员。

15.根据权利要求14所述的方法，其中所述宿主脚本解释器与所述变量容器在针对所述映射变量或所述映射函数进行读写或函数调用时，按如下方式实现自动转向的功能：

由所述宿主脚本解释器捕获对映射变量或映射函数的操作；和

隐式触发与所捕获的相关操作相应的目标转向函数。

16.根据权利要求15所述的方法，其中所有所述目标转向函数都作为类方法定义在映射实体中，所述映射实体包括所述映射变量和映射函数，包括：

用于读取映射实体自身或其子成员数值时自动转向到getValue方法；

用于给映射实体的子成员赋值时自动转向到setValue方法；

用于读取数组映射实体的子成员时自动转向到getItem方法；

用于给数组映射实体的子成员赋值时自动转向到setItem方法；

用于读取映射对象的指针指向值时自动转向到getPoint方法；

用于给映射实体的指针指向赋值时自动转向到setPoint方法；

用于调用映射实体时自动转向到_call_方法；

用于取映射实体的描述值时自动转向到_str_方法；

用于取映射实体的表述值时自动转向到_repr_方法。

17.根据权利要求16所述的方法，其中所述宿主脚本解释器捕获对映射变量或映射函数的操作包括：

读取映射实体自身或其子成员的数值；

给映射实体的子成员赋值；

读取数组映射实体的子成员；

给数组映射实体的子成员赋值；

读取映射实体的指针指向值；

给映射实体的指针指向赋值；

调用映射实体；

取映射实体的描述值；和

取映射实体的表述值。

Images