CN102156655B - Senior language code generation method and generator - Google Patents

Abstract

The invention discloses a high-level language code generator and a high-level language code generation method, by converting the input syntax support description information and verification or test strategies of an EDA design tool into corresponding syntax configuration tables and control constraint tables, and then According to the syntax configuration table and the control constraint table, the corresponding syntax library is called to construct a syntax tree, and then the syntax tree is converted into a corresponding executable high-level language code. Since the constructed syntax tree satisfies the syntax configuration table and the control constraint table, the executable of the generated high-level language code is guaranteed, and the correlation of the code is improved, so that the actual algorithm code can be simulated more naturally, so as to guarantee various EDA The design tool provides high-quality test cases for the correctness of the conversion described by various codes, and the test cases are well executable, thereby reducing the pressure of manually writing test codes.

Description

High-level language code generation method and its generator

technical field

The present invention relates to the field of verification and automatic code generation of electronic design automation (Electronic Design Automation, EDA) software tools, in particular to a high-level language code generator and a high-level language code generation method in the verification process of high-level comprehensive design tool development .

Background technique

EDA technology for integrated circuit design began in the 1970s. SPICE (Simulation program with integrated circuit emphasis, general-purpose analog circuit simulator) first appeared in circuit design, and changed from manual drawing to computer drawing in layout production; logic simulators and automatic layout and routing tools appeared in the early 1980s ; In the late 1980s, RTL (RegisterTransfer Level, register transfer level) level design simulation and logic synthesis tools, as well as formal verification and static timing analysis tools, appeared; the current fourth-generation EDA tools mainly include: reuse design, graphics State diagram input, algorithm synthesis, software and hardware complementary design, etc.

It can be seen from the development trend of EDA that the current aided design is gradually transforming to the algorithm level and system level. This is also an inevitable trend in response to the current needs of integrated circuit design companies for rapid development and rapid listing. With the improvement of the abstraction level of algorithm description, the advantages of using high-level language design system become more obvious. Designers can build functional functions quickly and concisely, and create more complex and high-speed systems through standard library and function call technology.

At present, EDA design tools support the direct mapping of the corresponding circuit structure from the algorithm description of the high-level language, but in the process of mapping from the algorithm description of the high-level language to the corresponding circuit structure, it is usually difficult to ensure that the high-level language syntax supported by the EDA design tool is within the range The various forms of algorithmic code describe the correct conversion.

Contents of the invention

The main technical problem to be solved by the present invention is to provide a high-level language code generator and a high-level language code generation method. The correlation and randomness of the algorithm make it more natural to simulate the actual algorithm code, thereby providing the high-level language code test cases required for testing or verification, and ensuring the direct executable of the high-level language code test cases, so that Reduce the pressure of manually writing test code.

In order to solve the problems of the technologies described above, the technical scheme adopted in the present invention is as follows:

A high-level language code generator including:

A syntax configuration module, configured to receive the syntax support description information of the input electronic design automation tool, and convert the syntax support description information into a corresponding syntax configuration table;

A control parameter extraction module, configured to receive input verification or test strategy-level description information, and convert the verification or test strategy-level description information into a corresponding control constraint table;

The high-level language grammar library is used to store all the grammar and lexical element descriptions of the high-level language required;

Syntax tree generating module, connected with the grammar configuration module, advanced language grammar library and control parameter extraction module, for the grammar configuration table generated according to the grammar configuration module, and the control constraint table generated by the parameter extraction module, calling Grammar and lexical elements in the high-level language grammar library, and generate a corresponding syntax tree;

A code generation module, connected to the syntax tree generation module, is used to convert the syntax tree generated by the syntax tree generation module into a corresponding executable high-level language code file.

Further, the code generation module is also used to generate a high-level language code characteristic description file corresponding to the executable high-level language code file according to the syntax tree, then the code generation module includes:

The code construction sub-module is connected with the syntax tree generation module, and is used to traverse and read the syntax tree generated by the syntax tree generation module, and generate a corresponding executable high-level language code file;

A code characteristic extraction submodule is connected to the code construction submodule and the conformity detection module, and is used to record the characteristics of the generated executable high-level language code while the code construction submodule traverses and reads the syntax tree, and Generate the corresponding high-level language code feature description file.

Furthermore, when the user needs specific annotation or annotation information, the code construction sub-module is also used to add interfaces for other information volume annotations on the basis of the standard language.

Further, the high-level language code generator also includes:

A compliance detection module, connected to the code feature extraction sub-module and the control parameter extraction module, for checking the compliance according to the high-level language code feature description file and the control constraint table, if the high-level language code feature The description file meets the control constraint table, then generates a corresponding compliance report, and outputs the compliance report, executable high-level language code file and high-level code feature description file; if the high-level language code feature description file does not meet the required When the above-mentioned control constraint table is used, the internal settings are automatically adjusted according to the preset allowable number of iterations, and a new executable high-level language code file is regenerated.

Further, the syntax tree generation module includes:

The subtree set generation submodule is connected with the grammar configuration module, the control parameter extraction module and the high-level language grammar library, and is used to use the grammar or lexical elements in the advanced language grammar library according to the grammar configuration table and the control constraint table. The class identifier or instance is a node, and the corresponding subtree set is generated;

The subtree merging submodule is connected with the grammar configuration module, the control parameter extraction module and the subtree set generation submodule, and is used to randomly merge the subtrees according to the grammar configuration table and the control constraint table to obtain a new subtree Tree set, the condition for merging is that the root node of one of the two subtrees to be merged is the same type as the leaf node of the other subtree;

The total syntax tree generation submodule is connected with the subtree merging submodule, syntax configuration module and control parameter extraction module, and is used to use the subtree with the most nodes in the obtained new subtree set as the main tree, and other subtrees as the main tree. The attached tree, and according to the grammar configuration table and the control constraint table, according to the direction of bottom-up extension, randomly perform multiple rounds of merging of the main tree and the attached tree to obtain the corresponding total grammar tree.

Further, it is characterized in that the syntax configuration table includes: syntax point support information, implementation form constraint information, and special syntax phenomenon constraint information; the control constraint table includes: program flow layout information, and variable usage information.

A high-level language code generation method comprising:

Generate a corresponding syntax configuration table according to the description information of the syntax support of the input electronic design automation tool;

According to the strategy-level description information of the input verification or test strategy, generate the corresponding control constraint table;

Call the syntax and lexical elements in the high-level language syntax library according to the syntax configuration table and the control constraint table, and construct a corresponding syntax tree through a syntax tree construction method;

The syntax tree is converted into a corresponding executable high-level language code file.

Further, converting the syntax tree into a corresponding executable high-level language code file includes:

Traversing and reading the syntax tree to generate a corresponding executable high-level language code file;

When specific annotation or annotation information is set, high-level language codes corresponding to the specific annotation or annotation information are generated in the executable high-level language code file.

Further, the method also includes:

While traversing and reading the syntax tree, record the characteristics of the generated executable high-level language code, and generate a corresponding high-level language code characteristic description file;

Detect whether the high-level language code feature description file satisfies the control constraint table, if so, generate and output a corresponding compliance report, and output the executable high-level language code file and high-level language code feature description file; otherwise, proceed Adjust accordingly, and generate a new executable high-level language code file.

Further, the syntax tree construction method includes:

According to the control constraint table and the syntax configuration table, using the class identifier or instance of the syntax or lexical element as a node, randomly generate a corresponding basic subtree set;

According to the control constraint table and the grammar configuration table, each subtree is randomly merged to generate a new subtree set. The leaf node types of are the same;

The subtree with the most nodes is used as the main tree, and the other subtrees are used as the attached trees. According to the control constraint table and the grammar configuration table, according to the direction of extending from bottom to top, randomly perform multiple rounds of merging of the main tree and the attached trees , to generate the corresponding total syntax tree.

The beneficial effects of the present invention are:

The high-level language code generator of the present invention converts the input syntax support description information into a corresponding syntax configuration table through the syntax configuration module; then converts the input verification or test strategy into a corresponding control constraint table through the control parameter extraction module; Then, the grammar tree generation module calls the grammar and lexical elements in the high-level language grammar library according to the grammar configuration table and the control constraint table to construct a corresponding grammar tree, and then the code generation module converts the generated grammar tree into a corresponding executable code, and generate an executable code feature description file at the same time. Because the syntax tree constructed by the syntax tree generation module can satisfy the control constraints and ensure the feasibility of the code. The high-level language code that the high-level language code generator of the present invention generates has good correlation and randomness, has guaranteed the simplification of code, makes can simulate actual algorithm code more naturally, thereby guarantees that EDA design tool is to various codes The correctness of the described transformations provides high-quality test cases, which relieves the pressure of manually writing test codes. On the other hand, because the high-level language syntax library can be modified according to the language supported by different EDA tools to support other language forms, thereby improving the scalability of the code generator.

Simultaneously, the high-level language code generator of the present invention also generates corresponding high-level language code characteristic description files, and users can directly understand the characteristics of the executable high-level language codes generated through the high-level language code characteristic description files, thereby facilitating checking of their own verification or testing Whether the strategy corresponds to the generated code, that is, to shift the focus of the verification or tester from the writing of the test code to the verification or testing strategy, and to provide the conversion or synthesis tools starting from the high-level language. What is needed for testing or verification Comprehensive test cases conforming to their respective design characteristics can guide the implementation of verification or test strategies according to the description of the characteristics of the executable file, thereby further reducing the pressure of manual code writing. The high-level language code generator of the present invention can also detect whether the generated high-level language code meets the requirements through the compliance degree detection module. Adjust the internal settings to regenerate new high-level language codes, and the upper limit of the number of iterations can be set, that is to say, the high-level language generator of the present invention is provided with a compliance detection module, so that the high-level language code generator can perform self-test .

The high-level language code generation method of the present invention converts the input syntax support description information and the strategy-level description information of the verification or test strategy into corresponding syntax configuration tables and control constraint tables respectively, and then according to the syntax configuration table and control The constraint table calls the grammar and lexical elements in the grammar library, constructs the corresponding grammar tree through the grammar tree construction method, and then generates the corresponding executable high-level language code and high-level language code feature description file by traversing and reading the grammar tree, so that Shift the focus of verification or testers from writing test codes to verification or testing strategies, avoiding the problems of incomplete grammar, unclear measurement points, and inconvenient debugging and positioning when using ready-made algorithm codes; at the same time, due to The constructed syntax trees all satisfy the control constraint table, so that the high-level language codes converted from the syntax trees have good correlation and randomness, and the generated high-level language codes are simplified, reducing irrelevant codes, so that more Naturally simulating the actual algorithm code ensures the direct executable of the generated high-level language code test cases, thereby reducing the pressure of manual code writing.

On the other hand, in the high-level language code generation method of the present invention, the construction method of the syntax tree is by randomly merging the subtrees into the main tree, and then randomly merging the main tree and the auxiliary tree in the direction of upward extension to generate the total grammar Tree. Since each subtree satisfies the control constraints, the controllability increases in the process of merging subtrees into the main tree; and in the process of merging the subtree set into the total syntax tree, the total number of subtrees gradually decreases, and the final convergence is A tree, so that the corresponding requirements can be met with as little code as possible, and it can converge as soon as possible under the premise of satisfying the control constraints, thereby improving the relevance and randomness of the code converted from the syntax tree, making it possible to More natural simulation of actual algorithmic code.

Description of drawings

Fig. 1 is the structural representation of an embodiment of the high-level language code generator of the present invention;

Fig. 2 is a schematic structural diagram of an embodiment of the code generation module of the present invention;

Fig. 3 is the flowchart of an embodiment of the high-level language code generation method of the present invention;

Fig. 4a, Fig. 4b and Fig. 4c are schematic diagrams of grammar point support information, implementation form constraint information and special grammar phenomenon constraint information of the grammar configuration table in an embodiment of the high-level language code generation method of the present invention;

FIG. 5a and FIG. 5b are schematic diagrams of variable usage information and program flow layout in an embodiment of the high-level language code generation method of the present invention;

Fig. 6 is the flowchart of an embodiment of the syntax tree construction method of the present invention;

Fig. 7a, Fig. 7b and Fig. 7c are respectively a schematic diagram of generating a subtree set in an embodiment of the syntax tree construction method of the present invention, a schematic diagram of merging subtree sets to generate a new subtree set, and a schematic diagram of generating a total syntax tree.

Detailed ways

The present invention will be further described in detail below through specific embodiments in conjunction with the accompanying drawings.

Please refer to FIG. 1 , which is a schematic structural diagram of an embodiment of the high-level language code generator of this embodiment. The high-level language code generator of the present embodiment comprises: grammar configuration module 1, is used to receive the grammar support situation description information of the EDA design tool of input, and this grammar support situation description information is converted into corresponding grammar configuration table; Control parameter The extraction module 2 is used to receive the strategy-level description information of the input verification or test strategy, and convert the strategy-level description information of the verification or test strategy into a corresponding control constraint table; the high-level language grammar library 3 is used to convert the required All grammatical and lexical element descriptions of the high-level language are classified and stored; the grammatical tree generation module 4 is connected with the grammatical configuration module 1, the high-level language grammatical library 3 and the control parameter extraction module 2, and is used for the grammatical configuration table generated by the grammatical configuration module 1 , and the control constraint table generated by the parameter extraction module 2, call the syntax and lexical elements in the high-level language grammar library to generate the corresponding syntax tree; the code generation module 5 is connected with the syntax tree generation module 4, and is used for traversing and reading the The syntax tree generated by the syntax tree generation module 4 generates a corresponding executable high-level language code file.

Usually we refer to the allowable grammatical phenomena defined in the high-level language grammar standards as standard languages. In the current various high-level language grammar standards, because some grammars are difficult to support, EDA design tools will choose to support some grammar points, and give up supporting other grammar points, that is, support a small set that is smaller than the standard grammar set , and even some unique syntax customized on top of it. The syntax support description information in this embodiment refers to the syntax that the EDA design tool allows the user to use when programming, that is, the scope that the EDA design tool can support.

The policy-level description information in this embodiment is relative to the code level, that is, it describes how to generate the test point strategy in a more abstract form, such as pseudo-code, or flowchart, etc., rather than in the form of code describe.

In this embodiment, the syntax configuration table generated by the syntax configuration module 1 includes syntax point support information, implementation form constraint information, and special syntax phenomenon constraint information; the control constraint table generated by the control parameter extraction module 2 includes: program flow layout information , variable usage information.

The high-level language code generator of this embodiment converts the received input grammar support description information into a corresponding grammar configuration table through the grammar configuration module 1, thereby passing through the grammar configuration, implementation form restrictions, and special grammar phenomenon annotations in the grammar configuration table , to realize the coarse adjustment, fine adjustment and fine adjustment of grammatical constraints; and then convert the input verification or test strategy into the corresponding control constraint table through the control parameter extraction module 2, so as to convert the thinking of the tester or verification personnel into the form of a list of digital parameters, forming friendly user interface; then the grammar tree generation module 4 calls the grammar and lexical elements in the high-level language grammar library according to the grammar configuration table and the control constraint table to construct a corresponding grammar tree, and then the grammar generated by the code generation module 5 Tree is converted into corresponding executable code. Since the constructed syntax tree satisfies the control constraint table, syntax configuration table, and conforms to the corresponding high-level language grammar and lexical rules, the high-level language code obtained from the syntax tree conversion is more relevant, enabling more Naturally simulate the actual algorithm code, thereby ensuring the executable of the generated high-level language code, so as to reduce the pressure of manual coding.

On the other hand, since the high-level language grammar library can be modified according to the different languages supported by different EDA tools to support other language forms, the scalability of the high-level language code generator is improved.

The code generation module 5 of the high-level language code generator in this embodiment is also used to record the characteristics of the generated executable high-level language code when traversing the syntax tree to generate the executable high-level language code, so as to generate a corresponding high-level language code characteristic description file. The high-level language generator of the present embodiment also includes a conformity detection module 6 connected with the code generation module 5 and the control parameter extraction module 2, which is used to combine the high-level language code characteristic description file generated by the code generation module 5 with the control parameter extraction module 2 Check the compliance of the generated control constraint table, if the high-level language code characteristic description file meets the control constraint table, generate a corresponding compliance report, and output the compliance report, executable high-level language code file and high-level language code characteristic description file ; Otherwise, automatically adjust the internal settings according to the preset allowable number of iterations, and regenerate a new executable high-level language code file.

The high-level language code generator in this embodiment generates a corresponding high-level language feature description file through the code generation module, so that the user can check whether the generated high-level language code meets requirements according to the high-level language feature description file. On the other hand, by checking the high-level language feature description file with the control constraint table converted from the strategy-level description information of the verification or test strategy, it is checked whether the generated code meets the requirements, thereby shifting the focus of the verification or tester from The writing of test code is transferred to the strategy of verification or testing, and provides comprehensive test cases that meet the respective design characteristics required for testing or verification for conversion or synthesis tools starting from the corresponding high-level language code, avoiding the use of off-the-shelf When using the algorithm code, the grammatical phenomenon is incomplete, the measurement points are not clear, and it is inconvenient to debug and locate, which in turn reduces the pressure of writing code. At the same time, when there is a problem with the generated high-level language code, the code can be regenerated by automatically adjusting the internal settings in the compliance detection module 6 within the allowable number of iterations, and the upper limit of the number of iterations can be set, that is to say, the upper limit of the number of iterations in this embodiment The code generator can perform self-test through the conformity detection module 6 .

Please refer to FIG. 2 , which is a schematic structural diagram of an embodiment of the code generation module 5 in this embodiment. The code generation module 5 of this embodiment includes a code construction submodule 51 connected to the syntax tree generation module 4 , and a code feature extraction submodule 52 connected to the code construction submodule 51 and the conformity detection module 6 . Wherein, the code construction submodule 51 is used for traversing and reading the syntax tree built by the syntax tree generation module 4, and generates an executable high-level language code file; the code feature extraction submodule 52 is used for traversing the While reading the syntax tree, record the characteristics of the generated executable high-level language code, and generate a corresponding high-level language code characteristic description file.

At the same time, in this embodiment, when the user needs specific annotation or annotation information, the code construction sub-module 51 provides an interface for adding other information volume annotations on the basis of the standard language, that is, it can output the specific annotation or annotation information corresponding to the user's needs. code.

Because some EDA tools define the grammatical phenomena that can be recognized by the EDA tool itself and are used for specific purposes outside of some grammatical standards for their respective purposes, therefore, it is necessary to add these non-common features when generating code grammatical content.

Based on the above-mentioned high-level language code generator, this embodiment also provides a high-level language code generation method. The high-level language code generation method in this embodiment will be described in detail below with reference to specific embodiments and drawings.

Please refer to FIG. 3 , which is a flow chart of an embodiment of the high-level language code generation method of this embodiment. Taking C language as an example, the high-level language code generation method of this embodiment includes:

S101. Generate a corresponding syntax configuration table according to the input syntax support description information of the EDA design tool.

In this embodiment, the generated grammar configuration table includes: grammar point support information, implementation form constraint information, special grammar phenomenon constraint information, etc., and the grammar configuration table will set default constraint values for some information.

In this embodiment, by converting the grammar support description information into a corresponding grammar configuration table, the coarse adjustment, fine adjustment and fine adjustment of grammar constraints are realized through the mechanism of grammar configuration, implementation form restriction, and special grammar phenomenon marking.

Please refer to FIG. 4a, FIG. 4b and FIG. 4c, which are schematic diagrams of grammar point support information, implementation form constraint information, and special grammar phenomenon constraint information in the grammar configuration table in this embodiment, respectively. Among them, the grammar point support information includes the support of grammar points such as data types and operator types, that is, on the grammar point support information form of the grammar configuration table, check the corresponding option (or Y/N); realize Formal constraint information includes: the constraints of information such as loop nesting times and conditional nesting times, which can only be entered on the existing implementation form constraint information form; special grammatical phenomenon constraint information refers to the situation where there are more special grammatical constraints Fill in under the conditions, and fill in on the basis of the special grammatical phenomenon description rules provided by the system, and the expression is rigorous.

Please refer to Figure 4c. In an example of this embodiment, the first item in the special syntax phenomenon constraint information indicates "If an expression composed of a binocular operator appears, the data types on the left and right sides of the binocular operator cannot be constants at the same time. , and the data types must be the same”; the second clause means “if there is an expression composed of a binary operator, when the binary operator is a shift operation, the data type of the second operand of the shift operation must be Immediate value"; the third item means "if there is a declaration statement, when the declaration statement uses a comma to complete the continuous declaration, some initialization and some non-initialization phenomena are not allowed."

S103. Generate a corresponding control constraint table according to the input strategy-level description information of the verification or test strategy.

The policy-level description information in this embodiment is relative to the code level, that is, it describes how to generate the test point strategy in a more abstract form, such as pseudo-code, or flowchart, etc., rather than in the form of code describe.

This embodiment transforms the strategy-level description information of the verification or test strategy into the corresponding control constraint table, and transforms the thinking of the tester or verification personnel into a list of digital parameters, forming a friendly user interface and facilitating communication between engineers.

In this embodiment, the generated control constraint table includes: program flow layout information, variable usage information, and the like. Please refer to FIG. 5a, which is a schematic diagram of variable usage information in an example of this embodiment. Since the code can be generated in units of functions, the variable usage information can include: when constructing a function, limit the number of variables in the function, Information such as the variable name, variable type, variable initial value, and scope of the variable is used preferentially.

Please refer to Figure 5b, which is a schematic diagram of the flow layout information of the program in an example of this embodiment, the flow layout information of the program may include the position arrangement of each grammar point, for example, if statement is inserted in the while statement; the attributes of each grammar point Setting, for example, setting the quantity attribute amount appearing in the assignment statement assignStatement; and inserting a specified code, for example, where "i_count+=i_refa;" is inserting a specified code, etc.

S105. According to the generated syntax configuration table and control constraint table, call the syntax and lexical elements in the corresponding syntax library, and construct the corresponding syntax tree through the syntax tree construction method.

Please refer to Fig. 6, the syntax tree construction method of the present embodiment comprises:

S1051. According to the control constraint table and the syntax configuration table, randomly generate a corresponding set of basic subtrees with class identifiers or instances of syntax or lexical elements as nodes.

In this embodiment, in order to ensure that there must be a grammar point selected by the user in the syntax tree, the user's needs are first read, and the basic grammar point selected by the user is used as the main framework to extend upward or downward, so that a subclass containing the basic grammar point is generated. The number of mergeable nodes of the tree increases, and the mergeability among the generated subtrees is improved, so that it is easier to complete the merger of each subtree of the basic subtree set formed by the subtree into the syntax tree.

Please refer to Fig. 7a, in an example of this embodiment, the code to be generated includes two if structures and two for structures, then four independent nodes are generated according to the control constraint table and the grammar configuration table: ifstat, ifstat , forstat, forstat. However, these four independent nodes cannot be merged directly. Therefore, we first extend these four nodes upwards or downwards, so that the number of mergeable nodes of the tree extended by these four independent nodes increases, improving The associability between each tree makes it easier to complete the merge into the total syntax tree. Because in the C language production, all ifstat and forstat must be derived from stat, that is, the parent node of all ifstat and forstat must be the node stat, and the node stat has a higher probability of appearing in the C language production , that is, the combinability rate is higher when merging, so the four nodes here are all extended one step upwards, so as to obtain two subtrees 101 and 102 containing if structures, and two subtrees 103 and subtrees containing for structures. tree 104, that is, to obtain the corresponding basic subtree set.

In this embodiment, a grammatical tree has only one root node, but there may be many leaf nodes, and when constructing a grammatical tree or a total grammatical tree, it is necessary to determine the node type or node content, and If the content or type of the node is optional in the rules constrained by the grammar configuration, it is randomly selected within the optional range according to the random function.

In this embodiment, the random function refers to generating a random number within a specified range, and the random number determines the number of subtrees that may be generated by the C language production. High-level languages usually provide random functions. For example, there is block->stat ⁿ in the C language production, that is, the block can generate n stats (n≥0), and the specific value of this n is determined by a random number generated by the random function.

The random function in this embodiment can be called multiple times, and each time according to different needs, the random numbers generated by the called random function are not reused, that is, the random numbers generated each time are different, but the random function generates a random number every time. When called, there will be a maximum value, which limits the range of random number generation. For example, the maximum value is 7, then the random value generated by the random function can only be any one of 0 to 6.

S1053. According to the control constraint table and the grammar configuration table, randomly merge the subtrees for multiple rounds to generate a new subtree set, wherein the merge condition is that the root node of one of the two subtrees to be merged is the same as the root node of the other. The leaf nodes of a subtree are of the same type.

In this embodiment, during each step of upward extension, the new root node can be randomly determined according to the requirements of the production formula, and during the extension process, the obtained non-leaf nodes, that is, non-terminal symbols, are replaced by new node A subtree that can be merged is searched for as a search condition.

Please refer to Figure 7b, randomly merge the subtrees in Figure 7a, and generate a new subtree set includes: First, since the production set of stat can be deduced as {block->stat ⁿ , ifStat->if(expr) stat, ...}, then the second production ifStat->if(expr)stat is obtained through a random function, that is, the leaf node ifstat of the subtree 101 can deduce if(expr)stat, because the deduced The leaf node stat is of the same type as the root node stat of subtree 103, so subtree 201 is obtained by merging subtrees 101 and 103, and the first round of merging ends.

Certainly, the subtree 101, the subtree 102, the subtree 103 and the subtree 104 in this embodiment can all be merged with each other. However, when performing a specific merging operation, the merging possibility between each subtree will be counted, and according to the merging possibility, a random number generated by a random function will determine which two subtrees will be merged. For example, there are M schemes that can be merged between subtrees, then the input value of the random function is M, if the output is N, then 0=<N<M, and the obtained value indicates that the Nth scheme is called. For example, in this embodiment, when the value generated by the random function is 0, the subtree 101 and the subtree 102 are merged; when the value generated by the random function is 1, the subtree 101 and the subtree 103 are merged.

In this embodiment, simple structures such as expr (expression) and stat (general statement) without nesting can be randomly generated in a top-down manner. In order to assist in generating random attached trees more quickly, sufficient expr (expression) and stat (general statement) need to be generated in the set of subtrees.

In this embodiment, when there is some kind of grammatical nesting, if the user does not specify the allowable nesting level, it needs to be determined before building the tree, which can be determined randomly or set by default. For example, at the beginning of the program, the random number 3 is obtained by the random function (this number can be set directly by the user, or take a default value), then the number of nesting layers is determined to be 3, that is, each path downward of stat is not allowed There are more than 3 stats on any one of the paths; if a random number 0 is obtained at the beginning of the program, then in the process of stat derivation, no stat can appear again, and any path from the root node to the leaf node The complete path and the nesting level of a certain grammar can be calculated by counting the number of nodes of the same grammar type appearing on the path.

Secondly, block or forstat can be selected here as the new root node of the subtree 201. In this embodiment, block is selected as the new root node, then a random function is run to obtain the production block->statstat, and the The new stat in the two stats introduced by the production is a non-terminal symbol, then use the non-terminal symbol stat as a new node to search for an attached tree that can be merged, and then search for the subtree 104 and the subtree whose root node is stat. Tree 102, and then decides to merge subtree 201 and subtree 104 according to the random number generated by the random function, thereby merging subtree 201 and subtree 104 to obtain subtree 202, and the second round of merging ends.

In this embodiment, the subtree 201 can be merged with the subtree 102 or the subtree 104, but it is determined by a random function that the subtree 201 is merged with the subtree 102 or with the subtree 104.

Finally, due to the root node/leaf node of the subtree 102, the corresponding mergeable leaf node/root node cannot be found in the subtree 202, therefore, cannot be merged to obtain a new subtree set: Tree 202 and subtree 102.

S1055, taking the subtree with the most nodes as the main tree, and other subtrees as auxiliary trees, extending the main tree from bottom to top, randomly performing multiple rounds of merging, and generating a corresponding total syntax tree.

Please refer to FIG. 7 c , which is a schematic diagram of an example of merging the main tree and the subsidiary tree to generate a total syntax tree according to this embodiment. In a specific example of this embodiment, merging the main tree and the attached tree to generate the total syntax tree includes: according to the above-mentioned merging result, selecting the subtree 202 with more nodes as the main tree, and the subtree 102 as the attached tree Carry out a new round of merging: extend the main tree 202 upwards, obtain the production formula stat->block through the random function, then the root node of the main tree 202 becomes stat; then, obtain the production formula ifStat->if(expr )stat, that is, the if Stat in the subtree 102 is released if (expr)stat; since the leaf node stat after the subtree 102 is released is the same as the root node stat type of the main tree 202, then the main tree 202 and the subtree 102 merge, then all subtrees are merged.

Please refer to Figure 7c, the subtree 301 is obtained after the subtree is merged with the main tree, and the node expr in the subtree is a non-terminal symbol. Since there is no subtree with expr as the root node in the subtree, it will be randomly generated An attached tree with the node expr as the root node, and then merge this attached tree into the node expr of the main tree 301; at the same time, since the root node of the subtree 301 is already the vertex of the tree, the resulting Click expr to continue to extend downwards to complete itself.

The terminator in the present embodiment is the most basic element in the language, promptly can not be further decomposed, as in Fig. 7 c, because ifstat can release if (expr) stat, therefore, it is not a terminator; And the if released by ifstat In (expr)stat, because "if", "(" and ")" cannot deduce other elements, they are terminators.

In this embodiment, when there is only one main tree, the shortest path is selected to reach the function root node. In this embodiment, since there is only one main tree 202, in the process of extending the main tree 202 upwards, the random production is no longer selected, but the shortest path to function is detected forward, and finally through the production block- >stat, function->type ID (formalParameter) block obtains subtree 301, so far, the subtree with function as the root node, that is, the syntax tree is constructed.

In this embodiment, one syntax tree represents only one function, and the total number of generated syntax trees is determined by the number of functions during the complete code generation process.

Of course, when there is not only one subtree 102 in the attached tree, after merging the attached tree 102 with the main tree 202, the rest of the attached trees are randomly merged for multiple rounds, and in the main way of extending from bottom to top, finally Get the total syntax tree.

In this embodiment, each time the main tree is extended upwards, the new root node can be randomly determined according to the requirements of the production formula, and during the extension process, if a non-leaf node, that is, a non-terminal symbol, is obtained, then the The new non-terminal symbol is used as the search condition to search for the attached trees that can be merged. If the attached trees that meet the conditions do not exist, then the eligible attached trees can be randomly generated for merging.

In this embodiment, multiple rounds of merging are randomly performed on each subtree, and in the process of extending upward to generate the total syntax tree, the purpose of satisfying the terms on the control constraint table must be met, limited by the syntax configuration table, and conform to the C language grammar and vocabulary Rules, use a reasonable random mechanism with constraints, and use bottom-up extension as the main method to generate a syntax tree that meets user needs, and each time the main tree is extended upwards, it must be guaranteed that all leaf nodes are terminal symbols. Otherwise, use the non-terminal symbol as the search condition to search for merging attached trees for merging, or randomly generate eligible attached trees for merging, that is, combine the downward completion method without nesting to generate a syntax tree that meets the requirements.

In this embodiment, the syntax tree is constructed by extending upwards and filling in missing nodes downwards, which can well control the implementation of constraints such as the number of nesting times. At the same time, the main tree is extended from the bottom up to Generate more nodes that need to be completed, so that the attached tree can be merged into the main tree according to the condition of the root node of the attached tree, and finally converge into a total syntax tree, and because the merger must meet the requirements of the attached tree The root node is of the same type as the leaf node that needs to be completed on the main tree, so only when the node that is a terminal symbol is a leaf node, it does not need to continue to complete. If the existing attached tree cannot be used to complete the main tree, a corresponding subtree is generated according to the random function to complete it.

Of course, in this embodiment, when merging the main tree and the subsidiary tree for multiple rounds, it can also follow the direction of downward extension, but in the end, the missing nodes need to be completed to form a complete syntax tree.

In this embodiment, in the process of constructing the grammar tree, when the number of the same subtrees that may be generated by the C language production is uncertain, the number of subtrees is determined by a random function, and the maximum value of the random number is determined by the current attached tree. The number of trees is determined; in addition, if the user does not specify the maximum number of occurrences of main statements such as if and while, it will be determined before building the syntax tree, which can be determined randomly or set by default.

In this embodiment, in the process of constructing the main tree from the subtrees and finally merging them into the total syntax tree, since each subtree must satisfy the control constraint table, the controllability of the process of constructing the syntax tree from the subtrees is increased, and it is fast. Converge to the total syntax tree, and then make the generated total syntax tree meet the control constraint table, and make the high-level language code converted from the total syntax tree also meet the requirements, and the amount of generated code is less, the correlation is better, and the generated A valid value of the high-level language code for .

S107, traversing and reading the syntax tree, and generating a corresponding executable high-level language code file.

In this embodiment, if the user sets specific annotation or annotation information, the executable high-level language code corresponding to the specific annotation or annotation information is also generated from the executable high-level language code, so as to provide additional information on the basis of the standard language. An interface for information volume labeling.

S109, while traversing and reading the syntax tree, record the characteristics of the generated high-level language code, and generate a corresponding high-level language code characteristic description file.

In this embodiment, by recording the characteristics of the generated high-level language code, a corresponding high-level language code characteristic description file is generated, so that users can understand the characteristics of the generated high-level language code through the high-level language code characteristic description file, and then it is convenient to check their own verification or testing Whether the policy corresponds to the code, and at the same time, according to the feature description of the high-level language code in the high-level language feature description file, it can guide the implementation of the verification or test strategy, reducing the pressure of manual code writing.

S1011. According to the high-level language code characteristic description file, detect whether the high-level language code characteristic description file satisfies the control constraint table, and if so, execute step S1013a; otherwise, execute step S1013b.

S1013a, generating and outputting a corresponding compliance report, and simultaneously outputting an executable high-level language code file and a high-level language code characteristic description file.

S1013b, making corresponding adjustments, and generating a new executable high-level language code file.

In this embodiment, by checking whether the high-level language code characteristic description file satisfies the control constraint table, it is judged whether the generated executable high-level language code meets the requirements. When it meets the requirements, the corresponding executable high-level language code and high-level language code characteristic Description file and compliance report; when it does not meet the requirements, automatically adjust the corresponding settings under the premise of the number of iterations allowed, and regenerate a new executable high-level language code.

In the high-level language code generation method of this embodiment, first, the input syntax support description information and the strategy-level description information of the verification or test strategy are respectively converted into corresponding syntax configuration tables and control constraint tables; secondly, according to the syntax configuration table and control constraint table, call the grammar and lexical elements in the grammar library, and construct the corresponding grammar tree through the grammar tree construction method; moreover, read the grammar tree by traversing to generate the corresponding executable high-level language code file; at the same time Record the characteristics of the generated high-level language code file, and generate a corresponding high-level language code feature description file. At the same time, this embodiment converts it into a corresponding executable high-level language code by constructing a syntax tree. Since the syntax tree satisfies the control constraints The requirements of the table increase the controllability in the process of building from the subtree to the total syntax tree, and converge as soon as possible under the premise of satisfying the control constraints, so that the code generated under the premise of satisfying the user's control conditions is simplified and has a good The correlation and randomness of the algorithm make it more natural to simulate the actual algorithm code, ensuring the direct executable of the generated high-level language code test cases, thereby reducing the pressure of manual code writing.

The above content is a further detailed description of the present invention in conjunction with specific embodiments, and it cannot be assumed that the specific implementation of the present invention is limited to these descriptions. For those of ordinary skill in the technical field of the present invention, without departing from the concept of the present invention, some simple deduction or replacement can be made, which should be regarded as belonging to the protection scope of the present invention.

Claims (8)

1. a higher-level language code generator, is characterized in that, comprising:

Grammer configuration module, supports situation descriptor for receiving the grammer of the electronic design automation tool of input, and supports situation descriptor to be converted to corresponding grammer allocation list described grammer;

Control parameter extraction module, for receiving the checking of input or the strategy level descriptor of Test Strategy, and the strategy level descriptor of described checking or Test Strategy is converted into corresponding control restriction table;

Higher level lanquage syntax library, for storing all grammers of the higher level lanquage of needs and lexical element description;

Syntax tree generation module, be connected with described grammer configuration module, higher level lanquage syntax library and control parameter extraction module, for the grammer allocation list generating according to described grammer configuration module, and the control restriction table of described parameter extraction module generation, call grammer and lexical element in described higher level lanquage syntax library, and generate corresponding syntax tree;

Code generation module, is connected with described syntax tree generation module, for the syntax tree that described syntax tree generation module is generated, is converted to accordingly and can carries out higher-level language code file;

Described syntax tree generation module comprises:

Subtree set generates submodule, be connected with higher level lanquage syntax library with described grammer configuration module, control parameter extraction module, be used for according to described grammer allocation list and control restriction table, class sign or the example of grammer in higher level lanquage syntax library or lexical element of take is node, generates corresponding subtree set;

Subtree merges submodule, generating submodule with described grammer configuration module, control parameter extraction module with subtree set is connected, be used for according to described grammer allocation list and control restriction table, at random each subtree is merged, obtain new subtree set, the leaf node type that the condition of merging is set with another stalk for the root node of the stalk tree in the two stalk trees that will merge is identical;

Total syntax tree generates submodule, merge submodule, grammer configuration module and control parameter extraction module with described subtree and be connected, for using the maximum subtree of the new subtree set node obtaining as main tree, other subtrees are as attached tree, and according to described grammer allocation list and control restriction table, according to the direction of bottom-up extension, at random described main tree and attached tree are carried out to many wheel merging, obtain corresponding total syntax tree.

2. higher-level language code generator as claimed in claim 1, it is characterized in that, described code generation module also, for according to described syntax tree, generates corresponding to the described higher-level language code characteristic description file of carrying out higher-level language code file, and described code generation module comprises:

Code construction submodule, is connected with described syntax tree generation module, for the syntax tree that described syntax tree generation module is generated, travels through and reads, and generates the corresponding higher-level language code carried out file;

Code feature extraction submodule, be connected with degree of conformity detection module with described code construction submodule, for the characteristic of the higher-level language code carried out that record produces when described code construction submodule traversal reads described syntax tree, and produce corresponding higher-level language code characteristic description file.

3. higher-level language code generator as claimed in claim 2, is characterized in that, when the specific mark of needs or annotation information, described code construction submodule also for increasing the interface of other quantity of information marks on standard language basis.

4. higher-level language code generator as claimed in claim 2, is characterized in that, also comprises:

Degree of conformity detection module, be connected with control parameter extraction module with described code feature extraction submodule, be used for according to described higher-level language code characteristic description file, and described control restriction table carries out degree of conformity and checks, if described higher-level language code characteristic description file meets described control restriction table, generate the report of corresponding degree of conformity, and export described degree of conformity report, can carry out higher-level language code file and high-level code characteristic description file; When if described higher-level language code characteristic description file does not meet described control restriction table, according to the iterations of the permission setting in advance, automatically adjust inner setting, regenerate the new higher-level language code carried out file.

5. the higher-level language code generator as described in any one in claim 1 to 4, is characterized in that, described grammer allocation list comprises: grammer point support information, way of realization constraint information, special grammar phenomenon constraint information; Described control restriction table comprises: process-oriented layout's information of program, variable uses information.

6. a higher-level language code generation method, is characterized in that, comprising:

According to the grammer of the electronic design automation tool of input, support situation descriptor, generate corresponding grammer allocation list;

Strategy level descriptor according to the checking of input or Test Strategy, generates the corresponding restriction table of controlling;

According to described grammer allocation list and control restriction table, call grammer and lexical element in higher level lanquage syntax library, and build corresponding syntax tree by syntax tree construction method;

Described syntax tree is converted to accordingly and can carries out higher-level language code file;

Described syntax tree construction method comprises:

According to described control restriction table and grammer allocation list, class sign or the example of grammer or lexical element of take is node, generates corresponding basic subtree set at random;

According to described control restriction table and grammer allocation list, at random each subtree is merged, generate new subtree set, the leaf node type that the condition of merging is set with another stalk for the root node of the stalk tree in the two stalk trees that will merge is identical;

Using the maximum subtree of node as main tree, other subtree is as attached tree, according to described control restriction table and grammer allocation list, according to the direction of bottom-up extension, at random described main tree and attached tree carried out to many wheels and merges, and generates corresponding total syntax tree.

7. method as claimed in claim 6, is characterized in that, described syntax tree is converted to and can carries out accordingly higher-level language code file and comprise:

Traversal reads described syntax tree, generates and can carry out higher-level language code file accordingly;

When having set specific mark or annotation information, described, generate the higher-level language code corresponding to described specific mark or annotation information in carrying out higher-level language code file.

8. method as claimed in claim 7, is characterized in that, also comprises:

When traversal reads described syntax tree, the characteristic of the higher-level language code carried out that record generates, and generate corresponding higher-level language code characteristic description file;

Detect described higher-level language code characteristic description file and whether meet described control restriction table, if met, generate and export corresponding degree of conformity report, described in output, can carry out higher-level language code file and higher-level language code characteristic description file simultaneously; Otherwise adjust accordingly, and generate the new higher-level language code carried out file.

Images