JP2000339175A - Dynamic assigning method for type information in data structure definition using abstract syntax description method - Google Patents

Abstract

PROBLEM TO BE SOLVED: To dynamically assign type information by applying data structure definition described according to an ASN.1 specification at the time of executing a program described in an object-oriented language at the time of executing the operation of a data structure based on the data structure definition by the program. SOLUTION: A function jump table 5 is prepared for each basic classification of an ASN.1 type, and a dictionary item instance 2 is prepared for a type which can be referred to by the other without necessitating the inner modification of a type based on the data structure definition and the integrated type of the ASN.1, and a dictionary instance 1 for holding the dictionary item instances is prepared. At the time of operating the data structure, the pointer of the dictionary item instance 2 is set at a value handle instance 4 so that the type information can be assigned, and processing corresponding to the type can be called by referring to the function jump table 5.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

[0001] 1. Field of the Invention [0002] The present invention relates to a method for dynamically allocating type information in a data structure definition using an abstract syntax notation in which the data structure definition is described in accordance with ISO8824 "ASN.1 Specification".

[0002]

2. Description of the Related Art A description for defining an abstract syntax of data includes "ASN.1 specification (A
bstract Syntax Notation On
e: abstract syntax notation) ". ASN. 1 is an integer value,
The logical structure (abstract syntax) of data can be expressed by combining basic data elements such as character strings and bit strings as ordered sequences and sets.

[0003] Conventionally, the data structure definition is based on the ASN. FIG. 17 shows a procedure for performing a data structure operation based on the data structure definition, which is described in conformity with one specification, using a computer program (application program) described in an object-oriented language such as C ++. I have. Of course, the application program described here is AS
N. 1 depends on a class description representing a structure definition described in conformity with the specifications. Referring to FIG. 17, a procedure for creating the application program will be briefly described. The programmer can add each of the types based on the data structure definition to the ASN. 1 of the ASN. In one description, a class definition corresponding to each type that requires no modification and can be referred to from others is created in advance. Then, an application program for creating those instances and performing a value operation is described (steps S171 to S171).
SS174). Next, an executable computer program is obtained from the application program description by an object-oriented language compiler and a linker, and the executable application program is executed (steps S175 to S177).
Was.

[0004]

According to the prior art as described above, the data structure definition is ASN. A computer system which is described in conformity with the specification and executes an operation of a data structure based on the data structure definition by an application program described in an object-oriented language. It was necessary to provide a data structure definition based on one specification. Therefore, first, each of the types based on the data structure definition and the ASN. 1 of the ASN. In one description, a class definition corresponding to each type that does not require qualification and that can be referred to from others is generated in advance, an application program description for creating instances thereof and performing value operations is performed, and then the application program An executable application program was obtained from the description by a compiler and a linker, and the executable application program was executed. For this reason, it was not possible to handle a target for which a complete description of the data structure defined in accordance with ISO8824 “ASN.1 specification” cannot be obtained in advance.

[0005] The present invention has been made based on the above circumstances, and the data structure definition is ASN. When the operation of the data structure based on the data structure definition is performed by an application program described in an object-oriented language, the ASN. Application programs can be created without obtaining a complete description of the data structure conforming to the ASN.1 specification. Reads the data structure definition conforming to the specification 1 during execution of the application program created in advance and
N. 1 is created, and ASN.1 is created during execution of the application program. The object of the present invention is to provide a method of dynamically allocating type information in a data structure definition using an abstract syntax notation, which searches for a type dictionary instance of the first type, thereby specifying a data structure and performing a value operation. And

[0006]

According to a first aspect of the present invention, there is provided a method for dynamically allocating type information in a data structure definition using an abstract syntax notation according to the present invention. 1. A computer system which is described in conformity with the specification and executes a data structure operation based on the data structure definition by a program described in an object-oriented language. 1. A function jump table is prepared for each basic type of a type based on the data structure definition, and when the program is executed after compiling, the data structure definition is read, and each type based on the data structure definition and the ASN. For each type of the built-in type that can be referred to without requiring internal qualification, a dictionary entry instance including a pointer to the function jump table and at least type basic information is created. When creating a type dictionary instance holding a pointer and manipulating the data structure,
By obtaining a pointer to the dictionary item instance corresponding to the value type to be operated from the type dictionary instance and setting it in a value handle instance, specifying type information, and referring to the function jump table as necessary The method is characterized in that a function prepared in accordance with the type information is operated on a call value.

According to a second aspect of the present invention, there is provided a method for dynamically allocating type information in a data structure definition using an abstract syntax notation according to the first aspect. When the type declared by is a structured type, each component of the structured type is associated with a value handle instance as type auxiliary information, and the structure element auxiliary information that holds the sequence of the value handle instances is set. And A dynamic allocation method of type information in a data structure definition using an abstract syntax notation according to claim 3 is a method according to claim 2, wherein the function prepared in the function jump table is, if necessary, A value internal representation holding unit corresponding to the type is prepared, and the array of value handle instances in the structure element auxiliary information is copied to the value internal expression holding unit, and the value handle instance is a pointer to the value internal expression holding unit. , And a value corresponding to the operation is set in the value internal expression holding unit. A method for dynamically allocating type information in a data structure definition using the abstract syntax notation according to claim 4 is a method according to claim 1, wherein
In the value operation by the value handle instance, depending on the nature of the operation, whether to only access the value handle instance, follow the pointer to the dictionary item instance of the value handle instance, and only refer to the dictionary item instance, or A pointer to a function jump table of an item instance is traced, and a function corresponding to the operation prepared in the function jump table is called.

According to a fifth aspect of the present invention, there is provided a method for dynamically allocating type information in a data structure definition using an abstract syntax notation. (1) a computer system which is described in conformity with a specification and executes an operation of a data structure based on a data structure definition by a program described in an object-oriented language, compiling the program and creating an execution program; When manipulating a data structure in the execution of a program, the ASN. 1 is read, and each of the types declared in the data structure definition is read from the ASN. 1 of the ASN. Creating a dictionary item instance corresponding to each of the types that can be referenced from others without requiring modification in one description, and creating a type dictionary instance holding a pointer to the dictionary item instance; Creating a dictionary instance that holds everything; generating a value handle instance; generating the value handle instance; obtaining a pointer from the type information dictionary instance to a dictionary item instance corresponding to the type of the value to be operated; Setting the value handle instance; and performing a value operation by the value handle instance, depending on the nature of the operation, either accessing only the value handle instance or tracing a pointer to a dictionary item instance of the value handle instance, Each step of referencing an item instance or tracing a pointer to a function jump table of a dictionary item instance and calling a function corresponding to the operation prepared in the function jump table; and Checking whether the function has a value internal expression holding unit. If not, preparing a value internal expression holding unit, and the value handle instance holds a pointer to the value internal expression holding unit. And accessing the value internal expression holding unit. 7. The method of dynamically allocating type information in a data structure definition using an abstract syntax notation according to claim 6, further comprising checking whether or not to perform a value operation on an existing value handle instance, and performing the value operation. Or creating a new value handle instance.

A method for dynamically allocating type information in a data structure definition using an abstract syntax notation according to the present invention is described in ASN. The present invention provides a data structure definition at the time of program execution without dynamically providing a data structure definition based on one specification, thereby enabling dynamic assignment of types. Therefore, ASN. 1 has a function jump table corresponding to each of the basic types, reads a data structure definition at the time of executing a program, and stores each of the types based on the data structure definition and the ASN. 1 of the ASN. 1
In the description, a dictionary item instance corresponding to each type that does not require modification and can be referred to from others is created, and type auxiliary information corresponding to the type of the dictionary item instance in each is created.

In particular, in the case of a structural type, as type auxiliary information,
Each component of the structural type is associated with a value handle instance, information indicating a structural element holding the sequence of the value handle instances is set, and each dictionary item instance points to a corresponding type auxiliary information by a pointer. Set as follows. Then, create a type dictionary instance that holds pointers to those dictionary item instances,
A data type or ASN. ASN.1 of the built-in type When manipulating a value of a type that does not require qualification in one description and can be referenced by others, a value handle instance is created as preparation. Next, a pointer to a dictionary item instance corresponding to the value type operated by the value handle instance is obtained from the type dictionary instance, and is set in the value handle instance. Depending on the nature of the operation, when actually operating on the value of the data type, access to only the value handle instance may be performed, or the pointer to the dictionary item instance of the value handle instance may be traced to refer to the dictionary item instance. In some cases, the pointer to the function jump table of the dictionary item instance may be followed, and the function corresponding to the operation prepared in the function jump table may be called. If necessary, prepare a value internal representation holding unit corresponding to the type, especially for structured types, copy the value handle instance list in the type auxiliary information to the value internal expression holding unit, and It is set to hold the pointer to the value internal representation storage unit, and the value corresponding to the operation is stored in the value internal representation storage. Set to the holding part.

[0011] Thereby, a type can be dynamically assigned by giving a data structure definition at the time of program execution,
ASN. By describing general-purpose processing that does not specify type 1, an application program can be created, and the burden on the programmer is reduced. Further, since the type information is dictionary-stored using the type as a key, the type to be assigned can be handled as data.

[0012]

FIG. 1 is a block diagram showing an embodiment of the present invention. The method for dynamically allocating type information in a data structure definition using the abstract syntax notation according to the present invention is, as shown in the figure, a type dictionary instance 1, a dictionary item instance 2, a type auxiliary information 3, a value handle instance 4, a function jump. Table 5, value internal expression holding unit 6, and "AS
N. Data Structure Definition 7 described in conformance with “1 Specification”
Is realized by: Here, C +
+++ language is used. Since C ++ is an object-oriented language based on a class instance model, it is assumed that it has a type dictionary class 11, a dictionary item class 12, and a value handle class 13 as class definitions.

The ASN. The data structure definition 7 described according to the specification 1 is read during execution of the computer program, and a type dictionary instance 1 and a dictionary item instance 2 are created. The dictionary entry instance 2 is composed of each of the types based on the data structure definition 7 and the ASN. 1 built-in type ASN. In one description, it is created corresponding to each of the types that can be referenced from others without requiring modification. The dictionary item instance 2 is generated for each data type that can be assigned at the time of reading the data structure definition, and has as its contents a pointer to the function jump table 5, a pointer to the type auxiliary information 3, and type basic information 21. The type dictionary instance 1 holds a pointer to the dictionary item instance 2 and provides a function of searching the dictionary item instance 2 by name or the like. Type dictionary instance 1
Is generated when the data structure definition is read, like the dictionary item instance. Value handle instance 4 is AS
N. 1 is an instance of the value handle class 13 for handling a value on a computer program. This instance is created as needed on the computer program. The value handle instance 4 is simply created and has no data type. Prior to value manipulation, a search for a dictionary instance (a set of dictionary item instances 2) must be performed, and a pointer to dictionary item instance 2 must be set. The pointer setting to this dictionary item instance 2 is ASN. This corresponds to a type 1 assignment.
In the value handle instance 4, a value manipulation function for manipulating a value is comprehensively prepared regardless of a specific type. Some of the value manipulation functions prepared in the value handle instance 4 call the respective functions prepared in the function jump table 5 finally.

The function jump table 5 stores the ASN. It is prepared for each type 1 basic type. ASN. The choice of type 1 basic type is left to the implementation. An example of the choice made by this implementation is:
This is shown as (List 1) in FIG. The order of the function types in each function jump table 5 is common. Each function is set in advance in the ASN. 1
It is prepared according to the type basic type. The prepared function type is left to the implementation. An example of the prepared function type is shown in FIG. 15 as (List 2). Value internal expression holding unit 6
Is ASN. The form differs depending on the type 1 basic type. The handling is performed by the function linked to the function jump table 5.

FIG. 2 and FIG. 3 are flowcharts showing procedures for realizing a method for dynamically allocating type information in a data structure definition using the abstract syntax notation according to the present invention. Hereinafter, the operation procedure of the embodiment of the present invention shown in FIG. 1 will be described with reference to the flowcharts shown in FIGS. First, ASN. An object-oriented language that operates on a data structure described in conformance with the 1 specification, for example, C
++ is programmed (step S21).
Then, the program is compiled to create an execution program (steps S22 and S23). Next, the created execution program is executed (step S24). The execution program is ASN. 1 is read (step S25), and each of the types based on the data structure definition is read from the ASN. 1 of the ASN. 1. A dictionary item instance 2 corresponding to each type that does not require modification in one description and can be referred to from others is created, and type auxiliary information 3 corresponding to the type of each dictionary item instance 2 is created. In this case, as the type auxiliary information, each component of the structural type is associated with the value handle instance 4, and information indicating a structural element that holds the arrangement of the value handle instances 4 is set (step S26). A type dictionary instance 1 holding all of the dictionary item instances 4 is created (step S27).

A data type or ASN. ASN.1 of the built-in type In preparation for manipulating a value of a type that does not require qualification in one description and can be referenced from another, create a value handle instance 4 and then
A pointer to the dictionary item instance 2 corresponding to the value type operated by the value handle instance 4 is obtained from the type dictionary instance 1, and the value handle instance 4
Is set (step S31). Then, a value operation is performed on the value handle instance 4. The processing procedure for the value operation includes accessing only the value handle instance 4 (step S35) and tracing the pointer to the dictionary item instance 2 of the value handle instance 4 to access the dictionary item instance 2 (step S35). S34) tracing a pointer to the dictionary item instance 2 of the value handle instance 2, further tracing a pointer to the function jump table 5, and calling a function corresponding to the operation prepared in the function jump table 5 (Step S33).

The function prepared in the function jump table 5 checks whether or not there is a value internal expression holding unit 6 (step S36). If not, the value internal expression holding unit 6 is prepared.
The value handle instance 4 is set so as to hold a pointer to the value internal expression holding unit 6 (step S3).
7). The function prepared in the function jump table 5 then accesses the value internal expression holding unit 6 (step S
38). When a value operation is performed on an existing value handle instance 4 (step S39), the above-described processes from steps S32 to S38 are repeated to create a new value handle instance 4 (step S4).
0) repeats the creation of the value handle instance 4 according to steps S31 to S39 described above.

FIGS. 4 to 13 are drawings cited for describing a specific operation of the embodiment of the present invention, and a specific ASN. One description and a procedure in an application program prepared by the present invention will be described in detail. It should be noted that names such as C ++ class names, function names, and type names that appear in the following description are merely examples, and do not limit the gist of the present invention.

FIG. 4 is a diagram showing an example of creating a dictionary. As a dictionary item instance (2 shown in FIG. 1), ASN. 1 shows a state in which the contents of the data structure description 7 described according to the specification 1 are set. In the figure, blocks denoted by the same reference numerals as those in FIG. 1 are the same as those in FIG. Adg_dict on the application program 10 is a type dictionary class having a dictionary function. dic is a type dictionary instance. dic.Read ("E
x1.ats ") instructs the type dictionary instance 1 to read dictionary information. In the embodiment of the present invention, the data structure definition description is once converted into a dictionary file." Ex1.at
"s" is a dictionary file name. The dictionary file generation procedure and the dictionary file format are not directly related to the gist of the present invention, and thus will not be described in detail here.

In FIG. 4, Ex1.PersonalRecord (241) and Ex1.YEAR (24)
2) and ASN. 1 Built-in type INTEGER (243)
Is displayed. In addition to this, the definition of Ex1.WhenAndWhere and ASN. 1 built-in type ASN. In one description, BOOLEAN or EXTER that can be referenced from other without the need for qualification
A dictionary item instance 2 of a type such as NAL has been generated. Ex1.PersonalRecord dictionary item instance 241
Since Ex1.PersonalRecord is derived from SequenceType,
It has a pointer to the function jump table 5 (544) for SequenceType. Further, it has element information inside the structure as type auxiliary information 345. Since the dictionary item instance 242 of Ex1.YEAR is a derivative of IntegerType,
It has a pointer to the function jump table 5 (546) for tegerType. ASN. The dictionary item instance 243 of 1 built-in type INTEGER also has a pointer to the function jump table 5 (546) for IntegerType.

SequenceType function jump table 5
In (544), an area allocation function for SequenceType is set as an area allocation function, but an error handling function is set as an int value setting function or a character string value setting function. Int value setting operation (SetInt) for the value handle instance (4 in FIG. 1) to which SequenceType is assigned
Val (int) call), this error handling function will eventually work. Function jump table 5 for IntegerType
In (546), an area securing function for IntegerType is set as the area securing function. This performs an operation different from that of the area securing function for SequenceType. In addition, a function to set an int value IntegerType is set as an int value setting function. When an int value setting operation (SetIntVal (int) call) is performed on the value handle instance (4 in FIG. 1) to which the IntegerType is assigned, the int value setting function finally operates.

FIG. 5 is a diagram showing an example of type assignment.
The value handle instance (4 in FIG. 1) has the ASN.
This shows a state where type 1 is assigned, that is, a state where the pointer of the dictionary item instance (2 in FIG. 1) is set. In the drawing, blocks denoted by the same reference numerals as those in FIGS. 1 and 4 are the same as those in FIGS. 1 and 4, respectively. Adg_data on the application program 10 is ASN. A value handle class 13 representing one value, and data is an instance thereof. At the time of declaring Adg_data data ;, there is no connection to dictionary item instance 2 and ASN. Type 1 is unassigned. dict.Assign (data, "Ex1.YEAR")
ASN. This is the procedure for assigning type 1. Here, for the type dictionary instance dict, ASN. Requests that Type 1 Ex1.YEAR be allocated. The type dictionary class 11 searches the dictionary item instance 2 in response to the request, and specifies the designated ASN. When the type 1 information is found, the pointer to the dictionary item instance 2 is set to the value handle instance 4.

FIG. 6 is a diagram showing an example of setting a type-specific value as an example of a value operation. In FIG. 6, an ASN. A mechanism for setting a value specified for type 1 is shown. In addition,
Here, types other than Ex1.YEAR are omitted. In the figure, blocks denoted by the same numbers as the blocks shown in FIGS. 1 and 4 are the same as those shown in FIGS. 1 and 4, respectively. Data.SetIntVal (5) on the application program 10 is a request for setting an int value “5” to the value handle instance. SetIntVa for value handle instance 4
The l () function first checks the pointer 61 to the dictionary item instance 2 on the value handle instance 4, then checks the pointer 62 of the function jump table 5 on the dictionary item instance 2, int
The function indicated by the pointer 63 to the value setting function 5462 is called. Called IntegerType int value setting function 546
2 checks whether the pointer 65 to the value internal representation holding unit 6 (63) for IntegerType is set in the value handle instance 4, and if the pointer is not set here, the area reservation function 5461 for IntegerType. Call.

The area allocation function 5461 for IntegerType
The necessary area is secured in the value internal expression holding unit 63 for ntegerType, and the value internal expression holding unit pointer 65 of the value handle instance 4 is set. If the value internal expression holding unit 6 is pointed in advance, there is no call of the IntegerType area securing function 5461. Then int for IntegerType
The value setting function 5462 sets the argument of SetIntVal, that is, “5” in this case, to the internal representation storage area for Integer that the value internal representation storage unit 6 indicated by the internal representation storage pointer 65 has. Even if a type other than IntegerType is assigned, the procedure (61, 62, 63 described above) up to the invocation of the function indicated by the pointer to the int value setting function for each type is the same. However, the operation of the int value setting function differs for each type. For BOOLEAN, set “false” if “0”, set “true” for other than “0”, and for REAL, set the internal representation Set to a value after converting to double. The structured type and the character string type perform error handling (calling the error handling function 5463).

FIG. 7 is a diagram showing an example of encoding a value as an example of a value operation other than the value setting. A mechanism for encoding a value of a value handle instance in which one value is set in a user area is shown. In the figure, blocks denoted by the same numbers as the blocks shown in FIGS. 1 and 4 are the same as those shown in FIGS. 1 and 4, respectively. Data.EncodeTo (buf, buf_len) on the application program 10 is
This is a request to encode the value of data into the buffer buf (70) specified by the user. buf_len indicates the capacity of the buffer. The EncodeTo () function for the value handle instance 4 first checks the pointer 71 to the dictionary item instance 2 on the value handle instance 4, and then checks the pointer 72 of the function jump table 5 on the dictionary item instance 2. Encode in function jump table 5
The function indicated by the pointer 73 to the function 5464 is called.
The called IntegerType encode function 5364 checks whether or not the pointer 75 to the value internal representation holding unit 6 (63) for IntegerType is set in the value handle instance 4, and if the pointer is set, the value The value in the internal expression holding unit 6 (63) is stored in the ASN. The encoding is performed on the user buffer 70 in accordance with the encoding method 1. Inte
Encode for each type even if a type other than gerType is assigned
The procedure (71, 72, 73 described above) up to the invocation of the function indicated by the pointer to the function is the same. However,
The encoding process itself differs for each type.

Note that all operations are ASN. It is not performed via the function jump table 5 prepared for each basic type. FIG. 8 is a diagram illustrating an operation example in which the processing is terminated only by accessing the dictionary item instance. In the figures, FIGS. 1 and 4
Blocks given the same numbers as the blocks shown in FIG. 4 are the same as those shown in FIGS. In FIG. 8, data.IsString () on the application program 10 is data
This is a procedure for inquiring whether or not a character string type is assigned to. IsSt for value handle instance 4
The rig () function first checks the pointer 81 to the dictionary item instance 2 on the value handle instance 4, then checks the type basic information 211 on the dictionary item instance 2. Return "true", otherwise return "false" and exit. Here, the function jump table 5 is not used.

Next, handling of structured data when implementing the present invention will be described with reference to FIGS. FIG. 9 shows an internal information structure of the dictionary item instance corresponding to the structure type definition and the type auxiliary information. In the figure, blocks denoted by the same numbers as the blocks shown in FIGS. 1 and 4 are the same as those shown in FIGS. 1 and 4, respectively. In FIG. 9, the type auxiliary information 3 on the structural type is information on the structural element, that is, the type auxiliary information 311 for the structural type.
(312). Mold type auxiliary information 311 (31
2) is an ASN. Corresponding to the type of each structural element. The same type as the value handle instance 4 to which the type 1 is assigned is arranged, and serves as a template of the value type internal expression holding unit 6 of the structured type. Here, the description of the function jump table 5 is omitted to avoid complicating the drawing, but it is assumed that they are pointed to from the dictionary item instance 2 as in the description so far.

In FIG. 9, the structural type auxiliary information 311 pointed out from the type information of Ex1.PersonalRecord is Ex.
1. Along with the elements of the PersonalRecord, there is a value handle instance 41 for name, a value handle instance 42 for born, and a value handle instance 43 for num-of-children. As shown in the data structure definition, since the name is IA5String, the IA5String type is assigned to the value handle instance 41 for name, and IA5St
Points to the dictionary item instance 244 of the ring. Since born is Ex1.WhenAndWhere, the value handle instance 42 for born is assigned the Ex1.WhenAndWhere type, and the dictionary entry instance 2 of WhenAndWhere
It points to 45. The element itself is a structured type, but its handling is no different from the other two simple types. The only point is that the dictionary item instance 2 that is pointed to is of a structured type. num-of-children is INTEG
Since it is ER, the INTEGER type is assigned to the value handle instance 43 for num-of-children, and points to the dictionary item instance 243 of INTEGER. Any of these three value handle instances (41, 42,
Also in 43), the value internal expression holding unit 6 does not point, and the value internal expression holding unit 6 does not eventually point. These serve as a template for the contents of the value internal expression holding unit 6 of Ex1.PersonalRecord. In the type information of Ex1.WhenAndWhere, type auxiliary information for structural type 3 having value handle instances for year and place (44 and 45, respectively)
Pointer 12 is set.

A mechanism for setting a value to a structural type element will be described with reference to FIGS. FIG.
It is a figure which shows the process until Ex1.PersonalRecord accesses the structural element "name" of the assigned value handle instance. In the figure, blocks denoted by the same reference numerals as those shown in FIGS. 1, 4, and 9 are the same as those shown in FIGS. 1, 4, and 9, respectively. Further, data ["name"] on the application program 10 is a description for accessing an element by designating the element name. Ag_data & Adg_dat as function
a :: operator [] (const char *) The [] operator function for value handle instance 4
The pointer 101 to the dictionary item instance 2 on the value handle instance 4 is checked.
From 1 confirm that the type is a structural type. Subsequently, it is determined whether or not the pointer 102 to the value internal expression holding unit 6 of the value handle instance 4 is set. If not set, point (1) from dictionary item instance 2
03) Call the area allocation function 5441 for the structural type pointed to by the pointer 104 to the area allocation function on the function jump table 5 to be executed. The structural type area securing function 5441 secures an area of a required size (an ellipse A surrounded by a broken line in the figure),
Copy the value handle instance list of 1 (10
7). Then, this area A is stored in the internal representation storage unit 6 of the value handle instance 4 (the internal representation storage unit 61 for the structure).
Is set so as to point to the pointer 102. The internal representation of the structured type is one in which the value handle instances 4 of the element values are arranged. At this point, the value handle instance 4, which is each element, has the ASN. Type 1 is assigned, but the pointer to each value internal expression holding unit 6 is not set. That is, no value is set. After that, the [] operator determines the order of the specified element from the specified element name by referring to the element name table on the type auxiliary information 3 of the dictionary item instance 2, and determines the specified element 108 as a function Return as return. That is, data ["name"]
Represents the name element itself (108) in the value handle instance data.

FIG. 11 is a diagram cited for explaining a mechanism for setting a value for a selected structural element.
In the figure, blocks denoted by the same reference numerals as those shown in FIGS. 1, 4, and 9 are the same as those shown in FIGS. 1, 4, and 9, respectively. SetStrVal on application program 10
Is a function that sets a string value. Although the form of the value internal expression holding unit 6 is different, the basic operation flow is SetInt
Same as Val. The SetStrVal () function for the value handle instance 4 obtained as described with reference to FIG. 10 first checks the pointer (111) to the dictionary item instance 2 on the value handle instance 4, and then checks the type information The function checks the pointer 112 of the function jump table 5 and calls the function indicated by the pointer 113 to the character string value setting function in the function jump table 5. Called IA
The 5String character string value setting function 5471 checks whether the pointer 115 to the IA5String value internal expression holding unit 6 (character string internal expression holding unit 62) is set in the value handle instance 4 and the pointer is set. If not, the IA5String area reservation function 5472 is called. I
The A5String area allocation function 5472 allocates the area 62 as the IA5String value internal expression holding unit 6 and stores the pointer 11 to the value internal expression holding unit 6 of the value handle instance 4.
Set 5. If the value internal representation holding unit 6 has been pointed in advance, the IA5String area securing function 5471
There is no call. After that, the IA5String character string value setting function 5471 secures the variable length area 621 for character string data in the pointer of the character string expression holding area 62 indicated by the value internal expression holding pointer 115 and sets the argument of SetStrVal. I do. These series of operations are independent of whether the target value handle instance 4 is a single instance or a structural type element.

FIG. 12 is a diagram cited for explaining a state in which values are set in other elements as in FIG.
The explanation is omitted to avoid duplication of the explanation, but the element born
Although the structure type is assigned, the basic operation is exactly the same. In the figure, 63 and 631 are IntegerType internal expression holding units, 611 is a structural type internal expression holding unit, and 621
Is a character string internal expression holding unit.

Next, an auxiliary mechanism for accessing a structural element will be described with reference to FIG. FIG.
It is a conceptual diagram which shows the mechanism for accessing a structural type element sequentially. Adg_probe on the application program 10 is a class for sequentially accessing structural type elements. Here, the elements of the value handle instance data to which the Ex1.PersonalRecord type is assigned are sequentially accessed. The structure element sequential access instance 8 has a pointer to the structured type value internal expression holding unit 61, and separately has an index value for positioning the value handle instance 4 arranged on the structured type value internal expression holding unit 61. have nil.
By sequentially changing the index value, it is possible to sequentially access the value handle instances 4 (41, 42, 43, 44, 45) arranged on the structural type value internal expression holding unit 61 along the line. Pb.Stand on application program
by () is a function that positions the virtual position immediately before the head. pb.Next () moves the position to the next element. The Next () function returns “false” after the last element, so it can be used for judgments such as for statements.

For reference, the application program shown as List 3 in FIG. 16 is an application of the above-described mechanism, and is an ASN. Receiving a one-valued C ++ class instance, and giving an integer value to an element whose content
This is an example of interactively setting a character string for a string type element, recursively for a nested structure.

As described above, according to the present invention, the data structure definition is ASN. When the operation of the data structure based on the data structure definition is performed by an application program described in an object-oriented language, the ASN. Application programs can be created without obtaining a complete description of the data structure conforming to
N. The data structure definition conforming to the ASN.1 specification is read during execution of an application program created in advance, and the ASN. Create a type dictionary instance of AS1 and execute AS during application program execution.
N. A type dictionary instance can be searched for, and thereby, a method of dynamically allocating type information in a data structure definition using an abstract syntax notation that can specify a data structure and perform a value operation can be provided.

[0035]

As described above, according to the present invention, the data structure can be dynamically specified during the execution of a program. A computer program can be created without specifying the type information of the first type, and the burden on the programmer can be reduced. In addition, since the type information is stored as a dictionary of what the type is as a key, the type to be assigned can be handled as data. This is especially true for OSI (Open System Interconnection).
In the mechanism for specifying a type by an object identifier in the object management function of e), a remarkable effect can be obtained when the type needs to be dynamically assigned by a computer program. Further, in creating a computer program, ASN. A computer program can be made compact by describing general-purpose processing that does not specify type 1. Also, ASN. 1 type information can be handled as data. The reason is that the dictionary item instance and the value handle instance in the present invention are ASN. This is because type 1 information is held. As a result, the present invention can be used as a parser for description conforming to ISO8824 “ASN.1 specification”.

[Brief description of the drawings]

FIG. 1 is a block diagram showing an embodiment of the present invention.

FIG. 2 is a flowchart showing an operation procedure of the embodiment of the present invention.

FIG. 3 is a flowchart showing an operation procedure of the embodiment of the present invention.

FIG. 4 is a diagram cited for explaining the operation of the embodiment of the present invention, and is a diagram showing a state in which a dictionary item instance and a type dictionary instance are constructed.

FIG. 5 is a diagram cited for explaining the operation of the embodiment of the present invention, in which an ASN. It is a figure showing the state where type 1 was allocated.

FIG. 6 is a diagram cited for explaining the operation of the embodiment of the present invention, and is a diagram showing a mechanism for setting a value in a value handle instance.

FIG. 7 is a diagram cited for explaining the operation of the embodiment of the present invention, and is a diagram illustrating an operation concept when encoding the value of a value handle instance as an operation example other than the value setting.

FIG. 8 is a diagram cited for explaining the operation of the embodiment of the present invention, and is a diagram showing an operation example without interposing a function jump table.

FIG. 9 is a diagram cited for explaining the operation of the embodiment of the present invention, and is a diagram showing a structured dictionary item instance format.

FIG. 10 is a diagram cited for explaining the operation of the embodiment of the present invention, and is a diagram showing a mechanism for accessing a structural type element.

FIG. 11 is a diagram cited for explaining the operation of the embodiment of the present invention, and is a diagram showing a mechanism for setting a value to a structural type element.

FIG. 12 is a diagram cited for explaining the operation of the embodiment of the present invention, and is a diagram showing a state where values are set in a hierarchical structure.

FIG. 13 is a diagram cited for explaining the operation of the embodiment of the present invention, and is a diagram showing a mechanism for sequentially accessing structural type elements.

FIG. 14 is a diagram cited for explaining the operation of the embodiment of the present invention; FIG. 2 is a diagram showing a basic type 1 as a list 1.

FIG. 15 is a diagram cited for describing the operation of the embodiment of the present invention, and is a diagram showing an example of a function connected to the function jump table as a list 2;

FIG. 16 is a diagram cited for explaining the operation of the embodiment of the present invention; FIG. 9 is a diagram showing a program description of an example of a function for setting a value to a numeric / character string element of one structure type as a list 3.

FIG. 17 is a flowchart showing a procedure according to a conventional technique.

[Explanation of symbols]

1 Type dictionary instance 2 (241, 242, 243, 244, 245) Dictionary item instance 3 (311, 312) Type auxiliary information 4 (41, 42, 43, 44, 45) Value handle instance 5 (544) , 546, 547) Function jump table 6 (61, 62, 63, 611, 621, 631) Value internal representation storage unit 7 Data structure definition based on "ASN.1 specification" 8 Structure element sequential access instance 10 ... Application program 11 ... Type dictionary class 12 ... Dictionary item class 13 ... Value handle class 21 (211) ... Type basic information 61 (62,71,72,81,82,101,10)
2, 103, 111, 113, 115) pointer 5461 (5462, 5463, 5464) function

Claims (6)

[Claims] The data structure definition is ASN. In a computer system which is described in conformity with one specification and executes a data structure operation based on the data structure definition by a program described in an object-oriented language, a function jump table is provided for each basic type of a type based on the data structure definition. Is prepared, the above-mentioned data structure definition is read at the time of execution of the program after compiling, and each type and ASN. A dictionary entry instance including a pointer to the function jump table and at least type basic information is created for each type of the built-in type that can be referred to by others without requiring internal modification,
When a type dictionary instance that holds pointers to these dictionary item instances is created and the data structure is operated, a pointer to the dictionary item instance corresponding to the value type to be operated is obtained from the type dictionary instance, and a value handle is obtained. Abstract: The method is characterized in that type information is specified by setting an instance, and a function prepared in accordance with the type information is operated on a call value by referring to the function jump table as necessary. A method for dynamically assigning type information in a data structure definition using syntax notation. 2. When the dictionary item instance is created, if a type declared by a data structure definition is a structured type, each component of the structured type is associated with the value handle instance as type auxiliary information. 2. The method of dynamically assigning type information in a data structure definition using an abstract syntax notation according to claim 1, wherein structure element auxiliary information that holds a sequence of value handle instances is set. 3. The function prepared in the function jump table prepares a value internal expression holding unit corresponding to the type as needed, and stores the value handle instance in the structure element auxiliary information into the value internal expression holding unit. And setting the value handle instance to hold a pointer to the value internal expression holding unit, and setting a value corresponding to an operation in the value internal expression holding unit. 2. A method for dynamically assigning type information in a data structure definition using the abstract syntax notation described in 2. 4. In a value operation using the value handle instance, only access to the value handle instance is performed or a pointer to a dictionary item instance of the value handle instance is traced, and only reference to the dictionary item instance is performed according to the nature of the operation. 2. The abstract syntax notation according to claim 1, wherein a function corresponding to the operation prepared in the function jump table is called by tracing a pointer to a function jump table of the dictionary item instance. Dynamic allocation method of type information in the used data structure definition. 5. The data structure definition is ASN. (1) a computer system which is described in conformity with a specification and executes an operation of a data structure based on a data structure definition by a program described in an object-oriented language, compiling the program and creating an execution program; When manipulating a data structure in the execution of a program, the ASN. 1 is read, and each of the types declared in the data structure definition is read from the ASN. AS of 1 built-in type
N. Creating a dictionary item instance corresponding to each of the types that can be referenced from others without requiring modification in one description, and creating a type dictionary instance holding a pointer to the dictionary item instance; Creating a dictionary instance that holds everything; generating a value handle instance; obtaining from the type information dictionary instance a pointer generated by the value handle instance and pointing to a dictionary item instance corresponding to the type of the value to be operated on Setting the value handle instance and, in the value operation by the value handle instance, performing only access to the value handle instance or tracing a pointer to a dictionary item instance of the value handle instance according to the nature of the operation; Each step of only referencing a book item instance or tracing a pointer to a function jump table of a dictionary item instance to call a function corresponding to the operation prepared in the function jump table, and calling the function A step of checking whether or not the function has a value internal expression holding unit. If not, preparing a value internal expression holding unit, and the value handle instance holds a pointer to the value internal expression holding unit. And a step of accessing the value internal representation holding unit. The method of dynamically assigning type information in a data structure definition using an abstract syntax notation. 6. The method according to claim 1, further comprising the step of checking whether or not to perform a value operation on an existing value handle instance, and performing the value operation or creating a new value handle instance. 5. A method of dynamically allocating type information in a data structure definition using the abstract syntax notation described in 5.