JP2004094837A - State transition control method - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a technique for preventing a control program using a state transition table from miscalling a callback function with a static/dynamic change of the state transition table, while securing the readability of a source generated by the state transition table. <P>SOLUTION: In this state transition control method, there are provided an event analysis manager, generated event storage means, current state storage means, callback function name pointer solution means, state transition table storage/management means, a state transition control manager, callback function execution means, callback function operation input/output means, the state transition table, and transition description unit current value storage means. The callback function name pointer solution means for converting a callback function name as a character string described in the state transition table into a pointer of a corresponding callback function is utilized to determine the callback function to be executed. <P>COPYRIGHT: (C)2004,JPO

Description

[0001]
TECHNICAL FIELD OF THE INVENTION
The present invention relates to a program for performing control using a state transition, and particularly to a method of reflecting a callback function described in a state transition table on source code (source code, original program) and a callback function to be called at the time of program execution. It relates to improvement of the selection method.
[0002]
[Prior art]
In general, the control structure of a program having an internal state is often defined using a state transition table. At this time, in order to perform the operation faithful to the state transition table, a mechanism for realizing the operation defined in the state transition table by some method is necessary.
[0003]
In the construction of a control structure using the conventional state transition table, a callback function name generated mechanically from column numbers and row numbers in the state transition table is used, or a callback table listing callback functions is used. Used to call the callback function. As such an example, there is a technique described in JP-A-8-190476 or JP-A-11-282658.
[0004]
One method for realizing the operation of the state transition table definition is to directly describe the processing contents of the callback function instead of the callback function name in the state transition table, and to mechanically read from the columns and rows of the state transition table. Some generate a callback function name. An example of such an example is “Latest State Transition Table Design Method and Simulation in the Design Phase” (Masahiko Watanabe, CQ Publishing Company, Interface, February 1999, p. 169-175). Another method for realizing the operation of the state transition table definition is to describe only the callback function name in the state transition table, and to store the call table (array of pointers to the callback functions) according to the description order of the state transition table. To create.
[0005]
[Problems to be solved by the invention]
When a callback function name is generated mechanically from the columns and rows of the state transition table, it is very difficult to infer the operation from the callback function name in the generated source code, and the readability of the source code is reduced. There was a problem.
[0006]
When creating a call table according to the description order of the state transition table, if the state transition table is changed between when the call table is created and when the state transition is executed, it is not possible to prevent an error that calls the wrong callback function. there were.
[0007]
[Means for Solving the Problems]
In order to solve the above-mentioned problem, in the present invention, a callback function name is described in a state transition table, and a callback function name as a “character string” in the state transition table and an “identifier” in a source code. And a means for calling the callback function by its name as a “character string” when executing the state transition. By this means, the readability of the source code is ensured, and the miscall of the callback function is prevented.
[0008]
BEST MODE FOR CARRYING OUT THE INVENTION
FIG. 1 shows the configuration of an embodiment using the present invention. The state transition control manager 0160 controls the overall operation. The event analysis manager 0110 analyzes an event that occurs along with the operation of the program to be subjected to the state transition control, and stores the analysis result of the event in the event storage unit 0120. The current state storage unit 0130 holds the current state of the program to be subjected to state transition control. The callback function name pointer resolving means 0140 provides a function of returning a pointer of the corresponding callback function from the name of the callback function given as a character string.
[0009]
The state transition table storage / management unit 0150 provides a function of returning a set of contents described in the state transition table in the state transition table from the current state value and the event that has occurred. Hereinafter, this set of state transition table description contents determined by designating one state and one event in the state transition table is referred to as a transition description unit. The callback function executing means 0170 executes the callback function by calling the callback function given as a pointer. Callback function action input / output means
0180 provides input / output operations generated by the execution of the callback function. The state transition table 0190 is a state transition table stored in a file or the like. The transition description unit current value storage unit 01100 stores the contents of the current transition description unit.
[0010]
Next, the operation of FIG. 1 will be described. First, it is assumed that the information of the state transition table 0190 has been read into the state transition table storage / management unit 0150 upon initialization. Further, it is assumed that an initial state value has been input to the current state storage unit 0130. Here, an event that occurs with the operation of the program to be subjected to the state transition control is analyzed by the event analysis manager 0110 and stored in the event storage unit 0120. In FIG. 1, the external world is a program to be subjected to state transition control excluding a part that controls state transition. Except for the part of the state transition control, whether it is a process of the same program or input / output hardware, it is described as “outside world” here. The event source includes the state transition control manager 0160 itself. When an event is stored in the occurred event storage unit 0120, the state transition control manager 0160 sends the transition description unit from the state transition table storage / management unit 0150 based on the event and the state value obtained from the current state storage unit 0130. To get. The acquired transition description unit is stored in the transition description unit current value storage unit 01100.
[0011]
Next, the name of the callback function as a character string is obtained from the transition description unit current value storage unit 01100. Then, the callback function name as a character string is converted into a pointer of the corresponding callback function using the callback function name pointer solving means 0140. Then, the converted callback function pointer is sent to the callback function execution means 0170, and the actual callback function is executed. Input and output of information with the outside world due to execution of the callback function is performed by the callback function action input / output unit 0180. After the execution of the callback function, the return value of the execution result is passed from the callback function execution means 0170 to the state transition control manager 0160. The state transition control manager 0160 acquires the next state value to be transitioned from the transition description unit current value storage unit 01100 based on the return value of the passed callback function, and updates the current state of the current state storage unit 0130. I do.
[0012]
FIG. 2 is a flowchart when the present invention is executed. The feature of the embodiment of the present invention is that, at the time of the state transition operation, a desired callback function is searched by the callback function name by referring to the state transition table including the callback function name as a character string. And obtaining a pointer to the callback function associated with the callback function name.
[0013]
Hereinafter, the operation at the time of execution will be described step by step. After the program starts, the whole initialization processing is performed (0210). Next, in a process 0220, the state transition table data 0230 defined in the external file or the like is read. In the process 0240, processes other than those related to the state transition are performed among the operations of the entire program. Processes 0250 to 0290 collectively show status transition-related processes. In the process 0250, as a prerequisite necessary for the state transition, an event generated as a result of performing a process other than the state transition related in the process 0240 and the current state value are acquired.
[0014]
Next, in process 0260, the name of the corresponding callback function is acquired by following the state transition based on the acquired occurrence event and the current state value. processing
At 0270, a pointer to the corresponding callback function is acquired by referring to a dictionary indicating the relationship between the callback function name and the callback function pointer based on the acquired callback function name. In the process 0280, the callback function accompanied by the state transition is executed by calling the pointer of the acquired callback function. Finally, at 0290, after the execution of the callback function, the next transition destination is determined based on the return value information, and the transition is performed. Here, the transition means updating the current state value with a new state value to be transited.
[0015]
The state transition table may be hard-coded (written directly into the program) when the program is created. Alternatively, the reading may be performed every time immediately before searching for a necessary callback function from the state transition table (0260). This applies when the state transition table can be changed by an external program during the operation of the program. The state transition table which is read once and exists in the memory of the computer may be dynamically changed.
[0016]
Next, a procedure for mounting the embodiment according to the present invention will be described with reference to FIG. The state transition table 0310 of this embodiment has, as headings, a state column (0320) listing states in the leftmost column and an event row (0330) listing events in the top row. The part of the table characterizing the state transition operation located on the right side of the state column 0320 and below the event row 0330 is called a state transition operation description section (0340), and the state transition operation description section
(0340) A description of a set of state transition tables determined by designating one state and one event is called a transition description unit (0350). The transition description unit (0350) is composed of one or a plurality of cells, and has at least a cell that describes a callback function. Both the state column 0320 and the event row 0330 need only be distinguishable from other elements, and need not necessarily be in the leftmost column and the uppermost row. Further, the rows and columns may be exchanged. The following description is based on the format of the state transition table 0310 shown in FIG.
[0017]
At the time of mounting, two file groups are roughly divided based on this state transition table. One is a definition file, which describes various definitions that do not involve execution. The other is an executable statement description file that contains a description of the operation of the callback function.
[0018]
The definition file generated based on the state transition table is at least one of an event definition file (0360), a callback function definition file (0370), and a state definition file (0380). The event definition file (0360) lists the contents of the event row (0330) in the state transition table (0310). Similarly, the state definition file (0380) lists the contents of the state column (0320) in the state transition table (0310). The callback function definition file (0370) is a header file listing the callback functions in the transition description unit (0350) for all the state transition operation description sections (0340). Only one callback function having the same name is listed as the same function. Of these definition files, only the callback function definition file (0370) is essential for the embodiment of the present invention, and the others are used as needed.
[0019]
The executable statement description file includes a function name mapping file (0390) and a function body description (03100). The function name mapping file (0390) associates the callback function name as “character string” extracted from the state transition table with the callback function name as “identifier” described in the callback function definition file (0370). .
[0020]
When creating the function name mapping file (0390), the state transition table
(0310) Alternatively, after extracting the callback function name from the callback function definition file (0370), a form in which the callback function name is quoted as a character string and the function pointer is quoted as a function argument is given as an argument of the operation to be associated. And The associating operation uses a mechanism for obtaining a pointer using a character string as a search key. For example, in the C / C ++ language, a map library can be used. In other languages and environments, the functions required in the present invention can be easily realized by using a dictionary or a library that provides an associative array function.
[0021]
In the example of the format of the function name mapping file 0390 in this embodiment, the function name is enclosed in double quotes (") to give the function name as a character string, and an"&"symbol is added to the function name to indicate a pointer to the function name. I have. Even when a language / library other than the C / C ++ language is used, the same function can be realized by using a mechanism for obtaining a pointer using a character string as a key. Since the format of the function name mapping file for performing the association is simple, it is advantageous when a state transition table is provided and generated mechanically.
[0022]
The function body description 03100 is the body description of the callback function, and describes the actual operation of each callback function. The function name mapping (0390) and the function body description (03100) refer to the callback function definition file (0370).
[0023]
FIG. 4 shows an example of the description content of the transition description unit (0350 in FIG. 3). 0410 is a state transition table, and 0420 is a transition description unit. In this example, the transition description unit is composed of a cell (0430) indicating a callback function name, a cell (0440) indicating a transition destination, and an annotation cell (0450). The minimum required item in this transition description unit is a cell 0430 indicating a callback function name. Also, due to the nature of the state transition table, by providing a cell (0440) indicating the transition destination, the transition destination can be clearly indicated in the table, thereby improving the convenience. When the cell indicating the transition destination is not used, the transition processing is performed in the callback function. Similarly, by providing the annotation cell (0450), information that cannot be expressed only by the callback function name (0430) can be included. 0460 to 04100 are examples of the format of the cell (0440) indicating the transition destination. 0460 is a format in the case of transition to another state in the same state transition table, and has a format in which transitionable states are listed. The transition destination from the current state is determined by the return value of the callback function. For example, when the return value of the callback function is 0, a transition is made to the transition destination state 1, and similarly, when the return value is 1, a transition is made to the transition destination state 2, and the like.
[0024]
Reference numeral 0470 is an example of a format when a transition state of another state transition table is included as a transition destination. In the example of this format, a description (0480) listing a state transition table to be a transition destination is provided at the head of the list of transition destinations, and subsequently, a transition destination state in the same table is listed (0490). . The reason why the enumeration of the transition destination table and the enumeration of the transition destination state are described separately is for convenience when the state returns to the original state transition table after transitioning to another state transition table. For example, when the transition destination is the transition destination table 2 (04100) in 0470, the current state transition table is switched to the table indicated by the transition destination table 2 (a so-called nested state transition table structure). After that, after the process based on the transition destination table 2, an appropriate event occurs, and the phase of returning to the original state transition table comes. At that time, it is necessary to specify to which state in the original state transition table to transition. The list of transition destination states (0490) is used to specify the transition destination at the time of the return. Note that the list of transition destination states (0490) is used not only when returning from another table, but also when specifying a transition destination state in the same table when not shifting to a nested another table.
[0025]
In the embodiments described above, the callback function name is an abstract one that is mechanically numbered for explanation. The present method is characterized in that since the name of an arbitrary callback function can be assigned within a range that can be recognized by a language processing system such as a compiler, the readability of the generated source is good. Therefore, an example close to the actual example using a more specific callback function name will be described by taking the operation of establishing the transport connection in the communication program shown in FIGS. 5 and 6 as an example.
[0026]
FIG. 5 is a sequence chart related to the connection establishment to be described. In the scope of the present embodiment, a description will be given focusing on a series of operations in establishing and releasing a connection, and a description of an exception handling system will be omitted. Reference numerals 0510 and 0520 denote communication program layers of the station of interest. The transport layer of the station which 0510 focuses on,
0520 corresponds to the upper layer. Similarly, 0540 and 0550 are a transport layer of a station facing the station of interest and an upper layer thereof. Reference numeral 0530 denotes a layer below the transport layer of both the target station and the opposite station, and a communication medium interposed between the two stations.
[0027]
Here, a case is considered in which the connection request and disconnection request of the transport connection are issued from the target station side, and the opposite station responds thereto. 0560 is a connection request from the upper layer of the station of interest. After receiving the request from the upper layer of the target station, the request passes through the transport layer of the target station, a connection request to the opposite transport layer is transmitted, and after reaching the transport layer of the opposite station, the upper layer of the opposite station. As an indication of a connection request to The response of the connection request reception for the indication reaches the transport layer of the target station via the transport layer of the opposite station, and is transmitted as a confirmation to the upper layer of the target station which is the original connection request source (0570). . A similar sequence is followed for disconnection. Reference numeral 0580 denotes a disconnection request message, and 0590 denotes a disconnection request acceptance message sequence. 05100 indicates a state transition of the transport layer of the station of interest.
[0028]
FIG. 6 is a table showing the state transition of the target station in FIG. 0610 is a state column listing states, 0620 is an event row listing events, 0630 is a state transition operation description section describing the state transition operation, 0640 to 0670 is a transition description unit,
0680 is the description of the cell in the transition description unit. 0680 is provided for the description of the embodiment and is not always necessary. Note that the initial value of the state in the state transition table can be specified by another flag, but it is convenient to use the uppermost row of the state column. Since the initial state related to the connection of the transport layer is the “disconnected” state, the top row of the state column in FIG. 6 is set to the “disconnected” state. The reason why the contents are described only in the diagonal elements in the table is to show the operation of only the normal system for the sake of explanation. Generally, the contents are described in addition to the diagonal elements so that the exceptional processing can be appropriately performed.
[0029]
Next, an example of a transition from the “disconnected” state, which is the initial state, to the “waiting for connection acceptance” state in FIG. FIG. 7 is a diagram showing the change of the variable value. Reference numeral 0710 denotes a variable value in the first step of a series of transition operations, and subsequent reference numerals 0720 to 0760 indicate changes in the variable value following the steps of the state transition operation. In one table of FIG. 7, the left half is an example of a variable item name, and the right half is an example of a variable value corresponding to a variable item name. Of the variable values, the case of indefinite or unquestionable is indicated by a horizontal bar "-". Those that have changed in comparison with the immediately preceding variable value are indicated by thick frames. The variable value 0770 holds the current state. The variable value 0780 stores the input event, 0790 stores the character string of the callback function name, 07100 stores the pointer to the callback function, and 07110 stores the return value after executing the callback function.
[0030]
First, as shown at 0710, the variable value at the start of the state transition operation holds only information indicating that the current state is the “disconnected” state. Next, assuming that the event “reception of connection request from upper layer” has occurred, the value of the occurred event (07120) is input to the input event item, such as 0720. Next, the state transition table 07130 is referred to from the two values of the current state and the input event (07140). The name as a character string of the callback function obtained as a result of the reference is input to the callback function name as shown by 0730 (07150). Next, by referring to the callback function mapping 07170 generated based on the function name mapping file based on the callback function name (07160), a pointer to the corresponding callback function is obtained (07180). Since the pointer of the callback function has been obtained by the above operations, in the next step, the callback function is executed by calling the pointer to the function (07190) (07230). The return value of the callback function obtained as a result of executing the callback function is stored in the state of the variable value of 0750 (07200).
[0031]
Next, based on this return value, in order to determine the transition destination of the updated state, the transition destination is searched from the state transition table 07130 in the variable value state 0750. As a result of updating the current state by overwriting the obtained current state of the transition destination, the state of the variable value becomes 0760. Hereinafter, the same operation is repeated.
[0032]
In the embodiment of the present invention, since the callback function to be executed can be specified by its name, it is possible to cope with a case where the state transition table is dynamically changed at the time of execution. In the case of the dynamic change of the state transition table, the callback function after the change needs to be defined in advance. Unless the changed callback function is already used in the state transition table, the callback functions that can be used after the dynamic change are a callback function definition file (0370), a function name mapping file (0390), and It must be defined in advance in the function body description (03100). If a callback function that is considered to be frequently used is prepared as a standard callback function, the number of steps can be reduced and the management can be facilitated. In addition, examples of the standard callback function include a function for transmitting a standard ack response for keep alive that keeps the line active, and a nop function that does nothing.
[0033]
A feature of the present invention is that code management efficiency is high. For example, in the case of a method of mechanically generating a name of a callback function from a row number and a column number of a state transition table, a callback function is generated for all elements. Since the number of elements is required, the number of management steps is increased. Furthermore, since the column number and the row number change with the change of the state transition table, it is necessary to always check the code with the state transition table. However, according to the method of the present invention, the above problems do not occur.
[0034]
The reason why unnecessary callback functions do not increase in the present invention is that callback functions are managed by name. In the present invention, the same function can be referred to from a plurality of places in the state transition table by associating one callback function with the same name. For example, an off-diagonal element in the state transition table often describes an exceptional operation, but the exception processing often has the same content, and in the present invention, the same callback function name is used for these. , The number of callback functions can be reduced. As described above, since it is not necessary to define different callback functions for all off-diagonal elements, the creation and management of callback functions can be greatly simplified in the present invention.
[0035]
Further, in the present invention, a code is not directly described in the state transition table. This approach has several advantages, as described below.
[0036]
One of the advantages is that the layering of the state transition table is facilitated. If a dedicated CASE tool is used, a code can be directly written in the cells of the state transition table, and the state transition table can be nested. However, in this case, browsing and editing become impossible in an environment where the CASE tool is not prepared. On the other hand, according to the method of the present invention, since a nested structure is realized by specifying another state transition table name for the transition destination, a uniform state transition table format is used at all nesting levels. It is possible to browse and edit the state transition table using ordinary spreadsheet software or editor.
[0037]
Another advantage is improved reusability of the callback function. Usually, as the development of the program progresses, the processing content of the callback function changes. At this time, there is a case where it is desired to reuse the processing of the callback function used previously with trial and error. If the codes are directly written in the state transition table, the contents of the callback function before the change are lost when the state transition table is edited. However, in the method of the present invention, when the callback function processing content is changed, by changing the name of the callback function and storing it, it is easy to retain the processing content before the change. When the reuse becomes necessary, the callback function before the change can be used by changing only the name of the callback function.
[0038]
When there are a plurality of state transition tables for one project, the callback functions are distinguished by adding a prefix identifying the table to the callback function. Similarly, the event name is given a prefix according to a plurality of state transition tables.
[0039]
FIG. 8 shows an example of the format of various files when the state transition table of FIG. 6 is used.
0810 is an example of a callback function definition file. The definition part of the callback function is extracted from the state transition table and enumerated. For arguments, creating an abstracted argument type (“ARG_TYPE” in the example of 0810) that covers the values required for each callback function can be used for mechanical processing because the format of the argument part can be unified. It is. Further, in the method of the present invention in which the callback function is called by the “name” of the function, it is possible to give the callback function an arbitrary name reflecting the processing contents, and thus the callback function definition file alone Excellent readability at On the other hand, in a method of generating a callback function name by abstracting it from a column number and a row number, it is difficult to infer the processing content from only the callback function name.
[0040]
0820 is an example of a function name mapping file. Using a mechanism in which a search key of a character string such as map and a value of a pointer or the like corresponding to the search key can be stored / retrieved as a pair, a function name as a character string and a pointer to a function as an identifier are stored as a pair. . The pointer to the function as the identifier can be used in this format because the callback function definition file 0810 has already defined the callback function. Since the function name mapping file has a simple format, it is suitable for mechanical processing that is automatically generated from the state transition table. Reference numeral 0830 is a function body description. Since the callback function has a common return type and argument type, parts other than the processing unit unique to each function (so-called templates or skeletons) are automatically processed by machine processing from the state transition table. Can be generated. Also, when creating a skeleton of a callback function from the state transition table, regardless of whether it is manual or automatic, the annotation in the state transition table (the contents of the annotation cell in the transition description unit) is commented to the corresponding callback function. When inserted, convenience is improved. Annotations in the state transition table may be inserted not only in the function body description 0830 but also in the callback function definition file (0810) and the function name mapping file (0820).
[0041]
0840 is an example of a state transition execution log. When a program to which the present invention is applied operates, outputting a state transition execution log such as 0840 using the description contents of the state transition table is effective for operation analysis. Since these log outputs can be based on the contents of the state transition table, it is not necessary to input new data. In addition, if the state transition table body is modified, a log output based on the modified state transition table can be output during the subsequent program operation.
[0042]
The mechanical processing for generating various files refers to processing for automatically creating a callback function definition file from a state transition table. In the case of the file group in FIG. 3 as the target of the machine processing, the skeleton part of the common format excluding the specific processing for each function among the event definition file 0360, the state definition file 0380, the function name mapping file 0390, and the function body description 03100 .
[0043]
Next, a process for generating a template of a callback function from the state transition table will be described with reference to FIG. To generate the template, the updated state transition table 0910 and the existing source code 0920 in the state before the update of the state transition table is reflected are used. As the automatically generated file 0930 from the state transition table 0910 and the existing source code 0920, at least one of a callback function mapping definition file and a callback function skeleton file for linking a callback function name as a character string and a callback function pointer. Is created. 0940 is an example of a callback function definition file, and 0950 is an example of a callback function skeleton (model) file. When these files are generated, either a callback function that matches both the state transition table and the existing callback function description, or a function that exists only in the state transition table and is newly added by updating this state transition table These are classified into three types: callback functions that have been added, or callback functions that exist only in the existing callback function description and have been deleted by updating the current state transition table. 0960, 0970, and 0980 show specific examples of the classification using the callback function mapping definition file.
[0044]
0960 is a definition of the callback function existing in both the state transition table and the existing source code, 0970 is a definition of the callback function existing only in the existing source code, and 0980 is a definition of the callback function existing only in the state transition table. is there. Since 0960 indicates that it exists in both the updated state transition table and the existing source code, it indicates a callback function that does not need to be changed. Reference numeral 0970 denotes a callback function that is deleted from the state transition table with the update of the state transition table and exists only in the existing source code before the update.
[0045]
If it is clear that these callback functions will not be used in the future, they can be deleted. Conversely, if there is a possibility that the callback function described in 0970 may be used again due to a further change in the state transition table, it is easier to manage the code without deleting it. When the state transition table is dynamically changed at the time of execution, a newly used callback function also appears in the column of 0970, but also in this case, the callback function is not deleted. Reference numeral 0980 denotes a callback function newly added by updating the state transition table. Therefore, the callback function shown in this section needs to be newly added to the source code. At that time, by automatically generating a template of the callback function such as the callback function skeleton file 0950, the man-hour can be reduced and the description of only the original contents of the callback function can be concentrated.
[0046]
When automatically generating a callback function template, unexpected loss of code can be prevented by not editing the existing source code directly but using a separate file that is easier to guess than the original file name. Conversely, by automatically editing the existing source code, it is possible to reduce the number of code management steps. By providing an option to switch between these methods as needed, more flexible operation becomes possible.
[0047]
【The invention's effect】
According to the present invention, in a program that performs control using a state transition table, by providing a mechanism for associating a callback function name as a character string with a callback function name as an identifier in source code, Since the callback function is called as the "character string" of the identifier name (that is, the function name), the callback function name can be any name that makes it easy to grasp the contents, and is generated from the state transition table. It is possible to improve the readability of the source code. In addition, it is possible to prevent a callback function from being missed due to a dynamic state transition table change.
[Brief description of the drawings]
FIG. 1 is a configuration of the invention.
FIG. 2 is a flowchart at the time of execution.
FIG. 3 shows a procedure at the time of mounting.
FIG. 4 is an example of description content in a transition description unit.
FIG. 5 is a sequence chart related to connection establishment.
FIG. 6 is an example of a state transition table when a transport layer connection is established.
FIG. 7 is a diagram showing a change in a variable value.
FIG. 8 shows examples of formats of various files.
FIG. 9 Generation of a template.
[Explanation of symbols]
0110: Event analysis manager, 0120: Occurrence event storage means, 0130: Current state storage means, 0140: Callback function name pointer resolution means, 0150: State transition table storage / management means, 0160: State transition control manager, 0170: Call Back function execution means, 0180 ... callback function action input / output means, 0190,0310,0410,07130 ... state transition table, 0230 ... state transition table data, 0360 ... event definition file, 0370,0810 ... callback function definition file, 0380: State definition file, 0390: Function name mapping file, 0820: Callback function name mapping file, 0840: State transition execution log, 01100: Transition description unit current value storage means, 07170: Callback function mapping.

Claims (4)

In a state transition control method for performing control based on a state transition table for selecting a process by a combination of an event and a state,
When selecting a callback function that describes the processing method determined by the current state and the event,
Obtain the character string of the function name described in the state transition table of the callback function executed from the current state and the occurrence event,
From the character string of this function name, the address of the function to be executed is obtained, and execution is moved to the address of the function.
A state transition control method comprising: obtaining a next transition state based on a state transition table using a return value when the execution of the function is completed; and updating a current state. 2. The state transition control method according to claim 1, wherein the state transition table includes a state transition operation description section characterizing the operation of the state transition, and specifies one state and one event in the state transition operation description section. A set of determined state transition table description contents is a transition description unit, and the transition description unit is composed of one or more cells, and has at least a cell that describes a callback function;
Execute state transition control by associating the callback function name as a character string with the callback function as an identifier in the source code based on the callback function name described in the cell that describes the callback function A state transition control method characterized by the following. 3. The state transition control method according to claim 2, wherein the state transition table description unit further includes a cell for inputting an annotation and a cell for inputting a transition state. 3. The state transition control method according to claim 2, wherein at least one of an event definition file listing event names included in the state transition table and a state definition file listing states included in the state transition table is generated. A state transition control method for ensuring consistency between a state transition table and contents of a file generated from the state transition table.

Images