JPH01298439A - List analyzing device - Google Patents

Abstract

PURPOSE:To automatically analyze a list and to rewrite to other language providing by providing an LISP processing part, an analyzing part, a code preparing part, an input output part and a storing part. CONSTITUTION:A list inputted through an input output part 1e is processed by an LISP processing part 1b in accordance with the program inputted through the input output part 1e in the same way and a result is stored into a storing part 1f. Next, the contents and construction of the processed list are analyzed by an analyzing part 1c and the result is stored into the storing part 1f. Next, a code preparing part 1d describes the list with other language of a purpose and stores it into the storing part 1f from the analyzing result stored in the storing part 1f. The above-mentioned work is automatically executed by the control of a central processing part 1a. The list described with other language is obtained through the input output part 1e. Thus, since the analysis of the list and the rewriting to other language can be automatically executed and the correct description of the list by other language can be executed in a short time, the error does not occur.

Description

DETAILED DESCRIPTION OF THE INVENTION Field of the Invention The present invention relates to a list analysis device for analyzing list data on a computer.

Conventional Technology In recent years, research and development of artificial intelligence technology has been actively conducted, and some of the results are beginning to be put into practical use.

Lisp (hereinafter referred to as LISP) is often used as a programming language at the research and development stage.

LISP is a language that is easy to write programming because it processes data with a flexible structure called a list. However, data that is flexible for the user has a very complicated structure inside the computer. As a result, LISP processing systems have to perform data type determination and complex data processing, resulting in slow processing speed. Therefore, when putting it into practical use,
Practical processing speeds are often achieved by rewriting programs written in LISP in other languages with faster processing speeds, such as C language or assembly language.

The data handled at this time is the data handled by the LISP processing system (
In some cases, it may be more suitable to have the same structure as a list), so the contents and structure of the list must be rewritten in another language, just like a program.

The list is generally expressed in a form called 8 expressions as shown in FIG. 6(a). In addition, the data structure inside the computer is as shown in FIG. 5(b), as shown in FIG.
) is called a cons cell (Fig. 6, 5c1-6
c6). Generally, atoms have types such as symbols, character strings, arrays, numbers, etc.
There are special data called L and T, and various information is managed in structures according to each type. List is LI
In the process of being processed by the SP processing system, various environmental information is added to the atom.

When writing lists in other languages, it is often necessary to also write environmental information attached to atoms. However, this environmental information often has a complicated list structure, and its contents change dynamically during the processing process. It is difficult to know directly.

Conventionally, a program analyzes the internal structure of the target list while tracking changes in the contents of the list and environmental information added to atoms according to the flow of processing, and based on the results, converts the target list into another language. It is described in

Problems that the invention aims to solve However, the conventional method of manually parsing the list and rewriting it into another language takes a lot of time.

Another problem was that there was a high possibility of human error.

In view of the above problems, the present invention aims to provide a list analysis device that can automatically analyze a list and rewrite it into another language.

Means for Solving the Problems The present invention includes an LISP processing unit that processes a list using LISP, an analysis unit that analyzes the list, and a list written in another language based on the analysis result by the analysis unit. The above object is achieved by including a code generation section that generates a code, an input/output section that interfaces with the user, and a storage section that stores data as appropriate during processing.

Operation In the above configuration, the present invention processes the list inputted through the input/output section in the LISP processing section according to the program also inputted through the input/output section, and stores the results in the storage section. Next, the contents and structure of the processed list are analyzed by the analysis section, and the results are stored in the storage section. Next, the code generation section writes a list in the target language from the analysis results stored in the storage section, and stores it in the storage section. The above operations are automatically performed under the control of the central processing unit. The user obtains a list written in another language via the input/output section.

EXAMPLE Hereinafter, an example of the present invention will be described along with its operation with reference to the drawings.

FIG. 1 is a block diagram of a list analysis device according to an embodiment of the present invention when a list is written in C language.

A list expressed by 8 formulas as shown in FIG. 5(a) is input from the input/output section 1c, and is subjected to LISP processing by the LISP processing section 1b. Then, it is converted into the internal representation of the computer as shown in FIG. 6(b) and stored in the storage unit 1f. At this time, required environmental information is also added to each atom making up the list.

Next, the analysis section 1C analyzes the specified list. The analysis analyzes the number of cons cells and the type and number of atoms by recursively following the components of the specified list (cons cells and atoms) and the environmental information added to the atoms.

The operation of the analysis section 1C will be explained below based on the block diagram of the analysis section 1c shown in FIG. In Figure 2, 2a
2b is an address determination unit, 2b is an address table, 2c is a type determination unit that determines the type, 2d is a counting table, 2c is a scanning unit, 2f is type structure information, and 2g is a stack memory. Address table 2b, count table 2d.

The type structure information 2f and the stack 2g are stored in the storage unit 1 shown in FIG.
It is provided as appropriate on f. Addresses of cons cells or atoms that have already been analyzed are registered in the address table 2b. In the counting table 2d, the number of cons cells making up the list and the type and number of atoms are registered. Type structure information 2f
Information about the basic structure of cons cells and atoms is pre-filled. The stack 2g is a first-in, last-out storage device.

Now, the address of the element at the head of the list stored in the storage section 1f shown in FIG. 1 is input to the address determination section 2a.

The address determination unit 2a refers to the address table 2b to avoid redundant analysis, and determines whether the input address is the address of an already analyzed cons cell or atom. If it has already been analyzed, a signal is sent to the scanning unit 2e to perform the next process. If the address has not been analyzed, the address is registered in the address table 2b and then input to the type determination section 2c.

The type determination unit 2c determines the type of the element at the input address and registers it in the counting table 2d, and then inputs the address and type information to the scanning unit 2e.

The scanning unit 2e checks whether the element at the currently input address contains a pointer to another element or another list, based on the information in the type structure information 2f. N pieces (
If a pointer (N is a natural number) is included, all elements or lists pointed to by the pointer are analyzed before the element at the currently input address. Therefore, the currently input address is stored in the stack 2g, then the addresses of (N-1) elements or lists are obtained from the pointer, and they are sequentially stored in the stack 2g. Address determination unit 2a
Enter. If a pointer is included and it is not rare, or if a signal indicating a transition to the next process is input from the address determination unit 2a, the address input immediately before is taken out from the stack 2g and sent to the address determination unit 2a. input.

If the stack 2g is empty, the analysis ends.

Next, the code generation section 1d generates a code written in list C language based on the analysis result from the analysis section 1c.

The operation of the code generation section 1d will be explained below with reference to FIGS. 3 and 4. FIG. 3 is a schematic diagram of the generated code, which is composed of a declaration section 3a that declares the types of the constituent elements of the list, and a function section 3b that defines the contents of each constituent element. FIG. 4 is a block diagram showing the structure of the code generation section 1d. In Figure 4, 4a is a declaration section, 4b is a counting table, and 4c
4d is a definition section that performs definitions, 4d is type structure information, 4e is an address table, 4f is a stack memory, and 4g is a code storage file. Count table 4b, address table 4e, type structure information 4
d, a stack 4f, and a code storage file 4g are provided as appropriate on the storage section 1f shown in FIG. The counting table 4b and the mold structure information 4d have the same contents as the counting table 2d and the mold structure information 2f shown in FIG. 2, respectively. Also, address table 4e
and stack 4f are address table 2b shown in FIG.
, is used for the same purpose as stack 2g.

Here, the declaration unit 4a first generates a header file inclusion (3a1 in FIG. 3) in which structures representing each component are defined. Next, the analysis section 1c shown in FIG.
The type and number of constituent elements are read from the count table 4b created by the above, and a declaration part 3a2 shown in FIG. 3 is generated. Finally, the function name of the function part 3b shown in Fig. 3 (Fig. 3, 3b
1), the generated code is stored in the code storage file 4g. When the storage is completed, the address of the element at the head of the list stored in the storage section 1r shown in FIG. 1 is input to the definition section 4c.

In the definition section 4c, as described below, elements are described in C language while recursively tracing the elements, and the elements are connected.

The generated code is then stored in the code storage file 4g.

After determining the type of the element at the input address, it is checked based on the information in the type structure information 4d whether or not the element contains a pointer to another element or another list. If a pointer is included, it is checked using the address table 4e whether the element or list pointed to by each pointer is written in C language.

If all elements or lists have already been written in C language, the elements at the input address are written in C language using the element templates in the type structure information 4d. At that time, the notation in C language of the element pointed to by the pointer is retrieved from the address table 4e, and information other than the pointer is obtained by directly referring to the contents of the structure in the storage unit 1r (Fig. 1) representing the element. obtain. When the description is completed, the input address and the C language notation of the corresponding element are paired and registered in the table 4e. Next, stack 4f
The address input just before is extracted from the definition section 4c.
Enter. If the stack 4f is empty, a code (3b3 in FIG. 3) indicating the end of the function is generated and the process is ended.

If some elements or lists have not yet been written in C language, the elements or lists not written in C language are written before the element at the currently input address. So the currently input address is stacked 4
Then, the address of the element or list to be written is obtained from the pointer and sequentially stored in the stack 4f. Then, one address is taken out from the stack 4f and input to the definition section 4c.

If a pointer is not included, the content of the structure in the storage unit 1f (Figure 1) is directly referenced based on the type structure information 4d, and the input address is written in C language. Furthermore, the input address and the C language notation of the element are registered as a pair in the address table 4c. Next, the address input immediately before is taken out from the stack 4f and inputted to the definition section 4c. If the stack 4f is empty, a code (3b3 in FIG. 3) indicating the end of the function is generated and the process is ended.

This completes the analysis of the list and the description of the list in C language. The user can obtain the generated code through the input/output unit 1e.

As described in detail, according to the present invention, a list can be automatically analyzed and rewritten into another language, and a list can be accurately described in another language. This has the effect that it can be achieved in a short period of time and there are no errors.

[Brief explanation of the drawing]

FIG. 1 is a block diagram showing a list analysis device according to an embodiment of the present invention, FIG. 2 is a block diagram of an analysis unit according to an embodiment of the present invention, and FIG. 3 is a code generation diagram according to an embodiment of the present invention. A schematic code diagram of the code generated by the section,
FIG. 4 is a block diagram of a code generation unit in an embodiment of the present invention, and FIGS. 5(a) and 5(b) are block diagrams showing a list expression using Expression 8 and general internal expression. 1a...Central processing unit, 1b...LISP processing unit, 1c
...Analysis section, 1d...Code generation section, 1e...Input/output section, 1r...Storage section. Name of agent: Patent attorney Toshio Nakao and 1 other person No. 1
Figure N2 Figure 3 Figure 4 Figure 5 (Q) 5oz 5a3

Claims (1)

[Claims] A LISP processing unit that performs LISP processing on a list, an analysis unit that analyzes the list, a code generation unit that generates a code describing the list in another language based on the analysis result by the analysis unit, and an interface with the user. What is claimed is: 1. A list analysis device comprising: an input/output unit that performs processing; and a storage unit that stores data as appropriate in the process of processing.