JP5541102B2 - Language conversion device and language conversion program - Google Patents

Description

  The present invention relates to a language conversion device and a language conversion program for converting 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 (hereinafter simply referred to as “PLC”) 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. 7, for example, an expression dependent part (mnemonic description, ladder diagram, function block diagram, SFC diagram (Sequential Function Chart), decision table, Etc.) and a machine dependent part as a machine language, there is a functional control language (hereinafter referred to as “FCL”) as an intermediate language.

  The FCL is a language that expresses a sequence control program with a functional program structure. In the FCL, as shown in FIG. 8, one function is represented by a function formula F having arguments Ar1, Ar2, Ar3,. Another function expression can be used as an argument of the function expression F. Therefore, the relationship between a certain function expression and an argument (including the function expression) of the certain function expression can be expressed two-dimensionally as a tree structure (functional structure).

For example, in FIG. 9, function A has function B and function C as arguments, function B has arguments v and w, function C has arguments x and D, and function D has arguments y and z. In other words, a two-dimensional structure for the following equation is expressed.
(A (B v w) (C x (D y z)))
For example, Patent Documents 1 and 2 show a method of executing an operation using an instruction stack and a data stack as a functional language execution method.

  In the case of a method of executing an operation using this instruction stack and data stack, naturally, means such as an instruction stack and a data stack are necessary, and a device without such means (for example, executing procedural instruction processing) However, it is difficult to execute the method, or the processing performance deteriorates due to emulation of the method.

JP-A-2-230426 JP-A-1-243126

  The present invention provides a language conversion device and a language conversion program that can execute a 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). For the purpose.

  The proposed language conversion device converts a control processing program described in a functional language into a language format that can be executed by a device that performs procedural instruction processing. This language conversion apparatus acquires a functional language storage unit storing an array of elements of instruction / variable operands of a functional language, and obtains each element of the array, creates a tree structure using each element as a node, A tree structure creation unit that outputs to the structure storage unit, an instance name assignment unit that assigns instance names to nodes other than leaves that are nodes that do not have child nodes in the tree structure, and a tree structure that is assigned the instance name On the other hand, a node whose child node has only a leaf is found, a function described in the node is called, an assignment statement as a result of the call is created, and an assignment destination is created as an instance name given to the node. An assignment statement creation unit that outputs to the procedural language storage unit that stores the instruction group of the node and a child node of the node that is output to the procedural language storage unit. The hand has a deletion section to be deleted from the tree structure, until the tree structure is one node, but repeating the assignment statement creation processing and the deletion processing.

  According to the proposed language conversion device, using a tree structure generated from an array of each element of a functional language instruction / variable operand, a nested child function is preceded by a 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).

It is a block diagram which shows the structure of the language converter which concerns on one Embodiment of this invention. It is the figure which showed an example of the arrangement | sequence corresponding to the expression of FCL stored in a functional language (FCL) storage device. It is the figure which showed an example of the tree structure stored in a two-dimensional structure storage apparatus. It is the figure which showed an example of the instruction group of the procedural language stored in the procedural language storage device. It is a flowchart of the process which produces a tree structure from the content of the array memorize | stored in the functional language (FCL) storage device. It is a flowchart of the language conversion process of this embodiment. It is a figure which shows the positioning of a functional control language. It is a figure which shows the basic structure of a functional control language. It is a figure expressing an example of the two-dimensional functional structure of a functional control language.

Hereinafter, embodiments of the present invention will be described in detail with reference to the drawings.
FIG. 1 is a block diagram showing a configuration of a language conversion apparatus according to an embodiment of the present invention. For example, each block in the figure is realized as hardware or software.

  As shown in FIG. 1, the language conversion device includes a functional language (FCL) storage device 11, a two-dimensional structure (tree) conversion unit 12, a two-dimensional structure storage device 13, and a function name-instance name creation unit 14. And an instruction rearrangement unit 15 and a procedural language storage device 16.

The functional language (FCL) storage device 11 is a memory that stores FCL instructions and variable operands as an array.
For example, an array as shown in FIG. 2 is stored in the functional language (FCL) storage device 11 for the following expression of FCL.
(A (B v w) (C x (D y z)))
In the above equation, A, B, C, and D are functions, and v, w, x, y, and z are arguments. As shown in FIG. 2, the variable indicating the function is stored in the array element of the functional language (FCL) storage device 11 together with the opening parenthesis “(”. The function terminator is the closing parenthesis “). ", The argument (operand) is stored in the array element as it is.

  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”).

  As shown in FIG. 3, each node has items of a node name, an instance name, a pointer to a child node, and a pointer to the next node. One function can take other functions and variable operands as arguments. When pointing the argument from the caller function, set a value to "pointer to child node". On the other hand, between the arguments with the same caller function, the argument following itself is specified by setting a value to “pointer to next node”.

  The two-dimensional structure (tree) conversion unit 12 sets a function part as a parent node and an argument part as a child node when forming a tree structure. The processing result of the two-dimensional structure (tree) conversion unit 12 is output to the two-dimensional structure storage device 13.

  The function name-instance name creation unit 14 refers to the stored contents of the two-dimensional structure storage device 13 and refers to the end of the tree structure (ie, a node having no child nodes, hereinafter referred to as “leaf”). A unique name in the tree (hereinafter referred to as “instance name”) is assigned to a node other than After this process, only the leaf instance name is blank.

  FIG. 3 shows an example of a tree structure stored in the two-dimensional structure storage device. In FIG. 3, the instance name is in the form of “INST _” + “number (assigned by automatic numbering)”, but the instance name can be given by any method that can identify each function. Further, 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 instruction rearrangement unit 15 sequentially searches the tree structure stored in the two-dimensional structure storage device 13 in the direction toward the end, finds a node whose child node has only a leaf, Is called, and an assignment statement for assigning the value of the function is created and stored in the procedural language storage device 16. The assignment destination is the instance name of the node.

  Subsequently, the instruction rearrangement unit 15 deletes all child nodes of the nodes stored in the procedural language storage device 16 by the above processing. Then, the process returns to the highest parent node and the same processing is repeated. This process is performed until the number of nodes on the tree structure becomes one.

  Through the above operations by the instruction rearrangement unit 15, the nested child functions are rearranged before the parent function in the instruction execution order, and the parent function is an operand (instance name is assigned to the execution result of the child function). It is executed using the attached variable).

  FIG. 4 shows an example of a procedural language instruction group stored in the procedural language storage device 16. FIG. 4 shows the case of the PASCAL language as an instruction that can be executed by a device that performs procedural instruction processing. In this language, substitution is represented by “: =”, and function call is represented by “function name (argument 1, argument 2,...)”.

  FIG. 5 is a flowchart of a process for creating a tree structure from the contents of the array stored in the functional language (FCL) storage device 11. The processing of this flowchart is executed by the two-dimensional structure (tree) conversion unit 12.

  In step S1 of FIG. 5, a root node (highest element: a dummy node for recursively executing the process) is generated, and the root node is set as a currently processing node. That is, the address of the root node is set in the currently processed node pointer.

In subsequent step S2, data is read from the current position of the array stored in the functional language (FCL) storage device 11. In step S3, the type of data is determined.
If the read data (element of the array) is in the form of open parenthesis “(” + “character (string)”, it is determined in step S3 that the data is a function. In S4, a new node is created in which the name of the function (“character (string)”) is set as the node name, and the process proceeds to step S7.

  If the read data (array element) is in the form of “character (string)”, it is determined in step S3 that the data is an operand. In this case, in step S5, a new node is created with the name of the operand ("character (string)") set as the node name. In step S6, a pointer to the child node of the newly created node is set to "NULL". "Is set, and the process proceeds to step S7.

In step S7 to which control is passed from step S4 or step S6, the newly created node is set as the currently processing node.
In step S8 following step S7, a process for setting a pointer to the next node or child node for the newly created node is executed.

  That is, when the currently processed node corresponds to a function and the newly created node corresponds to a function, “NULL” is set to the pointer to the next node of the newly created node, and the current process is performed. When the middle node corresponds to the operand and the newly created node corresponds to the operand, “NULL” is set to the pointer to the next node of the newly created node, and the currently processed node is the operand. If the newly created node corresponds to a function and the pointer to the next node of the newly created node is set to “NULL”, the currently processed node corresponds to the function. And the newly created node corresponds to the operand, the pointer to the child node of the newly created node is “N The process of setting the LL "is executed. Then, the process returns to step S2, and the next data (array element) reading process is executed.

  On the other hand, if the data (element of the array) read in step S2 is in the form of a closing parenthesis “)”, it is determined in step S3 that the data is a function terminator. In this case, in step S9, "NULL" is set to the pointer to the next node of the current processing node at that time, and in the subsequent step S10, the node of the finished function is set as the current processing node. Then, the process returns to step S2, and the next data (array element) reading process is executed.

FIG. 6 is a flowchart of language conversion processing according to this embodiment. This flowchart is executed by each block of the language conversion apparatus of FIG.
Prior to this processing, it is assumed that FCL instruction / variable operands are stored in advance in the functional language (FCL) storage device 11 as an array.

  In step S21 of FIG. 6, the contents of the array stored in the functional language (FCL) storage device 11 are made into a tree structure by using each element of the array as a node by the two-dimensional structure (tree) conversion unit 12. . The details are as shown in the flowchart of FIG. The processing result (tree structure) by the two-dimensional structure (tree) conversion unit 12 is stored in the two-dimensional structure storage device 13.

  In step S22, the function name-instance name creation unit 14 refers to the stored contents of the two-dimensional structure storage device 13 and assigns instance names to nodes other than the leaves of the tree structure.

  In step S23 subsequent to step S22, the node total count processing is performed by a node total count section (not shown). This is a process of counting the total number of nodes at that point in the tree structure.

In subsequent step S24, it is determined whether or not the total number of nodes counted in step S23 is equal to "1".
If it is determined in step S24 that the total number of nodes is equal to “1”, the series of processing ends.

  When it is determined in step S24 that the total number of nodes is not equal to “1”, in step S25, the instruction rearrangement unit 15 traces the tree structure stored in the two-dimensional structure storage device 13 in the direction toward the end. Thus, a node having only a leaf as a child node is searched. As a result of this search, a node whose child node only has a leaf is found, and for the node whose child node only has a leaf, the function described in the node is called, and an assignment statement that assigns the value of that function is assigned The destination is created as the instance name of the node and stored in the procedural language storage device 16.

  In step S26, the instruction rearrangement unit 15 deletes all child nodes of the nodes stored in the procedural language storage device 16 by the above processing. And it returns to step S23 and repeats the same process. This process is performed until the number of nodes on the tree structure becomes one.

  Using the tree structure generated from the array of each element of the instruction / variable operand in the functional language, the above operation by the instruction rearrangement unit 15 is performed before the nested child function precedes the parent function in the instruction execution order. The parent function is executed using an operand (a variable with an instance name) to which the execution result of the child function is assigned.

  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).

DESCRIPTION OF SYMBOLS 11 Functional language (FCL) storage device 12 Two-dimensional structure (tree) conversion unit 13 Two-dimensional structure storage device 14 Function name-instance name creation unit 15 Instruction rearrangement unit 16 Procedural language storage device

Claims (6)

In a language conversion device that converts a control processing program described in a functional language into a language format executable by a device that performs procedural instruction processing,
A functional language storage unit storing an array of each element of a functional language instruction / variable operand;
A tree structure that obtains each element of the array, creates a tree structure having the function corresponding to the instruction and the variable operand among the elements as nodes, and outputs the tree structure to a tree structure storage unit that stores the tree structure The creation department;
An instance name giving unit that gives an instance name to a node other than a leaf that is a node having no child nodes in the tree structure;
For the tree structure given the instance name, find a node whose child node has only a leaf, call the function described in that node, and assign the assignment statement of the call result to the node. An assignment statement creation unit that creates an instance name and outputs it to a procedural language storage unit that stores a procedural language instruction group;
A deletion processing unit that deletes all child nodes of the node output to the procedural language storage unit from the tree structure;
The language conversion device, wherein the processing by the assignment statement creation unit and the processing by the deletion processing unit are repeated until the tree structure becomes one node. The node is a node name, a pointer to a child node used when the calling function points to the argument, and a next node used when pointing to the next argument between arguments having the same calling function. Each item with a pointer to
When the tree structure creation unit reads a function from the array of the functional language storage unit, the tree structure creation unit newly creates a node having the name of the function as a node name, and sets the newly created node as a currently processing node. ,
When an operand is read from the array of the functional language storage unit, a node having the name of the operand as a node name is newly created, and the newly created node is set as a currently processing node, and the newly created node Invalidate the pointer to the child node,
When a function terminator is read from the array of the functional language storage unit, the pointer to the next node of the current processing node at that time is invalidated, and the node of the completed function is set as the current processing node. The language conversion device according to claim 1, wherein the language conversion device is executed every time an element is read from the array of the functional language storage unit. The tree structure creation unit
When the node currently being processed corresponds to a function, and the newly created node corresponds to a function, the pointer to the next node of the newly created node is invalidated,
When the currently processed node corresponds to an operand and the newly created node corresponds to an operand, the pointer to the next node of the newly created node is invalidated,
When the node currently being processed corresponds to an operand, and the newly created node corresponds to a function, the pointer to the next node of the newly created node is invalidated,
A pointer to a child node of the newly created node is invalidated when the node currently being processed corresponds to a function and the newly created node corresponds to an operand. The language conversion device according to claim 2. A functional language that stores an array of elements of instruction / variable operands in a functional language to convert a control processing program written in a functional language into a language format that can be executed by a device that performs procedural instruction processing In a program to be executed by a language conversion device having a storage unit and a procedural language storage unit that stores a procedural language instruction group,
A tree structure storage that obtains each element of the array of the functional language storage unit, creates a tree structure with the function corresponding to the instruction and the variable operand as a node among the elements, and stores the tree structure Tree structure creation step to output to
An instance name giving step for giving an instance name to a node other than a leaf that is a node having no child nodes in the tree structure;
For the tree structure given the instance name, find a node whose child node has only a leaf, call the function described in that node, and assign the assignment statement of the call result to the node. Creating an assigned instance name and outputting it to the procedural language storage unit,
A deletion processing step of deleting all child nodes of the node output to the procedural language storage unit from the tree structure,
A language conversion program characterized by repeating the assignment statement creation step and the deletion processing step until the tree structure becomes one node. The node is a node name, a pointer to a child node used when the calling function points to the argument, and a next node used when pointing to the next argument between arguments having the same calling function. Each item with a pointer to
In the tree structure creation step, when a function is read from the array of the functional language storage unit, a node having the name of the function as a node name is newly created, and the newly created node is set as a currently processing node. ,
When an operand is read from the array of the functional language storage unit, a node having the name of the operand as a node name is newly created, and the newly created node is set as a currently processing node, and the newly created node Invalidate the pointer to the child node,
When a function terminator is read from the array of the functional language storage unit, the pointer to the next node of the current processing node at that time is invalidated, and the node of the completed function is set as the current processing node. 5. The language conversion program according to claim 4, which is executed every time an element is read from the array of the functional language storage unit. Furthermore, in the tree structure creation step,
When the node currently being processed corresponds to a function, and the newly created node corresponds to a function, the pointer to the next node of the newly created node is invalidated,
When the currently processed node corresponds to an operand and the newly created node corresponds to an operand, the pointer to the next node of the newly created node is invalidated,
When the node currently being processed corresponds to an operand, and the newly created node corresponds to a function, the pointer to the next node of the newly created node is invalidated,
A pointer to a child node of the newly created node is invalidated when the node currently being processed corresponds to a function and the newly created node corresponds to an operand. The language conversion program according to claim 5.

Images