WO2008058473A1 - Mapping method in the program testing system and program testing system - Google Patents

Abstract

A mapping method for a software testing and its program testing system using the method. The program testing system includes a testing host (1) and a target machine (2), and the testing host (1) tests the program in the target machine (2) in which a mapping support module (2112) is included. The method includes: 1) the mapping support module (2112) generates a symbol table and a type list of a tested program according to the testing database obtained after the tested program is compiled; 2) the mapping support module (2112) maps the variable and the function in the type list and the symbol table to a variable container to generate the mapping variable and the mapping function operated by a host script system, in which the variable container is a class object of the script TContainer class. The tested target machine (2) also can selectively reside a heterogonous script system to enhance the testing ability. The variable and the function in the heterogonous script system can be mapped into the host script system to be the mapping variable and the mapping function, thereby the host script system is provided with the ability to cross-language call the testing service.

Description

 Mapping method and program commissioning system in program commissioning system

 The invention relates to the field of software debugging and testing, and particularly relates to a debugging system and method for software debugging and testing of a C/C++ language development environment. ' Background technique

 In the field of software development, the Tornado programming environment supporting VxWorks real-time operating system development is one of the best programming environments for debugging performance in many embedded programming languages. The Tornado test command interpretation module tool supports scripted variable read and write and function call calls, and is more powerful. For a detailed description of Tornado, see "Tornado User's Guide (Windows Version)", V2.0 Edition 1, by Wind River Systems, Inc.

 Although the Tornado test command interpretation module is powerful, it uses two interpreters, the C interpreter and the TCL interpreter, and because it only has a symbol table that resides in the target server, there is no type table, so its debugging capability. Subject to many restrictions, mainly including:

 1) Since the type table of variables and functions does not reside, it is difficult to support operations for the type of the repeat;

2) The C interpreter and TCL interpreter used for the commissioning control reside on the test host, which causes the commissioning control to be unable to support the commissioning when it is tightly coupled with the code under test;

 3) Variable read and write and function calls and if, else, etc. are implemented in two scripting languages respectively. Therefore, when the test command interpretation module runs the commissioning command, it is often cumbersome to switch between the C interpreter and the TCL solver. Although the C interpreter can embed an API to call TCL scripts, the TCL script can also embed the C interpreter, but it is still inconvenient to use, and it is inefficient.

 4)' Moreover, due to the above 3), the C interpreter and the TCL interpreter are two sets of systems, which are difficult to integrate at the grammar and semantic levels, which increases the user's learning burden and is not conducive to the expansion of the debugging function.

 The 4th generation white box test method combines the best practices of software white box testing, reflecting the development direction of today's white box testing. In order to meet the requirements of the 4th generation white box test method, the following adjustments to the Tornado technology-based commissioning system are required:

 1. Introduce a system that supports real-time commissioning. The test control and the code under test should be in the same body.

2. Use a scripting language that describes both the control of the C/C++ variables and functions being tested (similar to the C interpreter in the Tornado Shell) and the test control (similar to the TCL interpreter in the Tornado Shell). These two types of descriptions maintain an approximate language style. ' Invention content The invention aims to improve the problem of insufficient commissioning capability and poor test efficiency which are prevalent in current software development, and meets the requirements of the fourth generation white box test method, and applies the relevant test methodology to the field of C/C++ language development. A set of programming language mapping techniques is proposed, namely: mapping the variable operations and correspondence operations of the C/C++ language to a scripting language system, and the scripting language system resides in the system under test, so that the scripting languages are both scripted. The test description, and can directly manipulate the variables, functions, etc. in the system under test, and make this test description as consistent as possible with the C/C++ grammar rules.

 In addition, for large software testing, often with a powerful scripting language (such as Python, Ruby, TCL, etc.), the mapping technique of the present invention can also be as close as possible to the grammar rules (approx. Python, or Ruby, or TCL), describes the functional interface provided by this scripting language, which is called directly in the commissioning.

 Moreover, the present invention also introduces a system that supports real-time debugging, so that the test control and the code to be tested are in the same execution body. The present invention uses a scripting language to describe both the control of variables and functions for the C/C++ language being tested, as well as the test control, and to keep both types of descriptions of the same style.

 According to the present invention, there is provided a program commissioning system comprising a test host and a target machine, the test host commissioning a program of the target machine. The target machine includes a mapping support module, and the mapping support module includes a variable container; the variable container is a class object of the script's TContainer class, and the debugged C/C++ target program system The variable and the function 'number are mapped into a mapping variable and a mapping function in the variable container, and when the operation of the mapping variable or the mapping function is described in the host scripting language, the mapping variable and the mapping function and the variable of the program under test And a function having a similar expression; by means of the variable container, the operation of the mapping variable using the host script language is diverted to the operation of a corresponding variable in the C/C++ target program system being debugged, the host The operation of the mapping language by the scripting language is directed to the operation of the corresponding function in the C/C++ target program system being debugged.

 According to another aspect of the present invention, a mapping method applied to a program commissioning system is provided. The program commissioning system includes a test host and a target machine, and the test host performs debugging on a program in the target machine, and includes a mapping support module in the target machine, the method includes: 1) The mapping support module generates a symbol table and a type table of the tested program according to the debug database compiled by the commissioning program; 2) the mapping support module sets the variables and functions in the type table and the symbol table Mapping to a variable container, generating a mapping variable and a mapping function operable by the host script system, wherein the variable container is a class object of the script TContainer class.

With the system and method of the present invention, arithmetic processing of software commissioning can be assigned to the test host and the target machine. The scripting of the test case of the test program is processed by the test host, the script is issued (the host script system that is delivered to the target machine), and the output information is displayed during the test. Residing in the destination The scripting system of the standard machine completes the mapping and control of the C/C++ language variables and functions of the tested terminal, that is, mapping the variable operations and functions of the C/C++ language to a scripting language system (ie, the host scripting system). This scripting language, which resides in the system under test, not only implements scripted test descriptions, but also directly manipulates variables, functions, etc. in the system under test.

 The mapping technique of the present invention effectively improves the debugging capability of the software product and the white box testing capability. Compared with the Tornado test command interpretation module, the present invention includes the commissioning module and the mapping module in the scripting system of the testing agent, so that both the test control and the tested code are in one system. The commissioning control is more closely coupled to the code under test. Tightly coupled interactions do not have the latency of the two systems due to communication connections, and the complexity of the test control process is also reduced.

 In summary, the advantages of the present invention are: By using a mapping technique, the commissioning script can directly control the behavior of the system under test. Due to the online definition of the script and the online execution characteristics, the development efficiency of the commissioning script is greatly improved, which effectively guarantees the instrumentation implementation of the online test and gray box debugging required by the 4th generation white box test method. Compared to the Tornado test command interpretation module, the commissioning efficiency is improved. In addition, test scripts do not have to be frequently switched between the two scripting languages, and data transfer and control transfer are more free. As mentioned above, the C interpreter and the TCL interpreter in the Tornado system are difficult to integrate at the syntax and semantic level.

 At the same time, the method of the present invention can also ensure that the test description is as consistent as possible with the C/C++ language regulations. In addition, for large software testing, often with a powerful scripting language (such as Python, Ruby, TCL, etc.), the method of the present invention also describes this as much as possible with approximate grammar rules (approx. Python, or Ruby, or TCL). The function interface provided by the scripting language is called directly in the commissioning.

 Therefore, the invention can improve the debugging capability of the embedded software, reduce the learning threshold of the test expression, and greatly improve the development efficiency of the commissioning script. DRAWINGS

 Figure 1 shows the logical structure of the existing Tornado technology;

 Figure 2 shows the logical structure of the program commissioning system of the present invention;

 Figure 3 shows the composition of the program commissioning system of the present invention;

 Figure 4 is a hierarchical structure of the test agent in the present invention;

 Figure 5 is an initialization process of the mapping support module;

 Figure 6 is a mapping instance generation process;

Fig. 7 exemplarily shows a TData correspondence with a TType of a mapping instance; Fig. 8 exemplarily shows attributes of a mapping instance according to the present invention. detailed description A program language mapping method for software commissioning and a program commissioning system to which the method is applied will be described in detail below with reference to the accompanying drawings. Although the C language will be described below as an example, the concepts and solutions of the present invention can also be applied to programs in other languages, such as the C++ language.

 In the present invention, the mapped scripting language is referred to as "heterogeneous scripting language", and the mapped mapping variable and the scripting language in which the mapping function is located are referred to as "host scripting language". That is, the host script language is the main scripting language used for normal debugging in this system environment. Any scripting language that is different from the current host script language and resides in the system under test for debugging is a heterogeneous scripting language. Because of heterogeneity, there is a need to implement operational mapping across languages.

 To facilitate a clear understanding of the technology evolution of the present invention relative to Tornado, the following two logical solutions are logically analyzed and then the differences between the two are compared. As shown in FIG. 1 and FIG. 2, the mapping host script interpreter in the present invention is equivalent to the C interpreter in Tornado, and the script interpreter (such as Python, or Ruby, or TCL) providing the debugging base library in the present invention is equivalent. The TCL interpreter in Tornado. In the Tornado technology system, variable scripting and reading and function scripting calls (ie mapping) for C/C++ are jointly performed by Tornado Shell, Target Server, and Agent in the target machine, but in the present invention. , is to achieve the function of the three in the target machine, so that the test control and the code under test are in an execution body.

 In the present invention, mapping entities (including mapping variables and mapping functions) for implementing mapping exist in the host scripting language. The host scripting language can be a CSE language, but is not limited to this. This presentation: The mapping technique supports both mapping of variables and functions in C/C++, as well as mapping to heterogeneous scripting languages that provide a debugging base library. This mapping focuses on the functional interfaces used by the host script to call other underlying libraries (such as Python, Ruby, TCL, etc.) that serve the purpose of debugging. For example, you can also host a heterogeneous scripting language, Python, in the target machine. The system debugging capability can be greatly enhanced by the functions of database interface, file operation interface and XML parsing service provided by Python. Because the various modules in the heterogeneous scripting language are mapped and can be directly called by the host scripting language, cross-language monthly service calls can be implemented.

 The mapping support module of the present invention can be applied to a target system generated by the C/C++ language development, and the C/C++ variables and functions in the system are mapped to the host script system to generate a mapping variable having the same name as the C/C++ variable and the function. With the mapping function, and then manipulate the mapping variables in a script mode, you can achieve the following functions:

 Read variable

 2. Write variables

 3. Converting a type of mapped variable to another type of mapped variable, that is, forcing a type conversion. By manipulating the mapping function in a script mode, the following functions can be implemented:

 1. Call the function by cdecl

2. Call the function by stdcall 3. Call the function as a C/C++ function prototype

 4. Support piling for C/C++ functions, replacing the original C/C++ function with a script function. After implementing the mapping from the C/C++ language to the scripting language, you can directly read and write the measured variables in the debugging script, and you can also use the script to initiate the function call. By mapping entities (including mapping variables and mapping functions), the present invention implements a commissioning mode equivalent to writing C/C++ code using a script.

 The mapping for heterogeneous scripting languages is similar to the above mapping for C/C++. It also includes variables and functions in heterogeneous scripting systems. It maps to the host script system and becomes a mapping variable and mapping function. The same implementation includes reading variables and writing. Mapping operations such as variables and calling functions.

 ^ In the mapping method of the present invention, the concept of "variable container" is proposed, and the following variables will be

Variable container

 1.1 The function of the variable container

 A variable container is essentially a class object in the host scripting system that exists in the mapping support module in the host scripting system. Define a variable container class in the host script system

TContainer, the variable container is the instantiated object of this TContainer class. But unlike regular class objects, the variable container is a class object with special functions. These functions include:

 1) Variable containers can be nested in layers. Because the mapped variables (such as struct defined in C/C++) can be layered, a tree structure with a layer-to-layer relationship is formed. This invention uses a variable container tree to describe this tree relationship. Each node on the tree is a variable container. The variable container can contain one or more variable containers of the next level to construct the layer attribution. Tree relationship.

 2) It has the function of automatic operation steering when operating sub-members of the variable container. For example, by reading a sub-member of a variable container, you can implicitly and automatically switch to a function call.

 3) With the variable container to assign values to the mapping variables, the expression of the assignment statement can be compatible with both strong and weak types.

 4) A mapping variable with a variable container property has an automatic, implicit steering function depending on the context in which it is used in the host scripting system. For example, a map variable is used as an operator in mathematical operations, and it automatically reads the meaning of the value it represents. As another example, if the mapping variable is printed out, its string representation is taken. For another example, when a mapped variable is called as a function, it is called in a specific format (for example, a function mapped from C/C++, the calling format is cdecl, stdcalK thiscall, etc.).

 5) The variable container represents an entity (variable or function) in a heterogeneous system (heterogeneous C/C++ system or heterogeneous scripting system) that can be implemented when it is passed in an assignment statement or in a function parameter. The life cycle of the mapped entities is automatically managed.

Among the above five characteristics of the variable container, the first four items ensure that the variable container is used for mapping expressions. It is expressed in a manner close to the statement of the language being mapped. For example, when mapping C/C++ variables and functions, related mapping operations (such as: reading and writing variables and calling functions) should be similar in expression, C language style, and when the variable container is used to describe the heterogeneous scripting language Python When variables and functions, the read-write mapping variable and the calling mapping function are similarly expressed in Python.

 1.2 variable container tree

 The mapping variables and mapping functions are represented by TData class instances. The TData class inherits from TContainer, so both the map variable and the map function have variable container properties.

 For example, call the MapCString function in the host script system to create a C/C++ string mapping variable, call MapCInt to create a C/C++ int type mapping variable, call MapCStract to create a C/C++ mapped variable of the specified struct type, and call MapPyString to create it. Python's string type mapping variable, call MapPylnt to create Python's int type variable. Here are five examples of functions that create mapped variables, and finally generate a variable container of type TData. The TData class inherits all the properties of the TContainer class, so the TData class property has the characteristics of a complete variable container.

 TData adds several attributes indicating the characteristics of the mapping entity to the TContainer definition, such as who the mapping entity belongs to, that is, the Owner attribute of TData, and the data type of the mapping entity, that is, the DataType attribute of TData. An instance of the TType class.

 The TType class definition is used to indicate the data type of the mapped entity. For example, create an int variable mapped from a C/C++ system, indicating that its type is a 4-byte integer type. In addition to describing basic types such as int, short > double, TType also describes class, struct, union, etc. type of data. In addition, TType also defines function types, including function prototype definitions for styles such as cdecl and stdcalK thiscall.

 In addition to the mapping variable and the mapping function are variable containers, there is also a collection for accommodating mapping variables and mapping functions, which is also a variable container, which is referred to as a "heterogeneous set container" in the present invention. The heterogeneous container is an instance of the TDataSet class, and the TDataSet class inherits from the TContainer class, so the heterogeneous container also has variable container properties. Heterogeneous container is used to describe an abstract collection of mapped heterogeneous systems, including heterogeneous C/C++ systems and heterogeneous scripting systems. The TDataSet inherits all the attributes of the TContainer and attaches several attributes that represent the characteristics of the mapped system, such as what is the system being mapped (for example, C/C++ or Python), and the relevant configuration required to implement the mapping, such as : Whether to generate a mapping entity for a constant, whether the enumeration value is 2 bytes or 4 bytes.

 The variables and functions in a heterogeneous system (heterogeneous C/C++ system or heterogeneous scripting system) are mapped to the host scripting system and become an entity in the scripting system. It is required to use a variable container, a heterogeneous set container, to accommodate all of these mapped entities.

In general, the mapping from the mapped language ( / ++ 3⁄4 heterogeneous scripting language) The body (mapped variable or mapping function), as well as the dynamically created new mapped variable, should be placed under the heterogeneous set container. Otherwise, there is no guarantee that the assignment operation for the mapped variable will maintain the style of the mapped language. The assignment style is consistent with the mapped language only if the map variable is assigned as a member of a heterogeneous set container.

 A heterogeneous set container is used as a root node, and one or more mapping entities are stored under it to form a tree set, which is referred to as a "variable container tree" in the present invention. The variable container tree can have only one layer or multiple layers. When a heterogeneous set container only saves the primitive type of mapped entity, there is only one layer; and when the heterogeneous set container holds the mapping variable of the composite data (such as class, struct or union data in C/C++, or heterogeneous There are multiple layers of class objects in the script system. Each node of each layer is an instance of TContainer class, and thus has a TContainer attribute), and the number of child nodes is consistent with the name of each layer of the child node and the mapped composite data, which enables the sub-members of each layer to accurately describe The mapped variables, when the sub-members are read and written layer by layer, the number of child nodes of the variable, the sub-members of each layer node, the names of the sub-layer members and the data types are consistent before and after the mapping.

 In the variable container tree, because the variable container holding the mapped entity must be a heterogeneous set container, the heterogeneous set container can only be in the root node of the variable container tree. Creating an empty heterogeneous container can be packaged into a scripted API (application programming interface) call. For example, define the newVarContainer function in the host script system to create an empty heterogeneous container for a C/C++ system or a Python system. .,

 The following is an example of a C/C++ system, such as defining the following variables and functions in the system under test: int i Value = 3;

 Struct MyStmct {

 Int memberl ;

 Char member2 [12];

 } struValue = {5,"example"} ; int sum(int i, int j)

 {

 Return i + j;

 }

 Then define the following statement in the host scripting system (for example, the CSE language system):

 Vc = newVarContainer("C/C++"); II Create a C/C++ Heterogeneous Container

 ScanCMapData(vc); // Scan the current C/C++ system, generate mapping variables and mapping functions to vc

Print(vc.iValue); // value should be 3 Print(vc.sum(vc.iValue,12)); II The result value should be 15

 Print(vc.stru Value. member2); II value should be "example"

 Vc.varl = MapCInt(7); II Create a mapping variable of type int, assign initial value 7 print(vc.varl); // value should be 7

 Vc.var2 = MapCString(" Another string"); II Create char[] mapping variable

 Print(vc.var2); II value should be "Another string"

 In the above example, vc is a heterogeneous set container. It is itself a variable container, which contains mapping entities such as iValue, struValue, sum, varl, var2, etc. These mapping entities are all variable containers. Since struValue is a struct structure, there are two sub-members, member 1 and member 2. These two sub-members are both TData objects and variable containers, which are hung under the struValue mapping variable. Here, "hanging" is a kind of retrieval pointing, indicating that a link points to a relationship, and also implies a master-slave derivation relationship. The expression "vc.stmValue.member2," is the second sub-member. It can be seen that the above tree with vc as the root node is nested by the property support layer of the variable container.

1.3 Operational steering for variable container sub-members

 The operation of the sub-attributes of the variable container can support the following three kinds of operation steering:

 1) Automatically implement operation steering when reading and writing sub-members of the variable container

 2) Automatically implement operation steering when reading and writing the array sub-members of the variable container

 3) When the pointer of the variable container is read or written, the operation is automatically turned

 When you read and write a child member of a variable container by value, it automatically redirects to the container's getValue and setValue method calls, for example:

 Vc = newVarContainer("C/C++"); II Create a C/C++ heterogeneous container vc.varl = MapCInt(7); II ^Object in C: int varl = 7

 Vc.varl = 8; II turns to implicit call vc.setValue(,varr,8)

 Print(vc.varl + 1); II print value should be 9

 II Implicit steering is:

 Print(vc. get Value(" varl ' )+ 1 )

 The first parameter passed to getValue and setValue above is nil, which means that the mapping variable itself is read or assigned; if it is not nil, it means that the specified member of the mapping variable is read or assigned. For example, in the above example, adding the statement vc.varl .getValue(nil) , the value is 8, which is equivalent to vc.getValue(,varr).

 When reading and writing the array child members of the variable container, it automatically redirects to the getltem and setltem method calls of the array member, for example:

Vc - newVarContainer("C/C++"); II Create a C/C++ heterogeneous container; vc.var3 = MapCArray(vt.int,4); II is equivalent to int var3 in C language [4] Vc.var3 [0] = 1 ; II turns to implicitly call vc.var3.setltem(0,l)

 Print(vc.var3 [0]); II Turn to implicit call vc.var3.getltem(0)

 When the pointer to the variable container is pointed to a value (here, the read and write pointer and the read and write pointer point to the value are two concepts, such as defining the variable "char * buff" in C language, assigning a pointer such as: buff = AnotherVar, and Assigning a pointer to a value is: ' *buff = 'Α' ) , which automatically redirects to the member's getPoint and setPoint method calls, for example:

 Vc = newVarContainer("C/C++"); II Create a C/C++ heterogeneous set container vc.var4 = MapCStruct(vt.MyStruct); II Equivalent to: struct MyStmct var4 vc.var5 = MapCPoint(vt.struct. MyStmct, vc.var4); II is equivalent to C:

 Struct MyStmct *var5 = &var4;

 Vc.var5->memberl = 17; 〃 turn to call vc.var5.setPoint(,memberr, 17) print( vc . var5 ->member 1 ); 〃 turn to call vc.var5.getPoint(, member ) due to the above The three operations on the sub-members of the mapping variable can be automatically turned into specific method calls under the mapping entity, which ensures that the mapping operation is expressed as much as possible in the style of the mapped language. Because the same operation (such as reading and writing child members, accessing array members) has different meanings in different languages, and the same operation has a clear meaning when running in the host script system, the native operation method of the host scripting language cannot be directly used for mapping. The data object coming over. However, after the implicit steering, a dedicated implementation can be provided in the steering function.

 The so-called private implementation means: For example, the variable assignment in the host scripting language is different from the variable assignment in the C/C++ language. In the host's system, the C/C++ variable assignment is described in the host scripting language, and the actual implementation assignment is With the help of the steering function. Assignment is specifically implemented in the steering function for C/C++ language specifications. Similarly, if the mapped variable is mapped from a heterogeneous scripting system, the steering function is specifically assigned to the specification of the heterogeneous function.

1.4 Compatible with strong and weak types of assignment style

 C/C++ is a strongly typed style language, but host scripting languages, like regular scripting languages, are a weakly typed style language. The data type of the variable of the former (strongly typed language) is determined when the code is compiled, and the data type of the variable does not change dynamically during dynamic operation. The latter is a dynamic data type, and the data type of the variable changes at any time during the running process. For example, run the following statement in a host scripting language (such as the CSE language):

 Cao 1 = MapCInt(7);

 Varl = 8;

 Varl = 8.5;

After the first script is run, varl is the mapping variable (that is, the TData class instance), and after the second sentence is run, varl becomes the int type variable of the host scripting language, and then val is no longer Is a class instance, and is no longer a mapping variable, and the value of the original mapping variable is still 7. When the last third sentence is run, varl becomes the float type variable of the host scripting language.

 When the above syntax is used to express a mapping operation, there is a semantic conflict. Because in C language, the original meaning of the above second sentence is: Change the value of the int variable from 7 to 8. This semantic conflict is inherent in the mapping of strongly typed languages to weakly typed languages.

 To solve this problem, the present invention places the mapping variable under the variable container. Because the assignment to the variable container sub-member can be redirected to the setValue method call, it can be assigned in the C language style in the setValue call. E.g:

 Vc = newVarContainer("C/C++"); II Create a C/C++ heterogeneous container vc.varl = MapCInt(7); II is equivalent to C: int varl = 7

 Vc.varl = 8; 转向 Steer to implicit call vc.setValue(,varr,8)

 In this way, the mapping variable is placed in the variable container, and the default is assigned in C style, and the variable assignment outside the variable container can still maintain the dynamic data type style of the host scripting language.

 On the other hand, if the mapping variable under the variable container maintains the strong type assignment style, it will also bring inconvenience to the commissioning work. For example, in the first test case, a mapping variable named var is temporarily created. This mapping variable is not used when the use case ends. Now let's design the second test case, also using a mapping variable of type int called var. At this time, the mapping variable named var exists in the variable container (it is the pointer type variable left after the previous use case is executed). If the assignment still maintains the strong type style, it is easy to cause problems, for example: II Test Case 1 Statement

 Vc = newVarContainer("C/C++"); II Create a C/C++ heterogeneous container vc.var = MapCPoint(vt.int); II var is the "int *" mapping variable

 II ... '

 II Test statement in test case 2

 Vc.var = MapCInt(3); II At this point, vc.varl is still "int *,, type, pointer value is 3

II ...

 Expected in the second use case "vc.var = MapCInt(3), after execution, vc.var is an int type variable with a value of 3, but in fact this variable is of type "int *".

 To solve this problem, the host scripting system can provide an API to delete the child members specified under the variable container. For example, the API can be delete VcAttr. In the above example, if you run "deleteVcAttr(vc, ar7,) before the "vc.var = MapCInt(3)" statement, the semantic conflict can be eliminated.

If you want to further improve ease of use, you can also let the host scripting language support a special assignment operation. Delete an existing child member of the same name before the assignment, for example: "vc.var := MapCInt(3)". Thus, the assignment of sub-members to the variable container forms a clear rule. The default "=" assignment is done in the style of the mapped language, and the ":=" assignment is based on the original style of the host language. Row. Here ":=" is a legal operator in the CSE language, meaning "special assignment".

 1.5 Mapping entities are implicitly redirected by usage environment

 The same mapping entity has different meanings in different usage environments. For example, sum is a cdecl-style mapping function, run the following script:

 Print(vc.sum); 〃 Print the function prototype, ie: int a cdecl sum(int,int) vc.sum(3,5); C The C function sum should be called, the return value is 8

 Print(vc.sum + 1); // Think of the mapping function as a numeric value, ie: take its address value plus 1

 The first line above looks at the description value of the mapped entity (usually used for printouts, allowing the debugger to see what the entity is at a glance), the second line is a function call in C style, and the third line is looking at the mapping entity. Use as a numerical value.

 To achieve the above automatic steering function, the host scripting language kernel is first required to recognize the context in which the current variable container is located. For example, if the mapping entity is used in addition, subtraction, multiplication, and division, the system automatically calls the map entity's getValue method to extract the value it represents. The third line of script in the above example reflects this situation.

 In addition to the system being able to capture read and write operations for mapping entity sub-members as described above, the present invention requires the host scripting language to recognize the following four contexts and implement implicit steering:

 1) When a mapped entity is used as an operator in a mathematical or logical operation, or when a mapped entity is passed as a parameter in a mapping function call, the mapped entity is treated as a numeric value. : That is: implicitly redirect the current operation to the getValue method call of this object.

 2) If the mapping entity is used directly as a function call, then the mapping entity will be interpreted as a mapping ^) number, the current operation will implicitly redirect to the _call-method call of the object, and the mapped language will be implemented in the -call method. Related function calls.

 3) If the mapping entity is used to fetch its own description value, for example in a print statement, the current operation will implicitly redirect to the -str-method call of the mapping entity.

 4) If the mapping entity is used to retrieve its own representation value, for example in the repr function, the current operation will implicitly redirect to the -repr-method call of the mapping entity.

In the above 2), the mapping entity is used to transfer to the -call_ method of the entity when the function is called. The call-method implementation should accurately simulate how the function works in the mapped language. The first step is to identify the incoming parameter. If the incoming parameter is a mapped entity, it will automatically take the value it represents to suppress it. In the process of taking its value, it should also check whether the type of the incoming parameter matches against the function prototype. If it does not match, it should report an error. If the called mapping entity is derived from the C++ language, you should also pay attention to the prototype declaration of the polymorphic function. Because of multiple functions with the same name, the number or type of parameters is not the same. Therefore, the present invention analyzes the incoming parameters one by one, and performs matching analysis with reference to a plurality of prototypes of the same name function. If the match is matched, select the function that matches it to call, if the match does not match Report an exception. The push and pop methods of the simulation call should also be consistent with the style declared by the function (eg cdecl, stdcalK thiscall> fastcall, etc.).

 In addition, after the result of the call to the mapping function, if the return type required by the function prototype is not void, the result value must also be mapped to the mapped variable according to the specified return type. For example, mapping functions are mapped from a C/C++ system. After simulating the function call in the call- method, a value is returned, which has an exact meaning in the C/C++ system (for example, an int value). However, this return value cannot be used directly in the host script. According to the same mapping method, the return value is mapped to the host script system and becomes a mapping variable in the host script system before it can be used.

 In the above 3) and 4), the self-description value is different from the expression value. The former takes the description value only for browsing to view the purpose, while the latter takes the representation value to obtain a textual description of the object without loss. This textual description can be generated back to its own data after being calculated by its own scripting language. For example, in the Python language, run the expression "eval(repr(100)), and get the int data with a value of 100, while running the expression "eval(repr("100"))") is still the value String data with a value of "100". Because the representation value can be streamed without loss and can be easily converted back, it is often used to transparently transmit an entity across processes or across machines. The descriptive value "is consistent with the meaning of the Python inline function "str". The "representation value" described in the present invention is consistent with the meaning of the Python inline function "repr", and will not be explained in detail herein.

 The mapping entity takes the representation value automatically to the -repr-method call of the entity. This rule is only supported in heterogeneous scripting language mapping. C/C++ mapping is not supported because there is no corresponding "representation value" in C/C++ language. "the concept of.

 1.6 Mapping entity life cycle automatic management

 Automatic management of variable life cycle is a feature commonly supported by scripting languages. The principle is to record the number of citations for each managed data. When you create an object and use it for the first time, the number of references is set to 1. When the object is passed to another entity and other entities use it at the same time, the number of references is incremented by 1. If an object no longer uses the object, the number of references is decremented by 1. If the reference count for an object drops to 0, the object is no longer used, and the system immediately releases the resources it occupies.

The present invention provides two types of mapping support, one is to map variables or functions from a C/C++ system to a host scripting system, and the other is to map variables or functions from a heterogeneous scripting system to a host scripting system. In the second case, since the heterogeneous scripting system itself supports the automatic management of the variable life cycle, and maps to the instance of the host scripting system, the life cycle of the mapping entity is naturally managed automatically according to the conventional programming method. But for the first case, because C/C++ does not have the ability to provide automatic lifecycle management for all data types, special mapping support for variables and functions in C/C++ is required. After the mapping is implemented, it is guaranteed to use the host script to read and write C/C++ variables and call C/C++ functions. However, after a new mapping variable is created, it uses the variable space (ie: Spaces corresponding to C/C++ language variables are not automatically managed. If the manual release to each release is undoubtedly cumbersome, the design efficiency of the test case will be greatly reduced, and the code quality of the test case will be lost.

 In order to allow the variables mapped from the C/C++ system to automatically manage its life cycle, the present invention stipulates that the memory block occupied by each mapping variable has its owner, that is, the Owner attribute is set in the TData class. When the same memory block is used as a whole, or when it is locally generated to generate other mapping entities, the usage status is recorded by the "reference counting" method. When the mapped entity no longer uses the block memory, the resources it occupies are released by itself.

 2. Implementation of the commissioning system

 3 is a schematic block diagram of a script interpreter driven test system in accordance with the present invention. As shown in the figure, the test host 1 includes a test shell 11 for initiating commissioning commands and a platform for development and testing. The test host can use a personal desktop system (such as Windows, Linux, etc.). The test case 11 can be one of the executable programs.

 The target machine 1 is usually the board being tested, or a simulation program. A Test Agent 21 resides in the target 2. The test agent 21 can be a scripting language system. In the present invention, the type of the script language is not limited as long as the mapping rule defined by the present invention can be satisfied. The symbol table and type table of the program under test are included in the test agent 21 of the target machine 2. The symbol table and type table will be described later.

 The target machine 2 can share the same device as the test host 1, such as a computer. In this case, the program under test is an exe program, and the test host is also an exe program. Both can run on the operating system of one machine (such as a multi-process platform such as Windows).

 The test housing 11 of the test host 1 has a communication connection with the test agent 21. The communication method for this connection can be shared memory communication (for the case where the target computer shares the same computer with the test host, TCP/IP communication, or other forms such as serial communication).

 As shown in FIG. 4, the test agent 21 includes a script system 211 and a communication unit 212. The communication unit 212 is responsible for processing the above communication connection between the test agent 21 and the test casing 11 of the test host 1.

 The scripting system 211 includes an inline debugging support module 2111 and a mapping support module 2112. The embedded debug support module 2111 is a collection of conventional commissioning application programming interfaces (APIs) that provide functions such as resetting the target, starting or stopping a task, setting breakpoints, and deleting breakpoints. The mapping support module 2112 is used to implement the function of mapping C/C++ language variables and functions in the system under test to the script system. After the mapping is completed, the script system 21 1 generates mapping variables and mapping functions having the same names as the variables and functions of the C/C++ language.

When the target machine 2 performs the test and feeds back the results, or issues print information during the test, the test shell 11 of the test host 1 will receive the result or information and process it. 3. C/C++ mapping

 3.1 Mapping support module initialization

 Referring to Fig. 5, first, the target machine 2 is subjected to initialization processing. When the test host 1 starts the program of the command interpretation module, the target machine 2 starts the program under test (S501). Then, the target machine 2 initializes the script system 211 contained therein, including setting the relevant configuration of the test agent 21 (S502). In this process, the table generation unit (not shown) of the test agent 21 extracts information related to the mapped variables/functions from the GDB or PDB debug database generated by the software of the target machine 2 after the last compilation thereof. , a symbol table and a type table (to be described later) are generated and recorded in the test agent 21 (S503). Then, the scripting system 21 of the test agent 21 maps the symbol table and the type table to a global variable container (i.e., a heterogeneous set container) (S504). The symbols of the type table and the symbol table are mapped to the variable container according to the predetermined script (S505). This operation describes the variables and functions in the program under test as mapping entities (that is, script TData class objects) in the script system. Since converting all symbols results in wasted CPU and memory resources, in accordance with one embodiment of the present invention, the symbols are not converted all at once, but only for testing purposes. For example, when running a test script, the script contains which mapped variables and functions, dynamically convert those variables or functions, or the user can determine the rules to convert on demand, for example, all externally defined symbols are not mapped.

 Thereafter, a normal test of the system under test is performed (S506). In test host 1, the user operates on the transmitted code using a script file similar to the C/C++ language. The command in the test shell 11 causes the interpretation module to interpret the user's input and issue the corresponding test command. It is transmitted to the test target machine 2 and runs in its script system 21 1 to obtain the test run result obtained by encoding the code. The test run result can be fed back to the test host 1 and displayed to the user. In the method, since the test script can be written online, the measured variable can be visually viewed or modified, and the measured function can be called, the test result can be immediately seen, and the test can be improved immediately, thereby improving the efficiency of the test.

 Because C/C++ language coding is very strict on the structure/type of its data, its mapped script must be able to support the basic C/C++ programming features and requirements.

 3.2 Basic requirements for host scripting languages

 In order to achieve the object of the present invention, the host scripting language used in the present invention needs to satisfy the following description in the expression:

 1) The pointer is consistent with the C/C++ language style, including the "->" operator usage, such as "pStmct->Memberl" to describe a structure pointer to a member; also includes rules for pointer movement, such as "pint +2" moves the int pointer backward by 2, and the actual pointer will offset 2 * sizeof(int) bytes.

2) The way to access array members is consistent with the style of the C/C++ language. Use square brackets The subscript takes the sub-member, for example, with "ArrayVar[2],, the third sub-member of the array variable Array Var.

 3) The way to access struct and union members is consistent with the C/C++ language style. Use the dot to separate the stmct/union variable from its members. For example, a Struct type defines two child members, Member 1 and Member2. Accessing the type variable, the first child member of StmVar, is described as " StruVar.Member 1 ".

 4) Support the following binary operations that are consistent with the C/C++ language, and the operator expressions are consistent with the priority.

 The above descriptions of the values should also apply to assignment descriptions such as "pStmct->Memberl = 3", "ArrayVar[2] = 3", "StruVar.Member 1 = 3".

 At the same time, in order to achieve high efficiency testing and support the necessary scalability, reside in the test agent. The host scripting language should preferably meet the following requirements:

 1) All variables and functions in the script can realize automatic management of life cycle. Most script languages have this feature. Usually, the life cycle is automatically managed by using the reference counting technology.

 2) Support common data types, such as 4-byte integers, single-precision or double-precision floating-point numbers, word 'strings, array sequences, dictionaries, and so on.

 3) Support basic branch and loop control such as if, else, and while.

 4) Support for function definition extensions and module definition extensions.

 5) Support for class definitions and class inheritance. This is due to the fact that the mapping rules used by the present invention depend on a particular class definition format. Therefore the functionality of the class definition is required.

 6) Variables, functions, and class definitions can be added and removed online without restarting the scripting system. Many scripting languages in the technology now support this.

 Scripting systems that meet the above requirements are available from the prior art, such as Python, Ruby, etc., which support the addition or deletion of variable definitions or function definitions online.

 3.3 Resident Symbol Table and Type Table

In order to achieve mapping of C/C++ language encoding, according to the present invention, the symbol table and data type table of the program under test are resident in the test agent 21 of the target machine 2. These two tables will directly support the implementation of the mapping rules specified by the present invention. The mapping method of the present invention relies on the collection and analysis of various symbols of the target system and their type information. Debugging the database by the compiler during compilation Generated, for example, during Visual C/C++ compilation, the compiler extracts relevant information from the source code to generate a PDB file as intermediate format data. GCC also compiles the GDB debug information of the intermediate format data into the target program at compile time. The mapping support module residing on the target machine will further analyze the intermediate format data (PDB/GDB) to generate a symbol table and a type table.

 The debug database format generated by different C/C++ compilers is not the same. The invention achieves the unification of different formats by generating the type table and the symbol table. The type table records the various types defined by the system under test. These types must include: primary type information, subtype information, and occupancy. Bytes. Table 1 is an example of a type definition format:

 Table 1 :

 Also make sure that the columns under the type table are unique, that is, there can only be one type of the same main type and subtype and the same number of bytes.

 The symbol table records the address value of a variable or function and its type ID. The symbol address has two forms, which can be either an absolute address or a relative address. For example, when accessing a local variable or passing in a parameter, the offset value relative to the current top position is used. For another example, a variable exists in another variable space, and its address is also expressed by the address of the other variable plus an offset.

There are two ways to source symbols, one is from another mapping entity, and the other is from an absolute address. The latter is a general way of describing variables or functions. The former is often used when the same memory space is treated as multiple types of variables, such as forced type conversion, 'is an array of strings An offset is treated as an integer type variable.

 3.4 Mapping of variables and functions

 The above type table and symbol table are organized according to a specific format and reside in the system under test. Each symbol in the symbol table can be mapped to the host script system and become a mapping entity, that is, an instance of the TData class in the script system. In order to save resource overhead, one aspect of the present invention is to map on demand rather than all at once, so that variables and functions are mapped to script objects only when they are used.

 After the symbol table and the type table are generated, in order to facilitate the operation of the script, it is necessary to define a conversion script class object corresponding to the data in the table, that is, the TType class object corresponds to the type table, and the TData class object corresponds to the symbol table. The instantiated data defined in the TType class object contains the following information: The type unique identifier, type main category information, type subcategory information, type size. Each symbol is mapped to the instantiated data defined by the TData class and contains the following information: The type ID of the symbol, the source of the symbol, the offset from the source, whether the memory is automatically freed.

 The mapping process of the table contents is performed as shown in Fig. 6. First, the script system 211 finds the required symbol (variable or function) information from the symbol table, such as the symbol name, the type ID of the symbol, and the symbol address (S601). The script system 211 then finds whether the corresponding type has the generated TType class object by using the type ID. If not, the TType class object is created first, that is, by defining a TData or TType class object, calling the class definition constructor to create the class object. An instance (S602). Finally, a TData class object of the mapped symbol is created according to the source of the symbol, the associated TType object, the address offset, and whether the memory is automatically released (S603).

 When the created mapping entity includes mapping variables and mapping functions, the corresponding TType object must first indicate the type information. When the items in the type table are converted into TType class instances, the original type information table is no longer useful, and the occupied resources can be released, and the newly generated TType class instances form a new table, that is, the TType type table. Both map variables and map functions are instances of the TData class. As shown in Figure 7, each TData class instance uses the type ID ( Data type ) of the symbol to indicate which type in the TType type table it uses.

 Note that objects of the TType class may be nested references. Some composite types such as stmct/union/pointers contain subtypes, and the same subtype may be referenced by multiple composite types. Therefore, when creating each TType object, other types involved in that type are also created at the same time.

 3.4 Automatic management of the life cycle of mapping data

Since the system resources of the test host and the target machine are limited, in order to test more effectively, it is very important to handle the use of resources in the corresponding period. According to the present invention, in order to effectively utilize system resources, variables, functions, class objects, and the like exist as an entity in a scripting language, and automatic life cycle management is realized. The resources occupied by these entities are automatically applied and automatically released. Mapping data as a script class object also supports the automatic application and release of the resources it involves. For example, the script system 21 creates a mapping variable buff, which is an array of strings of length 24 bytes. At this time, the script system 21 automatically requests the memory occupied by the target machine 2, including the buff variable as an example of the script TData class. The amount of memory to occupy, and the 24-byte space of the string array. For convenience of description, in the present invention, the former type of space is referred to as a script instance space, and the latter type of space is referred to as a C/C++ instance space (referred to as a C instance space in this description). When the life cycle of the newly created mapping variable ends, both spaces will be released.

 However, due to the complexity of programming, the script instance space and the C instance space are not always applied or released at the same time. For example, for the global variables of the system under test, the occupied space is statically allocated. The mapping entity of the global variable should only release the script instance space at the end of the life cycle, and should not release the C instance space. For another example, after creating a mapping variable a in the script file, the script instance space of this variable and the C instance space should be applied or released at the same time. However, if this mapping variable a is treated as another type of mapping variable b, such as a mandatory type conversion in C language, a variable in the same address space is treated as another type of variable, then the variable b should be created. Newly apply for script instance space, but you should not apply for C instance space repeatedly. In addition, when the variable a or the variable b is deleted, regardless of which one is deleted first, it should be guaranteed that the C instance space operated by another variable that is still in use is still valid. That is: the C instance space can be shared by multiple mapping variables, and only the mapping variables involved in the C instance space are released, and the C instance space is automatically released. In addition, the C instance space used by the mapping variable needs to be tested together, and the flag can be modified if necessary. For example, the Autofree attribute is set for the mapping variable. The attribute is TRUE, indicating that the C instance space of the mapping variable is released with the release of its script instance space. Otherwise, the value of the attribute is FALSE, indicating that the C instance space is not released with the release of the script instance space. .

 To achieve the above object, according to one embodiment of the present invention, three attributes are set for the mapping entity. Figure 8 shows an example of a mapped entity. As shown in Figure 8, this attribute includes: Yes No Auto Free Memory (Autofree), Symbol Source (Owner), Offset Address (Offset) relative to the source. The attribute "whether the memory is automatically freed" is used to indicate whether the C instance space of the mapped variable is released along with the script instance space. The "symbol source" is used to indicate the attribution object of the mapping entity, and its value can be either an absolute address value or another mapping entity. The offset address relative to the source is used to indicate the offset of the starting address of the C. instance space used by the mapping entity relative to the spatial address indicated by its symbol source. Since the scripting language has the automatic lifecycle management feature, if the symbol source attribute indicates another mapping instance, the automatic management of resources can be realized when the same C instance space is shared by multiple mapping instances.

 3.5 Implementation of the steering

 In summary, the operational steering required by the present invention includes the following items:

1) When assigning a value to a child member of a variable container by value, it automatically switches to the setValue method call of the child member; ^ 2) When the variable container is used as an operator (ie: in a mathematical operation or a logical operation, or in an incoming parameter of a mapping function call), implicitly redirects to the getValue method call of the object to take its value. Form value

 3) When reading and writing the array sub-members of the variable container, they are automatically redirected to the getltem and setltem method calls of the array member;

 4) When the pointer of the read/write variable container points to a value, it automatically switches to the member's getPoint and setPoint method calls respectively;

 5) When the variable container is directly used for function call, it implicitly redirects to the call-method call of this object;

 6) When the variable container takes its own description value (as used in print and other statements), it implicitly redirects to the --str method call of this object;

 7) When the variable container is used to obtain its own expression value (as used in repr and other statements), it implicitly redirects to the -repr method call of this object.

 The automatic steering of the above seven operations depends on two conditions:

 First, there should be a form to define the target steering function.

 As mentioned earlier, these targets are defined in the variable container as functions of TContainer (such as getValue, setValue, getltem, setltem ^ getPoint;, setPoint - call -, "str", "repr").

 There are already some scripting languages that support similar implementations, such as the Python language. The members of the read-write class object can be directed to the _getattr_ and -setattr_ii functions, respectively. You only need to add -getattr - a setattr to the two class methods in Python's related class definitions. Read and write class members can capture and automatically jump. Similarly, Python also supports class objects as arrays. When reading and writing its children, it can automatically jump to the _getitem of the class pair and a setitem-method. If a call-method is defined for a class object in Python, then when the object is called as a function, it will automatically jump to the __call-method. The same is true for the description value and the representation value, as long as the -str_ and -repr methods are defined separately. Therefore, the Python language has been able to implement seven of the nine steerings required by the present invention. .

 Second, the host interpreter should be able to capture the automatic steering when interpreting the operation, and then trigger an automatic jump. This is a requirement for the ability to interpret the execution of the host interpreter kernel.

The automatic steering of the above operations is achievable, and the existing Python language has provided 7 of the 9 kinds of steering we have requested. Only the pointer to the value of the read-write variable container (jump to getPoint and setPoint) is not provided. The "->" operator for reading and writing pointers is illegal in the Python language. Therefore, the host scripting language required by the present invention can be developed in the same way as Python. Because Python is an open source product, based on the existing knowledge in the field, it is not difficult to implement the implicit mapping operation required by this patent. To the function.

4. Mapping of heterogeneous scripting languages

 With the features of the variable container described above, it is also possible to map a heterogeneous scripting language to a host scripting language. The following example will introduce the implementation of this mapping using Python and CSE as an example. Python (see www.python.org) is used as a heterogeneous scripting language, and CSE (see www.cse-soft.org) is used as a host script. Language. Those skilled in the art will appreciate that the description is merely an example and that the implementation of the invention is not limited to the two languages.

 4.1 mapping content

 Heterogeneous script mapping is usually in the form of script modules. The objects involved in mapping are also limited to the entities that can be provided by the mapped language at the module's crest level, including: variables (including class objects) and functions.

 The content of heterogeneous script mapping includes three aspects:

 i) Implement mapping of basic type data specified by the heterogeneous scripting system, and support related operations for the mapping entity, including: create, release, read, assign, and function call.

 2) Implement class instance mapping in a heterogeneous scripting system, and support related operations for the class instance, including: creating, releasing, reading and writing members, and calling class methods.

 3) Map a module in a heterogeneous scripting system to a variable container in the host scripting system. ,

 The above three aspects involve the three mapping entities included in the heterogeneous script mapping, namely: basic type data mapping, class instance mapping, and script module mapping.

 These three types of mapping entities are all TData class objects of the host script. Similarly, the TType class object records the TType instance data, thereby indicating the data type of the mapping entity in the mapped system. The TData and TType structure definitions for heterogeneous script mapping should be consistent with the TData and TType used in the C/C++ mapping described earlier. If some attribute definitions are not used, for example, the attribute used to indicate whether the C instance space of the mapped instance is released with the script instance space is no longer used, then leave it alone.

 4.2 Basic Type Data Mapping 'Common scripting languages such as Python, Ruby, and TCL have basic types such as integer (int), float (float), string (string), and function. These basic type data, as data in a specific format that exists in heterogeneous scripting systems, cannot be directly used as variables in the host scripting language. Otherwise, an error occurs in data access. The same type of data is in two heterogeneous systems, and its internal format is not the same. The purpose of basic type data mapping is to ensure that the same type of data is automatically converted when passed across languages.

The basic type data being mapped is accessed across languages (such as values or assignments, or in function arguments) Implicit conversions are made when the number or return value is passed. Therefore, types involving large data transfers are not suitable for use as primitive types for mapping, as described below, but should be mapped as a class object form.

― Here again, the TType class instance is used to record information about each basic type in the heterogeneous script system, including type definition, type length, and so on. This information can be obtained through the API functions of the heterogeneous scripting system. For example, calling Python's inline function "type(obj)" can get the type of the specified variable, call the inline function "len(obj)" to get the length of the specified variable, and so on.

 Also, in this embodiment, the TData class is used to express the mapping entity. Of course, the TData class inherits from TContainer and is also a variable container. In the TData class instance, the type of the mapping entity (the value of TType), the address of the entity object, and the like are also recorded.

 After a new mapping entity is created, the referenced object in the heterogeneous scripting system is incremented by one reference, which is implemented by calling the API provided by the heterogeneous scripting system. For example, the API for adding a reference in Python is Py-INCREF, and the API for reducing one reference is Py-DEC EF. If the mapped entity is released, the reference of the corresponding mapped object is decremented by 1.

 As described above, the operation of the mapping entity implements the specific function in the steering objective function by reading and writing the sub-member, reading and writing the array member, calling the entity, taking the self-description value, and the implicit steering function when taking the self-representation value. , specific operations for the mapped entity. The specific operation is achieved by calling the API of the heterogeneous script system. For example, if the heterogeneous scripting system is Python, the mapping function is called and implicitly redirected to the call-method call. The present invention calls the API provided by Python in the call-method to call the related function in the mapped system. The API that calls a function in Python is PyObject— CallFunction , and the API that calls the class method is PyObject_CallMethod.

 4.3 i instance and script module mapping.

 In many scripting languages, the basic types are often not clearly distinguished from the class class, such as the dictionary type (diet) in Python. Although it is a basic type, it can be used in the form of a class example in the present invention. For example the following Python code:

Class TDict:

 Def― init one (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"); # is equivalent to: ADict[3] = "abc";

Print ADict. get Value(3); # equate to: print ADict[3];

 Because some data types may store large amounts of data, and basic data is converted as it traverses two heterogeneous scripting systems, it is inconvenient to cross-language data types involving large amounts of data as basic types to avoid inefficient use. For this type of data, the present invention treats it as a class object. For the Python dictionary type exemplified above, first wrap it as a class and then implement the mapping as a class object. In this case, although the diet data as a whole does not span two heterogeneous scripting systems, the components of diet can normally span two heterogeneous scripting systems. E.g:

 Vc = newVarContainer("PYTHON");

 Vc. ADict = MapPyDict();

 vc.ADict[3] = "abc"; II implicitly redirected to the call: vc.ADict.setItem(3,"abc,,); print(vc.ADict[3]); II implicitly redirected to call: print (vc.ADict.getItem(3)); In the turn function setltem and getltem, call the API provided by Python to read and write the Python dictionary data.

 For the class method call of each class object mapping entity, you can also dynamically generate a variable container of a class method, and then call the variable container (that is, the class method mapping entity), then automatically turn to the call method of the class mapping entity - call one method. In the _0&11-method, a special Python class method call can be implemented by calling the Python API. E.g:

 Vc = newVarContainer("PYTHON");

 vc.AObj = MapPyInstace('ACkss,,argl,arg2); II Create class instance mapping entity vc.AObj. method 1(1 , 2); // Step 1: Execute vc.AObj .method 1

 〃Step 2: Dynamically generate an AObj.methodl mapping function

〃 Step 3: Execute AObj .methodl (1 , 2)

 II turns to AObj .method 1.—call—( 1 ,2)

 For the class object mapping entity, each time its method is called, a corresponding mapping function is dynamically generated, and when the mapping function is called, it automatically switches to the call method call of the mapping function. In the call-method, the special call process of the corresponding class method of Python is implemented. That is, if the heterogeneous language is Python, the corresponding call is implemented in Python format. If the heterogeneous language is Ruby, the corresponding call is implemented in Ruby format. Of course, the result values of the calls are also automatically assembled into mapped variables.

For different heterogeneous scripting languages, the way to search for its members from a class definition is different. However, whether the heterogeneous scripting language is Python, or Ruby or TCL, with this scripting system Providing the API and the type format defined by the scripting language, it is always possible to traverse which methods are defined under the specified class class and which class members are defined. Similarly, it is always possible to traverse which object entities are defined under the specified module. For example, the Python language provides a "dir(namespace)" inline function that scans which objects are defined under the specified namespace, which objects are defined under the module, and which properties are defined under the class. These can be known by calling the dir function. Therefore, for a class object mapping entity, each time the method is called, the corresponding function definition can be dynamically obtained, and a mapping function can be dynamically generated.

 You can also scan the modules in the heterogeneous script system. After you know which objects are defined under the module, you can generate different mapping entities according to their TType and save them under the specified variable container.

 Because some large scripting languages such as Python and Ruby can provide rich software functions, the present invention uses heterogeneous scripting language mapping, which can greatly enhance the system's debugging capabilities. Mapping heterogeneous scripts to the host scripting language, on the one hand, enables cross-language function calls, 'on the other hand, it also reduces the learning threshold, because the mapping syntax masks the differences in the representation of heterogeneous languages.

Claims

Claims:

A program commissioning system, comprising: a test host and a target machine, wherein the test host performs commissioning on a C/C++ target program system of the target machine, wherein

 The target machine includes a mapping support module, the mapping support module includes a variable container; the variable container is a class object of a script TContainer class, and variables and functions in the debugged C/C++ target program system are Mapping to a mapping variable and a mapping function in the variable container, when describing an operation of mapping a variable or a mapping function in a host scripting language, the mapping variable and the mapping function are similar to corresponding variables and functions of the tested program expression;

 Through the variable container, operations on the mapping variables and mapping functions using the host scripting language are diverted to operations of corresponding variables and functions in the C/C++ target program system being debugged.

2. The program commissioning system according to claim 1, wherein the target machine further comprises a heterogeneous scripting language system for providing a scripting system for testing services. '

3. The program commissioning system according to claim 2, wherein said variable container layer nesting constitutes a variable container tree, and each node in said variable container tree has a TContainer attribute.

4. The program commissioning system according to claim 3, wherein a root node of the variable container tree includes a heterogeneous set container, the heterogeneous set container records a type of the mapped system and a related configuration required to implement the mapping ;with

 The mapping variable and the mapping function are both class objects of the script TData class, the TData class inherits from the TContainer class, and the mapping variable and the mapping function are recorded in the heterogeneous set container.

The program commissioning system according to claim 2, wherein the variable container tree further includes a composite data mapping variable, and the hierarchical and sub-member affiliation of the composite data mapping variable is consistent with that before the mapping, the composite The data includes classes, structs, unions in the C/C++ language, and class definitions in the heterogeneous scripting system.

6. The program commissioning system of claim 1, wherein the target machine includes a host script interpreter, wherein an assignment operation to the map variable in the variable container is scripted in the host script interpreter When the language is expressed, the strong class of the C/C++ target program system is maintained by default. Style, where:

 When assigning a value to a child member of the variable container, the type of the child member does not change before and after the assignment, and only the value represented by the mapping entity of the child member in the mapped system is modified;

 Using the API in the host script interpreter can remove the specified sub-members under the variable container.

7. The program commissioning system of claim 6, wherein a non-default weak type style is also allowed.

8. The program commissioning system according to claim 1, wherein the host script interpreter and the variable container have an automatic steering function when performing read/write or function call for the mapping variable or the mapping function. , including:

 Capturing operations on mapping variables or mapping functions by the host script interpreter; and

 The target steering function corresponding to the captured related operation is implicitly triggered. '

9. The program commissioning system of claim 8, wherein all of the target steering functions are defined as class methods in a mapping entity.

10. The program commissioning system according to claim 8, wherein the operation of the host script interpreter to capture a mapping variable or a mapping function comprises:

 Read the value of the mapped entity itself or its child members;

 Assign values to child members of the mapped entity;

 Read the child members of the array mapping entity;

 Assign a value to a child member of an array map entity;

 Read the pointer of the mapped entity to the value;

 Pointer to the mapping entity points to the assignment;

 Calling the mapping entity;

 Take the description value of the mapping entity;

 Take the representation value of the mapped entity.

The program commissioning system according to claim 1, wherein the host script interpreter automatically manages a resource space of a mapping entity, where the resource space includes a C instance space and a script instance space, and the automatic management includes:

 The script instance space is applied and released simultaneously with the C instance space;

Automatic management of resource space for global variables: The C instance space is not empty with the script instance Apply and release together;

 Automatic resource space management when another mapping variable is generated by one mapping variable: The C instance space is applied with the script instance space request of the first mapping variable, and the last script that shares the mapping variable of the C instance space Released by the release of the instance space;

 Supports manual modification of the flag of the mapped variable to control whether the C instance space is released with the release of the script's instance space of the variable.

12. The program commissioning system according to claim 4, wherein the TData object includes the following attributes:

 An attribute indicating a data type of the mapping instance;

 An attribute indicating whether the C instance space of the mapping instance is released along with the script instance space;

 An attribute of a home object used to indicate a C instance space of the mapping instance; and an attribute indicating an offset of a C instance space used by the mapping instance relative to its home object.

13. A mapping method applied to a program commissioning system, the program commissioning system comprising a test host and a target machine, wherein the test host performs commissioning on a program in the target machine, in the target machine Include a mapping support module, the method comprising: '

 1) the mapping support module generates a symbol table and a type table of the tested program according to the debug database compiled by the debugger;

 2) the mapping support module maps the variables and functions in the type table and the symbol table to a variable container, and generates a mapping variable and a mapping function operable by the host script system.

 Among them, the variable container is a class object of the script TContainer class.

14. The method of claim 13, further comprising selectively hosting a heterogeneous scripting system different from a host scripting language in the target machine, wherein variables, functions in the heterogeneous scripting system can be mapped to a host script The variable container of the system.

15. The method of claim 14, wherein the operation of assigning a value of a mapping variable of the C/C++ target program system in the variable container is expressed in a scripting language in a host script interpreter of the host script system The default type of the mapped system is maintained as follows: When assigning values to sub-members of the variable container, the type of the child member does not change before and after the assignment, and only the system represented by the sub-member mapping entity is modified. Value in

The host script interpreter uses an API to delete the specified sub-members under the variable container.

16. The method according to claim 15, wherein the host script interpreter and the variable container implement automatic steering function as follows when performing read/write or function call on the mapped variable or the mapping function. :

 Capturing operations on mapping variables or mapping functions by the host script de-spreader; and

 The target steering function corresponding to the captured related operation is implicitly triggered.

The method according to claim 16, wherein all the target steering functions are defined as a class method in a mapping entity, the mapping entity including the mapping variable and a mapping function, including:

 It is used to automatically switch to the getValue method when reading the value of the mapping entity itself or its sub-members; it is used to automatically redirect to the setValue method when assigning values to the child members of the mapping entity;

 Used to read the child members of the array mapping entity automatically to the getltem method; used to automatically assign to the setltem method when assigning values to the child members of the array mapping entity; automatically redirects to getPoint when the pointer used to read the mapping object points to the value Method; is used to automatically point to the setPoint method when the pointer to the mapping entity points to the assignment; automatically redirects to the call-call method when calling the mapping entity;

 Automatically switch to a str_ method when used to fetch the value of the mapped entity;

 Used to take the representation value of the mapped entity and automatically switch to the -repr-method.

18. The method of claim 17, wherein the operation of the host script interpreter to capture a mapping variable or mapping function comprises:

 Read the value of the mapped entity itself or its child members;

 Assign values to child members of the mapped entity;

 Read the child members of the array mapping entity;

 Assign a value to a child member of an array map entity;

 Read the pointer of the mapped entity to the value;

 Pointer to the mapping entity points to the assignment;

 Calling the mapping entity;

 Take the description value of the mapped entity; and

 Take the representation value of the mapped entity.