JP2014059848A - Language conversion device, and program - Google Patents

Abstract

PROBLEM TO BE SOLVED: To convert a function type control language into a procedure type language and particularly to convert into adequate syntax even when conditional branch is nested.SOLUTION: A two-dimensional structure storage 13 stores a tree structure created corresponding to a function type language program. Though a unique instance name is given to a function node of the tree structure, the same instance name may be given to a plurality of nodes involved in a conditional branch. Though a command rearranging part 16 converts into a procedure type language based on the tree structure, it converts using a predetermined form for a conditional branch.

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 functional control language (FCL: Functional Control Language) representing a control program of a programmable controller (PLC) with a functional program structure is used. .

  Although FCL is described in Patent Document 1, Patent Document 2, and the like, FCL will be briefly described here. In FCL, one function is expressed by a function expression of the format shown in FIG. 10, and the function expression itself can be used as an argument of another function expression as shown in the upper part of FIG. Therefore, as shown in the upper and lower sides of FIG. 11, a two-dimensional expression (two-dimensional structure tree expression) of the language can be performed, and the descriptiveness is improved. As a result, for example, as shown in FIG. 12, it can serve as an intermediate language that connects the expression dependent part and the machine dependent part of the PLC program.

There are methods for executing operations using an instruction stack and a data stack as a functional language execution method (Patent Documents 1 and 2 and Patent Document 3).
However, in order to perform operations using the above method, a configuration of an instruction stack and a data stack is required, and it is difficult to execute with a device that does not have these configurations, or there is a problem that performance is degraded due to emulation of the above method. It was. In order to solve the problem, a method of converting a functional language into a procedural language and executing it in a procedural language (for example, C language) has been proposed (Patent Document 4).

In Patent Document 4, for example, the functional expression of the functional language shown in the upper part of FIG. 11 is arranged as shown in FIG. 13, and a two-dimensional structure (tree structure) as shown in FIG. Generate and convert to a procedural language program based on this tree structure.
The tree structure shown in FIG. 14 is created by sequentially generating each node shown in FIG. 14 from each element of this array according to the array order shown in FIG. Each node shown in FIG. 14 includes data items of “node name”, “instance name”, “pointer to child node”, and “pointer to next node”.

  “Node name” stores a function or operand stored in an element of the array. A function in the form of “open parenthesis“ (”+ arbitrary name)” is a function, and the other is an operand (excluding a closing parenthesis) (such as a variable). If the element of the array is a closing parenthesis “)”, the processing target is returned to the node of the opening parenthesis corresponding to the closing parenthesis without generating a node. “Instance name” is a node identifier in a tree structure that is given to a node other than a leaf. Note that a leaf is a node (a terminal node) having no child nodes.

  In the following description, it is assumed that each node is described using its “node name”. For example, a node whose “node name” is “(A”) is referred to as a node “(A” or the like.

  Here, a function can have another function and an operand (such as a variable) as arguments. When pointing (linking) the argument node from the function node, the pointer for linking is set in “pointer to child node”. That is, a pointer value for designating a node of the argument (any one when there is a plurality) is set in “pointer to child node” in the caller function node.

  On the other hand, for a node (a plurality of nodes) of an argument having the same caller function node, a predetermined pointer value is set in “pointer to next node”, thereby designating an argument following itself.

  In the example illustrated in FIG. 14, for example, a “pointer to a child node” in the node “(B”) stores a pointer that designates (links) a “v” node that is one of its argument nodes. Furthermore, since the arguments of the function B are v and w, the “v” node “pointer to the next node” includes a pointer that designates (links) the “w” node that is the argument node following the self node. Stored.

  Then, based on the tree structure shown in FIG. 14, the functional language program shown in the upper part of FIG. 11 is changed to a procedural language program (not shown; for the example shown in FIG. An example is shown in FIG. 15B).

  This conversion process is performed every time a “node having only a child node leaf” (referred to as a corresponding node) is found from the tree structure shown in FIG. 14 from the function of the corresponding node and the argument of the child node. Generates an assignment statement (command statement) with the instance name as the assignment destination. This is a procedural language program. Then, all child nodes of the corresponding node are deleted. This is repeated until there is one node.

Japanese Patent Laid-Open No. 01-298444 Japanese Patent Laid-Open No. 02-230426 JP-A-01-243126 JP 2012-104065 A

Here, the invention of the above-mentioned Patent Document 4 solves the above-described problems of the prior art, but has the following problems.
Since the functional language has values for all functions and functions can be described as function arguments, conditional branches (eg IF to THEN to ELSE to END_IF) are performed, and the results are further used as conditions. The description can be done easily.

  As an example, an FCL program in which conditional branches are nested (FIG. 15A) and a FCL program converted into a procedural language program by a conventional method (FIG. 15B) are shown. FIG. 15A shows a description example in the PASCAL language (assignment is indicated by “: =” and function call is indicated by “Function (a, b,...)”), But the language is limited to the PASCAL language. Do not mean.

  In FIG. 15B, funcGt, funcSub, funcIf, funcEq, funcMul are functions in the procedural language of the conversion destination corresponding to the (>, (−, (IF, (=, (* functions) of the FCL program. Etc.

  In addition, the example of FIG. 15B is composed of a command statement (assignment statement) of about 10 lines as shown. Each command statement basically has, for each transformation target node, a function related to the transformation target node, using each operand or identifier relating to each child node of the transformation target node as an argument, and This is a statement with an identifier (instance name) as the assignment destination.

  Here, in conditional branch processing, only one expression (THEN part or ELSE part) selected according to the execution condition should be executed, whereas in this conversion result, both the THEN part and the ELSE part , And the result is selected (funcIf part), and there is a problem that extra processing is executed. In addition, it is necessary to provide an extra temporary variable in order to save the execution result, and the converted program execution environment is compressed (an increase in memory usage). Actually, in FIG. 15B, 10 variables and 10 executable statements are required.

Note that the above-described problem occurs not only in the case where the conditional branch is nested (nested) but also in the case of a program including a conditional branch.
An object of the present invention is to convert a functional control language program into a procedural language program, to perform procedural instruction processing that does not wait for an instruction stack and a data stack, and in particular to a functional type having a conditional branch. For a control language program, a language conversion device, program, etc. that can convert conditional branch instructions in a functional control language into an appropriate syntax and realize efficient execution without creating extra execution or temporary variables. Is to provide.

  The language conversion device of the present invention is a language conversion device that converts a control processing program described in a functional language into a procedural language program that is a language format program that can be executed by a device that performs procedural instruction processing. Functional language storage means for storing an array of each element of the function / operand in the control processing program described in the functional language, and sequentially acquiring each element of the array, and a node corresponding to each element and the node A tree structure creating means for generating a tree structure composed of links between the nodes, a node in the tree structure comprising a leaf that is a node having no child node and a child node that is a node other than the leaf, and the tree Of each node in the structure, a unique identifier is assigned to the child node, and the child node of the node related to the conditional branch function is the same. An identifier assigning means for assigning an identifier, and means for performing conversion into the procedural language based on each node of the tree structure after the identifier is assigned, wherein the conversion target node is a node related to the conditional branch function In this case, the information processing apparatus includes conversion means for generating the procedural language program using a predetermined template related to conditional branch processing registered in advance.

  In the language conversion device configured as described above, for example, the predetermined model is an if-then-else statement, and the conversion unit converts the procedural language related to each child node of the node related to the conditional branch function. The procedural language program is generated by fitting the conversion result to the corresponding part of the predetermined template.

If the statement is an if-then-else statement, only one of either then or else is executed according to the conditional branch result, so that the above-described problem of excessive execution can be solved.
In the language conversion device having the above configuration, for example, the identifier is an assignment destination in the procedural language, and the assignment of the same identifier is performed by the identifier assigning unit, so that , The same identifier is used for the substitution destination related to else.

  Regardless of whether the above or else is executed, the variable name (identifier) that is the assignment destination is the same (common use), so there are fewer temporary variables for storing the execution result. Can solve the problem of squeezing the program execution environment.

  According to the language conversion device, program, etc. of the present invention, a functional control language program can be converted into a procedural language program, and procedural instruction processing without waiting for an instruction stack and a data stack can be performed. 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. .

It is a structure and functional block diagram of the language conversion apparatus of this example. This is an array corresponding to the FCL program example of FIG. It is an example of the two-dimensional structure (tree) produced | generated by the conventional method according to the example of FIG. It is an example of the two-dimensional structure (tree) produced | generated by this method according to the example of FIG. It is a figure which shows the example of a program conversion result by this method. It is a whole flowchart figure of the process of the language converter of this example. It is a detailed flowchart figure (the 1) of the process of the language converter of this example. It is a detailed flowchart figure (the 2) of the process of the language converter of this example. It is a detailed flowchart figure (the 3) of a process of the language converter of this example. It is a figure which shows the basic structure of a functional control language. A functional control language that expresses a two-dimensional structure. It is a figure which shows the positioning of a functional control language. It is an example of the arrangement | sequence according to the example of FIG. It is an example of the two-dimensional structure tree according to the example of FIG. 11 and FIG. (A) is an example of an FCL program in which conditional branches are nested, and (b) is an FCL program converted into a procedural language by a conventional method.

Embodiments of the present invention will be described below with reference to the drawings.
FIG. 1 is a configuration / function block diagram of the language conversion apparatus of this example.
According to the illustrated language conversion apparatus 10, a functional control language (FCL) can be converted into a procedural language (C language or the like), and procedural instruction processing that does not wait for an instruction stack and a data stack is performed. Ability to convert FCL conditional branching instructions into appropriate syntax, especially for FCL programs with conditional branching, eliminating the need for extra processing execution and creating extra temporary variables Therefore, it is possible to realize efficient execution.

  1 includes a functional language (FCL) storage unit 11, a two-dimensional structure (tree) conversion unit 12, a two-dimensional structure storage unit 13, a function name-instance name creation unit 14, an instance name. Each functional unit includes a management unit 15, an instruction rearrangement unit (conversion unit) 16, and a procedural language storage unit 17.

  The function name-instance name creation unit 14 and the instance name management unit 15 may be collectively referred to as “identifier assignment unit”. The “identifier assigning unit” assigns a unique identifier to a node other than a leaf among the nodes in the tree structure, and the child node of the node related to the conditional branch function (for example, among the child nodes). A part (for example, two of the three) is given the same identifier.

  Since the language conversion device 10 is realized by, for example, a general-purpose personal computer or server device, a general computer such as a CPU, a storage device (such as a hard disk), a memory, an input unit, a display unit, and a communication unit is not particularly illustrated. It has the configuration of the device.

  A predetermined application program is stored in advance in the storage device (not shown), and the processing functions of the various functional units are realized by the CPU reading and executing the application program. That is, a functional language (FCL) storage unit 11, a two-dimensional structure (tree) conversion unit 12, a two-dimensional structure storage unit 13, a function name-instance name creation unit 14, an instance name management unit 15, an instruction rearrangement unit 16, The procedural language storage unit 17 and the like are realized by the CPU reading and executing the application program.

  In addition, the present invention is not limited to the form of the language conversion device 10 but can be configured as the application program itself for realizing various functions by a computer or the like.

  Of these various functional units, the functional language (FCL) storage unit 11, the two-dimensional structure (tree) conversion unit 12, and the “function name-instance name creation unit” 14 are described in the above-mentioned conventional patent document 4. It may be the same as the functional language (FCL) storage device 11, the two-dimensional structure (tree) conversion unit 12, and the function name-instance name creation unit 14. The two-dimensional structure storage unit 13 may be substantially the same as the two-dimensional structure storage device 13 of Patent Document 4 in that the generated two-dimensional structure (tree structure) is stored, but the storage contents are different. . The procedural language storage unit 17 may be substantially the same as the procedural language storage device 16 of Patent Document 4 in that it stores a program converted into a procedural language, but the stored contents are different.

  From the above description, for example, the language conversion device 10 of this example includes, for example, the instance name management unit 15 added to the language conversion device of Patent Document 4 and the processing contents of the instruction rearrangement unit 16. Although it can be regarded as different, it is not limited to this example.

  The functional language (FCL) storage unit 11 stores an arbitrary program (FCL program) of the functional language, and further arranges each element such as an instruction (function) / operand (variable etc.) of the FCL program. As stored. Here, if the example shown in FIG. 15A is used as an example of the FCL program, the arrangement corresponding to this program example is as shown in FIG. Such array generation itself has been conventionally performed as shown in FIG. 13, for example, and is not particularly described here.

  The two-dimensional structure (tree) conversion unit 12 and the “function name-instance name creation unit” 14 may be existing functions as described above, and the two-dimensional structure (tree) conversion unit 12 may include the functional language (FCL). ) Based on the above array stored in the storage unit 11, the FCL program is expressed in a two-dimensional structure (tree structure) representation as shown in FIG. 14 (in a link structure having a double parent-child relationship). Is).

  Further, the “function name-instance name creation unit” 14 has a unique node identifier (this example) in the tree with respect to a node (referred to as a child node) other than the terminal part (leaf) of the tree structure. In this example, the instance name is not limited to this example.

  For the example shown in FIG. 2, the tree structure shown in FIG. 3 is generated in the case of the conventional method of Patent Document 4. However, in this example, the instance name management unit 15 may further assign the same instance name to a plurality of nodes. As a result, the two-dimensional structure storage unit 13 generates the tree structure shown in FIG. Will be stored. As described above, a leaf is a node having no child node (terminal node).

  The tree structure is created by sequentially reading each element (function, operand, etc.) of the array to generate a node corresponding to each element and generating a link (pointer, etc.) between the nodes ( For details, refer to Patent Document 4 and the like; the process of S7 and the process of S8 in FIG. 5 in Patent Document 4 may be reversed).

  Here, “a pointer to a child node” and “a pointer to the next node” in a node will be briefly described. First of all, for the elements that start with “(” (such as “IF”), the argument is up to the closing parenthesis “)”, so the closing parenthesis “)” The node related to the next element is “next node”. Further, all the nodes as arguments are child nodes, but only the first node is pointed (linked) by the “pointer to child node”.

  On the other hand, for a node of an element without an opening parenthesis “(” or closing parenthesis “)” (that is, for an operand node), there is no child node. Therefore, NULL is always set for the “pointer to child node”.

In this description, a node corresponding to a function is sometimes called a function node, and a node corresponding to an operand (such as a variable) is sometimes called a variable node.
As apparent from a comparison between FIG. 3 and FIG. 4, the difference between the two is the instance name. That is, as shown in FIG. 3 (and as described in Patent Document 4), the instance name is conventionally unique, and therefore, the same instance name is not assigned to a plurality of nodes. . On the other hand, as shown in FIG. 4, in this example, the same instance name may be given to a plurality of nodes.

  For example, in FIG.3, the instance names of two nodes having a node name "(-") near the center in the figure are "INST_5" on one side and "INST_6" on the other side. The instance names of these two nodes in FIG. 4 are both “INST_5”.

  This is because the instance name management unit 15 assigns the same instance name to a plurality of nodes corresponding to a predetermined condition (for example, in the case of conditional branching (IF etc.) during instance name assignment processing). When a node related to a function is detected, the same instance name may be given to two of the child nodes). For example, when there is a function node of a conditional branch function (IF or the like), the instance name management unit 15 has, for example, the same for the second node and the third node of the child nodes. Give the instance name.

  In order to represent the data having the two-dimensional structure as described above, a text data structure described in XML (Extensible Markup Language), which is only this data structure, may be used. With XML, it is easy to create operation means such as addition / deletion / search for tree structure data.

  The instruction rearrangement unit 16 may basically perform substantially the same processing as the instruction rearrangement unit 15 of Patent Document 4, but further performs processing described later regarding conditional branching. Thereby, for example, the program shown in FIG. 5 is generated. Details will be described later.

The procedural language storage unit 17 stores a procedural language program (for example, one shown in FIG. 5) generated by the instruction rearranging unit 16.
Hereinafter, the various functional units described above will be described in more detail with reference to specific examples.

  First, the two-dimensional structure (tree structure) generation processing by the two-dimensional structure (tree) conversion unit 12 and the function name-instance name creation unit 14 will be described below. Since these may be existing technologies as described above, they will be briefly described. As a specific example, the above-described program example shown in FIG.

  As already described, as in the case of Patent Document 4, the two-dimensional structure (tree) conversion unit 12 starts from a program stored in the functional language (FCL) storage unit 11 (referred to as an FCL program). Generate a structure. For example, the contents (array) of the FCL program are directly tree-structured. At this time, for example, the function part is a parent node (node) and the argument part is a child node. For example, in the case of the FCL program example shown in FIG. 15A, first, the array shown in FIG. 2 is generated, and the tree structure shown in FIG. 3 is generated based on this array.

Such tree structure generation processing is described in Patent Document 4, but will be briefly described below.
The two-dimensional structure (tree) conversion unit 12 sequentially reads each element of the array (in this example, the FCL code) stored in the functional language (FCL) storage unit 11 to generate the tree structure (however, There is no instance name yet). For example, as described in Patent Document 4, this processing is performed based on a function starter (open parenthesis “(”), function end child (close parenthesis “)”), operand (other than parentheses), etc. Can be realized.

  That is, the root node (the highest element: a dummy node for recursively executing the process) is first created and recorded as “currently processing node”. Then, the FCL code of the array is read sequentially. Basically, if it is a function or an operand (in other words, other than a closing parenthesis), a corresponding node is newly generated, and this A link (pointer) between the new node and the “currently processing node” at that time is generated. This is linked by “pointer to child node” or “pointer to next node”. Then, the new node is set as a new “currently processing node”.

  In other words, if the element (FCL code, etc.) acquired from the array is an arbitrary function, a node with the name of the function as “node name” is newly created, and the new node is pointed from the currently processing node. Is set to either “pointer to child node” or “pointer to next node” in the current processing node, and the new node is set as the new current processing node.

  If the element acquired from the array is an arbitrary operand, a new node having the name of the operand as “node name” is newly created, and a pointer pointing to the new node from the currently processing node is It is set to either “pointer to child node” or “pointer to next node” in the currently processing node, and further invalidates “pointer to child node” in the new node. Is the new currently processed node.

  When the FCL code read from the array is the closing parenthesis, the node is not created as described above, and in this case, the “currently processing node” is set to the opening parenthesis ( Set to the node of (function).

  The pointer from the “currently processing node” to the new node is stored in either the “pointer to the child node” or the “pointer to the next node” in the “currently processing node”. For example, as described in Patent Document 4, NULL is always stored in the “pointer to child node” of the variable node. Therefore, when the “currently processing node” is a variable node, the pointer to the new node is always stored in the “pointer to the next node”.

  On the other hand, if the “currently processing node” is a variable node, the pointer to this new node is stored in “pointer to child node” for the first new node, and there is a second new node. Stores a pointer to this new node in “pointer to next node”. In other words, if the pointer has already been set in the “pointer to child node”, the pointer to the new node is set in “pointer to next node”; otherwise, the new node is set in “pointer to child node”. Set a pointer to.

  Note that the node indicated by the “pointer to child node” is literally the child node of the node. The node indicated by “pointer to next node” is another node having the same parent node as that node. For example, the parent nodes of three nodes whose instance names are INST_4, INST_5, and INST_6 shown in FIG. 3 are all the same (all of the nodes of INST_3 are parent nodes).

  For example, in FIG. 3, when the “(>” node (INST_4) shown in the middle in the figure is the “currently processing node”, the “a” node shown on the right side of the figure is created as a new node. As a result, the pointer to the node “a” is stored in the “pointer to the child node” of the node “>” (in the drawing, such a pointer is indicated by an arrow). Since the node “a” is a variable node, NULL is stored in the “pointer to child node”.

  Next, the node “a” becomes a new “currently processing node”, and the node “b” on the right side is created as a new node, thereby the “currently processing node” (the node “a”). In “Pointer to next node”, a pointer linked to the node of “b” is stored. Since the node “b” is a variable node, NULL is stored in the “pointer to child node”.

  Since the next read FCL code is a closing parenthesis “)”, NULL is stored in “pointer to next node” of “currently processing node” (node “b”) and this closing The opening parenthesis “(” (“(>” node (INST_4)) corresponding to the parenthesis “)” (in other words, the parent node of “currently processing node”) is the new “currently processing node” "

  In this state, since the FCL code to be read next is “(−”, a “(−” node (INST_5) shown in the figure is newly created and a “currently processing node” (“(>” node) ) Is stored in the “pointer to the next node”, and the “(−” node is the new “currently processing node”. It becomes.

Other nodes are also created in substantially the same way as in the above example, whereby the tree structure shown in FIG. 3 is generated for the arrangement of FIG. 2 in the case of the conventional method.
In addition, although the example of the setting method of NULL was mentioned above, since the other example is described in patent document 4, it abbreviate | omits here. In FIG. 3 and FIG. 4, diagonal lines mean NULL. Thus, for example, in the case of the node “b” shown in the upper right corner of the figure, NULL is set in the three items “instance name”, “pointer to child node”, and “pointer to next node”. Will be.

  The “function name-instance name creation unit” 14 assigns a unique node identifier (instance name in this example) in the tree to a node other than the terminal part (leaf) of the tree structure. Leave is left as it is a concrete variable operand.

  In other words, the “function name-instance name creation unit” 14 sequentially generates and assigns unique (non-overlapping) names / symbols / numbers to the function nodes. In this example, a serial number prefixed with “INST_” is assigned. The allocation order is the appearance order of function nodes. In other words, when only “function name-instance name creation unit” 14 is used, different instance names are assigned to all nodes, and the same instance name is not assigned to a plurality of nodes. .

  Here, in the instance name allocation process by the “function name-instance name creation unit” 14, if there are a plurality of nodes that satisfy a predetermined condition by the instance name management unit 15, the plurality of nodes Assign the same instance name to.

  The predetermined condition is that a parent node is a node that is a conditional branch, in other words, a child node of the conditional branch node. In addition to the first condition, there are further conditions, which will be described later.

  In other words, when the function described in the node is a conditional branch or the like (when it is a function for a syntax having no value), the instance name management unit 15 executes the same instance for the content to be branched and executed. The instance name is managed so as to be assigned (since only one of them is executed depending on the condition, the execution result is stored in the same instance variable regardless of the condition).

  The instruction rearrangement unit 16 sequentially traces the tree structure stored in the two-dimensional structure storage unit 13 in the direction from the beginning to the end, and searches for a node having only a leaf as a child node. As a result of this search, every time a node whose child node only has a leaf is detected, the function described in the node is called for the node whose child node only has a leaf, and an assignment statement that assigns the value of that function Is created as the instance name of the node (referred to as an instance variable) and stored in the procedural language storage unit 17. Then, all child nodes of the nodes stored in the procedural language storage unit 17 by the above processing are deleted. These processes are repeatedly executed until the number of nodes on the tree structure becomes one.

  Using the tree structure generated from the array of each element of the functional language instruction (function) / variable (operand), the instruction reordering unit allows the nested child function to precede the parent function in the instruction execution order. The parent function is executed by using an operand (a variable with an instance name) substituted with the execution result of the child function.

  By such rearrangement, it is possible to execute the functional control language in a device that does not have an instruction stack and a data stack (for example, a device that executes procedural instruction processing).

  However, the processing of the instruction rearrangement unit 16 may be regarded as a processing function substantially similar to the instruction rearrangement unit 15 in Patent Document 4. In the instruction rearrangement unit 16 of this example, when a conditional branch function node is detected, the FCL conditional branch instruction is converted into an appropriate conditional branch in the procedural language of the conversion destination by performing the processing described later. It can be converted into syntax.

  In general, the procedural language of the conversion destination has an appropriate conditional branch syntax, and if the FCL conditional branch instruction can be converted into an appropriate syntax, it is efficient without executing extra processing and creating temporary variables. Execution is possible.

  As described above, the instruction rearrangement unit 16 sequentially traverses the tree structure, and whenever it finds a node having only a leaf as a child node (to be converted), it converts to a procedural language program and is necessary. In response to this, the conversion result is stored in the procedural language storage unit 17.

  This conversion is basically performed in the same manner as in the above-mentioned Patent Document 4, such as a function call described in the conversion target node (a function to be converted corresponding to the described function, an argument described in the child node, etc. ) And the resulting assignment statement. The substitution destination is the instance name of the conversion target node (the instance variable is the substitution destination).

  However, in the case of this method, when the function described in the conversion target node is a conditional branch, it is converted into a corresponding procedural language conditional branch syntax instead of an assignment statement. This will be described in detail later.

  Through the various processes described above, the nested child functions are rearranged before the parent function, and after execution of the child function, the parent function is executed using this execution result, so there is no instruction stack and data stack. Is converted into a format that can be executed without any problem (this is substantially the same as Patent Document 4).

  In addition to this, in this method, the part whose execution is controlled by the conditional branch function is converted into the corresponding procedural language conditional branch syntax. In particular, only one process is performed according to the result of the conditional branch. Since the format is executed, useless processing is not performed. Furthermore, as described above, the number of instance variables can be reduced by giving the same instance name to the child node related to the conditional branch function.

6 to 9 show process flowcharts of the language conversion apparatus 10 of this example.
FIG. 6 is an overall flowchart, and FIGS. 7 to 9 are detailed flowcharts of each process of FIG.

  In FIG. 6, first, the two-dimensional structure (tree) conversion unit 12 converts the FCL program stored in the functional language storage unit 11 into a two-dimensional structure (tree structure) by the existing processing as described above. (Step S1).

  A unique node identifier (instance name in this example) in the tree is assigned by the function name-instance name creation unit 14 to each node (excluding leaves) of this tree structure. However, at that time, the instance name management unit 15 may assign the same instance name to a plurality of nodes (step S2). Details of the processing in step S2 are shown in FIG. 7 and will be described later.

The created tree structure is stored in the two-dimensional structure storage unit 13.
Then, a scanning position (for example, a pointer indicating the “currently processing node”) is set at the top node of the tree structure (step S3). Then, while sequentially moving the scanning position toward the end (changing the “currently processing node”), a node whose child node is only a leaf is searched (step S4). Details of the processing in step S4 are shown in FIG. 8 and will be described later.

  The node found in step S4 (conversion target node) is converted into a procedural language (step S5). Details of the processing in step S5 are shown in FIG. 9 and will be described later.

  Then, all child nodes (leafs) of the conversion target node are deleted (step S6). If the deletion results in a state where there is only one node on the tree structure (step S7, YES), this processing ends. On the other hand, if two or more nodes still remain (step S7, NO), the scanning position is set to the parent node of the conversion target node (the parent node is set as a new “currently processing node”). (Step S8) The process returns to step S4.

FIG. 7 is a detailed flowchart of the instance name assignment process in step S2.
In the processing of FIG. 7, each node is sequentially designated as “currently processed node” from the top of the tree structure, and the current “currently processed node” is a node related to a conditional branch function (here, “(IF”)). In this case (step S21, YES), the number of child nodes of this node is counted (step S22), and it is determined whether or not there are two child nodes (step S23).

  Here, if the function of the “currently processing node” is not a conditional branch (step S21, NO), or if it is a conditional branch but there are two child nodes (steps S21 and S23 are YES), the above patent is issued. A unique (different) instance name is given to each child node by a conventional method as in Reference 4 (of course, as in the conventional method, when a child node is a leaf, no instance name is given) ( Step S25).

  On the other hand, when the function of “currently processing node” is a conditional branch (step S21, YES) and the number of child nodes is not two (step S23, NO), this is basically a child node. It is assumed that there are three, and for the first and second of the three child nodes, unique (different) instance names are assigned by the above conventional method (of course, it is not given in the case of a leaf) . Furthermore, the same instance name as the second child node is assigned to the third child node (step S24).

  When the node with instance name = “INST_3” in the example shown in FIG. 4 is “currently processing node” by the above processing, for example, there are three child nodes (the node names are “(>” and “(− "" And "(-"), so the determination in step S23 is NO, and since these three nodes are not leaves, the first node ("(" ( > ”Node) and the second node (first“ (− ”node) are assigned unique instance names (“ INST_4 ”and“ INST_5 ”respectively). The third node (second “(−” node) is assigned the same instance name (= “INST_5”) as the second node.

  As a result, as shown in FIG. 4, the instance name of the third node is different from the conventional example shown in FIG. Accordingly, the instance name assignment to the subsequent nodes is also different from that in FIG. 3 (since the numerical value is incremented by one).

FIG. 8 is a detailed flowchart of the process of “searching for a node having only a leaf as a child node” in step S4.
In the process of FIG. 8, the scan position is the first child node (the node indicated by the “pointer to the child node”) of the “currently processed node” for the node that currently has the scan position (“currently processed node”). (That is, the first child node is set as a new “currently processing node”) (step S41), and the processing from step S42 onward is repeated.

  That is, first, it is determined whether or not the current “currently processing node” (as described above, the first child node is currently “currently processing node”) is a leaf (step S42). If it is not a leaf (step S42, NO), the scanning position is moved to the first child node of this “currently processed node” (the node indicated by “pointer to child node”) (new “current” ("Processing node") (step S46), the process returns to step S42.

  In this way, the scanning position is sequentially moved toward the end of the tree until a leaf is found. When a leaf is found (YES in step S42), this is the last node (the current “currently processing node”). It is determined whether or not (the node whose “pointer to the next node” is NULL) (step S43). If it is not the last node (step S43, NO), the current “currently processing” The scanning position is moved to the node indicated by the “pointer to the next node” in the “node” (step S44, returning to step S42).

  If the determination at step S42 is not NO during the process and the scanning position is at the last node (step S43, YES), the parent node of the current “currently processing node” is the child. Since all the nodes are leaves, the parent node of the current “currently processed node” is returned as a search result (that is, the conversion target node) (step S45), and this process is terminated.

In step S5, processing is executed using the search result returned in step S45.
FIG. 9 is a detailed flowchart of the “convert searched node position to procedural language” process in step S5.

  The process of FIG. 9 is a process of converting to a procedural language based on each node of the tree structure after giving the identifier (instance name), and in particular, the conversion target node is related to a conditional branch function. In the case of a node, this is a process for generating a procedural language program using a predetermined template registered in advance.

  The predetermined template is, for example, an if-then-else statement. Then, the result of conversion into the procedural language related to each child node of the node related to the conditional branch function (temporarily stored) is converted into the corresponding part of the predetermined template ("condition part" and " The procedural language program is generated by fitting to the “then part”. A detailed example is shown in FIG. 9 and the following description.

  The processing in FIG. 9 determines whether the “node name” of the conversion target node is “(IF)” for the conversion target node (a node whose child node is only a leaf) searched in step S4. (Step S51) That is, it is determined whether or not the function node is a conditional branch.

  When the target node is not “(IF)” (step S51, NO), the same conversion processing as in the past (Patent Document 4, etc.) is performed (step S55), which is described with reference to FIG. As described above, for example, basically, for each transformation target node, for each transformation target node, each transformation target node is used as an argument by using each operand or identifier relating to each child node of the transformation target node. A command statement (assignment statement) is generated with the identifier (instance name) of the target node as the assignment destination.

  However, in this example, the conversion process is performed, but the conversion result is not temporarily output to the procedural language storage unit 17 but temporarily stored. When step S51 becomes YES, an appropriate conditional branch process of the procedural language is generated by fitting the temporarily stored conversion process result to the predetermined template (step S52). The generation result is output to the procedural language storage unit 17 and all the temporarily stored conversion processing results are deleted. However, if the process ends without YES at step S51, all the conversion processing results temporarily stored are output to the procedural language storage unit 17 before the end.

  In the case of the example of FIG. 4, first, three lines from the top to the third line shown in FIG. 15B (however, the third line becomes INST6 → INST5) are temporarily converted as the conversion processing result. Will be remembered. Note that, as described above, funcGT and the like shown in FIG. 15 (b) represent functions of the language of the conversion destination for convenience. Actually, for example, funcGT (a, b) is, for example, “a> b”, It is assumed that funcSub (a, b) is, for example, “ab”.

  According to the conventional conversion process, all the child nodes (leafs) of the conversion target node at that time are deleted. Therefore, after the conversion process for the three rows, the node whose instance name is INST_3 shown in FIG. It becomes a conversion object node, and determination of step S51 will be YES.

  In this case, the temporarily stored conversion result related to the first child node of the conversion target node (that is, the first recorded conversion result) is used as the “condition part” and the temporary data related to the second child node. Stored conversion results (that is, the second recorded conversion result) are set as “then parts”, and these are applied to the following first template registered in advance (processing in step S52). .

“If (condition part) {
the then part;
}
As a result, in the case of the above example, the following conversion result is obtained and output to the procedural language storage unit 17 for writing. The conversion result temporarily stored is deleted when it is output to the procedural language storage unit 17.

“If (a> b) {
INST_5: = a−b
}
If there is no third child node in the conversion target node (step S53, NO), the process is terminated as it is (however, if there is an unprocessed part, the process returns to step S51).

  On the other hand, when there is a third child node in the conversion target node (step S53, YES), the temporarily stored conversion result relating to the third child node is set as “contents of child node”. Is applied to the following second template registered in advance (step S54).

"Else {
Content of child node}
As a result, in the case of the above example, the following conversion result is obtained and output to the procedural language storage unit 17 for writing.

"Else {
INST_5: = ba
}
In the processes of steps S52 and S54, immediately after any conversion result is applied to the template, the next conversion result is also referred to, and the conversion result applied to the template is added to the next conversion result. When the instance name of the assignment destination is included, the next conversion result may be further output to and written in the secondary language storage unit 17.

For example, the second “(IF” is detected in the process of step S51 of FIG. 9, and “INST_5 = 10”, which is the conversion result relating to the first child node, is output as the “condition part”. As a result, if (INST_5 = 10) in the example shown in FIG.
In this case, with reference to “INST_7: = a * a”, which is the conversion result relating to the second child node, whether or not INST_5 is included is determined. judge. In this case, nothing is done because it is not included.

Then, “INST — 7: = a * a”, which is the conversion result relating to the second child node, is output as the “then part”, thereby allowing the example shown in FIG.
INST_7: = a * a;
In this case, with reference to “INST_6: = (c: = INST_7)” which is the next conversion result, it is determined whether or not the above INST_7 is included in this. . Since this case is included, “INST_6: = (c: = INST_7)” is further output.

Thus, in this case, if (INST_5 = 10) {in the example shown in FIG.
INST_7: = a * a;
INST_6: = (c: = INST_7);
Will be generated.

The same applies to the processing in step S54. As a result, as shown in FIG. 5, two conversion results are output for else.
In this case, in the case of “if the conversion target node has a third child node (step S53, YES)” in step S53, for example, the conversion result relating to the nth child node has been output so far. In this case, it is replaced with “if the conversion target node has the (n + 1) th child node (step S53, YES)”.

  As for the conversion of the program in FIG. 15 (a), if it can be converted into a syntax using a conditional branch of a procedural language as shown in FIG. 5, the number of variables may be three (INST5, INST6, INST7) and executed at the time of program execution. This is efficient because it requires only five executable statements enclosed in a frame (actually, another part may be executed depending on the result of conditional branching).

  Of course, in the present invention, similar to the invention of Patent Document 4, the program contents described in the functional control language are rearranged, and a means for generating and managing a temporary variable required by the rearrangement is provided. Also, it is possible to obtain the effect that the function-type control language can be executed by a device that performs procedural instruction processing that does not wait for the instruction stack and the data stack (device constituted by assignment and processing call).

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 Function name-instance name creation part 15 Instance name management part 16 Instruction rearrangement part 17 Procedural language Storage

Claims (8)

In a language conversion device that converts a control processing program described in a functional language into a procedural language program that is a program in a language format that can be executed by a device that performs procedural instruction processing.
A functional language storage means for storing an array of elements of functions or operands in the control processing program described in the functional language;
Tree structure creation 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;
A node in the tree structure is composed of a leaf that is a node having no child node and a child node that is a node other than the leaf, and assigns a unique identifier to the child node among the nodes in the tree structure. In addition, identifier assigning means for assigning the same identifier to the child nodes of the node related to the conditional branch function;
A means for performing conversion to the procedural language based on each node of the tree structure after giving the identifier, and when the conversion target node is a node related to the conditional branch function, it is registered in advance. Conversion means for generating the procedural language program using a predetermined template related to conditional branching processing,
A language conversion apparatus comprising: The predetermined template is an if-then-else statement,
The conversion means generates the procedural language program by applying the conversion result to the procedural language related to each child node of the node related to the conditional branch function to the corresponding part of the predetermined template. The language conversion apparatus according to claim 1, wherein the language conversion apparatus performs the conversion. The identifier is an assignment destination in the procedural language,
The same identifier is used for the substitution destination related to the tenth and the substitution destination related to the else when the same identifier is given by the identifier giving means. Item 3. The language conversion device according to Item 2.   4. The identifier assigning unit assigns the same identifier to a second and a third node among a plurality of child nodes of a node related to the conditional branch function. The language converter described in 1. The converting means includes
The node whose child node is only the leaf is the conversion target node,
When the conversion target node is a node other than the node related to the conditional branch function, the operand or the identifier related to the child node of the conversion target node is used as an argument for the function related to the conversion target node. , Generating a command sentence with the identifier of the conversion target node as a substitution destination and temporarily storing it, and deleting all the child nodes of the conversion target node to make the conversion target node the leaf 3. The language conversion device according to claim 2, wherein   The converting means applies each temporarily stored statement to the corresponding part of the predetermined template as a conversion result to the procedural language related to each child node of the node related to the conditional branch function. 6. The language conversion device according to claim 5, wherein the language conversion device is adapted to be fitted and to erase all the temporarily stored command statements. The node has each item of a node name, an identifier, a pointer to a child node, and a pointer to a next node that points to another node having the same parent node,
The tree structure creating means includes:
When the element acquired from the array is an arbitrary function, a node having the name of the function as the node name is newly created, and a pointer pointing to the newly created node from the currently processed node is set to the current Set to either the pointer to the child node or the pointer to the next node in the processing node, and the newly created node is the new current processing node,
If the element acquired from the array is an arbitrary operand, a node having the name of the operand as the node name is newly created, and a pointer pointing to the newly created node from the currently processed node is The pointer is set to either the pointer to the child node or the pointer to the next node in the currently processing node, and the pointer to the child node in the newly created node is invalidated. The current processing node,
If the element acquired from the array is a function terminator, the pointer to the next node in the current processing node at that time is invalidated, and a node already created for the function corresponding to the function terminator The language conversion device according to claim 1, wherein the language conversion device is a new current processing node. A computer of a language conversion device that converts a control processing program described in a functional language into a procedural language program that is a language format program executable by a device that performs procedural instruction processing.
A functional language storage means for storing an array of elements of functions or operands in the control processing program described in the functional language;
Tree structure creation 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;
A node in the tree structure is composed of a leaf that is a node having no child node and a child node that is a node other than the leaf, and assigns a unique identifier to the child node among the nodes in the tree structure. In addition, identifier assigning means for assigning the same identifier to the child nodes of the node related to the conditional branch function;
A means for performing conversion to the procedural language based on each node of the tree structure after giving the identifier, and when the conversion target node is a node related to the conditional branch function, it is registered in advance. Conversion means for generating the procedural language program using a predetermined template,
Program to function as.