JPH08272622A - Program conversion device - Google Patents

Abstract

PURPOSE: To attain the conversion of a program without using a complicated description rule by analyzing the syntax of a conversion rule as well as an input program to be converted to prepare a syntax tree of the conversion rule for the input program and then rewriting the syntax tree of the input program by means of the syntax tree of the conversion rule. CONSTITUTION: A syntax tree analysis device 101 analyzes the syntax tree of an input program 102 to be converted and the syntax of a conversion rule 103 and prepares a syntax tree 104 and the syntax tree of the rule 103. The syntax tree of the program 102 is rewritten by the syntax tree of a syntax tree rewriting rule 105. The rewritten syntax tree 107 of the program 102 is outputted by an output device 108 as a converted program 109. In other words, a syntax tree rewriting device 106 compares the tree 104 of the program 102 with the syntax tree of the rule 105 to check whether the nodes conformable to every node of the syntax tree of the rule 105 are included in the tree 104. Then the conformable nodes are rewritten by means of the syntax tree of the rule 105.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program conversion device, and more particularly to a program conversion device which parses an input program having a complicated syntax and converts the result into another program based on a conversion rule. .

[0002]

2. Description of the Related Art Conventionally, as a method of converting an input program to be converted into another program, there is known a method in which the input program is regarded as simple text data and a document editing tool is used for rewriting the program. .

For the symbol processing language Lisp, a rewriting tool considering the structure of the program is prepared as a part of the language specification and is used as a standard for the purpose of introducing a new control structure. Focuses on the fact that the Lisp language has a very simple syntax and the program itself is already in the form of a syntax tree.

On the other hand, as disclosed in Japanese Patent Application Laid-Open No. 5-181651, "Automatic Program Generator", by separating the design knowledge into a conversion target part and a non-conversion target part, the specifications in the middle of conversion can be reduced. There are ways to keep and reduce search time.

[0005]

However, in the above-mentioned prior art, since the structure of the syntax tree, in particular, the normal program having a complicated structure is not considered as the conversion target,
It is impossible to convert such a program.

On the other hand, the syntax of a programming language actually used for software development is complicated, and if an accurate parsing is attempted, the parsing routine becomes large and the parsing tree as the parsing result becomes complicated. Will end up.

This is because not only is it difficult to implement a syntax analysis unit when implementing a program conversion device, but the description of rules is complicated when describing conversion rules for rewriting syntax trees. It means that it becomes a shape.

Further, when trying to define a new control structure using a conversion tool, if the parsing is too strict, the parsing of the new control structure to be defined will result in a syntax error and the form of rewriting the syntax tree There is a problem that can not be realized in.

An object of the present invention is to provide a program conversion device capable of converting a program having a complicated structure into another program without using a complicated description rule.

[0010]

In order to achieve the above object, the program conversion device of the present invention uses the syntax of an input program to be converted and the syntax of its conversion rule, in which a type hierarchy is used for nodes constituting a syntax tree. Parsing means for performing an analysis and creating a syntax tree of an input program and a syntax tree of a conversion rule, a syntax tree rewriting means for rewriting the syntax tree of the input program with the syntax tree of the conversion rule, and the rewritten input program And an output unit for outputting the syntax tree as a converted program.

The syntax analyzing means outputs the syntax tree of the conversion rule which matches the syntax of the input program to be converted.

[0012]

According to the above means, the input conversion target program is parsed according to the conversion rule to obtain the syntax tree of the conversion target program.

Similarly, the conversion rule itself is also parsed to obtain the syntax tree of the conversion rule.

Next, the syntax tree conversion rule is applied to the syntax tree of the program to obtain the syntax tree of the rewritten program.

Finally, the rewritten syntax tree is output as a converted program.

Here, the syntactic analysis means performs syntactic analysis using the type hierarchy for the nodes forming the syntactic tree. When the type hierarchy is introduced to the nodes of the syntax tree, it is possible to allow the nodes of the lower type where the nodes of the upper type can appear in the syntax tree. As a result, the syntactic analysis routine only needs to output a simplified syntactic tree in which only upper-type nodes appear, which facilitates processing.

Further, it becomes possible to perform object-oriented programming in which the conversion rule of the syntax tree is described according to the type, and the description and processing of the conversion rule become simple and clear.

Ambiguity may occur in the analysis result due to the reduction of the syntax tree, but this can be solved by giving a ambiguity resolution rule to the node type that may have ambiguity.

Further, as the conversion rule of the syntax tree, the same syntax as the programming language to be converted is used,
If the entire program conversion device is also created using the target programming language, it becomes possible to apply the program conversion device to itself, and it is possible to easily perform porting and expansion to programs of different models having different operating systems.

[0020]

An embodiment of the present invention will be described below with reference to the drawings.

FIG. 1 is a block diagram showing an embodiment of the present invention. The syntax of an input program 102 to be converted and its conversion rule 103 is parsed by using a type hierarchy for nodes constituting a syntax tree. Input program 102
Syntax tree 104 and a syntax tree 101 of the conversion rule 103 (hereinafter referred to as a syntax tree rewriting rule), and a syntax tree rewriting apparatus rewriting the syntax tree of the input program 102 with the syntax tree of the rewriting rule 105. 106 and syntax tree 1 of the rewritten input program
And an output device 108 that outputs 07 as the converted program 109.

The syntax tree rewriting device 106 compares the syntax tree 104 of the input program with the syntax tree of the syntax tree rewriting rule 105, and the node corresponding to each node of the syntax tree of the rewriting rule 105 is the syntax tree 104 of the input program.
Is checked, and the applicable node performs the rewriting operation with the syntax tree of the rewriting rule 105.

In this embodiment, the C language is selected as the programming language to be converted, and the syntactic analysis can be performed by using a syntactic analysis device known by the standard parser generation device (Lex, Yacc) or the like. , Easy to implement.

However, it is known that the syntax of C language cannot be completely parsed by the context-free grammar, and there is a possibility that the syntax tree 104 as the analysis result has an error. However, the places of occurrence of this error are limited, and in the case of C language, it is only when the declaration statement and the execution statement are analyzed and mistaken in the first part of the compound statement.

Therefore, this error is corrected by giving a correction rule to the type of the syntax tree node indicating the compound sentence. The correction rule is automatically added to the beginning of the conversion rule described by the user of this system.

To create a strict syntax tree for the C language, about 100 kinds of syntax tree nodes are required, but by introducing a type hierarchy, it is possible to simplify the syntax tree to about 10 kinds of node types. .

For example, in an ordinary syntax tree, there are required 30 or more types of executable statements such as labeled executable statements, expressions, compound statements, conditional statements, repeated statements, jump statements, assignment expressions, and logical expressions. In the embodiment, the type hierarchy as shown in FIG. 2 is used, and the types of nodes are five types: the execution statement 201, the compound statement 202, the control statement 203, the conditional statement 204, and the repetition 205.

Of these, the control statement 203 is introduced as a node type that is a supertype of the conditional statement 201 and the repetition statement 205, and is a node type that was not found in the original syntax tree.

In the normal syntax analysis, the analysis processing of the conditional statement and the repeated statement checks the keywords (if, while, for etc.), so that the syntax analysis results in an error if a new control structure is defined.

On the other hand, in this embodiment, the control statement 203
Since the analysis is stopped by the upper type, no error will occur and a new control structure can be defined.

FIG. 3 shows an algorithm for rewriting a syntax tree.

First, the syntax analysis device 101 (Parse)
, And the syntax tree 1 of the program 102 (P) to be converted
04 (TP) is obtained (step 301).

Next, the part TP 'to be rewritten next is selected from the syntax tree 104 (TP) (step 302).
This selection depends on the rewriting strategy, and several kinds of strategies such as innermost rewriting and outermost rewriting are known, but the strategy to be adopted can be switched by the value of the global variable "strategy" (default is the innermost rewriting. Has been adopted).

When there is no subtree to be rewritten, T
Since "False" is returned as the value of P ', the processing ends and T
Return P as a syntax tree of the rewriting result (step 303,
311).

If not, the set of rules applicable to TP 'is retrieved by "get_rule" (step 304). “Get_rule” is a function that extracts an applicable rule set according to the type of the root node of a given syntax tree. The rules that are the elements of this rule set are three sets of (A, B, C).

However, A is an input pattern designation, B is an intermediate processing designation, and C is an output pattern designation.

Although each of A, B, and C is described in the syntax of C language, a pattern variable can be used in the syntax, and matching and instantiation are performed on this pattern variable.

The rule is applied to the rule (the first one) in which the syntax tree TA of the result of the parsing of A matches TP 'and the intermediate process B succeeds. T
Retrieve a set of rules for P '(step 30
4). If the rule set is NIL (step 3
05), and returns to step 302. When there is a set of rules, the first rule is taken out, and the variable binding "bind" of the pattern variable is created from the matching of TA and TP '(step 306).

If "bind" is "false" (step 307), this rule is not applicable, and the process returns to step 305.

When "bind" is not "false", the intermediate processing specification B is evaluated by the intermediate processing evaluation device "Eval" under this variable binding to obtain a new variable binding "new_bind" (step 308).

When the output of the intermediate process fails, "new_b"
Since "ind" becomes "false" (step 30
9) and returns to step 302.

When "new_bind" is not "false", the output pattern C is determined by "new_bind".
Constructs a pattern tree instantiated in the syntax tree TC of the above, and replaces the subtree TP 'in the TP with this (step 310).

The above processing is repeated until there are no rewritable subtrees TP '.

FIG. 4 shows an example of the rule description. A pattern variable is represented by adding "?" At the beginning like "? X". In addition, after the variable, a regular expression representing the node type can be described following "@".

For example, "? X @ stmt *" is "? X"
Is 0 of the item of "stmt type" (node type that represents an executable statement)
Represents a match with more than one sequence.

Reference numeral 41 is an example of defining a function that takes an argument of indefinite length.

For example, the function call "foo (a, b)" follows the first rule, "bar (a, b)".
b) ”, both rules are applied to the function call“ foo (a, b, c) ”, and“ bar (a, bar)
(B, c)) ”.

Reference numeral 42 is an example of rewriting the C function definition of Kanihan Rich's (old) specification to a function definition based on the (new) specification corresponding to ANSIC.

5 and 6 show how to parse 41 rules and regard them as rewriting rules of a syntax tree.

FIG. 5 corresponds to the first rule 41, and FIG. 6 corresponds to the second rule 42.

FIG. 7 shows the operation of the system for the input "foo (a, b, c)". Input 61 is the parser 1
01 is parsed into a syntax tree 63. The system searches for rules applicable to this syntax tree or its subtrees according to the specified strategy.

In this example, the syntax tree 521 of FIG.
= A ”,“? Y = b ”, and“? Z = c ”given variable bindings match the syntax tree 63, so rule 5 in FIG.
20 is applied, and the syntax tree 522 is rewritten to the syntax tree 64 in which the above-mentioned substitution for the pattern variable is performed.

Similarly, the subtree 65 of the subtree 64 and the subtree 511 have the same variable bindings as "? X = b" and "? Y = c", so that the rule 510 of FIG. 5 is applied. And is rewritten as the syntax tree 66 of FIG.

The syntax tree rewritten in this way is
The output processing device 108 outputs the program 109.

FIG. 9 shows a rewriting rule of the syntax tree corresponding to the rule 42 of FIG.

However, for simplicity, the output part corresponding to the prototype declaration is omitted.

The input pattern 43 and the output pattern 44 of the rule 42 are parsed into syntax trees 71 and 73, respectively,
It is regarded as a rule for rewriting a syntax tree that involves processing on a specific node by the filter unit 72.

The application of this rule 42 is shown in FIG.
Is.

When the program 81 to be rewritten is given, a syntax tree of the program is created, compared with the syntax tree 71, and a match with a pattern variable is performed.
"_Type" has "int" 82 and "? Fct_nam".
"e" is "foo" 83, and "? args" is "(x,
y, z) list 84, “? arg_decls” has list 85 “int x, y; long y;”
The function definition body 86 is associated with “? Fct_body”.

By the filter unit 87, “? Result_
"decl" is calculated, the pattern variable 72 in the output syntax tree is replaced with the corresponding values 88 to 811, and the converted program 109 is obtained as a result.

As described above, according to this embodiment, by introducing the type hierarchy into the syntax tree, the description of the program conversion rule and the conversion process can be simplified.

It can also be used for the purpose of extending the syntax and introducing new control structures.

Further, although it can be used for porting and extending a program, since the description of the conversion rule is described by the same syntax as the program to be converted, the program conversion can be used for the processing itself for the conversion rule. A highly scalable system can be realized.

Furthermore, in the case of the C language conversion system described in the embodiment, since the system is also realized by the C language, the conversion can be applied to the processing system itself to rewrite the system, which is especially portable. It is possible to build a high system.

[0065]

As described above, according to the present invention,
A program with a complicated structure can be converted into another program without using complicated description rules.

In particular, by introducing the type hierarchy into the syntax tree, the description of the program conversion rule and the conversion process can be simplified.

As the conversion rule of the syntax tree, the same syntax as the programming language to be converted is used,
If the entire program conversion device is also created using the target programming language, it becomes possible to apply the program conversion device to itself, and it is possible to easily perform porting and expansion to programs of different models having different operating systems.

[Brief description of drawings]

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

FIG. 2 is an explanatory diagram showing an example of a type hierarchy of nodes in a syntax tree.

FIG. 3 is a flowchart showing a procedure for rewriting a syntax tree.

FIG. 4 is an explanatory diagram showing a description example of a conversion rule for C language.

5 is an explanatory diagram showing how to parse the rule 41 of FIG. 4 and regard it as conversion of a syntax tree.

FIG. 6 is an explanatory diagram showing a sequel to FIG. 4;

FIG. 7 is an explanatory diagram showing an application example of a rule 510.

FIG. 8 is an explanatory diagram showing a sequel to FIG. 7;

FIG. 9 is an explanatory diagram showing how to parse a rule 42 and regard it as conversion of a syntax tree.

FIG. 10 is an explanatory diagram showing an application example of a rule 42.

[Explanation of symbols]

101 ... Syntax analysis device, 102 ... Conversion target program, 103 ... Conversion rule, 104 ... Syntax tree, 105 ... Syntax tree rewriting rule, 106 ... Syntax tree rewriting device, 10
7 ... Rewritten syntax tree, 108 ... Output processing device, 1
09 ... Converted program.

Claims (2)

[Claims] 1. A syntax for parsing the syntax of an input program to be converted and its conversion rule using a type hierarchy for nodes constituting the syntax tree to create a syntax tree of the input program and a syntax tree of the conversion rule. A program conversion device comprising: an analysis unit; a syntax tree rewriting unit that rewrites the syntax tree of the input program with a syntax tree of the conversion rule; and an output unit that outputs the rewritten syntax tree of the input program as a converted program. 2. The program conversion device according to claim 1, wherein the syntax analysis unit outputs a syntax tree of a conversion rule that matches the syntax of an input program to be converted.