JP2016136368A - Language conversion device - Google Patents

Abstract

PROBLEM TO BE SOLVED: To solve problems for example, when converting a program sentence containing a selection structure containing a PROGN function, creation and allocation of a temporary variable which is substantially useless, are not performed.SOLUTION: A conversion part 14 converts a FCL program sentence which is a conversion object into a procedure type language program, based on two-dimensional structure (tree) data of a two-dimensional structure storage part 13. At the time, if there is an if sentence (step S1, YES), first a function expression of a condition clause related to the if sentence, is converted (step S2). Then, if there is PROGN in the condition clause, only one function expression is determined to an allocation object of a temporary variable, out of plural function expressions related to the PROGN (step S3), and then an optional temporary variable is allocated to the determined function expression (step S4). Then, using the allocated temporary variable, a condition branch part (then clause or the like) is created (step S5).SELECTED DRAWING: Figure 1

Description

  The present invention relates to a language conversion device that converts a program written in a functional language into a form that can be executed by an arithmetic processing device unsuitable for functional language processing.

  A programmable controller (programmable logic controller; hereinafter simply referred to as “PLC” in some cases) executes a sequence control program and controls a device to be controlled.

  As a sequence control program executed by the programmable controller, as shown in FIG. 6, for example, there is a functional control language as an intermediate language between an expression dependency portion as a PLC language and a machine dependency portion as a machine language. . Examples of the PLC language include a mnemonic description, a ladder diagram, a function block diagram, an SFC diagram (Sequential Function Chart), a decision table, etc., as shown in the figure. The functional control language is Functional Control Language, which may be abbreviated as “FCL” hereinafter. The functional control language is sometimes referred to as a functional language.

Although FCL is described in Patent Document 1, Patent Document 2, and the like, FCL will be briefly described here.
The FCL is a language expressing a sequence control program with a functional program structure.

FIG. 7 is a diagram illustrating an example of a basic structure of a functional control language.
In FCL, as shown in FIG. 7, one function is represented by a function formula F having arguments Ar1, Ar2, Ar3,. The argument is, for example, an operand (such as a variable), but another function expression may be used as the argument of the function expression F. That is, a function expression itself can be an argument of another function expression. Therefore, the relationship between a certain function expression and an argument of this function expression (which may include another function expression) can be expressed two-dimensionally as a tree structure (functional structure).

FIG. 8 shows an example of a two-dimensional functional structure (tree structure) of a functional control language.
For example, in the example of FIG. 8, function A has function B and function C as arguments, function B has operand v and operand w as arguments, function C has operand x and function D as arguments, D has operand y and operand z as arguments. That is, in FIG. 8, a two-dimensional structure (tree structure) for the following expression is expressed.
(A (B v w) (C x (D y z)))

  In the two-dimensional functional structure (tree structure) shown in FIG. 8 as an example, each function or operand (variable, etc.) is a node (square in the figure), and a straight line between arbitrary nodes is a link between the nodes. Show. For example, the node A means the function A, and the node A is linked to the node B (function B) and the node C (function C). This assumes that node A is the parent node of node B and node C. In other words, it can be said that the child nodes of node A are node B and node C. Similarly, for example, it can be said that the child nodes of the node B are the node v and the node w. The other nodes will not be described in particular, but the parent-child relationship is shown by the links shown by the straight lines in the figure.

  As described above, the functional control language can perform a two-dimensional expression of a language as shown in FIG. 8, for example, and has a high descriptive property. Therefore, a PLC program as shown in FIG. It can play a role as an intermediate language that connects the expression dependent part and the machine dependent part.

  Here, Patent Documents 1 and 2 and Patent Document 3 show a method of executing an operation using an instruction stack and a data stack as an execution method of a functional language program. In the case of such a method of executing an operation using an instruction stack and a data stack, naturally, means such as an instruction stack and a data stack are required. Therefore, a device that does not have such means (for example, a device that executes procedural instruction processing) has a problem in that processing performance is degraded due to difficulty in program execution or emulation.

In order to solve such a problem, a method of converting a functional language into a procedural language and executing it in a general-purpose procedural language (for example, C language) has been proposed (Patent Document 4).
Alternatively, the present applicant has previously proposed the invention described in Patent Document 5.

The invention of Patent Document 5 relates to the invention of Patent Document 4 and solves the following problems.
First, since the above functional language has values for all functions and functions can be described as function arguments, conditional branches (for example, IF to THEN to ELSE to END_IF) are performed, and the results are It is possible to simply describe the condition. A program in which conditional branches are nested is well known. Here, in the conditional branch process, only one expression (THEN part or ELSE part) selected according to the execution condition should be executed, whereas in the conversion result by the conventional conversion process, the THEN part and ELSE This results in a process of executing both of the sections and selecting the result, causing a problem of performing an extra process.

  In response to the above problem, the invention of Patent Document 5 can convert a functional control language program into a procedural language program, perform procedural instruction processing without waiting for an instruction stack and a data stack, Especially for functional control language programs with conditional branches, conditional branch instructions in functional control languages can be converted into an appropriate syntax, and efficient execution can be realized without creating extra execution or temporary variables. A language conversion device is provided.

JP-A-1-298444 JP-A-2-230426 JP-A-1-243126 JP 2012-104065 A JP 2014-59848 A

  Here, the function-type control language (FCL) has values for all functions, and can describe a PROGN function as an argument of the function. As is well known, using the PROGN function allows multiple expressions to be evaluated, and the return value is the result of the last evaluated expression. Thus, using the PROGN function, it is possible to describe substantially multiple expressions in the conditional clause of a selection structure (for example, IF to THEN to ELSE to END_IF) or a loop structure (for example, WHILE to DO to ENDWHIL). is there.

FIG. 9 shows an example of a selection structure sentence using the PROGN function in FCL.
In the illustrated program example, the following two expressions are evaluated by the PROGN function.
(: = (+ B a) c)
(: = (-De) f)

  Then, if the return value is the result of the last evaluated expression, that is, (: = (− d e) f), and this return value is “10”, execute (: = (− c a) a). To do.

  FIG. 10 shows the result of converting the FCL program sentence shown in FIG. 9 into a procedural language using existing techniques such as Patent Documents 4 and 5 described above. Most of the conversion processing and the conversion result will be described later in the description of the conversion processing and conversion result according to the present method, and will not be described here. However, in this example, the problem is “INST — 5: This is explained below.

  First, “INST_5”, “INST_6”, and the like in the conversion result shown in FIG. 10 are temporary variables that are arbitrarily assigned to all functions (nodes other than leaves) during the conversion process. It is assumed that the generation rule is “INST _” + any integer. Note that “temporary variable” (temporary variable name) may be considered to correspond to “instance name” in Patent Documents 4 and 5 above.

  In the example shown in FIG. 10, as shown in the figure, “INST — 5” in the second line is not used at all after the third line and has no meaning. That is, “INST — 5” is substantially unnecessary. This is because, as described above, in the PROGN function, the return value is the result of the last evaluated expression, so when the conditional clause is composed of a plurality of expressions, the execution condition is determined by the execution result of the last expression. .

  In FIG. 9, since there are two functional expressions related to the PROGN function, there is only one temporary variable “INST — 5” which is substantially useless. For example, there are 10 functional expressions related to the PROGN function. If there are, there are nine temporary variables that are substantially useless, and the waste is large.

  In Patent Documents 4 and 5, the “function name-instance name creation unit 14” uses the “instance name” (for all nodes other than leaves (terminal nodes) among the nodes in the two-dimensional functional structure (tree structure). (Temporary variable) is assigned. That is, “instance names” (temporary variables) are assigned to all functions (instructions).

  In this way, in the conventional conversion process, temporary variables are assigned to the execution results of all the function expressions. Therefore, if there is a PROGN function, an extra temporary variable is generated, and the converted program execution environment is There is a problem of pressure. In other words, the amount of memory used increases.

Further, in the examples of FIGS. 9 and 10, the following problems also occur.
First, in the functional control language (FCL), it is possible to omit options (ELSE clause and OTHERW clause) when the conditional expression is not satisfied in the selection structure.

That is, for example, an if statement is generally described as follows.
if (conditional expression (conditional clause))
then clause else
else clause FIG. 9 shows an example in which there is no ELSE clause of the selection structure. Of course, there is no ELSE clause as well as the above-mentioned else itself, but it goes without saying. When there is no ELSE clause, nothing is converted in the conventional conversion process, and there is nothing after the last closing bracket “}” as shown in FIG. In the figure, nothing is indicated by hatching. Of course, no temporary variable is assigned because nothing is converted.

Regarding the above if statement, the part other than the conditional clause is called an execution clause. That is, in the above example, the execution clause includes the “then” clause, the “else” clause, and the like.
In the case of FCL, if the option when the condition is not satisfied is omitted, the execution result = 0 when the condition is not satisfied.

  On the other hand, when a program statement having no ELSE clause as shown in FIG. 10 is executed in a general-purpose procedural language (for example, C language, PASCAL, etc.), there arises a problem that the execution result becomes indefinite.

  An object of the present invention is to generate and assign temporary variables that are substantially useless when converting a program statement including a selection structure including a PROGN function in a language conversion device that converts a functional language into a procedural language. It is to provide a language conversion device that can be prevented from being performed.

  The language conversion device according to the present invention is a language conversion device that converts a program written in a functional language into a procedural language, and is a conversion means for converting the program, which is converted into a functional expression along with the conversion. Conversion means for generating and assigning an arbitrary temporary variable, and the conversion means is the last function expression when a plurality of function expressions are described in the conditional clause of the selection structure or loop structure in the program. The temporary variable is assigned only to.

  According to the language conversion device or the like of the present invention, in the language conversion device that converts a functional language into a procedural language, a temporary variable that is substantially useless when converting a program sentence including a selection structure including a PROGN function. Can be prevented from being generated or assigned. Alternatively, the problem that the converted program execution result becomes indefinite can be avoided even if the conversion source program statement has no ELSE clause.

(A) is a functional block diagram of a language converter, (b) is the schematic flowchart. It is a figure which shows the arrangement | sequence according to the example program of FIG. It is a figure which shows the two-dimensional structure (tree) according to the arrangement | sequence of FIG. It is a process flowchart figure of a conversion part. It is a figure which shows the conversion result by this method according to the example of a program of FIG. It is a figure for demonstrating the language for PLC. It is a figure which shows an example of the basic structure of a functional control language. An example of a two-dimensional functional structure of a functional control language is shown. It is a figure which shows an example of the selection structure sentence using a PROGN function. It is a figure which shows the result of having converted the program sentence of FIG. 9 by the conventional method.

Embodiments of the present invention will be described below with reference to the drawings.
FIG. 1A is a functional block diagram of the language conversion apparatus of this example.
The language conversion device 10 of this example is a language conversion device that converts a program written in a functional language into a form that can be executed by an arithmetic processing device unsuitable for functional language processing. This is a language conversion device that converts the program into a procedural language (such as C language or PASCAL).

  The language conversion device 10 shown in FIG. 1A includes a functional language (FCL) storage unit 11, a two-dimensional structure (tree) conversion unit 12, a two-dimensional structure storage unit 13, a conversion unit 14, and a procedural language storage. Part 15 and the like.

  The functional language (FCL) storage unit 11 stores an FCL program sentence to be converted. Here, the storage format of this program is, for example, an arrangement as shown in the example of FIG. That is, each function (instruction) and each operand (variable etc.) of the program are stored as each element of the array. The functional language (FCL) storage unit 11 itself may be the same as the conventional functional language (FCL) storage device disclosed in Patent Documents 4 and 5.

  Here, in the description of the present embodiment, the case where the FCL program sentence to be converted is the one shown in FIG. 9 will be described as an example. FIG. 2 shows an arrangement corresponding to the program example of FIG. That is, in this example, the functional language (FCL) storage unit 11 stores the FCL program sentence to be converted in the array format shown in FIG.

  Each element of this array is the same as in Patent Documents 4, 5, etc., and the function is stored as one element of the array together with an opening parenthesis “(”, and an operand (such as a variable) or a function terminator (closing parenthesis “)”. ) Is stored as it is as one element of the array. Thus, for example, functions (instructions) such as IF and PROGN are stored as one element of the array in the form of “(IF” and “(PROGN”) as shown in the figure.

  The two-dimensional structure (tree) conversion unit 12 converts the contents of the array stored in the functional language (FCL) storage device 11 into a tree structure with each element of the array as a clause (hereinafter referred to as “node”). Since the two-dimensional structure (tree) conversion unit 12 is also an existing function disclosed in Patent Documents 4 and 5 and the like, here, in a simple description, each element of the array is sequentially obtained, A tree structure composed of a corresponding node and a link between the nodes is generated. For example, in the case of the arrangement of FIG. 2, the two-dimensional structure (tree) shown in FIG. 3 is generated by the two-dimensional structure (tree) conversion unit 12. The generated two-dimensional structure (tree) data is stored in the two-dimensional structure storage unit 13.

  FIG. 3 schematically shows a tree structure. The data structure of each node is “child” as shown in FIG. 3 of Patent Document 4, FIG. 3, FIG. 14, FIG. It has pointers indicating links to other nodes such as “pointer to node” and “pointer to next node”. However, the present invention is not limited to this example. In FIG. 3, the parent-child relationship between the nodes based on such pointers and the like is shown by the illustrated straight line. For example, the parent nodes of the “b” node and the “a” node shown in the lower left of FIG. 3 are both “(+” nodes. In other words, the child node of the “(+” node is “b”. It can be said that the node is an “a” node, and in the case where the node is the data structure of FIG. 3 of the above-mentioned Patent Document 4, the “pointer to the child node” in the “(+” node) points to the “b” node. Thus, the “pointer to the next node” in the “b” node indicates the “a” node.

  As described above, the data structure of each node of the two-dimensional structure (tree) may be almost the same as that of Patent Documents 4 and 5 and the like, but in the case of this example, the instance name (in this example, a temporary variable) There is no. In this example, there is no “function name-instance name creation unit” in Patent Documents 4 and 5, and no instance name (temporary variable name) is assigned in the tree structure. In the case of Patent Document 4, the instance name (temporary variable name) is assigned to all the nodes other than the leaf by the “function name-instance name creation unit”, so that it is unnecessary as in the example of FIG. The temporary variable INST — 5 ”has been assigned.

  On the other hand, in this method, instead of uniformly assigning instance names (temporary variables) to all nodes other than the leaves as described above, the conversion unit 14 assigns temporary variables by the process described later. This will be described later. The leaf is a node at the end of the tree structure, that is, a node having no child nodes, as described in Patent Documents 4 and 5.

  Also in this example, a certain function can use another function or variable as an argument (child node). For example, in the example shown in FIG. 3, for example, the “(: =” node as the parent node of the illustrated “(+” node is the “(+” node ”and the illustrated“ c ”as its argument (child node). Note that “: =” is an assignment function, “+” is an addition function, and c is an operand (such as a variable).

  Note that a text data structure described in XML (Extensible Markup Language) can be used to express a two-dimensional structure (tree structure) as shown in FIG. In the case of XML, operations such as addition / deletion / retrieval of tree structure data can be easily performed.

The process of the conversion unit 14 will be described below.
First, FIG. 1B shows a schematic processing flow of the conversion unit 14.
The conversion unit 14 converts the FCL program sentence to be converted into a procedural language program based on the two-dimensional structure (tree) data stored in the two-dimensional structure storage unit 13. As shown in FIG. 1 (b), this process is roughly executed when an if statement is found in the sequential conversion of the FCL program according to the tree structure (step S1, YES). The function expression of the conditional clause related to the sentence is converted (step S2). If there is PROGN in this conditional clause, only one function expression is determined as a provisional variable assignment target among the plurality of function expressions related to PROGN (step S3), and the determined function expression is determined. An arbitrary temporary variable is assigned (step S4). Then, using this assigned temporary variable, a conditional branch part (then clause etc.) is created (step S5).

The procedural language program created by the conversion process is stored in the procedural language storage unit 15.
Note that the configurations and processes shown in FIGS. 1A and 1B are only examples, and are not limited to these examples. For example, the conversion unit 14 may perform the program conversion process using the array stored in the functional language (FCL) storage unit 11 instead of the two-dimensional structure storage unit 13.

  Here, the process of step S3 is a process of assigning a temporary variable only to the last function expression among the conversion results of a plurality of function expressions related to PROGN. As described above, the return value of the PROGN function is the result of the last evaluated expression. When there is a PROGN function related to the if statement, this return value is used for conditional branch determination.

  Conventionally, temporary variables are assigned to all functions by, for example, the above-mentioned “function name-instance name creation unit”, and therefore all temporary variables are also assigned to a plurality of function expressions related to PROGN. It was. On the other hand, in this method, as described above, instead of assigning temporary variables to the conversion results of all the function expressions related to PROGN, the temporary variables are assigned only to the function expressions necessary for condition determination. Efficient execution is possible without creating extra dummy variables. A specific example of such a temporary variable assignment process will be described later with reference to a flowchart.

  For example, as shown in a specific example described later, in this method, the FCL program statement of FIG. 9 is converted into a procedural language program statement of FIG. 5 described later, so that a plurality of function expressions related to PROGN as shown in FIG. Since a temporary variable is assigned only to the last function expression in the list, only three temporary variables (INST6, INST7, INST8) are needed, and the memory usage of the program after conversion can be reduced and the memory usage pressure can be avoided. It becomes like this.

  If there is a further selection structure inside the conditional clause, that is, if, for example, a so-called “if statement is nested”, the execution result of the last function expression executed after selection is the execution of the selection structure. As a result, it is used for condition determination. Therefore, for each option, only the conversion result of the last expression is assigned to a temporary variable.

  Alternatively, even if there is no option (ELSE clause or OTHERW clause) when the conditional expression is not satisfied in the FCL program statement to be converted, the option is added and the execution result is assigned. In this method, for example, when the PLC program sentence of FIG. 9 is converted into a procedural language, a process of automatically adding an else sentence shown at the end of FIG. 5 is performed. That is, a process for automatically setting a provisional variable = 0 is performed by automatically adding an option when the conditional expression is not satisfied. Although this will be described in detail later, this avoids a situation in which the execution result of the converted program becomes indefinite.

  A specific processing example for realizing the above-described feature of the present technique will be described in detail later with reference to FIG. As described above, the “select structure” in the following description is, for example, IF to THEN to ELSE to END_IF, and the “loop structure” is, for example, WHILE to DO to ENDWHIL. When the PROGN function is used, a plurality of expressions can be described in the conditional clauses of these structures.

In order to avoid useless allocation of temporary variables, for example, the following operations (a) and (b) are performed.
(A) After converting a plurality of function expressions related to the PROGN function into procedural instructions, the last function expression is searched among the plurality of function expressions related to the PROGN function (after conversion).

  (B) If the last function expression is not a selection structure or a loop structure, a temporary variable is generated and assigned to the last function expression. For example, a temporary variable is inserted at a location that coincides with the last function expression, going back from the end of the instruction code of the procedural language converted in connection with the PROGN function.

(C) On the other hand, when the last function expression is a selection structure or a loop structure, the temporary variable assigned in each execution clause is used as it is, and a new temporary variable is not generated.
By the above operation, when the conditional clause consists of a plurality of function expressions, only the temporary variable assigned to the last function expression is generated.

  (D) Also, if there is no option when the condition is not satisfied in the execution clause of the selection structure, that is, for example, when there is a Then clause but there is no else clause, an option when the condition is not satisfied is added and 0 is assigned to the temporary variable. Add an execution clause.

With the above operation, even if there is no option when the condition is not satisfied, the execution result of the conversion result program does not become indefinite.
The above (a) to (d) will be further described below.

  First, as described above, a plurality of function expressions can be used in the conditional clause of the selected structure by the PROGN function or the like. In general, further selection structures can be used inside conditional clauses. It is necessary to insert a temporary variable for each option, but it is troublesome to search all options when used in a conditional clause. In this method, a temporary variable is always inserted into the last expression of each option when the selection structure is converted to a procedural language.

  In the selection structure, there may be no option (ELSE statement or OTHERW statement) when the conditional expression is not satisfied. This method checks the existence of ELSE and OTHERW statements when converting the selected structure to a procedural language. If there is no ELSE or OTHERW statement, it automatically adds "else" and "default:" Variable): = 0 ”is added.

4 will be described with reference to the tree structure of FIG. 3 corresponding to the example of FIG.
FIG. 4 is a flowchart of the “node processing”.

  The processing in FIG. 4 is basically executed based on the processing target node. The processing target node is initially at the head of the tree structure, and in the example of FIG. 3, is a “(IF” node. However, during the processing of FIG. 4, the processing of steps S13, S16, etc. is the processing itself of FIG. Node processing "program) is called recursively.At this time, basically, by passing information indicating the child node of the processing target node as a parameter, the processing target node in the called" node processing " It will be a child node.

  The process of FIG. 4 roughly branches to four processes depending on the type of the processing target node. That is, whether the processing target node is an if statement (step S11, YES), a PROGN statement (step S31, YES), an arbitrary function other than these (step S41, YES), a variable (operand) (Step S41, NO), the process branches into four.

  As described above, since the processing target node is “(IF”), that is, an “if” statement, the determination in step S11 is YES, and the processing in steps S12 to S20 is executed. It is assumed that “node processing” is nest 1. “node processing” called from “node processing” of nest 1 is “node processing” of nest 2. Similarly, “Node processing” called from “node processing” is assumed to be “node processing” of nest 3. In this way, by calling “node processing” recursively, the nest is deepened by one level. Go.

Note that “1” and “2” in the nest 1, nest 2, etc. indicate the depth of the nest, and the larger the numerical value, the deeper the nest.
In addition, child node extraction (child node recognition) in the following description is realized by referring to the above-mentioned “pointer to child node” and “pointer to next node” included in each node, for example. it can.

  First, a conditional clause in the “if” statement is extracted (step S12), and “node processing” related to this conditional clause is executed (step S13). The process in step S12 is, for example, for recognizing one of the child nodes of the “processing target node (IF” node. Therefore, in the example of FIG. “(=” Node is recognized, and in step S13, “node processing” is called using the “(=” node as a parameter.

  As a result, in the “node process” to be called, the “(=” node becomes the process target node. In other words, the type of the process target node is a function. Therefore, the “node process” of the “(=” node. In (Nest 2), first, Steps S11 and S31 are NO and S41 is YES. From this, child nodes (arguments) of “(=” are sequentially taken out (Step S42). The process of calling “node process” (step S43) is repeated until it is executed for all child nodes.

  Here, since one of the child nodes of “(=” is a “(PROGN” node, the “node processing” of the PROGN statement may be executed in step S43. Can be said to be processing of nest 3.

  Therefore, when the node processing (nesting 3) of the “(PROGN” node is started, first, step S11 is NO and step S31 is YES, and the child nodes (arguments) of this “(PROGN” node are sequentially extracted. (Step S32), the "node process" is called for each of these child nodes (step S33) until the process is executed for all the child nodes.

  The “(PROGN” node has a plurality of child nodes, and in the example of FIG. 3, the first child node is a “(: =” node. Accordingly, in “node processing” called in step S33 according to this, processing is performed. The target node becomes a “(: =” node, and the processing is “(: =” (assignment function). This can be said to be processing of nest 4 hierarchically.

  In the “node processing” (nesting 4) of the “(: =” node, Steps S11 and S31 are NO and Step S41 is YES, so that the child nodes (arguments) of this “(: =” are sequentially extracted. (Step S42) The "node process" is called for each child node (Step S43), and the process is repeated until it is executed for all the child nodes.

  In the example of FIG. 3, since the first child node of “(: =” is a “(+” node), the “node processing” called in step S43 according to this is the processing of “(+” (addition function). This can be said to be processing of nest 5 hierarchically.

  In the “node processing” (nesting 5) of the “(+” node, steps S11 and S31 are NO and S41 is YES. From this, child nodes (arguments) of this “(+” node are sequentially extracted (step S42). ), Calling “node processing” for each child node (step S43) until the processing is executed for all child nodes.

  In the example of FIG. 3, since the first child node of the “(+” node is a “b” node, the “node processing” called in step S43 according to this is the processing of “b” (variable). This can be said to be “node processing” of nest 6 hierarchically.

  In the “node processing” (nesting 6) of the “b” node, steps S11, S31, and S41 are all NO, and the variable processing (step S46) is executed. This variable processing simply outputs the processing target node “b” to the syntax list. The syntax list is a conversion result output destination file or the like, and various outputs are generated by this processing, so that a syntax list having the conversion result shown in FIG. 5 is finally generated.

Note that an example of the procedural language storage unit 15 may be regarded as the syntax list.
When the processing of step S46 is executed, the “node processing” (nesting 6) of the “b” node ends, and the processing returns to the calling source processing (“(+) node“ node processing ”; nest 5). Thus, the process of step S43 in the “node process” of the “(+” node is completed, and it is determined whether or not the process has been performed for all the child nodes in step S44. Since there is an unprocessed child node (“a” node) regarding the “+” node, the process returns to step S42.

Then, in step S42, the “a” node is extracted, and the “node processing” called in step S43 according to this is the processing of “a” (variable).
In the “node processing” of the “a” node, steps S11, S31, and S41 are all NO, and thus variable processing (step S46) is executed. That is, the processing target node “a” is output to the syntax list. Thus, at this stage, only “b” and “a” are described in the syntax list. Then, when returning to the caller process (“(+” node “node process”)), since the determination in step S44 is NO, the process in step S45 is executed.

  In step S45, the function of the processing target node is output as a syntax list. Here, the function “+” is output as a syntax list. Here, when the target function is the four arithmetic operations of + (addition),-(subtraction), * (multiplication), and / (division), the output destination is the above-mentioned syntax related to the child node of this function. Between the output results to the list. That is, since “b” and “a” are output in the above example, “+” is output during this time. As a result, “b + a” is described in the syntax list.

In step S45, a process of assigning a temporary variable to the description “b + a” is further executed. The temporary variable may be generated according to a predetermined rule. Here, the temporary variable = ““ INST _ ”+ arbitrary numerical value” is set as the generation rule. Arbitrary numerical values may be anything as long as they do not overlap. Here, it is assumed that “6” is assumed, and temporary variable = “INST — 6” is assigned. This assignment means “: =” (substitution), and thus, the processing makes the following description in the syntax list. That is, only the first line in the syntax list of FIG. 5 is described.
INST — 6; = b + a;

  When the execution of the step S45 is completed, the “node processing” (nesting 5) of the “(+” node is completed, and thereby the “node processing” (nesting of the “(: =” node that is the call source). Thus, the process of step S43 in the “node processing” (nesting 4) of the “(: =” node is completed, and then the process of step S44 is executed. : = ”Since there is an unprocessed child node“ c ”in the node, the determination is no and the process returns to step S42.

  In step S42, the child node “c” is extracted, and the “node process” called in step S43 according to this is the process of “c” (variable) (nesting 5).

  In the “node processing” of the “c” node, steps S11, S31, and S41 are all NO, and thus variable processing (step S46) is executed. That is, the processing target node “c” is output to the syntax list. When the “node processing” is completed and the process returns to the “node processing” of the caller “(: =” node, the determination in step S44 is NO, so the processing in step S45 is executed.

In step S45, the function of the processing target node is output as a syntax list. Here, the function “: =” is output as a syntax list. Here, when the target function is “: =” (assignment function), “c” described above is used as the assignment destination, and the assignment source is the latest temporary variable. Here, since the existing latest temporary variable is “INST — 6”, the following description is added to the syntax list. That is, the description on the second line in FIG. 5 is generated.
c: = INST_6

  When the target function is “: =” (assignment function), no new temporary variable is assigned. In this case, as described above, an existing temporary variable is used.

  When the execution of the step S45 is completed, the “node processing” (nesting 4) of the “(: =” node is completed, and thereby the node processing of the calling source “(PROGN” node (nesting 3)) As a result, the process of step S33 ends, and subsequently, it is determined whether or not the process has been executed for all the child nodes of the “(PROGN” node (step S34). At this stage, since there are unprocessed child nodes remaining, the determination is NO, and the process returns to step S32.

  In the example of FIG. 3, “node processing” (nesting 4) of “(: =” node is called in step S33, and “node processing” of “(−” node is called in step S43 of this “node processing”. (Nest 5) is called, and "node processing" (nesting 6) of the "d" node and "node processing" (nesting 6) of the "e" node are sequentially called in step S43 of this "node processing". It will be.

These processes are substantially the same as the processes related to the variables “b”, “a”, and “+”, and thus will not be described in particular. However, these processes generate “d−e”, and further, a temporary variable. INST_8 will be allocated. That is, the description on the third line in FIG. 5 (the following description) is generated.
INST_8: = d-e;

Further, by returning to the “node processing” (nesting 4) of “(: =” above, the assignment source is set to the latest temporary variable in the same manner as described above by the processing of step S45, and the syntax list includes In other words, a part of the description on the fourth line in FIG.
f: = INST_8

  Then, when returning to the node processing (nesting 3) of the “(PROGN” node that is the call source, in the case of the example of FIG. 3, the determination in step S34 is now YES, so the processing in steps S35 to S37 is performed. Execute.

  The processing of steps S35 to S37 is performed by searching the last described function expression among the descriptions (function expressions) generated on the syntax list as described above for all child nodes of the “(PROGN” node. (Step S35) is a process of assigning a temporary variable only to the last described function expression (Step S37), provided that the last described function expression is a selection structure or a loop structure (Step S36, (YES), the process of assigning temporary variables (the process of step S37) is not performed, and the process of assigning temporary variables (NO in step S36) when the last described function expression is other than the selected structure or the loop structure (NO in step S36). Step S37) is performed.

When step S36 is YES, for example, the temporary variable assigned in the execution clause of the selection structure or the loop structure may be used as it is, but the present invention is not limited to this example.
In the above example, an arbitrary temporary variable is assigned only to the function expression on the fourth line in FIG. 5, and in the example of FIG. 5, the temporary variable INST_7 is assigned. As a result, the description on the fourth line in FIG. 5 is generated as follows.
INST_7: = (f: = INST_8)

  Note that the processing in steps S35 to S37 may be referred to as processing in step S35, for example.

Here, for comparison, the conversion result in the case of the conventional method of FIG. 10 will be described with reference to FIG.
In the conventional method, as described above, a temporary variable is assigned to all child nodes of the “(PROGN” node. In other words, the temporary variable (here, INST_5 is also assigned to the “c” node). Therefore, as shown in FIG. 10, the description on the second line is as follows.
INST_5: = (c: = INST_6)

  On the other hand, in this method, as described above, a temporary variable is assigned only to the last function expression by performing the process of step S35 and the like for the PROGN statement, so as shown in FIG. There is no description of “INST — 5: =”.

  As described above, in the prior art, temporary variables are assigned to the execution results of all the function expressions in the conversion results, and therefore, there are extra temporary variables, and the converted program execution environment is compressed (in the memory Problem). On the other hand, according to this method, as described above, it is possible to prevent an excess temporary variable from being present in the conversion result.

The description of the processing in FIG.
As described above, the processing in FIG. 4 has been described up to the last processing (step S35, etc.) of “node processing” (nesting 3) of the “(PROGN) node. Returning to the “node processing” of the caller, that is, returning to “node processing” of “(=” of nest 2 and performing the determination in step S44, the determination is NO because there is an unprocessed child node. Then, the process returns to step S42, and "node processing" of the "10" node that is an unprocessed child node is executed in step S43.

  Since “10” is an operand, in the “node processing” of the “10” node, steps S11, S31, and S41 are all NO, and the variable processing (step S46) is executed. That is, the operand “10” of the processing target node is output to the syntax list. When this “node processing” is completed and the process returns to the calling source processing (“(=” “node processing”; nest 2), the determination in step S44 is NO, so the processing in step S45 is performed. Execute.

Here, when the function of the processing target node is “=” (equal function), an expression obtained by connecting “10” described above and the existing latest temporary variable with “=” is as follows: Outputs to the syntax list. This adds the following to the syntax list: That is, a part of the description on the fifth line in FIG. 5 is generated.
INST_7 = 10

  In the case of the equal function, as in the substitution function, no new temporary variable is assigned in step S45.

  By executing the above process, the “node processing” (nesting 2) of the “(=” node is completed, so that the process returns to the “node processing” of the caller. ”(Nest 1) Here, the processing so far is processing related to the above“ (= ”which is the conditional part of the if statement taken out in step S12. The process is completed, and then the process of step S14 is executed.

  The process of step S14 is a process of adding an if statement to the current last line in the syntax list. In the above example, an “if” statement is added to “INST — 7 = 10”. As a result, the expression in the fifth row shown in FIG. 5 is almost completed. However, the last parenthesis “{” in the expression on the fifth line is not yet described. This “{” is described in the process of step S17 described later, and will be described later.

As described above, in the case of the above example, the following description in the expression on the fifth line shown in FIG. 5 is generated by the process of step S14.
if (INST_7 = 10)
Then, the Then part in the if sentence is extracted (step S16), and the “node processing” related to the Then part is executed (step S16). In the above example, the node processing related to the “(: =” node, which is the other child node of the “if” node, is executed.

In the “node processing” (nesting 2) of the “(: =” node, first, Steps S11 and S31 are NO, and Step S41 is YES. From this, the child node (argument) of this “(: =” node is changed. The process is sequentially taken out (step S42), and the "node process" is called for each child node (step S43) until the process is executed for all the child nodes. The processing is substantially the same as the processing when the eye formula is created, and the description is omitted here.As a result of this processing, the following formulas in the sixth and seventh lines in FIG. It will be.
INST — 10; = c−a;
INST_9: = (a: = INST_10)

  Then, the processing returns to the “node processing” (nesting 1) of the “if” node, and the processing in step S17 is executed. In the process of step S17, a description in which the conversion result related to the above-mentioned Then part in the syntax list is sandwiched between parentheses “{}” is added to the syntax list. In the case of the above example, an opening parenthesis “{” and a closing parenthesis “}” are additionally described so as to sandwich the expressions on the sixth and seventh lines in FIG.

With the above processing, the conversion results of the first to eighth lines in FIG. 5 are obtained.
Subsequently, it is determined whether or not there is an else portion as a conversion target (step S18). If there is an else portion (step S18, YES), the conversion process is executed (step S19). Since this is an existing process, it is not specifically described here.

  On the other hand, for example, when there is no else part as in the example of FIG. 9 (step S18, NO), nothing is performed conventionally, but in this example, the process of step S20 is executed. Since nothing is processed in the prior art, for example, for the example of FIG. 9, as shown in FIG. 10, only the conversion result up to the eighth line is present, and the ninth and subsequent lines do not exist. On the other hand, in the present technique, the descriptions of the ninth to eleventh lines shown in FIG. 5 are generated by the process of step S20.

The process of step S20 is a process in which one sentence for the following three lines is additionally described at the end of the syntax list.
else {
The latest (last) temporary variable: = 0;
}

In the case of the above example, the latest temporary variable is INST_9 that was assigned when the expression on the seventh line in FIG. 5 was generated. Therefore, in the case of the above example, the descriptions of the ninth to eleventh lines shown in FIG. 5 are added.
else {
INST_9: = 0;
}

  In the conventional case, as shown in FIG. 10, since there is no else statement in the conversion result, there arises a problem that the execution result becomes indefinite. In contrast, in this method, as described above, even if there is no else statement at the conversion source, the else statement is forcibly added to the conversion result. Absent. Note that “0” is an example, and the present invention is not limited to this example, and any numerical value may be used. That is, if a predetermined numerical value is forcibly assigned, the execution result will not be indefinite.

  In other words, in this method, when the option when the conditional expression is not satisfied is omitted in the selection structure in the FCL program, the option when the condition is not satisfied is added to the conversion result program, and the latest (last) temporary variable is added. An execution clause that assigns 0 to is added to the conversion result program.

  Although not shown in FIG. 3, for example, when another “if” node (not shown) exists in the example of FIG. 3, the processes of steps S <b> 12 to S <b> 20 are also performed for this “if” node. It will be.

In addition, there may be an if statement as one of a plurality of function expressions related to the PROGN function shown in FIG. In this case, as described above, a new temporary variable is not generated.
As described above, according to the language conversion apparatus 10 of the present example, in the language conversion apparatus that converts a functional language into a procedural language, the program sentence including the selection structure including the PROGN function is substantially converted. It is possible to prevent generation and assignment of temporary variables that are useless. Alternatively, the problem that the converted program execution result becomes indefinite can be avoided even if the conversion source program statement has no ELSE clause.

DESCRIPTION OF SYMBOLS 10 Language converter 11 Functional language (FCL) storage part 12 Two-dimensional structure (tree) conversion part 13 Two-dimensional structure storage part 14 Conversion part 15 Procedural language storage part

Claims (5)

A language conversion device for converting a program written in a functional language into a procedural language,
Conversion means for performing conversion of the program, and having conversion means for generating and assigning an arbitrary temporary variable to the function expression accompanying the conversion,
The language conversion is characterized in that the conversion means assigns the temporary variable only to the last function expression when a plurality of function expressions are described in the conditional clause of the selection structure or the loop structure in the program. apparatus.   The language conversion apparatus according to claim 1, wherein in the program, a plurality of expressions are described in a conditional clause of the selection structure or loop structure by a PROGN function.   When the program has the PROGN function, the conversion means converts all function expressions related to the PROGN function into the procedural language without assigning temporary variables, and then converts the function expression to the last function expression. 3. The language conversion apparatus according to claim 2, wherein the temporary variable is assigned only to the user.   The conversion means adds an option when the conditional expression is not satisfied in the selection structure in the program when the conditional expression is not satisfied, and adds an execution clause for substituting 0 for the latest temporary variable, The language conversion apparatus according to claim 1, wherein the language conversion apparatus is added to the conversion result program. A functional language storage means for storing an array of elements of functions or operands in a program described in the functional language;
Tree structure creating means for sequentially obtaining each element of the array and generating a tree structure composed of nodes corresponding to the elements and links between the nodes;
The language conversion apparatus according to claim 1, wherein the conversion unit converts the program based on the tree structure.