CN117389569B - Program interpretation execution method - Google Patents
Program interpretation execution method Download PDFInfo
- Publication number
- CN117389569B CN117389569B CN202311400374.8A CN202311400374A CN117389569B CN 117389569 B CN117389569 B CN 117389569B CN 202311400374 A CN202311400374 A CN 202311400374A CN 117389569 B CN117389569 B CN 117389569B
- Authority
- CN
- China
- Prior art keywords
- node
- type
- judging
- logic tree
- program
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 50
- 230000009191 jumping Effects 0.000 claims description 28
- 238000010276 construction Methods 0.000 claims description 10
- 230000001351 cycling effect Effects 0.000 claims description 4
- 125000004122 cyclic group Chemical group 0.000 claims description 3
- 238000012986 modification Methods 0.000 description 8
- 230000004048 modification Effects 0.000 description 8
- 238000011161 development Methods 0.000 description 5
- 101001072091 Homo sapiens ProSAAS Proteins 0.000 description 3
- 101150096185 PAAS gene Proteins 0.000 description 3
- 102100036366 ProSAAS Human genes 0.000 description 3
- 238000013473 artificial intelligence Methods 0.000 description 3
- 230000006870 function Effects 0.000 description 3
- 238000007726 management method Methods 0.000 description 3
- 230000008569 process Effects 0.000 description 3
- 238000005057 refrigeration Methods 0.000 description 3
- XLYOFNOQVPJJNP-UHFFFAOYSA-N water Substances O XLYOFNOQVPJJNP-UHFFFAOYSA-N 0.000 description 3
- 230000009286 beneficial effect Effects 0.000 description 2
- 238000010586 diagram Methods 0.000 description 2
- 230000000694 effects Effects 0.000 description 2
- 241000270295 Serpentes Species 0.000 description 1
- 230000002159 abnormal effect Effects 0.000 description 1
- 238000013459 approach Methods 0.000 description 1
- 230000008901 benefit Effects 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 238000013500 data storage Methods 0.000 description 1
- 230000002708 enhancing effect Effects 0.000 description 1
- 238000012163 sequencing technique Methods 0.000 description 1
- 238000012549 training Methods 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/42—Syntactic analysis
- G06F8/427—Parsing
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Devices For Executing Special Programs (AREA)
- Stored Programmes (AREA)
Abstract
The invention relates to the technical field of software development, and particularly discloses a program interpretation and execution method, which comprises the following steps: generating: generating a logic tree; the logic tree comprises one or more of upper and lower father and child node information, node type, parameter type and application value type; wherein the node type includes other extensions; analyzing: and writing a logic interpretation executive program, taking the logic tree as a parameter, and analyzing and executing the logic tree. By adopting the technical scheme of the invention, the computer language to be compiled and executed can have the interpretation and execution capability, the execution speed of the compiling and execution language is kept to be higher, and meanwhile, the flexibility of interpretation and execution is also provided, so that the application field is wide.
Description
Technical Field
The invention relates to the technical field of software development, in particular to a program interpretation and execution method.
Background
At present, the compiling and executing language needs to compile a source program to generate a target file, and then a computer executes the target program, so that the method has the characteristics of high executing speed, and the like, but needs to recompile when the program is modified, and lacks flexibility.
For example, embedded single-chip development processes typically require program code to be compiled into binary code, which is then programmed into a chip for execution. This compiling and programming operation must be repeatedly performed when the program needs to be updated.
In services provided on an online PAAS/SAAS platform, code is typically not modified online. Because after modifying the code, it is necessary to compile and restart the relevant service.
Currently, artificial intelligence techniques are capable of providing some code segment services, such as sequencing algorithms or codes for greedy snake games. However, these services cannot cover business models because existing business models often exist in unstructured forms, such as documents or graphics, which are difficult to match with codes. Therefore, artificial intelligence can only learn code samples, cannot learn business models, and cannot realize the capability of automatically generating business system codes.
Graphical programming methods generally involve converting graphical logic into executable code, and then compiling and executing the generated code. This process is cumbersome and inefficient because manual intervention is required to perfect the various details of code generation and is typically limited to implementation in a particular programming language.
Traditional program compiling methods have limitations in the fields of single chip microcomputer, PAAS/SAAS, artificial intelligence and graphical programming, and limit the development of the fields. Therefore, there is a need for a graphical programming method that can provide a computer language requiring compiled execution with interpreted execution capabilities and that has a wide application area, so as to solve the above-mentioned problems.
Disclosure of Invention
The invention provides a program interpretation execution method, which can enable a computer language to be compiled and executed to have interpretation execution capability and has wide application fields.
In order to solve the technical problems, the application provides the following technical scheme:
a program interpretation execution method, comprising:
Generating: generating a logic tree; the logic tree comprises one or more of upper and lower father and child node information, node type, parameter type and application value type; wherein the node type includes other extensions;
Analyzing: and writing a logic interpretation executive program, taking the logic tree as a parameter, and analyzing and executing the logic tree.
Further, the node type further includes one or more of a decision type, a loop type, a jump-out type, and a skip type.
Further, the parsing step includes:
s1, a node reading sub-step, namely, taking a logic tree as a parameter to be transmitted in; reading node information from top to bottom for the logic tree;
s2, judging the node type of each node by the node judging sub-step, and executing corresponding analysis operation.
Further, in the node determining sub-step, a node type determining step is performed according to a preset sequence, where the node type determining step includes one or more of a determining type determining step, a loop type determining step, a skip type determining step, and other extension type determining steps.
Further, in the node judgment sub-step, if the node cannot be identified, an unidentifiable node log is output.
Further, the judging type judging step includes:
judging whether the current node type is a judging type or not;
if yes, cutting the current judgment type node and the child nodes thereof into a new logic tree; calling and judging;
if not, jumping to the preset judging step of other node types;
the judging step comprises the following steps:
Step one, taking a new logic tree as a parameter to be transmitted in; wherein the type of the first tree node is a judgment type;
analyzing parameters of the node, wherein the parameters comprise one or more of variables and other program execution results;
judging whether the parameter result is true or false; if true, cutting all nodes below the true node into a new logic tree; if false, cutting all nodes below the false node into a new logic tree;
And step four, taking the new logic tree as a parameter to be input, and re-executing the step S1.
Further, the step of determining the skip type includes:
Judging whether the current node type is a skip type or not;
If yes, calling a skip step;
if not, jumping to the preset judging step of other node types;
wherein the skipping step comprises:
step one, judging which level of circulation needs to be skipped according to the parameters of the incoming node;
Step two, skipping is executed, and a current node execution log is output;
Step three, judging whether the skipped circulation is the circulation of the appointed level, if not, jumping to the step two; if so, ending.
Further, the step of determining the jump-out type includes:
Judging whether the current node type is a jump-out type or not;
if yes, calling a jump-out step;
if not, jumping to the preset judging step of other node types;
the step of jumping out comprises the following steps:
Step one, judging which level of circulation needs to jump out according to the parameters of the input node;
step two, executing skipping; outputting a current node execution log;
and step three, judging whether the cycle after the jump-out is the specified level cycle, if not, jumping to the step two, and if so, ending.
Further, the cycle type judging step includes:
judging whether the current node type is a circulation type or not;
If yes, cutting the current circulation type node and the child nodes thereof into a new logic tree; calling a circulation step;
if not, jumping to the preset judging step of other node types;
Wherein the cycling step comprises:
Step one, taking a new logic tree as a parameter to be transmitted in; wherein the type of the first tree node is a loop type;
Analyzing parameters of the node, wherein the parameters comprise one or more of a variable set, a variable count and other program execution results;
Step three, cutting all nodes below the cyclic type node into a new logic tree;
And step four, according to the node parameters of the circulation type, the new logic tree is circularly transmitted as the parameters, and the step S1 is re-executed.
Further, the other extension type judging step includes:
Judging whether the current node type is other expansion or not;
If yes, calling an expansion step;
if not, jumping to the preset judging step of other node types;
The expanding step comprises the following steps:
Step one, judging a calling method according to parameters of an incoming node, wherein the calling method comprises calling an internal program interface and calling an external application interface;
step two, calling an internal program or an external application interface according to a calling method;
and step three, receiving feedback result data of the called internal program or the external application.
The beneficial effects are that:
1. In the scheme, an ordinary user only needs to complete building of a logic tree, a logic interpretation execution program is compiled in advance by a professional, and one-time compiling can be applied to a plurality of application scenes through the logic interpretation execution program, so that stable interpretation execution capacity is provided, and repeated compiling is not needed.
2. The logic tree is a visual implementation of service logic, the service logic is stripped from the code, the data of the logic tree is a structured data storage, and the logic tree can be used as an AI training sample, thereby being beneficial to establishing an automatic service model and enhancing the development capability of an AI service system.
3. The logic interpretation executive program can be burnt and written into the embedded single chip microcomputer, and new business logic is realized through a remote transmission logic tree, so that the embedded development efficiency is improved.
4. The method is suitable for graphical programming application, does not need to generate codes or recompile, and is particularly suitable for children programming and simplifying programming flow.
5. The method is suitable for the PAAS/SAAS platform, and allows the online configuration of the existing logic tree, thereby realizing flexible service system adjustment.
In summary, the scheme can enable the computer language to be compiled and executed to have interpretation and execution capabilities, has flexibility and high efficiency in application in multiple fields, and reduces programming and development complexity.
Drawings
FIG. 1 is a flowchart illustrating steps for generating a program for explaining a first embodiment of a method;
FIG. 2 is a flowchart illustrating the parsing steps in a first embodiment of a program interpretation and execution method;
FIG. 3 is a flowchart illustrating a procedure for determining a first embodiment of a program explanation and execution method;
FIG. 4 is a flowchart illustrating the steps of a loop in a first embodiment of a method for performing program explanation;
FIG. 5 is a flowchart illustrating a procedure for performing the step skipped in the first embodiment of the method;
FIG. 6 is a flowchart illustrating a jump-out step in a first embodiment of a program interpretation and execution method;
FIG. 7 is a flowchart illustrating the expansion steps in a first embodiment of a program interpretation and execution method;
FIG. 8 is a schematic diagram of a logic tree in a second embodiment of a program interpretation and execution method;
Fig. 9 is a schematic diagram of a logic tree in a third embodiment of a program interpretation and execution method.
Detailed Description
The following is a further detailed description of the embodiments:
example 1
A program interpretation execution method of the present embodiment includes the following:
As shown in fig. 1, the generation step a: generating a logic tree; the logic tree generation mode comprises graphic construction, data splicing, object JSON (Java Server on) and the like; in this embodiment, a patterned build-up is used. The logical tree includes one or more of tree upper and lower parent-child node information, node type, parameter type, application value type, and in this embodiment, all of the above. The node type includes other extensions, and further includes one or more of a judgment type, a loop type, a jump-out type, and a skip type, and in this embodiment, all of the above may be included, and in other embodiments, a debug type may be further included.
The parameter type includes parameters required by the node type, such as judgment conditions, circulation times and the like, and the application value type is other data values required according to specific application scenes, such as temperature, humidity, pressure and the like.
As shown in fig. 2, the parsing step B: writing a logic interpretation executive program, resolving and executing a logic tree through the logic interpretation executive program, and specifically comprising the following steps:
S1, a node reading sub-step, which specifically comprises the following steps:
s101, taking a logic tree as a parameter to be transmitted in;
s102, reading node information from top to bottom for the logic tree;
s2, judging the node type of each node, executing the node type judging step according to a preset sequence, executing corresponding analysis operation, and outputting an unidentifiable node log if the node cannot be identified.
The node type judging step includes one or more of a judging type judging step, a loop type judging step, a skip type judging step, and other extension type judging steps. In this embodiment, the preset execution sequence includes a judgment type judgment step, a loop type judgment step, a skip type judgment step, and other extension type judgment steps. In other embodiments, the number and order of the node type determining steps may be adjusted according to the actual situation, for example, the determining type determining step and the other extension type determining step are performed.
In this embodiment, the node determining substeps specifically include:
S201, judging type judgment, judging whether the current node type is a judging type or not; if yes, jump to step S202, if not, jump to step S203;
s202, cutting the current node and the child node into a new logic tree, and jumping to a judging step C;
s203, judging the circulation type and judging whether the current node type is the circulation type; if yes, go to step S204, if not, go to step S205;
s204, cutting the current node and the child node into a new logic tree; jumping to a circulation step D;
S205, judging whether the current node type is a skip type or not; if yes, go to step S206, if not, go to step S207;
S206, calling a skip step E;
s207, judging whether the current node type is the jump-out type or not, if yes, jumping to the step S208, and if not, jumping to the step S209;
s208, calling a jump-out step F;
s209, judging other extension types, and judging whether the current node type is other extension; if yes, go to step S210, if not, go to step S211;
s210, calling an expansion step G;
s211, outputting an unidentifiable node log;
S212, analysis is finished.
As shown in fig. 3, the determining step C specifically includes:
Step one, taking a new logic tree as a parameter to be transmitted in; wherein the type of the first tree node is a judgment type;
Analyzing parameters of the node, wherein the parameters comprise one or more of variables and other program execution results; such as a variable of the number of cycles.
Judging whether the parameter result is true or false; if true, cutting all nodes below the true node into a new logic tree; if false, cutting all nodes below the false node into a new logic tree;
and step four, taking the new logic tree as a parameter to be input, re-executing the step S1, and outputting the current node execution log.
As shown in fig. 4, the cycling step D specifically includes:
Step one, taking a new logic tree as a parameter to be transmitted in; wherein the type of the first tree node is a loop type;
Analyzing parameters of the node, wherein the parameters comprise one or more of a variable set, a variable count and other program execution results. The other program execution results may be a set of a plurality of program execution results;
Step three, cutting all nodes below the cyclic type node into a new logic tree;
and step four, according to the parameters of the circulation type node, the new logic tree is circularly transmitted as the parameters, the step S1 is re-executed, and the current node execution log is output.
As shown in fig. 5, the skipping step E specifically includes:
step one, judging which level of circulation needs to be skipped according to the parameters of the incoming node;
step two, immediately executing skip, and outputting a current node execution log;
Step three, judging whether the skipped circulation is the circulation of the appointed level, if not, jumping to the step two; if so, ending.
As shown in fig. 6, the step F of jumping out specifically includes:
Step one, judging which level of circulation needs to jump out according to the parameters of the input node;
Step two, immediately executing skipping; outputting a current node execution log;
and step three, judging whether the cycle after the jump-out is the specified level cycle, if not, jumping to the step two, and if so, ending.
As shown in fig. 7, the expanding step G specifically includes:
step one, judging a calling method according to parameters of an incoming node, wherein the calling method comprises calling an internal program interface and calling an external application interface; the embodiment calls an external application interface through a communication protocol;
And step two, calling an internal program or an external application interface according to the calling method, and transmitting data, wherein the data can be manually input or the execution result of other programs. For example, a servo motor needs to be controlled, and the input data is a control parameter.
Step three, receiving feedback result data of the called internal program or external application; and outputting the current node execution log, and ending.
Example two
In the parsing step S101, the logic tree of the comparison refrigeration station energy management pushing information and the system configuration information in fig. 8 of the present embodiment is taken as a parameter to be input;
S102, node information is read from top to bottom for a logic tree;
S2, judging whether the node type of the water consumption is normal or not, cutting the node and the child node of the water consumption into a new logic tree, and jumping to a judging step; in the judging step, step one, a new logic tree is taken as a parameter to be transmitted in; analyzing parameters of whether the water consumption is normal or not; judging whether the parameter result is true or false; if true, cutting the normal data node recorded below the true node into a new logic tree; if the node is false, cutting the abnormal emergency plan node of the refrigeration station energy management below the false node into a new logic tree; step four, the new logic tree is taken as a parameter to be transmitted in, the step S1 is re-executed, and the current node execution log is output;
taking the case of cutting the recorded normal data node into a new logic tree, re-executing the steps S1 to S2, judging the current node type as other extensions, and calling the extension step: step one, judging that a calling method is an internal program interface according to parameters of an incoming node; step two, calling the extension node according to a calling method of the internal program interface: recording normal data; step three, after recording the normal data, receiving feedback result data of the calling node; and outputting the current node execution log, and ending.
And meanwhile, in S2, continuously reading the node information of whether the gas consumption is normal or not until the reading of the residual nodes in the refrigeration station energy management pushing information and the system configuration information logic tree is completed.
Example III
As shown in fig. 9, the button box in this embodiment calls the logical tree of the entry as a parameter input; reading node information from top to bottom for the logic tree; reading the node when the 'hoisting completion' function needs to be called, judging the node as a judging type node, cutting the node and the child node into a new logic tree when the 'hoisting completion' function needs to be called, and jumping to a judging step;
In the judging step, assuming that the parameter result is True, cutting all nodes below the True node into a new logic tree;
Reading node information from top to bottom for the new logic tree, wherein in step S209, "hoisting is completed (green button)" is judged as other expansion; jumping to step S210, and calling an expansion step;
Continuously reading node information from top to bottom for the new logic tree, and judging the node type of the IF node as a judgment type in step S201; step S202, cutting the current node and the child node into a new logic tree, and jumping to a judging step; in the judging step, assuming that the parameter result is True, cutting all nodes below the True node into a new logic tree;
Continuing to read node information from top to bottom for another new logic tree, and in step S203, judging that the node type of the "While node" is a cycle type; step S204, cutting the current node and the child node into a new logic tree; jumping to a circulation step;
in the circulation step, a new logic tree is taken as a parameter to be transmitted in; analyzing the parameters of the nodes, and cycling the type nodes: all nodes below the "While node" are cut into new logical trees; and according to the loop type node parameters, the new logic tree is circularly transmitted as the parameters, the step S1 is re-executed, the current node execution log is output, namely the repeated execution node 'sql statement parameters are analyzed to return to the result node'.
Example IV
The difference between the present embodiment and the first embodiment is that, in the present embodiment, the analyzing step further includes:
S3, an analysis sub-step, namely recording information and analysis time of the logic tree, and storing a specific judgment step and a preset sequence in the corresponding node judgment sub-step; the specific judging step refers to which of the judging type judging step, the cycle type judging step, the skip type judging step and the other extension type judging step is selected to be executed, and the preset sequence is the execution sequence of the selected steps.
Classifying the logic tree according to the stored information of the logic tree; in this embodiment, the classification is performed according to the node types included in the logical tree and the up-down structure of each node type in the logical tree, for example, the logical tree including only the judgment node is classified into one type.
Performing time-consuming analysis according to the information of the logic tree, the analysis time, the corresponding specific judgment steps and the preset sequence, determining the specific judgment step and the preset sequence adopted by the shortest analysis time under each logic tree classification, and generating the optimal node judgment sub-step setting; in this embodiment, the resolved time only calculates the time when the internal program interface call or the external application interface call request is issued, and does not include the time when the internal program or the external application is executed.
In the step S1 node reading sub-step of this embodiment, after node information is read, classification of the current logic tree is determined, and setting of the optimal node judgment sub-step under the corresponding classification is queried according to the classification of the logic tree.
And S2, judging the node type of each node in the node judging sub-step, setting and executing the node type judging step according to the optimal node judging sub-step, and executing the corresponding analysis operation.
According to the scheme of the embodiment, the node type judging step can be dynamically adjusted and executed according to different logic trees, and the analysis efficiency can be improved. For example, if only the node of the type is determined, the loop type determination step, the skip type determination step, and the skip type determination step are not performed, and the analysis time can be effectively shortened.
Example five
The difference between the present embodiment and the fourth embodiment is that in the present embodiment, in the generating step, the generating process of the logic tree is recorded in real time, the node information is identified, the classification of the current logic tree is determined, the setting of the optimal node judgment sub-step under the corresponding classification is queried according to the classification of the logic tree, and the setting of the optimal node judgment sub-step is used as a parameter to be transmitted in;
And S2, judging the node type of each node in the node judging sub-step, setting and executing the node type judging step according to the optimal node judging sub-step, and executing the corresponding analysis operation.
Compared with the fourth embodiment, the method and the device for classifying the logic tree in the generation stage of the logic tree are capable of completing classification and determination of setting of the optimal node judgment substep, the time of the stage is mainly influenced by the creation speed of a user, the classification and the determination of setting of the optimal node judgment substep are carried out, the time is not occupied independently, and the time of subsequent analysis can be further shortened.
Example six
The difference between the present embodiment and the fifth embodiment is that the present embodiment is further configured to obtain application scenario information when generating the logic tree, where the application scenario information includes business and teaching. Teaching includes child programming for use by personnel such as corporations, businesses, and the like to accomplish work tasks.
And when the application scene is commercial, judging whether the number of the nodes exceeds a first threshold value, if so, identifying node information and determining the classification of the current logic tree. The first threshold may be selected according to practical situations, for example, when different node numbers are counted, the difference of the resolving time in the fifth dynamic sequence mode and the first preset sequence mode is used, and the node number with the resolving time of the dynamic sequence being less than the resolving time of the preset sequence by more than 1 second is used as the first threshold. In order to avoid that the dynamic sequential approach does not take advantage of the fact that the number of nodes is small.
When the application scene is education, programming for children in the embodiment, acquiring whether the average node number of the user history generation logic tree is lower than a second threshold value, if so, judging whether the user adopts graphical construction, and if so, recording the interval time of the current construction of each node and the modification times of each current node; calculating the current average interval time and the average modification times; if the average interval time exceeds the set time, judging whether the number of the current nodes exceeds a third threshold value after the average modification times exceeds the set times, if so, executing an analysis step on the current logic tree after the nodes after the average modification times are exceeded; and after the user confirms that the construction is finished, displaying an execution result.
Wherein the second threshold is smaller than the first threshold, the embodiment is 20, the set time is 30 seconds, and the set times are 3 times; the third threshold is determined according to the average node number, and in this embodiment, the third threshold is the average node number-2.
In the child programming scenario, if the average node number of the history generation logic tree is lower than the second threshold, the node number is smaller, the realized function is simpler, and the time required for analysis execution is smaller. If the average interval time exceeds the set time, the average modification times exceed the set times, which indicates that the current proficiency of the user is low, the construction thinking time is long, and repeated modification can be experienced. After the number of the current nodes exceeds a third threshold, the possibility of ending the construction of the logic tree is high, the possibility that the user does not modify any more is high after the number of the current nodes exceeds the average modification times, and the average interval time of construction of each node is long, so that the current logic tree can be analyzed in enough time. After the analysis execution is finished, the user confirms that the construction is finished, the analysis execution result can be immediately obtained, waiting time is reduced, although the user spends more time in constructing the logic tree in the early stage, the analysis execution is fast, the user can easily generate achievement, the construction experience of the user is improved, the user is given forward feedback, the user can insist on learning, and the teaching effect can be improved.
The foregoing is merely an embodiment of the present application, the present application is not limited to the field of this embodiment, and the specific structures and features well known in the schemes are not described in any way herein, so that those skilled in the art will know all the prior art in the field before the application date or priority date of the present application, and will have the capability of applying the conventional experimental means before the date, and those skilled in the art may, in light of the present application, complete and implement the present scheme in combination with their own capabilities, and some typical known structures or known methods should not be an obstacle for those skilled in the art to practice the present application. It should be noted that modifications and improvements can be made by those skilled in the art without departing from the structure of the present application, and these should also be considered as the scope of the present application, which does not affect the effect of the implementation of the present application and the utility of the patent. The protection scope of the present application is subject to the content of the claims, and the description of the specific embodiments and the like in the specification can be used for explaining the content of the claims.
Claims (8)
1. A program interpretation execution method, characterized by comprising:
generating: generating a logic tree; the logic tree generation mode comprises graphic construction, data splicing and object JSON;
The logic tree comprises one or more of upper and lower father and child node information, node type, parameter type and application value type; the node type comprises other extensions and further comprises one or more of judging type, circulating type, jump-out type and skip type;
analyzing: writing a logic interpretation executive program, taking a logic tree as a parameter, and analyzing and executing the logic tree; the method specifically comprises the following steps:
s1, a node reading sub-step, namely, taking a logic tree as a parameter to be transmitted in; reading node information from top to bottom for the logic tree;
s2, judging the node type of each node by the node judging sub-step, and executing corresponding analysis operation;
S3, an analysis sub-step, namely recording information and analysis time of the logic tree, and storing a specific judgment step and a preset sequence in the corresponding node judgment sub-step; classifying the logic tree according to the stored information of the logic tree; and performing time-consuming analysis according to the information of the logic tree, the analysis time, the corresponding specific judgment steps and the preset sequence, determining the specific judgment step and the preset sequence adopted by the shortest analysis time under each logic tree classification, and generating the optimal node judgment sub-step setting.
2. The program interpretation execution method of claim 1, wherein: in the node judging sub-step, the node type judging step is executed according to a preset sequence, and the node type judging step comprises one or more of a judging type judging step, a circulating type judging step, a skipping type judging step, a jumping-out type judging step and other extension type judging steps.
3. The program interpretation execution method of claim 2, wherein: in the node judging sub-step, if the node cannot be identified, an unidentifiable node log is output.
4. A program interpretation execution method as claimed in claim 3, characterized in that: the judging type judging step comprises the following steps:
judging whether the current node type is a judging type or not;
if yes, cutting the current judgment type node and the child nodes thereof into a new logic tree; calling and judging;
if not, jumping to the preset judging step of other node types;
the judging step comprises the following steps:
Step one, taking a new logic tree as a parameter to be transmitted in; wherein the type of the first tree node is a judgment type;
analyzing parameters of the node, wherein the parameters comprise one or more of variables and other program execution results;
judging whether the parameter result is true or false; if true, cutting all nodes below the true node into a new logic tree; if false, cutting all nodes below the false node into a new logic tree;
And step four, taking the new logic tree as a parameter to be input, and re-executing the step S1.
5. The program interpretation execution method of claim 4, wherein: the step of judging the skip type includes:
Judging whether the current node type is a skip type or not;
If yes, calling a skip step;
if not, jumping to the preset judging step of other node types;
wherein the skipping step comprises:
step one, judging which level of circulation needs to be skipped according to the parameters of the incoming node;
Step two, skipping is executed, and a current node execution log is output;
Step three, judging whether the skipped circulation is the circulation of the appointed level, if not, jumping to the step two; if so, ending.
6. The program interpretation execution method of claim 5, wherein: the step of judging the jump-out type comprises the following steps:
Judging whether the current node type is a jump-out type or not;
if yes, calling a jump-out step;
if not, jumping to the preset judging step of other node types;
the step of jumping out comprises the following steps:
Step one, judging which level of circulation needs to jump out according to the parameters of the input node;
step two, executing skipping; outputting a current node execution log;
and step three, judging whether the cycle after the jump-out is the specified level cycle, if not, jumping to the step two, and if so, ending.
7. The program interpretation execution method of claim 6, wherein: the cycle type judging step includes:
judging whether the current node type is a circulation type or not;
If yes, cutting the current circulation type node and the child nodes thereof into a new logic tree; calling a circulation step;
if not, jumping to the preset judging step of other node types;
Wherein the cycling step comprises:
Step one, taking a new logic tree as a parameter to be transmitted in; wherein the type of the first tree node is a loop type;
Analyzing parameters of the node, wherein the parameters comprise one or more of a variable set, a variable count and other program execution results;
Step three, cutting all nodes below the cyclic type node into a new logic tree;
And step four, according to the node parameters of the circulation type, the new logic tree is circularly transmitted as the parameters, and the step S1 is re-executed.
8. The program interpretation execution method of claim 7, wherein: the other extension type judging step includes:
Judging whether the current node type is other expansion or not;
If yes, calling an expansion step;
if not, jumping to the preset judging step of other node types;
The expanding step comprises the following steps:
Step one, judging a calling method according to parameters of an incoming node, wherein the calling method comprises calling an internal program interface and calling an external application interface;
step two, calling an internal program or an external application interface according to a calling method;
and step three, receiving feedback result data of the called internal program or the external application.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311400374.8A CN117389569B (en) | 2023-10-26 | 2023-10-26 | Program interpretation execution method |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311400374.8A CN117389569B (en) | 2023-10-26 | 2023-10-26 | Program interpretation execution method |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN117389569A CN117389569A (en) | 2024-01-12 |
| CN117389569B true CN117389569B (en) | 2024-06-14 |
Family
ID=89468137
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311400374.8A Active CN117389569B (en) | 2023-10-26 | 2023-10-26 | Program interpretation execution method |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117389569B (en) |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109271237A (en) * | 2018-10-15 | 2019-01-25 | 浙江中控技术股份有限公司 | Simulation control method and device |
| CN109508298A (en) * | 2018-12-25 | 2019-03-22 | 网易（杭州）网络有限公司 | Patterned script testing method and system |
Family Cites Families (27)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| AU695554B2 (en) * | 1994-07-25 | 1998-08-13 | Canon Kabushiki Kaisha | Efficient methods for the evaluation of a graphical programming language |
| US6473896B1 (en) * | 1998-10-13 | 2002-10-29 | Parasoft, Corp. | Method and system for graphically generating user-defined rules for checking language quality |
| DE10206902A1 (en) * | 2002-02-19 | 2003-09-11 | Siemens Ag | Engineering process and engineering system for industrial automation systems |
| CN103838616B (en) * | 2014-03-05 | 2017-04-05 | 北京工业大学 | Computer program Just-In-Time method based on tree-shaped program branch |
| US9678724B2 (en) * | 2015-05-29 | 2017-06-13 | Intentional Software Corporation | System and method for combining text editing and tree encoding for computer programs |
| CN105183445B (en) * | 2015-07-10 | 2019-04-16 | 珠海金山网络游戏科技有限公司 | A kind of Visual Design System of the game artificial intelligence based on XML |
| CN105404507A (en) * | 2015-11-04 | 2016-03-16 | 山东中创软件工程股份有限公司 | Process template construction method and system |
| CN106775683B (en) * | 2016-11-30 | 2020-06-19 | 华南理工大学 | Graphical programming control and storage system |
| US10579351B2 (en) * | 2017-08-25 | 2020-03-03 | Adp, Llc | Computer speed via metadata-based business rule interpreter |
| CN107577460A (en) * | 2017-08-29 | 2018-01-12 | 苏州优圣美智能系统有限公司 | A kind of method from unstructured data extraction structural data |
| CN109189504B (en) * | 2018-09-20 | 2020-04-28 | 腾讯科技（深圳）有限公司 | Behavior execution method, behavior tree generation device and computer equipment |
| CN110032363B (en) * | 2019-03-21 | 2023-07-07 | 深圳点猫科技有限公司 | Data structure construction method and system for robot programming |
| CN110428054A (en) * | 2019-08-07 | 2019-11-08 | 浪潮云信息技术有限公司 | Business Rule Engine pattern matching system and implementation method based on technique of compiling |
| US20210263834A1 (en) * | 2020-02-20 | 2021-08-26 | 4Logik LLC | Code Generation Platform |
| CN113515272A (en) * | 2020-04-09 | 2021-10-19 | 深圳轩科华智能科技有限公司 | Visual programming method and system |
| CN114003216A (en) * | 2021-10-28 | 2022-02-01 | 中国建设银行股份有限公司 | Information processing method, device, equipment, storage medium and computer program product |
| CN114089987A (en) * | 2021-11-26 | 2022-02-25 | 网易（杭州）网络有限公司 | Visual script execution method and device and electronic equipment |
| WO2023164841A1 (en) * | 2022-03-02 | 2023-09-07 | 西门子股份公司 | Workflow execution method and apparatus, and storage medium and program product |
| CN114895886A (en) * | 2022-05-26 | 2022-08-12 | 中国平安人寿保险股份有限公司 | Programming statement conversion method, electronic equipment and storage medium |
| CN115048104A (en) * | 2022-06-15 | 2022-09-13 | 中国工商银行股份有限公司 | Code generation method and device based on syntax tree and electronic equipment |
| CN115202668A (en) * | 2022-08-04 | 2022-10-18 | 杭州电子科技大学 | AST-based workflow service generation method facing service arrangement |
| CN115421698A (en) * | 2022-08-30 | 2022-12-02 | 敏于行(北京)科技有限公司 | Data processing method and device based on declarative and distributed accounts book and electronic device |
| CN115309378A (en) * | 2022-08-31 | 2022-11-08 | 中通服和信科技有限公司 | Salary calculation method based on interpreted programming language |
| CN115408595B (en) * | 2022-11-03 | 2023-03-24 | 博和利统计大数据(天津)集团有限公司 | Data capture engine development method, data capture engine execution method, data capture engine equipment and storage medium |
| CN116149611A (en) * | 2022-12-08 | 2023-05-23 | 中水三立数据技术股份有限公司 | Software development method based on visual component tree |
| CN116009847A (en) * | 2023-02-16 | 2023-04-25 | 上海伯俊软件科技有限公司 | Code generation method, device, electronic equipment and storage medium |
| CN116107625A (en) * | 2023-02-21 | 2023-05-12 | 中移信息技术有限公司 | Flow design method, apparatus, device, storage medium, and program product |
-
2023
- 2023-10-26 CN CN202311400374.8A patent/CN117389569B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109271237A (en) * | 2018-10-15 | 2019-01-25 | 浙江中控技术股份有限公司 | Simulation control method and device |
| CN109508298A (en) * | 2018-12-25 | 2019-03-22 | 网易（杭州）网络有限公司 | Patterned script testing method and system |
Also Published As
| Publication number | Publication date |
|---|---|
| CN117389569A (en) | 2024-01-12 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN108846630B (en) | Resource control system and method | |
| US11579856B2 (en) | Multi-chip compatible compiling method and device | |
| CN102096631A (en) | Interface testing method and device | |
| CN112153165B (en) | Power service simulation environment construction method, system, equipment and storage medium | |
| EP4258175A1 (en) | Node fusion method for computational graph, and device | |
| CN115456150B (en) | Reinforced learning model construction method and system | |
| US20230394330A1 (en) | A method and system for designing ai modeling processes based on graph algorithms | |
| Janssen | Dexen: A scalable and extensible platform for experimenting with population-based design exploration algorithms | |
| CN111459490B (en) | Voice recognition engine transplanting method and device capable of automatically adapting to hardware platform | |
| CN117369521B (en) | Method, device and equipment for generating behavior tree model path for unmanned aerial vehicle decision | |
| CN113449856A (en) | Control flow graph processing method and related equipment | |
| CN117389569B (en) | Program interpretation execution method | |
| CN117311798A (en) | RPA flow generation system and method based on large language model | |
| CN117235527A (en) | End-to-end containerized big data model construction method, device, equipment and medium | |
| CN112416301A (en) | Deep learning model development method and device and computer readable storage medium | |
| CN115907022A (en) | Multi-quantum service conversion and simulation scheduling method, device, equipment and medium | |
| KR20200144296A (en) | Method and apparatus for parallel training of deep learning model | |
| CN116088842A (en) | AI algorithm engine system and method applied to Internet of things platform | |
| Dolk et al. | An active modeling system for econometric analysis | |
| CN112181951B (en) | Heterogeneous database data migration method, device and equipment | |
| CN114493360A (en) | Process creative evaluation method, device, equipment and medium based on RPA and AI | |
| CN112988597B (en) | Automatic test visualization method and system based on state transition | |
| CN114416533A (en) | Artificial intelligence-based use case generation method and system for vehicle-mounted electronic product | |
| CN111221731B (en) | Method for quickly acquiring test cases reaching specified points of program | |
| CN114416305A (en) | Robot engine implementation method and system and electronic equipment |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |