Table file and graphic program conversion system

Abstract

The invention belongs to the technical field of vehicle software development, and particularly relates to a table file and graphic program conversion system, which comprises a computer device, and the computer device is configured to comprise a table and graphic conversion module which is configured to read a table file and read a graphic program; reading the text content and coordinate information of all cells in at least one page of the table file into the corresponding two-dimensional object arrays, and setting the name of each two-dimensional object array as the name of the corresponding page; analyzing each two-dimensional object array into a flow chart area and an attribute area in sequence according to pages; constructing a graphic program according to an analysis result; and / or the graph and table conversion module is configured to create table empty pages, and the number of the table empty pages is equal to the sum of the number of main programs and the number of nested subprograms in the graph program; corresponding table pages are sequentially constructed according to program categories in the graphic program, one page corresponds to the main program, and the other pages correspond to the corresponding nested subprograms; and storing the constructed form file.

Description

[0001] This application is based on and claims priority to Japanese Patent Application No. JP 2024-59205, filed on April 1, 2024. The entire contents of the above application are hereby incorporated by reference into this application. TECHNICAL FIELD

[0002] The present application belongs to the technical field of vehicle software development, and specifically relates to a table file and graphical program conversion system. BACKGROUND

[0003] In the development and testing of automotive software, table files are often used to define test cases and write test steps in the automotive testing process, while graphical programs are often used for modeling development of automotive software and execution of test programs. Therefore, it is a common need to convert test cases written in table files into executable graphical programs.

[0004] This conversion process is often difficult to automate due to the variable formats of table files owned by individual automobile manufacturers. Moreover, after manually converting table files into graphical programs, repeated manual conversion costs are incurred due to changes in test cases in table files. Even if a converter is specially developed to convert table files into graphical programs, the same problem arises when users modify programs in graphical programs and want to synchronize the modifications to table files, which is difficult to automate and thus increases conversion costs. SUMMARY

[0005] The present application aims to provide a table file and graphical program conversion system.

[0006] To solve the above technical problems, the present application provides a table file and graphical program conversion system, comprising: a computer device configured to include:

[0007] a table and graphical conversion module configured to read a table file to read text content and coordinate information of all cells in at least one page of the table file into a corresponding two-dimensional object array, and set the name of each two-dimensional object array as a corresponding page name; sequentially parse each two-dimensional object array into a flowchart area and an attribute area according to page; construct a graphical program according to the parsing result; and / or

[0008] a graphical and table conversion module configured to create table empty pages, the number of table empty pages being equal to the sum of the number of main programs and nested sub-programs in the graphical program; sequentially construct corresponding table pages according to the program categories in the graphical program, wherein one page corresponds to a main program and the remaining pages correspond to corresponding nested sub-programs; and save the constructed table file.

[0009] The table file and the graphic program conversion system of the present application supports mutual conversion between the table file and the graphic program, so that the modification made by the user on the table file or the graphic program can be converted into the other format correctly. For the document writer and the test case maker, the document can be maintained more easily; for the test execution personnel, the graphic program can be understood and written more easily. Especially in the field of automobile test, the conversion from the table file to the graphic program improves the conversion efficiency from the test case to the test implementation and avoids the possibility of error caused by manual conversion. The conversion from the graphic program to the table file makes the graphic program modified by the user in real time be converted into the test case and saved, and also avoids the possibility of error caused by manual conversion.

[0010] Other features and advantages of the present application will be set forth in the descriptions that follow, and in part will be apparent from the description, or can be learned by practice of the present application. The purposes and other advantages of the present application will be realized and attained by the structure particularly pointed out in the description and the appended drawings.

[0011] In order to make the above-mentioned objects, features and advantages of the present application more apparent, the following will describe a preferred embodiment in detail, and the accompanying drawings will be described as follows. BRIEF DESCRIPTION OF DRAWINGS

[0012] In order to make the above-mentioned objects, features and advantages of the present application more apparent, the following will describe a preferred embodiment in detail, and the accompanying drawings will be described as follows.

[0013] Fig. 1(a) shows a step diagram of converting the table file into the graphic program in the table file and the graphic program conversion method according to some embodiments;

[0014] Fig. 1(b) shows a step diagram of converting the graphic program into the table file in the table file and the graphic program conversion method according to some embodiments;

[0015] Figure 2 Fig. 4 shows a schematic diagram of the graphic program constructed in case four according to some embodiments;

[0016] Figure 3 Fig. 5 shows a schematic diagram of the effect after adding the variable into the graphic program in case four according to some embodiments;

[0017] Figure 4 Fig. 6 shows a schematic diagram of the main program in the graphic program generated in case four according to some embodiments;

[0018] Figure 5 Figure showing the nested subroutines in the graph program generated for Case Four, to which some embodiments relate;

[0019] Figure 6 Figure showing the results resolved by the execution unit check in the attribute area in the graph program generated for Case Four, to which some embodiments relate;

[0020] Figure 7 Figure showing the two-dimensional object array file in Case Five, to which some embodiments relate;

[0021] Figure 8 Figure showing the fourth page in the two-dimensional object array file in Case Five, to which some embodiments relate;

[0022] Figure 9 Figure showing the graph program in Case Six, to which some embodiments relate;

[0023] Figure 10 Figure showing the table contents generated for Case Six, to which some embodiments relate;

[0024] Figure 11 Figure showing the nested subroutines in the graph program in Case Seven, to which some embodiments relate;

[0025] Figure 12 Figure showing the table contents generated for Case Seven, to which some embodiments relate;

[0026] Figure 13 Figure showing the page names for the table contents generated for Case Seven, to which some embodiments relate;

[0027] Figure 14 Figure showing the table contents for Case Eight, to which some embodiments relate;

[0028] Figure 15 Figure showing the attributes for the execution unit check in the graph program in Case Nine, to which some embodiments relate;

[0029] Figure 16 Figure showing the first page of the table file for Case Ten, to which some embodiments relate;

[0030] Figure 17 Figure showing the second page of the table file for Case Ten, to which some embodiments relate;

[0031] Figure 18 Figure showing the third page of the table file for Case Ten, to which some embodiments relate;

[0032] Figure 19The fourth page of the table file of Case Ten, to which some embodiments relate, shows the intent;

[0033] Figure 20 The fifth page of the table file of Case Ten, to which some embodiments relate, shows the intent;

[0034] Figure 21 The main program in the graphic program generated by Case Ten, to which some embodiments relate, is shown in the schematic diagram;

[0035] Figure 22 The main program in the graphic program to be converted by Case Eleven, to which some embodiments relate, is shown in the schematic diagram;

[0036] Figure 23 The first layer of nested subprograms in the graphic program to be converted by Case Eleven, to which some embodiments relate, is shown in the schematic diagram;

[0037] Figure 24 The second layer of nested subprograms in the graphic program to be converted by Case Eleven, to which some embodiments relate, is shown in the schematic diagram;

[0038] Figure 25 The third layer of nested subprograms in the graphic program to be converted by Case Eleven, to which some embodiments relate, is shown in the schematic diagram;

[0039] Figure 26 The empty program in the graphic program to be converted by Case Eleven, to which some embodiments relate, is shown in the schematic diagram;

[0040] Figure 27 The schematic diagram of the table file after conversion by Case Eleven, to which some embodiments relate, is shown;

[0041] Figure 28 The principle block diagram of the conversion system of the table file and the graphic program, to which some embodiments relate, is shown;

[0042] Figure 29 The principle block diagram of the electronic device, to which some embodiments relate, is shown;

[0043] Figure 30 The principle block diagram of the electronic device, to which some embodiments relate, is shown;

[0044] Figure 31 The principle block diagram of the system, to which some embodiments relate, is shown. DETAILED DESCRIPTION

[0045] In order to make the purposes, technical solutions and advantages of the embodiments of the present application clearer, the technical solutions of the present application will be described clearly and completely below with reference to the drawings. Obviously, the described embodiments are only some of the embodiments of the present application, but not all the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative work fall within the protection scope of the present application. In the development and testing of automobile software, table files are often used for the definition of test cases and the writing of test steps in the automobile testing process, and graphical programs are often used for the modeling development of automobile software and the execution of test procedures. Therefore, it is a common requirement to convert the test cases written in table files into executable graphical programs.

[0046] However, this conversion process is often difficult to be automatically completed due to the non-fixed format of the table files owned by each automobile manufacturer, and after the table files are manually converted into graphical programs, repeated manual conversion costs will be caused due to the changes of the test cases in the table files. In the related art, there are converters for converting table files into graphical programs, but new problems are also faced, i.e., when a user modifies a program in a graphical program and wants to synchronize the modification to a table file, it is also difficult to be automated, thereby causing the increase of conversion costs.

[0047] Therefore, at least one embodiment provides a conversion method of table files and graphical programs,

[0048] The conversion of table files into graphical programs includes: reading the table files to read the text content and coordinate information of all cells in at least one page of the table files into corresponding two-dimensional object arrays, and setting the name of each two-dimensional object array as the corresponding page name; sequentially parsing each two-dimensional object array into a flowchart area and an attribute area according to the page; constructing a graphical program according to the parsing result; and / or

[0049] The conversion of graphical programs into table files includes: creating table empty pages, the number of the table empty pages being equal to the sum of the number of main programs and nested sub-programs in the graphical program; sequentially constructing corresponding table pages according to the program categories in the graphical program, wherein one page corresponds to a main program, and the remaining pages correspond to corresponding nested sub-programs; and saving the constructed table files.

[0050] The table file and the graphic program conversion method of the embodiment supports mutual conversion between the table file and the graphic program, so that modifications made by a user on the table file or the graphic program can be correctly converted into the other format. For a document writer and a test case maker, the document can be maintained more easily; for a test execution person, the graphic program can be understood and written more easily. Especially in the field of automobile testing, conversion from the table file to the graphic program improves the conversion efficiency from the test case to the test implementation and avoids the possibility of errors caused by manual conversion. Conversion from the graphic program to the table file enables the graphic program modified by the user in real time to be converted into the test case for saving, and also avoids the possibility of errors caused by manual conversion.

[0051] Various non-limiting embodiments of the embodiments of the present disclosure will be described in detail below with reference to the accompanying drawings.

[0052] As shown in FIGS. 1(a) and 1(b), some embodiments provide a table file and graphic program conversion method, including: a method of converting a table file into a graphic program and / or a method of converting a graphic program into a table file; wherein

[0053] Converting the table file into the graphic program includes:

[0054] Step S101, reading the table file to read the text content and coordinate information of all cells in at least one page of the table file into a corresponding two-dimensional object array, and setting the name of each two-dimensional object array as a corresponding page name;

[0055] Step S102, sequentially parsing each two-dimensional object array into a flowchart area and an attribute area according to the page;

[0056] Step S103, constructing a graphic program according to the parsing result.

[0057] Converting the graphic program into the table file includes:

[0058] Step S201, creating table empty pages, the number of the table empty pages being equal to the sum of the number of the main program and the number of the nested sub-programs in the graphic program;

[0059] Step S202, sequentially constructing corresponding table pages according to the program categories in the graphic program, wherein one page corresponds to the main program, and the remaining pages correspond to corresponding nested sub-programs; and

[0060] Step S203, saving the constructed table file.

[0061] Specifically, in some embodiments, the number of the nested sub-programs can be 0.

[0062] Specifically, one table file corresponds to one graphic program. The table file includes at least one page corresponding to a main program in the graphic program, and if there are other pages, the other pages correspond to nested sub-programs in the image program, and the page corresponding to the main program is generally the first page of the table file, which can be named "Main".

[0063] In some embodiments, the flowchart area includes at least one execution unit type character corresponding to an execution unit in the graphic program, and the two-dimensional object array is parsed into a flowchart area, including:

[0064] Read the text content of each array element from top to bottom in turn, and determine the text content;

[0065] If the text content is determined to be an execution unit type character, the execution unit type is determined according to the text content, and the content of the array element above the execution unit type character is also an execution unit type character, then the corresponding execution unit is marked as the next execution unit of the execution unit above;

[0066] If the text content is empty, skip the text content and continue to read the next text content; and

[0067] If the text content listed from top to bottom is empty, the flowchart area parsing is completed.

[0068] Case 1

[0069] A case is used to illustrate the method of parsing the two-dimensional object array into a flowchart area in detail as follows:

[0070] The following table is an example of a two-dimensional object array with 4 rows and 6 columns:

[0071] EP Def Name Comment Configuration NOP Program GP1 1; 1; am_GP1; Program1 NOP A2 NOP 0；1；0 A3 NOP 0；1；0

[0072] The first column is the flowchart area, and the third to sixth columns are the attribute area.

[0073] The flowchart area includes EP, NOP, and NOP execution unit type characters. If it is an empty graphic program, at least the EP execution unit type character needs to be reserved.

[0074] The method of parsing the two-dimensional object array into a flowchart area is:

[0075] The text content of each array element is read from top to bottom and from left to right, and the text content is determined. In this case, the text content of the first column from top to bottom is EP, NOP, and NOP, all of which are execution unit type characters. The fourth row is a blank line, so the execution unit in this column has only three. The NOP in the third row is the next execution unit of the NOP execution unit in the second row, because the array element above the NOP in the third row is also an execution unit type character. The NOP in the second row is the next execution unit of the EP execution unit in the first row, because the array element above the NOP in the second row is also an execution unit type character. The EP in the first row is the first execution unit, which serves as the entry point of all graphic programs.

[0076] When parsing the second column, the first row of the second column is empty, so the blank text is skipped and the next text content is read.

[0077] When parsing the second column, the entire column is empty, so the parsing of the flowchart area is completed.

[0078] In some embodiments, the flowchart area further includes a connector.

[0079] The two-dimensional object array is parsed into a flowchart area, which further includes:

[0080] The text content of each array element is read from left to right, and the text content is determined.

[0081] If the text content is determined to be a connector, the first execution unit found to the left of the connector is marked as an execution unit that supports rightward execution, and the first execution unit found to the right of the connector is marked as the next execution unit to the right of the aforementioned execution unit.

[0082] Case Two

[0083] Another case is used to illustrate the method of parsing a two-dimensional object array into a flowchart area as follows:

[0084] The following table is an example of a two-dimensional object array with 5 rows and 8 columns:

[0085] EP Def Name Comment Configuration NOP - NOP Program GP1 program comment 1; 1; am_GP1; Program1 A2 NOP 0；1；0 A3 NOP 0；1；0 C2 NOP 0；1；0

[0086] The first to third columns are flowchart areas, and the fifth to eighth columns are attribute areas.

[0087] The method of parsing the two-dimensional object array in this case into a flowchart area is as follows:

[0088] The text content of each array element is read from top to bottom and from left to right, and the text content is determined.

[0089] If the judgment is that the execution unit type character, such as the first column in the case, the parsing method is the same as the parsing method involved in case one. If the judgment is that the connector, that is, when parsing the second column, the connector "-" in the second row is encountered, the first execution unit found to the left of the connector is marked, that is, "NOP" in the second row of the first column is the execution unit supporting the right execution, and the first execution unit found to the right of the connector is marked, that is, "NOP" in the second row of the third column is the next execution unit of the "NOP" execution unit in the second row of the first column to the right.

[0090] When parsing the second column, the first row of the second column is empty, so the blank text is skipped and the next text content is read down.

[0091] When parsing the fourth column, since the entire column is empty, the parsing of the flowchart area is completed.

[0092] In some embodiments, the attribute area includes: a definition column, a name column, a comment column, and a parameter configuration column.

[0093] The two-dimensional object array is parsed into an attribute area, including:

[0094] The text content of each array element in the definition column is read from top to bottom, and the text content is one of execution unit definition, variable definition, or program definition characters;

[0095] The text content of each array element in the name column is read from top to bottom, and the text content is the name attribute character corresponding to the definition in the definition column, such as execution unit name, variable name, and program name.

[0096] The text content of each array element in the comment column is read from top to bottom, and the text content is the comment attribute character corresponding to the definition in the definition column.

[0097] When the array element is a program definition character content, the parameter configuration column corresponding to the array element describes the attribute information of the target graphic program, such as program name, display name, repetition times, whether to activate, etc.

[0098] When the array element is a variable definition character content, the parameter configuration column corresponding to the array element describes the variable information of the target graphic program, such as variable type, variable initial value, etc.

[0099] When the array element is an execution unit definition character content, the parameter configuration column corresponding to the array element describes the execution unit information of the target graphic program, and the character content of the execution unit definition is a cell coordinate value. Different execution unit types have different parameter configuration requirements, and the execution unit has the following types:

[0100] 1) Entry Point (EP) type, which is the first execution unit of a graphic program and does not perform any substantive operation. After the execution of the EP type is completed, only the downward execution is allowed.

[0101] 2) No Operation (NOP) type, which does not perform any substantive operation. After the execution of the NOP type is completed, the downward or rightward execution is allowed.

[0102] Parameter configuration information: none.

[0103] 3) Read (RD) type, which reads one or more signals and judges whether the value of the signal is within the set range. If the judgment is in line with the expectation, the program continues to execute downward; otherwise, the program continues to execute rightward. The execution unit of the RD type supports both the downward and rightward execution paths.

[0104] Parameter configuration information includes: judgment timeout, variable quantity, name of each variable, type of each variable, minimum value of each variable, maximum value of each variable, judgment pass condition (and or or), etc.

[0105] 4) Write (WR) type, which writes one or more signals. The execution unit of the WR type supports either the downward or rightward execution path, but not both.

[0106] Parameter configuration information includes: variable quantity, name of each variable, type of each variable, value to be written into each variable, etc.

[0107] 5) Jump to (JMP) type, which supports the program to jump to the target execution unit for continuous execution. The JMP type does not have any downward or rightward connected path.

[0108] Parameter configuration information includes: jump label (inter-label jump), and multiple jump labels.

[0109] 6) Jump from (FROM) type, which supports the program to jump from the JMP type to the execution unit for continuous execution. The FROM type supports either the downward or rightward execution path, but not both.

[0110] Parameter configuration information includes: jump label (inter-label jump), and one jump label.

[0111] 7) Function Call type, which can be abbreviated as API (Application Interface). This execution unit is responsible for calling a target API function with specific parameters. The function call type supports either a downward or a rightward execution path, but not both.

[0112] The parameter configuration information can include, but is not limited to, the API function name, the API function type (such as system API, small program library API, and user self-programmed API), whether to ignore the return value of the API function, the variable type to which the return value is written, the variable name to which the return value is written, the number of parameters of the API function, the type of each parameter, the name of each parameter, and the value of each parameter.

[0113] 8) Subchart Group type, which can be abbreviated as Group. This execution unit contains a nested subchart. The nested subchart type supports either a downward or a rightward execution path, but not both.

[0114] The parameter configuration information can include, but is not limited to, the variable type corresponding to the number of repetitions and the variable name corresponding to the number of repetitions.

[0115] 9) Expression type, which can be abbreviated as EXP. This execution unit is used to execute a specific mathematical expression. The expression type supports either a downward or a rightward execution path, but not both.

[0116] The parameter configuration information includes the number of arguments, the expression, the variable type to which the expression result is written, the variable name to which the expression result is written, the type of each argument, the name of each argument, and the like.

[0117] Case Three

[0118] The method of parsing the two-dimensional object array into attribute areas is described in detail with a case as follows:

[0119] The following table is an example of a two-dimensional object array with 6 rows and 8 columns:

[0120] NOP EP Def Name Comment Configuration - NOP NOP Program GP1 program comment 1; 1; am_GP1; Program1 A2 NOP NOP1 0；1；0 A3 first Unit under EP NOP2 0；1；0 C2 second Unit under first Unit NOP3 0；1；0 third Unit on right side v0 Var 0；0；

[0121] The attribute area ranges from the 5th column to the 8th column, which are the definition column, the name column, the comment column, and the parameter configuration column, respectively.

[0122] The first row of column 5 is Def, which means that the column is the definition column. The second row is Program, which means that the row is the program definition. The third to fifth rows are the cell coordinate values, which means that the corresponding rows are the execution unit definition. For example, A2 means that the corresponding execution unit is in the A column and the second row. The sixth row is Var, which means that the row is the variable definition.

[0123] The first row of column 6 is Name, which means that the column is the name column. The second row is GP1, which means that the program name is GP1. The third to fifth rows are NOP1, NOP2, and NOP3, which means that the corresponding execution units are NOP1, NOP2, and NOP3. The sixth row is v0, which means that the variable name is v0.

[0124] The first row of column 7 is Comment, which means that the column is the comment column. The second row is the comment of the program GP1. The third to fifth rows are the comments of the execution units NOP1, NOP2, and NOP3. The sixth row is the comment of the variable v0.

[0125] The first row of column 8 is Configuration, which means that the column is the parameter configuration column. The second row is the parameter configuration information of the program GP1. The third to fifth rows are the parameter configuration information of the execution units NOP1, NOP2, and NOP3. The sixth row is the parameter configuration information of the variable v0.

[0126] In some embodiments, the method of constructing a graphical program according to the parsing result includes: constructing a graphical program according to the attribute information of the target graphical program; adding variables to the graphical program according to the variable information of the target graphical program; constructing the main program execution unit of the graphical program and the jump relationship between the execution units according to the parsed flowchart area; constructing the nested subprograms of the graphical program according to the parsed flowchart area, and associating the nested subprograms with the corresponding execution units of the main program or the previous layer of nested subprograms; constructing the execution units in the nested subprograms of the graphical program and the jump relationship between the execution units according to the parsed flowchart area; and configuring the execution units of the graphical program according to the execution unit information of the target graphical program.

[0127] Case Four

[0128] The following is a detailed description of the method of constructing a graphical program according to the parsing result, as follows:

[0129] The following table is a two-dimensional object array of two examples, Table 1 represents the main program parsing result of the graphical program, which has 8 rows and 8 columns.

[0130] Table 1 Main Program Parsing Result Table

[0131] variable define EP Def Name Comment Configuration - NOP JMP Program GP1 program comment 1; 1; am_GP1; Program1 NOP v0 Var 0；0； variable define A2 FROM check 1；1；0 first Unit under EP A3 Group Ignore 0；1；0 A4 this is ignored jmp from jump from other sources A5 jmp Group 1 C2 this is a sub group jmp to jump to another position

[0132] Table 2 represents the result of the nested subprogram parsing of the graph program, which has 3 rows and 6 columns.

[0133] Table 2 Nested subprogram parsing result table

[0134] jmp EP Def Name Comment Configuration A2 NOP NOP1 0；1；0 this is NOP1 A3 NOP NOP2 0；1；0

[0135] The two two-dimensional object arrays have been parsed into flowchart area and attribute area. The attribute area of the main program contains the attributes of the program and variables, while the attribute area of the nested subprogram does not contain the attributes of the program and variables. The definition column, name column, comment column and parameter configuration column in the attribute area of the two tables have been parsed and extracted. Then the graph program is constructed according to the following steps:

[0136] First, an empty graph program is constructed according to the parsed name, comment and parameter configuration information of Program, as shown in this is NOP2 .

[0137] In the empty graph program, the graph program module window title is Program1, which comes from the parameter configuration column information of the parsed Program; the display name of the graph program submodule is GP1, which comes from the name column of the parsed Program; the program name of the graph program submodule is am_GP1, which comes from the parameter configuration column information of the parsed Program; and the comment information of the graph program submodule comes from the comment column of the parsed Program.

[0138] Secondly, according to the parsed variable information, a variable is added to the graph program, as shown in Figure 2 , which is an integer type (Integer) from the parameter configuration column information of the parsed variable v0; the variable name is v0 from the name column of the parsed variable; the variable initial value is 0 from the parameter configuration column information of the parsed variable v0; and the variable comment is "variable define" from the comment column of the parsed variable.

[0139] Thirdly, the main program execution unit of the graph program and the jump relationship between each execution unit are constructed according to the flowchart area parsed in Table 1, where the execution unit name (type) of the main program has the following:

[0140] Entry (EP), check (NOP), Ignore (NOP), jmp to (JMP), jmp from (FROM), Group (Group). The jump relationship between them is:

[0141] Entry jumps down to check;

[0142] check branches down to Ignore, branches right to jmp to;

[0143] Ignore branches down to jmp from;

[0144] jmp to branches right to jmp from;

[0145] jmp from branches down to Group;

[0146] According to the execution units and the jump relationship between the execution units constructed above, the main program flowchart as shown in Figure 3 may be generated.

[0147] Again, according to the flowchart area parsed in Table 2, the nested subprogram of the graphic program is constructed, and each nested subprogram is associated with the corresponding execution unit of the main program or the previous layer of the nested subprogram, that is, the execution unit named Group in the main program in Table 1 is associated with the nested subprogram in Table 2, so that the user can double-click the execution unit named Group in the main program interface to open the nested subprogram.

[0148] Again, according to the execution units and the jump relationship between the execution units in the nested subprogram of the graphic program constructed according to the parsed flowchart area, the nested subprogram in this case is the nested subprogram of Group in the main program, and the names (types) of each execution unit are as follows:

[0149] Sub Entry (EP), NOP1 (NOP), and NOP2 (NOP). The jump relationship between them is as follows:

[0150] Sub Entr branches down to NOP1;

[0151] NOP1 branches down to NOP2;

[0152] According to the execution units and the jump relationship between the execution units constructed above, the nested subprogram flowchart as shown in Figure 4 may be generated.

[0153] Finally, according to the execution unit information of the target graphic program, each execution unit of the graphic program is configured, taking the execution unit named check as an example, according to the parsed results of its attribute area, its execution type is null operation, its display name is check, its timeout time is 0, its comment information is "first Unit under EP", its next step goes to the right execution, and its current step result is set to OK, as shown in Figure 5 .

[0154] In some embodiments, each nested subprogram is associated with the corresponding execution unit of the main program, including:

[0155] The name of the two-dimensional object array corresponding to each nested subprogram is set as the cell coordinate value of the corresponding execution unit in the main program corresponding to the nested subprogram; and the execution unit corresponding to the cell coordinate value in the name of the two-dimensional object array is associated with the main program in which the execution unit is located.

[0156] In some embodiments, each nested subprogram is associated with the corresponding execution unit of the upper layer nested subprogram corresponding thereto, including:

[0157] The name of the two-dimensional object array corresponding to each nested subprogram is set, wherein a separator is set between the name of the two-dimensional object array corresponding to the upper layer nested subprogram and the cell coordinate value of the corresponding execution unit in the upper layer nested subprogram corresponding to each nested subprogram; and the content left of the last separator in the name of the two-dimensional object array corresponding to each nested subprogram is extracted and matched with the remaining two-dimensional object array names, and after matching, the execution unit corresponding to the cell coordinate value right of the last separator in the name of the two-dimensional object array is associated with the nested subprogram parsed by the two-dimensional object array.

[0158] Specifically, the separator can be any symbol allowed by Excel for naming, such as but not limited to "|", ",", ".", and ">". This embodiment takes "|" as an example.

[0159] Case Five

[0160] A case is described in detail to associate each nested subprogram with the corresponding execution unit of the upper layer nested subprogram corresponding thereto, as follows:

[0161] As shown in Figure 6 The two-dimensional object array file can be understood as a file similar to the table file format. It is assumed that a two-dimensional object array file includes five two-dimensional object arrays, and the first page is the two-dimensional object array corresponding to the main program, and the remaining pages are the two-dimensional object arrays corresponding to the nested subprograms. The name of the two-dimensional object array in the second page is A7, indicating that the content of the two-dimensional object array is the nested subprogram of the execution unit in the A7 cell of the main program page. The name of the two-dimensional object array of the third page nested subprogram is "A7|A4", indicating that the content of the two-dimensional object array is the nested subprogram of the execution unit in the A4 cell of the A7 page. The same applies to the subsequent pages.

[0162] The second page nested subprogram two-dimensional object array name is "A7|A4", the execution unit of the C5 cell position of the two-dimensional object array is an execution unit with the next level of nested subprogram, and the method for associating the execution unit at the C5 cell position with the next level of nested subprogram is as follows:

[0163] First, the two-dimensional object array of the next level of nested subprogram corresponding to the cell C5 is named "A7|A4|C5", as shown in the fourth page two-dimensional object array. Figure 7

[0164] Then, the content "A7|A4" on the left side of the last separator in the fourth page two-dimensional object array name "A7|A4|C5" is extracted, and "A7|A4" is matched with the names of the remaining two-dimensional object arrays one by one, as shown in the above figure, and finally matched to the third page two-dimensional object array. The cell coordinate value "C5" on the right side of the last separator in the fourth page two-dimensional object array name is associated with the corresponding execution unit in the third page two-dimensional object array corresponding to the cell coordinate value "C5" and the nested subprogram parsed from the fourth page two-dimensional object array.

[0165] Specifically, the method of associating the nested subprogram with the corresponding execution unit of the main program according to the embodiment can realize several levels of nesting.

[0166] In some embodiments, the corresponding table pages are constructed in sequence according to the program categories in the graphical program, including:

[0167] The execution units of the main program and the connection relationship between the execution units are written in text form in the corresponding cells of the table page, and are used as a flowchart area, that is,

[0168] If the execution unit is an execution unit supporting right execution, the execution unit, the right execution unit connected to the execution unit, and the connection relationship between them are displayed in the same row and different column cells in the order of the execution direction;

[0169] If the execution unit is an execution unit supporting downward execution, the execution unit, the downward execution unit connected to the execution unit, and the connection relationship between them are displayed in the same column and different row cells in the order of the execution direction;

[0170] The text form of the execution unit is an execution unit type character, and the text form of the connection relationship is a connection symbol.

[0171] Specifically, the connection symbol can be a symbol such as but not limited to "-" and "_".

[0172] Case six

[0173] ​The following case will be described in detail according to the program category in the graphic program to construct the corresponding table page in sequence, as follows:

[0174] The example graphic program is shown in Figure 8 .

[0175] The names (types) of each execution unit of the main program in the graphic program are as follows:

[0176] Entry (EP), check (NOP), Ignore (NOP), jmp to (JMP), jmp from (FROM), Group (Group).

[0177] The jump relationship between them is:

[0178] Entry jumps down to check, and Entry and check are in the same column;

[0179] check jumps down to Ignore, and check and Ignore are in the same column;

[0180] check jumps right to jmp to, and check and jump to are in the same row, and check adds a connector to the right and connects jump to to the right;

[0181] Ignore jumps down to jmp from, and Ignore and jmp from are in the same column;

[0182] jmp to jumps right to jmp from, and the jump destination is not directly connected to jmp to, so jmp to and jmp from are not in the same row;

[0183] jmp from jumps down to Group, and jmp from and Group are in the same column;

[0184] The final output table content is shown in Figure 9 . The area in columns A to C is the flowchart area constructed.

[0185] In some embodiments, according to the program category in the graphic program to construct the corresponding table page in sequence, further comprising:

[0186] If there is an execution unit with a nested subprogram in the main program, the connection relationship between the execution unit of the nested subprogram and the execution unit is written in the corresponding cell of the table page in text form, and the table page written by the nested subprogram execution unit and the table page written by the main program execution unit are not the same table page; and

[0187] The name of the page is set to the cell coordinate value of the execution unit with the nested subprogram in the main program.

[0188] Case Seven

[0189] A case is used to illustrate the method of sequentially constructing corresponding table pages according to the program categories in the graphic program, as follows:

[0190] As shown in the graphic program, Figure 10 the execution unit "Group" of the main program GP1 contains nested subprograms, as shown in Figure 4 .

[0191] First, the table page corresponding to the nested subprogram is constructed according to the method of constructing the table page corresponding to the main program, as shown in Figure 11 .

[0192] Second, the name of the page where the table page is located is set to the cell coordinate value A5 of the execution unit with the nested subprogram in the main program, as shown in Figure 12 .

[0193] In some embodiments, if a nested subprogram has an execution unit with a next-level nested subprogram, the name of the table page where the next-level nested subprogram is located is set to: the name of the table page where the nested subprogram is located + "separator" + the cell coordinate value of the execution unit with the next-level nested subprogram in the nested subprogram.

[0194] Case Eight

[0195] For example, as shown in Figure 13 , the nested subprogram with the page name A7 has an execution unit in the A4 cell with a next-level nested subprogram. The name of the page where the next-level nested subprogram is located is set to: the name of the page where the nested subprogram is located "A7" plus the separator "|", and then plus the cell coordinate value "A4" of the execution unit with the next-level nested subprogram in the nested subprogram, i.e., the final page name is "A7|A4".

[0196] In some embodiments, the sequentially constructing corresponding table pages according to the program categories in the graphic program further includes:

[0197] Defining attribute areas in each table page, and constructing definition columns, name columns, comment columns, and parameter configuration columns in the corresponding attribute areas;

[0198] Writing the character contents of program definitions, variable definitions, and execution unit definitions from top to bottom into the cells of the definition columns, wherein the character contents of the execution unit definitions are the corresponding cell coordinate values;

[0199] The defined attribute character contents are written in the corresponding cells of the name column, the comment column and the parameter configuration column in turn.

[0200] Case Nine

[0201] The method of constructing the attribute area composed of the definition column, the name column, the comment column and the parameter configuration column in each page is described in detail by taking the sub-module GP1 of the graphic program Program1, the variable v0 and the execution unit check involved in the foregoing cases as examples:

[0202] Firstly, the right area of the graphic program corresponding to the table page of the corresponding program and separated from the flowchart area by a blank column is defined as the attribute area, and the definition column, the name column, the comment column and the parameter configuration column are created in the attribute area, and the column names are Def, Name, Comment and Configuration respectively.

[0203] In the definition column of the attribute area of the table page corresponding to the main program, Program is added, and the name column cell in the same row is modified to the sub-module name "GP1", the comment column cell in the same row is modified to the sub-module comment "program comment", and finally the parameter configuration column cell in the same row is modified to the configuration information of the sub-module "1; 1; am_GP1; Program1", and the display content of the row is finally shown in the following table:

[0204] Figure 14 Program GP1 program comment

[0205] According to the number of variables, Var is added in the definition column of the attribute area of the table page corresponding to the main program in turn, and the name column cell in the same row is modified to the variable name "v0", the comment column cell in the same row is modified to the variable comment "variable define", and finally the parameter configuration column cell in the same row is modified to the configuration information of the sub-module "0; 0;", and the display content of the row is finally shown in the following table:

[0206] 1; 1; am_GP1; Program1 v0 Var 0；0；

[0207] Subsequently, according to the number of execution units, the attribute of each type of program is output in turn, and the execution unit check is taken as an example, as shown in the following table: variable define

[0208] Firstly, the cell coordinate value A2 of the execution unit is output in the definition column; secondly, the name "check" of the execution unit is output in the name column; thirdly, the comment "first Unit under EP" of the execution unit is output in the comment column; and finally, the configuration information "0; 0;" of the execution unit is output in the parameter column.

[0209] ​Case ten

[0210] The following describes the process of converting a table file into a graphic program, taking a table file of a test script for an automobile part as an example. The table file has five pages of tables. The first page of tables is a main program Main, as shown in Figure 15 ; the second page of tables is as shown in Figure 16 ; the third page of tables is as shown in Figure 17 ; the fourth page of tables is as shown in Figure 18 ; and the fifth page of tables is an empty table, as shown in Figure 19 .

[0211] The above table file is read into corresponding two-dimensional object arrays, and the names of the two-dimensional object arrays are set as the corresponding page names. Taking the first page of tables as an example, the generated two-dimensional object array is shown in the following table:

[0212]

[0213]

[0214] Each two-dimensional object array is parsed one by one. First, the flowchart area in the two-dimensional object array is parsed to obtain each execution unit and the jump relationship between the execution units. Then, the attribute area in the two-dimensional object array is parsed to obtain the attributes of the program, the variable attributes, and the attribute information of each execution unit.

[0215] After parsing all the two-dimensional object arrays, the construction of the graphic program begins, following the steps below:

[0216] First, the graphic program is constructed according to the attribute information of the target graphic program. For example, the name of the current graphic program sub-module is Demo Program, and the comment information is program comment.

[0217] Second, variables are added to the graphic program according to the variable information of the target graphic program. For example, local1 and local2.

[0218] Third, the main program execution unit of the graphic program and the jump relationship between the execution units are constructed according to the parsed flowchart area.

[0219] Fourth, each nested sub-program of the graphic program is constructed according to the parsed flowchart area, and each nested sub-program is associated with the corresponding execution unit of the main program.

[0220] Finally, each execution unit in the nested sub-program of the graphic program and the jump relationship between the execution units are constructed according to the parsed flowchart area, and each execution unit of the graphic program is configured according to the execution unit information of the target graphic program.

[0221] The conversion method of the rest of the pages is described in the foregoing part of this embodiment, and will not be described here.

[0222] The construction of the graphical program is finally completed, wherein the main program of the graphical program is as shown in Figure 20 The test script can be directly run, and the program executes the test process according to the logic defined in the table file.

[0223] Case Eleven

[0224] The process of converting the graphical program into the table file is introduced by taking the graphical program submodule Demo Program of a test script of an automobile part as an example. The graphical program has five flowcharts, wherein the first flowchart is the flowchart corresponding to the main program, as shown in Figure 21

[0225] The second flowchart is the flowchart corresponding to the first layer of nested subprograms, as shown in Figure 22 The third flowchart is the flowchart corresponding to the second layer of nested subprograms, as shown in Figure 23 The fourth flowchart is the flowchart corresponding to the third layer of nested subprograms, as shown in Figure 24 The fifth flowchart is an empty flowchart, as shown in Figure 25

[0226] First, the table page corresponding to each flowchart is output, including the flowchart area and the attribute area. Second, starting from the flowchart of the main program, each execution unit in the flowchart is traversed, the execution unit of the flowchart containing the nested subprogram is associated with the corresponding nested subprogram, and the name of the corresponding table page is modified according to the rules. Finally, the entire table file is saved, the conversion from the graphical file to the table file is realized, and the specific conversion process is described in the foregoing part of this embodiment, and will not be described here.

[0227] The converted table file is as shown in Figure 26

[0228] As shown in Figure 27 Some embodiments also provide a conversion system, comprising: a computer device configured to include:

[0229] a table and graphical conversion module configured to read the table file to read the text content and coordinate information of all cells in at least one page of the table file into the corresponding two-dimensional object array, and set the name of each two-dimensional object array as the corresponding page name; sequentially parse each two-dimensional object array into a flowchart area and an attribute area according to the page; construct a graphical program according to the parsing result; and / or

[0230] ​​​The graphics and table conversion module is configured to create blank table pages, the number of which is equal to the sum of the number of main programs and nested subroutines in the graphics program; construct corresponding table pages in sequence according to the program categories in the graphics program, one page corresponding to the main program and the remaining pages corresponding to the corresponding nested subroutines; and save the constructed table file.

[0231] Among them, the specific implementation functions of the table and graphic conversion module and the graphic and table conversion module are realized in the computer device. The specific content of the conversion method between the table file and the graphic program can be referred to, and will not be repeated here.

[0232] In some embodiments, the table-to-graph conversion module and the graph-to-table conversion module can be used independently or in combination according to actual scenarios.

[0233] The electronic device in the embodiment of the present disclosure is described below from the perspective of hardware processing:

[0234] The embodiments of the present disclosure do not limit the specific implementation of the electronic device.

[0235] like Figure 28 As shown, some embodiments further provide an electronic device, comprising: a processor, a readable storage medium, and may also include a communication bus and a communication interface; wherein the processor, the readable storage medium and the communication interface communicate with each other via the communication bus; the readable storage medium is used to store a program for executing the method for converting the table file to the graphic program, and the program enables the processor to execute operations corresponding to the conversion method.

[0236] like Figure 29 As shown, some embodiments further provide an electronic device, including:

[0237] A processor, a display communicating with the processor to present a table file or a graphical interface, and a readable storage medium; wherein

[0238] The readable storage medium is configured to store an instruction program;

[0239] The processor is configured to execute the program of instructions to perform the following operations:

[0240] Reading a table file to read the text content and coordinate information of all cells in at least one page of the table file into corresponding two-dimensional object arrays, and setting the name of each two-dimensional object array to the name of the corresponding page; parsing each two-dimensional object array into a flowchart area and an attribute area in sequence according to the page; and constructing a graphics program based on the parsing results; and / or

[0241] create table empty pages, the number of table empty pages being equal to the sum of the number of main programs and nested sub-programs in the graphic program; construct corresponding table pages according to the program categories in the graphic program, one page corresponding to a main program and the rest corresponding to corresponding nested sub-programs; save the constructed table file; and

[0242] The display is configured to display the table file or display the graphic program through a graphic interface.

[0243] In some embodiments, the computer device or industrial computer can also be a kind of electronic device.

[0244] Figure 30 and Figure 29 The structure shown does not constitute a limitation on the electronic device, and can include fewer or more components than shown, or combine certain components, or arrange different components.

[0245] In some embodiments, the communication interface can be RS232, RS485, USB port, TYPE port, etc., and can be a communication interface connected with an external bus adapter. It can also include a wired or wireless network interface, which can optionally include a wired interface and / or a wireless interface (such as a WI-FI interface, a Bluetooth interface, etc.), and is usually used to establish a communication connection between the computer device and other electronic devices.

[0246] In some embodiments, the readable storage medium or computer readable storage medium includes at least one type of memory, such as flash memory, hard disk, multimedia card, card-type memory (such as SD memory, etc.), magnetic memory, disk, optical disk, etc. In some embodiments, it can be an internal storage unit of the computer device, such as the hard disk of the computer device. In other embodiments, the memory can also be an external storage device of the computer device, such as a plug-in hard disk, a smart media card (SMC), a secure digital (SD) card, a flash card, etc. Further, the memory can include both the internal storage unit and the external storage device of the computer device. The memory can be used not only to store application software and various data installed on the computer device, such as the code of the computer program, etc., but also to temporarily store data that has been output or will be output.

[0247] The processor in some embodiments can be a central processing unit (CPU), a controller, a microcontroller, a microprocessor, or other data processing chip, used to run the program code stored in the memory or process data, such as executing a computer program, etc.

[0248] In some embodiments, the communication bus can also be an input / output bus, which can be a Peripheral Component Interconnect (PCI) bus or an Enhanced Industry Standard Architecture (EISA) bus, etc. The bus can be divided into an address bus, a data bus, a control bus, etc.

[0249] Optionally, the computer device can further include a user interface, which can include a display, an input unit such as a keyboard, and optionally, a standard wired interface, a wireless interface. Optionally, in some embodiments, the display can be an LED display, a liquid crystal display, a touch liquid crystal display, an OLED (Organic Light-Emitting Diode) touch, etc. The display can also be appropriately referred to as a display screen or a display unit, for displaying information processed in the computer device and for displaying a visualized user interface.

[0250] The processor implements the steps in the above-described table file and graphical program conversion method embodiment shown in FIG. 1 when executing the program, such as the step diagram shown in FIG. 1. Alternatively, the processor implements the functions of each module or unit in the above-described various device embodiments when executing the computer program.

[0251] Some embodiments also provide a computer readable storage medium configured to store any of the above-described table file and graphical program conversion methods.

[0252] Some embodiments also provide a computer readable storage medium storing computer readable instructions which, when executed by at least one processor, cause the conversion method as described above to be performed, specifically as follows:

[0253] reading the table file to read the text content and coordinate information of all cells in at least one page of the table file into a corresponding two-dimensional object array, and setting the name of each two-dimensional object array as the corresponding page name; sequentially parsing each two-dimensional object array into a flowchart area and an attribute area according to page; constructing a graphical program according to the parsing result; and / or

[0254] creating table empty pages, the number of which is equal to the sum of the number of main programs and nested sub-programs in the graphical program; sequentially constructing corresponding table pages according to the program categories in the graphical program, wherein one page corresponds to a main program, and the remaining pages each correspond to a corresponding nested sub-program; and saving the constructed table file.

[0255] For details of the conversion method of the table file and the graphic program, please refer to the table file and the graphic program conversion method, which will not be described here.

[0256] Some embodiments also provide a computer program product comprising a computer program or instructions, wherein the computer program or instructions, when executed on a computer, enable the computer to perform any of the above possible table file and graphic program conversion methods.

[0257] Some embodiments also provide a computer program product comprising a computer readable storage medium having stored thereon a computer readable program code, the computer readable program code comprising instructions to cause at least one processor or one or more computer devices to perform any of the above possible table file and graphic program conversion methods, i.e.

[0258] reading the table file to read the text content and coordinate information of all cells in at least one page of the table file into the corresponding two-dimensional object array, and setting the name of each two-dimensional object array as the corresponding page name; sequentially parsing each two-dimensional object array into a flowchart area and an attribute area according to the page; constructing a graphic program according to the parsing result; and / or

[0259] creating table empty pages, the number of which is equal to the sum of the number of main programs and nested sub-programs in the graphic program; constructing corresponding table pages according to the program categories in the graphic program, wherein one page corresponds to a main program, and the remaining pages correspond to corresponding nested sub-programs; and saving the constructed table file.

[0260] As shown in Figure 30 Figure 31 some embodiments also provide a system comprising: one or more processors; and

[0261] a memory storing one or more programs configured to be executed by the one or more processors, the one or more programs comprising instructions to perform the following actions:

[0262] converting a table file into a graphic program, comprising: reading the table file to read the text content and coordinate information of all cells in at least one page of the table file into the corresponding two-dimensional object array, and setting the name of each two-dimensional object array as the corresponding page name; sequentially parsing each two-dimensional object array into a flowchart area and an attribute area according to the page; constructing a graphic program according to the parsing result; and / or

[0263] converting a graphic program into a table file, comprising: creating table empty pages, the number of which is equal to the sum of the number of main programs and nested sub-programs in the graphic program; constructing corresponding table pages according to the program categories in the graphic program, wherein one page corresponds to a main program, and the remaining pages correspond to corresponding nested sub-programs; and saving the constructed table file.

[0264] In some embodiments, it will be understood that the disclosed apparatus and methods can also be implemented in other ways. The apparatus embodiments described above are merely illustrative for the present application. For example, the flowcharts and block diagrams in the accompanying drawings show the possible implementation architectures, functions and operations of the apparatus, method and computer program product according to the embodiments of the present application. In this regard, each block in the flowcharts or block diagrams can represent a module, a program segment or a part of code, which contains one or more executable instructions for implementing the specified logic function. It should also be noted that in some alternative implementations, the functions noted in the blocks can occur in a different order than that shown in the accompanying drawings. For example, two consecutive blocks can actually be executed substantially in parallel, and they can also be executed in reverse order, depending on the functions involved. It should also be noted that each block in the block diagrams and / or flowcharts, and the combination of blocks in the block diagrams and / or flowcharts, can be implemented by a dedicated hardware-based system for performing the specified functions or actions, or can be implemented by a combination of dedicated hardware and computer instructions.

[0265] In addition, each functional module in the embodiments of the present application can be integrated together to form an independent part, or each module can exist independently, or two or more modules can be integrated to form an independent part.

[0266] If the functions are implemented in the form of software function modules and sold or used as independent products, they can be stored in a computer readable storage medium. Based on this understanding, the technical solutions of the present application can be embodied in the form of a software product, and the computer software product is stored in a storage medium, and includes a number of instructions for causing a computer device (which can be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the methods described in the embodiments of the present application.

[0267] Based on the above ideal embodiments according to the present application, through the above description, relevant personnel can make various changes and modifications without deviating from the scope of the technical idea of the present application. The technical scope of the present application is not limited to the content in the specification, and must be determined according to the scope of the claims.

Claims

1. A conversion system comprising: A computer device, the computer device being configured to include: A table and graphics conversion module is configured to read a table file, read the text content and coordinate information of all cells in at least one page of the table file into corresponding two-dimensional object arrays, and set the name of each two-dimensional object array to the name of the corresponding page; parse each two-dimensional object array into a flowchart area and an attribute area in sequence according to the page; and construct a graphics program based on the parsing results; and / or The graphics and table conversion module is configured to create blank table pages, the number of which is equal to the sum of the number of main programs and nested subroutines in the graphics program; construct corresponding table pages in sequence according to the program categories in the graphics program, one page corresponding to the main program and the remaining pages corresponding to the corresponding nested subroutines; and save the constructed table file.

2. The conversion system according to claim 1, characterized in that The flowchart area includes: at least one execution unit type character, each corresponding to an execution unit in the graphics program; and Parse the two-dimensional array of objects into flowchart regions, including: Read the text content of each array element from top to bottom and judge the text content; If it is determined that the text content is an execution unit type character, then the execution unit type is determined based on the text content, and if the content of the array element above the execution unit type character is also an execution unit type character, then the corresponding execution unit is marked as the next execution unit of the execution unit above; If the text content is determined to be empty, skip the text content and continue reading the next text content; and If the text content of the entire column from top to bottom is empty, the flowchart area parsing is completed.

3. The conversion system according to claim 2, characterized in that The flow chart area further includes: a connector; Parsing the two-dimensional object array into flowchart regions further includes: Read the text content of each array element from left to right and judge the text content; If the text content is determined to be a connector, mark the first execution unit found to the left of the connector as an execution unit that supports rightward execution, and at the same time mark the first execution unit found to the right of the connector as the next execution unit executed to the right by the aforementioned execution unit.

4. The conversion system according to claim 3, characterized in that The attribute area includes: a definition column, a name column, a comment column, and a parameter configuration column; Parse the two-dimensional object array into attribute areas, including: Read the text content of each array element in the definition column from top to bottom, the text content is a character in the execution unit definition, variable definition or program definition; When an array element is a character content defined by the program, the parameter configuration column corresponding to the array element describes the attribute information of the target graphics program; When an array element is the character content of a variable definition, the parameter configuration column corresponding to the array element describes the variable information of the target graphics program; When an array element is a character content defined by an execution unit, the parameter configuration column corresponding to the array element describes the execution unit information of the target graphics program; Read the text content of each array element in the name column from top to bottom. The text content is the name attribute character of the corresponding definition in the definition column. The text content of each array element in the comment column is read from top to bottom. The text content is the comment attribute character corresponding to the definition column.

5. The conversion system according to claim 4, characterized in that Build a graphics program based on the parsing results, including: constructing a graphics program according to the attribute information of the target graphics program; Add variables to the graphics program according to the variable information of the target graphics program; Constructing the main program execution unit of the graphic program and the jump relationship between the execution units according to the parsed flowchart area; Then, each nested subroutine of the graphic program is constructed according to the parsed flow chart area, and each nested subroutine is associated with the corresponding execution unit of the main program or its upper nested subroutine; Finally, constructing the execution units in the nested subroutines of the graphic program and the jump relationships between the execution units according to the parsed flowchart area; and Each execution unit of the graphics program is configured according to the execution unit information of the target graphics program.

6. The conversion system according to claim 5, characterized in that Associate each nested subroutine with the corresponding execution unit of the main program, including: Setting the name of the two-dimensional object array corresponding to each nested subroutine includes: the cell coordinate value where the corresponding execution unit of each nested subroutine in the main program is located; and Associate the execution unit corresponding to the cell coordinate value in the two-dimensional object array name with the main program where the execution unit is located.

7. The conversion system according to claim 5, characterized in that Associating each nested subroutine with the corresponding execution unit of the upper nested subroutine, including: Set the name of the two-dimensional object array corresponding to each nested subroutine, wherein a separator is set between the name of the two-dimensional object array corresponding to the upper nested subroutine and the cell coordinate value of the corresponding execution unit in the upper nested subroutine corresponding to each nested subroutine; and Extract the content on the left side of the last separator in the two-dimensional object array name corresponding to each nested subroutine and match it with the remaining two-dimensional object array names. After the match is consistent, associate the execution unit corresponding to the cell coordinate value on the right side of the last separator in the two-dimensional object array name with the nested subroutine parsed by the two-dimensional object array.

8. The conversion system according to claim 1, characterized in that Build the corresponding table pages in sequence according to the program categories in the graphics program, including: According to the execution units of the main program and the connection relationship between the execution units, the corresponding cells of the table page are written in text form to construct the flowchart area; If the execution unit supports rightward execution, the execution unit, the execution unit connected to the right of the execution unit, and the connection relationship between them are displayed in cells of the same row but different columns in the order of execution direction; If the execution unit is an execution unit that supports downward execution, the execution unit and the execution units connected to it are displayed in cells of the same column but different rows in the order of execution direction; The text form of the execution unit uses the execution unit type character, and the text form of the connection relationship uses the connector.

9. The conversion system according to claim 8, characterized in that The corresponding table pages are constructed in sequence according to the program categories in the graphics program, and also include: If the main program has an execution unit with a nested subroutine, the connection relationship between the execution unit of the nested subroutine corresponding to the execution unit and the execution unit is written in text form in the corresponding cell of the table page, and the table page written to the nested subroutine execution unit is different from the table page written to the main program execution unit; and The name of the page is set to the cell coordinate value of the execution unit with the nested subroutine in the main program; and If a nested subroutine has an execution unit with a next-level nested subroutine, the naming method of the table page where the next-level nested subroutine of the nested subroutine is located includes: a separator is set between the name of the table page where the nested subroutine is located and the cell coordinate value of the execution unit with the next-level nested subroutine in the nested subroutine.

10. The conversion system according to claim 9, characterized in that The corresponding table pages are constructed in sequence according to the program categories in the graphics program, and also include: Define the attribute area in each table page, and build the definition column, name column, comment column and parameter configuration column in the corresponding attribute area; Write the character contents of program definition, variable definition and execution unit definition into the cells of definition column from top to bottom, where the character contents of execution unit definition are the coordinate values ​​of the corresponding cells; Write the defined attribute character contents into the corresponding cells of the Name column, Comment column, and Parameter Configuration column row by row.

Images