CN116755704A - Real-time code generation method for rule behavior model based on rule description files - Google Patents

Abstract

The invention relates to a rule behavior model real-time code generation method based on a rule description file, belongs to the technical field of computer generation force, and solves the problem that development and maintenance efficiency of a model and execution efficiency of the model cannot be considered in the prior art. The method utilizes the rule modeling tool without manual hard coding, simplifies the rule modeling flow, improves the maintainability of the obtained rule behavior model and is convenient for subsequent development; the rule description file in a specific format is converted into an equivalent hard coding rule behavior model without using a rule interpretation reasoning engine, so that the execution efficiency of the rule behavior model is improved; the method has no requirement on specific hardware, the generated codes accord with the C/C++ language specification, and the generated behavior model codes can be compiled and accelerated as long as a certain back-end platform (such as x86/arm and the like) has the C/C++ compiler, so that the method can run on the back-end platform, and most of the back-end platforms have the C/C++ compiler, so that the method has strong universality.

Description

Real-time code generation method for rule behavior model based on rule description files

Technical field

The invention relates to the technical field of computer-generated military forces, and specifically relates to a real-time code generation method for a rule behavior model based on a rule description file.

Background technique

The use of computer-generated force technology for tactical research is a research field that has attracted much attention. This application scenario has high requirements on the execution speed of the combat simulation system. Therefore, how to improve the execution efficiency of computer-generated force models is a technical problem that needs to be solved.

In the process of behavioral modeling based on rule sets, there is a trade-off between execution efficiency and development and maintenance efficiency. The rule behavior model obtained by hard-coded rules can be directly compiled into machine code through the compiler, which has good execution efficiency. However, general programming languages are not designed for rule behavior modeling, and the structure of the rule set model written using it is less clear. This results in a certain degree of difficulty in development and maintenance in the later stage. Using special rule modeling tools can obtain a clearly structured rule behavior model. However, it generally can only obtain rule representation in a specific format and hand it over to the rule interpretation engine for interpretation and execution during execution. There are flaws in execution efficiency.

In summary, there is a problem in the existing technology that cannot take into account the efficiency of model development and maintenance and the efficiency of model execution.

Contents of the invention

In view of the above problems, the present invention provides a real-time code generation method for a rule behavior model based on a rule description file, which solves the problem in the prior art that the development and maintenance efficiency of the model and the execution efficiency of the model cannot be taken into consideration.

The present invention provides a real-time code generation method for a rule behavior model based on a rule description file, which includes the following steps:

Step S1. Obtain the rule description file and parse it to obtain the rule set meta-information and a rule set containing several sub-rule sets; wherein the sub-rule set includes several atomic rules, and each atomic rule includes the prefix of the atomic rule. Part expressions and atomic rule postpart expressions;

Step S2. Perform lexical analysis on the antecedent expression and the consequent expression, which includes splitting and conversion to obtain an expression symbol stream;

Step S3. Based on the recursive descent algorithm and operator priority analysis algorithm, perform syntax analysis on the expression symbol stream to construct an expression abstract syntax tree;

Step S4. Perform semantic analysis and processing on the expression abstract syntax tree to obtain a verified expression abstract syntax tree;

Step S5. Based on the verified expression abstract syntax tree corresponding to each sub-rule set, construct an abstract syntax tree for each sub-rule set; merge the abstract syntax trees of each sub-rule set to obtain an abstraction of the rule set syntax tree;

Step S6. Based on the abstract syntax tree of the rule set, traverse all sub-rule sets and atomic rules, perform function call processing to insert read variables, and obtain the abstract syntax tree used to generate code;

Step S7. Traverse each node in the abstract syntax tree used to generate code, generate the hard-coded behavior model source code, and then combine and compile it with the platform interface source code to obtain the rule behavior model.

Further, the step S1 specifically includes the following sub-steps:

Step S101. Use the rule editing tool to export the rule description file from the knowledge base;

Step S102. Use a rule set description file parsing tool to parse the rule description file to obtain rule set meta-information and a rule set containing several sub-rule sets, and store the rule set meta-information to record the rule set meta-information. The data structure; wherein, the rule set meta-information includes complex data type definition, input situation variable information, output action variable information and intermediate state cache variable information;

Step S103. Use the rule set description file parsing tool to sequentially traverse each atomic rule of each sub-rule set in the rule description file, obtain the precondition expression and postcondition expression of each atomic rule in each sub rule set, and Number it.

Further, the step S2 specifically includes the following sub-steps:

Step S201. Determine whether the current character of the antecedent expression or the consequent expression is a whitespace character. If so, add one to the current character pointer until the current character is not a whitespace character;

Step S202. Determine the current character type. If it is a number from 0 to 9, execute step S203-A. If it is an underline or an English letter, execute step S203-B. Otherwise, execute step S203-C;

Step S203-A. Starting from the current character, continue to read characters until a blank character or symbol is encountered, and return the read fragment as a numeric literal type;

Step S203-B. Starting from the current character, continue to read characters until a blank character or symbol is encountered, and determine whether the read string is a keyword. If so, return the read fragment as a keyword type, otherwise read The entered fragment is returned as identifier type;

Step S203-C. Read the character and return the fragment containing the character in symbol type;

Step S204. Execute steps S201 to S202 on all antecedent expressions and consequent expressions obtained in step S1 to obtain an expression symbol stream.

Further, the step S3 specifically includes the following sub-steps:

Step S301. Determine whether the current symbol in the expression symbol stream is a prefix operator. If so, read the prefix operator and obtain its corresponding prefix expression; if not, the current symbol corresponds to a basic expression and execute it. Step S302;

Continue to judge and temporarily store prefix operators on the remaining expression symbol streams until all prefix operators and their corresponding prefix expressions in the expression symbol stream are read, and the abstraction corresponding to each prefix expression is constructed. syntax tree;

Step S302. Determine whether the current symbol of the basic expression is a literal or an identifier. If it is a literal, perform step S303; if it is an identifier, perform step S304;

Step S303. Read the current symbol of the basic expression, construct an abstract syntax tree corresponding to the literal, and then execute step S305;

Step S304. Read the current symbol of the basic expression, construct an abstract syntax tree corresponding to the identifier, and then determine whether the subsequent symbol is an operator corresponding to structure member access, array member access, and function call. If so, cache the operator. And continue to execute step S302 for the remaining expression symbol stream, using the abstract syntax tree corresponding to the identifier and the abstract syntax tree corresponding to the literal obtained in step S303 to construct structure member access, array member access and function calling. abstract syntax tree, and then execute step S305; if not, execute step S305 directly;

Step S305. Determine whether the current symbol is an infix operator. If so, use the operator priority analysis algorithm to construct an abstract syntax tree corresponding to the infix expression based on the infix expression corresponding to the infix operator; if not , then directly save the currently constructed abstract syntax tree;

Step S306: Execute steps S302 to S306 on the expression symbol stream, and combine it with the abstract syntax tree corresponding to the prefix expression obtained in step S301 to obtain an expression abstract syntax tree.

Further, the step S4 specifically includes the following sub-steps:

Step S401. Based on the rule set meta-information recorded in the data structure described in step S102, determine the current node type of the expression abstract syntax tree. If it is an identifier or literal node, query and update the current node type and return; if it is If it is a function call node, execute step S402-A; if it is a member access operation, execute step S402-B; if it is an infix operation node, execute step S402-C;

Step S402-A. Execute step S401 for each actual parameter node of the function call, then search the function overload table according to the function parameter type, select the real function that matches the function parameter type and the called actual parameter type to replace the function call, and update the current The return type of the node and returned;

Step S402-B. Execute step S401 on the node corresponding to the accessed value, and then search the type definition to determine whether the current member access is feasible. If it is feasible, update the return type of the current node to the member type and return; if not, directly return;

Step S402-C. Execute step S401 on the left value and the right value participating in the infix operation, and then determine whether the types of the left value and the right value are both real number types. If so, update the return type of the current node to a real number. type and return; if not, return directly;

Step S403. Execute step S401 on all nodes of the expression abstract syntax tree to obtain the verified expression abstract syntax tree.

Further, the step S5 specifically includes the following sub-steps:

Step S501. Create a new conditional branch node on an atomic rule on the verified expression abstract syntax tree, and construct a conditional branch statement in the shape of IF-THEN-ELSE, so that the antecedent expression of the atomic rule is as The conditional expression of the conditional branch statement, the consequent expression of the atomic rule is used as the conditional expression of the conditional branch statement, and the abstract syntax tree corresponding to the remaining atomic rules is used as the false value branch of the conditional branch statement; for a Each atomic rule in the sub-rule set recursively undergoes the above processing to obtain an abstract syntax tree of the sub-rule set connected by a series of conditional branch statements and conditional branch nodes;

Step S502. Execute step S501 for each sub-rule set to obtain the abstract syntax tree of each sub-rule set;

Step S503. Merge the abstract syntax trees of each sub-rule set to obtain the abstract syntax tree of the rule set.

Further, the step S6 specifically includes the following sub-steps:

Step S601. Construct a set for recording the names of loaded situation variables. The set is initially empty;

Step S602. Traverse the abstract syntax tree nodes of the antecedent expression and the consequent expression of the current atomic rule, find the name of the loaded situation variable in the set used to record the names of loaded situation variables, and use it in the antecedent expression. Before the formula, add a function call of the situation variable reading function corresponding to the situation variable name that is not included in the set; store all accessed situation variable names into the set;

Step S603. In the abstract syntax tree of the rule set, traverse each atomic rule of each sub-rule set, and execute step S602 until all situation variable names accessed by each abstract syntax tree node are stored in the set, and the user Abstract syntax tree for generating code.

Further, the step S7 specifically includes the following sub-steps:

Step S701. Traverse the nodes of the abstract syntax tree used for code generation, convert the abstract syntax tree used for code generation into the corresponding C/C++ code, enter it into the source code file, and generate the corresponding header file;

Step S702. Organize the platform interface template and fill in the operations related to the behavioral model in the interface source code, including the read functions for input situation variables and intermediate state variables;

Step S703. Call the construction system to build the source code file and header file obtained in step S701 and the interface template compiled in step S702, and call the compiler to compile and generate a rule behavior model; wherein the rule behavior model refers to a rule behavior model that can be used for specific The dynamic library or executable file of the computer-generated force simulation platform.

Compared with the prior art, the present invention at least has the following beneficial effects:

(1) Compared with existing hard-coded rule modeling, the real-time code generation method of the rule behavior model based on the rule description file of the present invention uses rule modeling tools without manual hard coding, simplifying the rule modeling process and improving the obtained The maintainability of the rule behavior model facilitates subsequent development.

(2) Compared with the existing execution method that uses a rule interpretation inference engine to interpret and execute rule description files, the real-time code generation method of the rule behavior model based on the rule description file of the present invention can convert the rule description file in a specific format into an equivalent The hard-coded rule behavior model does not require the use of a rule interpretation inference engine to improve the execution efficiency of the rule behavior model.

(3) Compared with the existing acceleration methods using dedicated hardware such as FPGA or GPU, the real-time code generation method of the rule behavior model based on the rule description file of the present invention has no requirement for specific hardware, and the generated code conforms to the C/C++ language Specification, as long as a C/C++ compiler exists on a certain back-end platform (such as x86/arm, etc.), the generated behavioral model code can be compiled and accelerated, and it can be run on the back-end platform, and most back-end platforms have C/C++ compilers. C++ compiler, so this method is highly versatile.

Description of the drawings

The drawings are for the purpose of illustrating specific embodiments only and are not to be construed as limitations of the invention.

Figure 1 is a flow chart of a real-time code generation method for a rule behavior model based on a rule description file disclosed in an embodiment of the present invention;

Figure 2 is a schematic diagram of a rule description file used in a real-time code generation method for a rule behavior model based on a rule description file disclosed in an embodiment of the present invention;

Figure 3 is a flow chart of expression parsing in the real-time code generation method of the rule behavior model based on the rule description file disclosed by the embodiment of the present invention;

Figure 4 is a lexical analysis process of the expression parsing tool in the real-time code generation method of the rule behavior model based on the rule description file disclosed in the embodiment of the present invention.

Detailed ways

In order to more clearly understand the above objects, features and advantages of the present invention, the present invention will be described in further detail below in conjunction with the accompanying drawings and specific embodiments. It should be noted that, as long as there is no conflict, the embodiments of the present invention and the features in the embodiments can be combined with each other. In addition, the present invention can also be implemented in other ways different from those described here. Therefore, the protection scope of the present invention is not limited by the specific embodiments disclosed below.

Example 1

A specific embodiment of the present invention, as shown in Figure 1, discloses a real-time code generation method for a rule behavior model based on a rule description file, which includes the following steps:

Step S1. Obtain the rule description file and parse it to obtain the rule set meta-information and a rule set containing several sub-rule sets; among which, the sub-rule set includes several atomic rules, and each atomic rule includes an atomic rule precondition expression. expressions and atomic rule consequent expressions.

Step S2. Perform lexical analysis on the antecedent expression and the consequent expression, which includes splitting and conversion to obtain an expression symbol stream; wherein the antecedent expression and the consequent expression are in the form of strings.

Step S3. Based on the recursive descent algorithm and operator priority analysis algorithm, syntax analysis is performed on the expression symbol stream to construct an expression abstract syntax tree.

Step S4. Perform semantic analysis and processing on the expression abstract syntax tree, determine whether the access to the input situation variable information conforms to the situation variable type declared in the rule set meta-information, and obtain the verified expression abstract syntax tree; where,

Access to input situation variable information refers to the access to variables by expressions. For example, the expression "x=p.x+2" accesses two variables, x and p; situation variables declared in the rule set meta-information The type is obtained based on the set of meta-information of the rule set stored in step 102; the judgment here mainly refers to "judge whether the current member access is feasible" in step 403 in Embodiment 2 and "judge whether both types are real number types" in step 404. , the remaining steps are to provide information for these two judgments.

Step S5. Based on the verified expression abstract syntax tree corresponding to each sub-rule set, the abstract syntax tree of each sub-rule set is constructed; merge the abstract syntax trees of each sub-rule set to obtain the abstract syntax tree of the rule set .

Step S6. Based on the abstract syntax tree of the rule set, traverse all sub-rule sets and atomic rules, perform function call processing to insert read variables, and obtain the abstract syntax tree used to generate code.

As shown in FIG. 3 , it is a process of expression parsing in the real-time code generation method of a rule behavior model based on a rule description file disclosed in the embodiment of the present invention, corresponding to steps S2 to S4.

The function of inserting the function call processing of reading variables is to support lazy loading (Lazy Loading) to avoid redundant loading of unused input situation variable information; among them, the corresponding function calls need to be inserted before accessing the input situation variables and intermediate state variables. to read the actual value of the variable, and for each input situation variable and intermediate state variable, a function call to insert and read the variable must be made before accessing; because the output variable only needs to be written and does not need to read the corresponding value, so there is no need to add reading; lazy loading means loading the data when the data is actually accessed instead of loading all the data at the beginning. It belongs to "inserting a function call to read a variable before accessing it for the first time. "After the effect.

Step S7. Traverse each node in the abstract syntax tree used to generate code, generate the hard-coded behavior model source code, and then compile it with the platform interface source code to obtain the rule behavior model; where,

The model generated by the real-time code generation method proposed in this solution is completely consistent with the original rule set behavior model in the simulation platform and can be directly replaced; the original rule set behavior model refers to the combination of the rule interpretation inference engine and the rule description file The model obtained after combining.

Compared with existing hard-coded rule modeling, the real-time code generation method for rule behavior models based on rule description files in the embodiment of the present invention uses rule modeling tools without manual hard coding, simplifying the rule modeling process and improving the obtained rules. The maintainability of the behavior model facilitates subsequent development; compared with the existing execution method that uses a rule interpretation inference engine to interpret and execute the rule description file, the real-time code generation method for the rule behavior model of the embodiment of the present invention can convert rules in a specific format The description file is converted into an equivalent hard-coded rule behavior model without using a rule interpretation inference engine, thereby improving the execution efficiency of the rule behavior model; compared with the existing method of using dedicated hardware such as FPGA or GPU for acceleration, the embodiment of the present invention The real-time code generation method of the rule behavior model does not require specific hardware. The generated code complies with the C/C++ language specification. As long as a C/C++ compiler exists on a certain back-end platform (such as x86/arm, etc.), the generated behavior model code can be compiled. Therefore, it can be accelerated and run on the back-end platform, and most back-end platforms have C/C++ compilers, so this method is highly versatile.

Example 2

Based on the optimization in Embodiment 1, step S1 can be further refined into the following sub-steps:

Step S101. Use the rule editing tool to export the rule description file from the knowledge base.

Specifically, the rule description file is in XML format. The rule description XML file contains input situation variable information, output action variable information and intermediate state variable information of the rule set, complex data type definitions involved in the rule set reasoning process, and the rules of the rule set. Several sub-rule sets.

Step S102. Use the rule set description file parsing tool to parse the rule description file to obtain rule set meta-information and a rule set containing several sub-rule sets, as shown in Figure 2.

Store rule set meta-information to a data structure used to record rule set meta-information; where,

Rule set meta-information includes complex data type definitions, input situation variable information, output action variable information and intermediate state cache variable information; when stored, the rule set meta-information is converted into a form that is convenient for program processing.

Specifically, the input situation variable information includes the input situation variable name and its type; the output action variable information includes the output action variable name and its type; the intermediate state variable information includes the intermediate state variable name and its type; complex data refers to the data containing multiple basic Data element data, such as location data, is a complex data containing three floating point elements: longitude, latitude, and height.

Step S103. Use the rule set description file parsing tool to sequentially traverse each atomic rule of each sub-rule set in the rule description file, obtain the precondition expression and postcondition expression of each atomic rule in each sub rule set, and Number it; among them,

The antecedent expression refers to the expression of the input situation variable in the antecedent, and the consequent expression refers to the expression of the output action variable in the consequent.

As shown in Figure 4, step S2 can be further refined into the following sub-steps:

Step S201. Determine whether the current character of the antecedent expression or the consequent expression is a whitespace character. If so, increase the current character pointer by one until the current character is not a whitespace character.

Step S202. Determine the current character type. If it is a number from 0 to 9, execute step S203-A. If it is an underline or an English letter, execute step S203-B. Otherwise, execute step S203-C.

Step S203-A. Starting from the current character, continue reading characters until a blank character or symbol is encountered, and return the read fragment in a numeric literal type.

Step S203-B. Starting from the current character, continue to read characters until a blank character or symbol is encountered, and determine whether the read string is a keyword. If so, return the read fragment as a keyword type, otherwise read The incoming fragment is returned as an identifier type.

Step S203-C. Read the character and return the fragment containing the character in symbol type.

Step S204. Execute steps S201 to S202 on all the antecedent expressions and consequent expressions obtained in step S1 to obtain an expression symbol stream with an identified type.

Step S3 can be further refined into the following sub-steps:

Step S301. Determine whether the current symbol in the expression symbol stream is a prefix operator. If so, read the prefix operator and obtain its corresponding prefix expression; if not, the current symbol corresponds to a basic expression and execute it. Step S302.

Continue to judge and temporarily store the prefix operators in the remaining expression symbol stream until all the prefix operators and their corresponding prefix expressions in the expression symbol stream are read, and the abstract syntax tree corresponding to each prefix expression is constructed. .

Step S302. Determine whether the current symbol of the basic expression is a literal or an identifier. If it is a literal, perform step S303; if it is an identifier, perform step S304.

Step S303. Read the current symbol of the basic expression, construct an abstract syntax tree corresponding to the literal, and then execute step S305.

Step S304. Read the current symbol of the basic expression, construct an abstract syntax tree corresponding to the identifier, and then determine whether the subsequent symbol is an operator corresponding to structure member access, array member access, and function call. If so, cache the operator. And continue to execute step S302 for the remaining expression symbol stream, using the abstract syntax tree corresponding to the identifier and the abstract syntax tree corresponding to the literal obtained in step S303 to construct an abstract syntax tree for structure member access, array member access and function calling, Then execute step S305; if not, execute step S305 directly.

Step S305. Determine whether the current symbol is an infix operator. If so, use the operator priority analysis algorithm to construct an abstract syntax tree corresponding to the infix expression based on the infix expression corresponding to the infix operator; if not , then directly save the currently constructed abstract syntax tree.

Step S306: Execute steps S302 to S306 on the expression symbol stream, and combine it with the abstract syntax tree corresponding to the prefix expression obtained in step S301 to obtain an expression abstract syntax tree.

Step S4 can be further refined into the following sub-steps:

Step S401. Based on the rule set meta-information recorded in the data structure in step S102, determine the current node type of the expression abstract syntax tree. If it is an identifier or literal node, query and update the current node type and return; if it is a function call If it is a node, perform step S402-A; if it is a member access operation, perform step S402-B; if it is an infix operation node, perform step S402-C;

Step S402-A. Execute step S401 for each actual parameter node of the function call, then search the function overload table according to the function parameter type, select the real function that matches the function parameter type and the called actual parameter type to replace the function call, and update the current The return type of the node and returned;

Step S402-B. Execute step S401 on the node corresponding to the accessed value, and then search the type definition to determine whether the current member access is feasible. If it is feasible, update the return type of the current node to the member type and return; if not, directly return;

Step S402-C. Execute step S401 on the left value and the right value participating in the infix operation, and then determine whether the types of the left value and the right value are both real number types. If so, update the return type of the current node to a real number. type and return; if not, return directly;

Step S403. Execute step S401 on all nodes of the expression abstract syntax tree to obtain the verified expression abstract syntax tree.

Step S5 can be further refined into the following sub-steps:

Step S501. Create a new conditional branch node on an atomic rule on the verified expression abstract syntax tree, construct a conditional branch statement in the shape of IF-THEN-ELSE, and use the antecedent expression of the atomic rule as a conditional branch. The conditional expression of the statement, the consequent expression of the atomic rule is used as the conditional expression of the conditional branch statement, and the abstract syntax tree corresponding to the remaining atomic rules is used as the false value branch of the conditional branch statement; for each atomic rule in a sub-rule set Perform the above processing recursively to obtain an abstract syntax tree of a sub-rule set connected by a series of conditional branch statements and conditional branch nodes.

Step S502. Execute step S501 for each sub-rule set to obtain the abstract syntax tree of each sub-rule set.

Step S503. Merge the abstract syntax trees of each sub-rule set to obtain the abstract syntax tree of the rule set.

Step S6 can be further refined into the following sub-steps:

Step S601. Construct a set for recording the names of loaded situation variables. The set is initially empty;

Step S602. Traverse the abstract syntax tree nodes of the antecedent expression and the consequent expression of the current atomic rule, find the loaded situation variable name in the set used to record the loaded situation variable name, and search for the loaded situation variable name before the antecedent expression. Add function calls to the situation variable reading function corresponding to situation variable names that are not included in the collection; store all accessed situation variable names into the collection;

Step S603. In the abstract syntax tree of the rule set, traverse each atomic rule of each sub-rule set, and execute step S602 until all situation variable names accessed by each abstract syntax tree node are stored in the set, and the information used to generate code is obtained. Abstract syntax tree.

Step S7 can be further refined into the following sub-steps:

Step S701. Traverse the nodes of the abstract syntax tree used for code generation, convert the abstract syntax tree used for code generation into the corresponding C/C++ code, enter it into the source code file, and generate the corresponding header file;

Step S702. Organize the platform interface template and fill in the operations related to the behavioral model in the interface source code, including the read functions for input situation variables and intermediate state variables;

Step S703. Call the construction system to build the source code file and header file obtained in step S701 and the interface template compiled in step S702, and call the compiler to compile and generate a rule behavior model; where the rule behavior model refers to a rule behavior model that can be used for specific computer generation The dynamic library or executable file of the military simulation platform.

The above are only preferred specific embodiments of the present invention, but the protection scope of the present invention is not limited thereto. Any person familiar with the technical field can easily think of changes or modifications within the technical scope disclosed in the present invention. All substitutions are within the scope of the present invention.

Claims (8)

1. A rule behavior model real-time code generation method based on a rule description file is characterized by comprising the following steps:

s1, acquiring a rule description file, and analyzing the rule description file to obtain rule set meta-information and a rule set containing a plurality of sub-rule sets; wherein the sub-rule set comprises a plurality of atomic rules, each atomic rule comprising an atomic rule front-part expression and an atomic rule back-part expression;

s2, performing lexical analysis processing on the front part expression and the back part expression, wherein the processing comprises splitting and converting to obtain an expression symbol stream;

s3, carrying out grammar analysis processing on the expression symbol stream based on a recursion descent algorithm and an operator priority analysis algorithm, and constructing an expression abstract grammar tree;

s4, carrying out semantic analysis processing on the expression abstract syntax tree to obtain a verified expression abstract syntax tree;

s5, based on the verified expression abstract syntax tree corresponding to each sub-rule set, constructing an abstract syntax tree of each sub-rule set; merging the abstract syntax trees of each sub-rule set to obtain an abstract syntax tree of the rule set;

s6, traversing all sub-rule sets and atom rules based on the abstract syntax tree of the rule set, and performing function call processing of inserting reading variables to obtain the abstract syntax tree for generating codes;

and S7, traversing each node in the abstract syntax tree for generating codes, generating hard coding behavior model source codes, and then carrying out combined compiling on the hard coding behavior model source codes and platform interface source codes to obtain a rule behavior model.

2. The method for generating a rule behavior model real-time code based on a rule description file according to claim 1, wherein said step S1 specifically comprises the following sub-steps:

s101, deriving a rule description file from a knowledge base by using a rule editing tool;

s102, analyzing the rule description file by using a rule set description file analysis tool to obtain rule set meta-information and a rule set comprising a plurality of sub-rule sets, and storing the rule set meta-information into a data structure for recording the rule set meta-information; the rule set meta information comprises complex data type definition, input situation variable information, output action variable information and intermediate state cache variable information;

s103, traversing each atomic rule of each sub-rule set in the rule description file in turn by using a rule set description file analysis tool, acquiring a front part expression and a back part expression of each atomic rule in each sub-rule set, and numbering the front part expression and the back part expression.

3. The method for generating the real-time code of the rule behavior model based on the rule description file according to claim 2, wherein the step S2 specifically comprises the following sub-steps:

step S201, judging whether the current character of the front part expression or the back part expression is a blank character, if so, adding one to the current character pointer until the current character is not the blank character;

s202, judging the current character type, if the current character type is a number of 0-9, executing the step S203-A, if the current character type is an underline or English letter, executing the step S203-B, otherwise, executing the step S203-C;

step S203-A, from the current character, continuously reading the character until encountering a blank or a symbol, and returning the read fragment in a digital word size type;

step S203-B, continuously reading in characters from the current character until a blank or a symbol is encountered, judging whether the read-in character string is a keyword, if so, returning the read-in fragment with the keyword type, otherwise, returning the read-in fragment with the identifier type;

S203-C, reading the character, and returning the segment containing the character in a symbol type;

step S204, executing step S201 to step S202 on all the front piece expressions and the back piece expressions obtained in the step S1 to obtain an expression symbol stream.

4. The method for generating a rule behavior model real-time code based on a rule description file according to claim 3, wherein said step S3 specifically comprises the following sub-steps:

s301, judging whether a current symbol in the expression symbol stream is a prefix operator, if so, reading the prefix operator, and obtaining a corresponding prefix expression; if not, the current symbol corresponds to a basic expression, and step S302 is executed on the basic expression;

continuing judging and temporarily storing prefix operators on the rest of the expression symbol stream until all prefix operators and corresponding prefix expressions in the expression symbol stream are read in, and constructing and obtaining abstract syntax trees corresponding to the prefix expressions;

step S302, judging whether the current symbol of the basic expression is a literal quantity or an identifier, and if the current symbol is the literal quantity, executing step S303; if yes, executing step S304;

s303, reading in the current symbol of the basic expression, constructing an abstract syntax tree corresponding to the literal quantity, and then executing step S305;

step S304, reading in the current symbol of the basic expression, constructing an abstract syntax tree corresponding to an identifier, then judging whether the subsequent symbol is an operator corresponding to the member access of the structure, the member access of the array and the function call, if yes, caching the operator and continuously executing step S302 on the symbol stream of the residual expression, constructing the abstract syntax tree corresponding to the member access of the structure, the member access of the array and the function call by utilizing the abstract syntax tree corresponding to the identifier and the abstract syntax tree corresponding to the literal quantity obtained in step S303, and then executing step S305; if not, directly executing step S305;

s305, judging whether the current symbol is a prefix operator, if so, constructing an abstract syntax tree corresponding to a prefix expression based on the prefix expression corresponding to the prefix operator by utilizing an operator priority analysis algorithm; if not, directly storing the abstract syntax tree which is constructed currently;

step S306, executing step S302 to step S306 on the expression symbol stream, and combining the abstract syntax tree corresponding to the prefix expression obtained in step S301 to obtain an expression abstract syntax tree.

5. The method for generating the real-time code of the rule behavior model based on the rule description file according to claim 4, wherein said step S4 specifically comprises the following sub-steps:

s401, judging the current node type of the expression abstract syntax tree based on the rule set meta information recorded in the data structure in the step S102, and inquiring and updating the current node type and returning the current node type if the current node type is an identifier or a literal quantity node; if the function call node is the function call node, executing step S402-A; if the member access operation is the member access operation, executing step S402-B; if the node is a prefix operation node, executing the step S402-C;

step S402-A, executing step S401 on each real parameter node of the function call, searching a function reload table according to the function parameter type, selecting a real function with the function shape parameter type matched with the called real parameter type to replace the function call, updating the return type of the current node and returning;

step S402-B, executing step S401 on the node corresponding to the accessed value, then searching for a type definition to judge whether the current member access is feasible, and if so, updating the return type of the current node to the member type and returning; if not, directly returning;

step S402-C, executing step S401 on the left side value and the right side value which participate in the prefix operation, then judging whether the types of the left side value and the right side value are real types, if so, updating the return type of the current node to the real type and returning; if not, directly returning;

s403, executing the step S401 on all nodes of the expression abstract syntax tree to obtain the verified expression abstract syntax tree.

6. The method for generating a rule behavior model real-time code based on a rule description file according to claim 5, wherein said step S5 specifically comprises the following sub-steps:

s501, creating a conditional branch node on an atomic rule on the verified expression abstract syntax tree, and constructing a conditional branch statement in the form of an IF-THEN-ELSE, wherein a front part expression of the atomic rule is used as a conditional expression of the conditional branch statement, a rear part expression of the atomic rule is used as a conditional expression of the conditional branch statement, and an abstract syntax tree corresponding to the residual atomic rule is used as a false value branch of the conditional branch statement; recursively performing the above processing on each atomic rule in a sub-rule set to obtain an abstract syntax tree of the sub-rule set connected by a series of conditional branch sentences and conditional branch nodes;

s502, executing a step S501 on each sub-rule set to obtain an abstract syntax tree of each sub-rule set;

s503, merging the abstract syntax trees of all the sub-rule sets to obtain the abstract syntax tree of the rule set.

7. The method for generating the real-time code of the rule behavior model based on the rule description file according to claim 6, wherein said step S6 specifically comprises the following sub-steps:

s601, constructing a set for recording the names of the loaded situation variables, wherein the set is initially empty;

s602, traversing abstract syntax tree nodes of a front part expression and a back part expression of a current atomic rule, searching for a loaded situation variable name in the set for recording the loaded situation variable name, and adding function call of a situation variable reading function corresponding to the situation variable name which is not included in the set before the front part expression; storing all accessed situation variable names into the set;

step S603, traversing each atomic rule of each sub-rule set in the abstract syntax tree of the rule set, and executing step S602 until all situation variable names accessed by each abstract syntax tree node are stored in the set, so as to obtain the abstract syntax tree for generating codes.

8. The method for generating the real-time code of the rule behavior model based on the rule description file according to claim 7, wherein said step S7 specifically comprises the following sub-steps:

s701, traversing nodes of an abstract syntax tree for code generation, converting the abstract syntax tree for code generation into corresponding C/C++ codes, inputting the corresponding C/C++ codes into a source code file, and generating a corresponding header file;

s702, sorting a platform interface template, and filling operations related to a behavior model in interface source codes, wherein the operations comprise reading functions of input situation variables and intermediate state variables;

s703, calling a construction system to construct the source code file and the header file obtained in the step S701 and the interface template arranged in the step S702, and calling a compiler to compile and generate a rule behavior model; wherein, the rule behavior model refers to a dynamic library or executable file that can be used for a specific computer generated force simulation platform.