WO2026056340A1 - Compiler-based automatic code upgrade method and apparatus, and storage medium - Google Patents

Abstract

The present invention relates to the technical field of computer code upgrades. Disclosed are a compiler-based automatic code upgrade method and apparatus, and a storage medium. The method comprises: first, performing lexical analysis, syntactic analysis and semantic analysis on a source code, so as to generate an abstract syntax tree; and then, constructing a syntactic rule mapping table for a new standard, traversing the abstract syntax tree, performing a query to determine whether nodes of the abstract syntax tree can be found in the mapping table, and for nodes that are found, outputting character strings to which the nodes are mapped, and for nodes that are not found, outputting normally codes that conform to node semantics. By means of automatically traversing an abstract syntax tree of original codes, and performing node matching and transformation on the basis of a syntactic rule mapping table for a new standard, the need for manual intervention is greatly reduced, and the level of automation of code migration from an old standard to a new standard is improved, thereby saving on substantial manpower and time costs, and mitigating the problem of migration that is caused by human errors.

Description

Methods, apparatus, and storage media for automatic code upgrades based on compilers.

This application claims priority to Chinese Patent Application No. 202411279576.6, filed on September 12, 2024, entitled "Method, Apparatus and Storage Medium for Automatic Code Upgrade Based on Compiler", the entire contents of which are incorporated herein by reference.

Technical Field

This application relates to the field of computer code upgrade technology, such as a method, apparatus, and storage medium for automatic code upgrade based on a compiler.

Background Technology

In the field of software development, with the continuous advancement of technology and the ongoing evolution of programming languages, new programming standards (such as new versions of C++, Java, and Python) are constantly being introduced, providing developers with richer, more efficient, and safer programming tools and features. These new standards often include improvements in syntax, performance optimizations, new libraries and APIs, better concurrency support, improved memory management mechanisms, and enhanced security. However, due to various reasons such as legacy issues, compatibility considerations, resource constraints, or developer habits, many projects still use code written using older programming standards. Older code often falls short when faced with the advantages of new standards. To utilize the features provided by new standards, developers need to manually migrate old code to the new standard, a process that is not only time-consuming and laborious but also prone to errors. Manual migration requires developers to have a deep understanding of the old code and familiarity with all the changes in the new standard, placing high demands on their skills and experience. Furthermore, manual migration may introduce new errors, especially when dealing with large, complex codebases, where this risk is particularly pronounced.

It should be noted that the information disclosed in the background section above is only used to enhance the understanding of the background of this application, and therefore may include information that does not constitute prior art known to those skilled in the art.

Summary of the Invention

To provide a basic understanding of some aspects of the disclosed embodiments, a brief summary is given below. This summary is not intended as a general commentary, nor is it intended to identify key/important components or describe the scope of protection of these embodiments, but rather as a prelude to the detailed description that follows.

The method for automatic code upgrade based on compiler provided in this disclosure includes:

The front-end performs lexical analysis and syntax analysis on high-level programming languages to generate abstract syntax trees, and performs semantic analysis to generate intermediate representations;

The backend optimizes the intermediate representation, constructs a new standard syntax rule mapping table, traverses the abstract syntax tree, and queries whether the nodes of the abstract syntax tree can be found in the mapping table. For nodes that are found, the mapped string is output; for nodes that are not found, code that conforms to the node's semantics is output normally.

The lexical analysis includes receiving input source code text, the lexical analyzer reading the source code text, segmenting it into a series of tokens according to the lexical rules of the language, outputting a token sequence, and using the tokens as input for subsequent syntax analysis. The tokens include keywords, identifier type information, and the specific numerical information of the identifier name and literal.

In some embodiments, the above-mentioned syntax analysis includes using a syntax analyzer to construct an abstract syntax tree according to the grammatical rules of the language, using an AST as a tree-like representation of the source code structure to reflect the grammatical structure of the program, the nodes of the abstract syntax tree representing different building blocks of the program, and the abstract syntax tree serving as the basis for subsequent semantic analysis and optimization.

In some embodiments, the semantic analysis described above includes using a semantic analyzer to traverse the AST, checking the semantic correctness of the program, including type checking, scope resolution, and variable binding, to ensure that the program conforms to the semantic rules of the language while being syntactically correct, and outputting an AST with semantic attributes such as type information and scope information, which can be used as necessary semantic information for subsequent optimization and code generation.

In some embodiments, the generation of the intermediate representation includes converting the AST into a general intermediate representation, which is independent of a specific source language or target machine, for use in subsequent optimization and code generation.

In some embodiments, the above-described construction of the syntax rule mapping table for the new standard involves traversing the abstract syntax tree, querying whether a node of the abstract syntax tree can be found in the mapping table, and outputting the mapped string for a found node. For nodes not found, the code conforming to the node's semantics is output normally, including:

For the new standard of programming languages, a mapping table is constructed from the nodes of the abstract syntax tree to the new standard of the high-level programming language. The key in the mapping table is the node of the abstract syntax tree, the value in the mapping table is a specific string, and the specific string is the code of the new standard.

Traverse the abstract syntax tree, query the mapping table of the new standard, and mark the node if it conforms to the new standard. Check whether each node of the abstract syntax tree conforms to the syntax rules of the new standard.

Traverse the matched abstract syntax tree and use a code generator to generate source code that conforms to the new standard. The code generator serializes and formats the nodes in the abstract syntax tree according to the syntax and style requirements of the new standard.

Output the source code under the new standard and output the string generated by the code to a file.

The apparatus for automatic code upgrade based on compiler provided in this disclosure includes:

The front-end module is used to perform lexical analysis and syntax analysis on high-level programming languages, generate abstract syntax trees, and perform semantic analysis to generate intermediate representations.

The backend module is used to optimize the intermediate representation, build a new standard syntax rule mapping table, traverse the abstract syntax tree, query whether the node of the abstract syntax tree can be found in the mapping table, output the mapped string for the found node, and output the code that conforms to the node semantics for the node that is not found.

The lexical analysis includes receiving input source code text, the lexical analyzer reading the source code text, segmenting it into a series of tokens according to the lexical rules of the language, outputting a token sequence, and using the tokens as input for subsequent syntax analysis. The tokens include keywords, identifier type information, and the specific numerical information of the identifier name and literal.

In some embodiments, the backend optimizes the intermediate representation, performs instruction selection, instruction scheduling, register scheduling, and generates an executable program, including:

For the new standard of programming languages, a mapping table is constructed from the nodes of the abstract syntax tree to the new standard of the high-level programming language. The key in the mapping table is the node of the abstract syntax tree, the value in the mapping table is a specific string, and the specific string is the code of the new standard.

Traverse the abstract syntax tree, query the mapping table of the new standard, and mark the node if it conforms to the new standard. Check whether each node of the abstract syntax tree conforms to the syntax rules of the new standard.

Traverse the matched abstract syntax tree and use a code generator to generate source code that conforms to the new standard. The code generator serializes and formats the nodes in the abstract syntax tree according to the syntax and style requirements of the new standard.

Output the source code under the new standard and output the string generated by the code to a file.

The storage medium provided in this embodiment stores program instructions, characterized in that, when the program instructions are executed, they perform the method for automatic code upgrade based on the compiler in the above embodiment.

The enhanced method, apparatus, and storage medium for automatic code upgrade based on compiler provided in this disclosure can achieve the following technical effects:

By automatically traversing the abstract syntax tree (AST) of the original code and performing node matching and transformation according to the new standard's syntax rule mapping table, the need for manual intervention is greatly reduced, improving the automation level of code migration from the old standard to the new standard. This not only saves significant manpower and time costs but also reduces migration problems caused by human error. Furthermore, the code of the new standard often has a clearer syntactic structure and more standardized naming conventions; the code generated through automatic transformation better meets these requirements, thereby improving code readability and maintainability.

The above general description and the description below are exemplary and illustrative only and are not intended to limit this application.

Attached Figure Description

One or more embodiments are illustrated by way of example with reference to the accompanying drawings. These illustrations and drawings do not constitute a limitation on the embodiments. Elements having the same reference numerals in the drawings are shown as similar elements. The drawings are not to be scaled. And wherein:

Figure 1 is a flowchart illustrating a method for automatic code upgrade based on a compiler, provided in an embodiment of this disclosure.

Figure 2 is a schematic diagram of a front-end process provided in an embodiment of this disclosure;

Figure 3 is a flowchart illustrating another method for automatic code upgrade based on a compiler, provided in an embodiment of this disclosure.

Figure 4 is a schematic diagram illustrating the effect of an embodiment of this disclosure;

Figure 5 is a schematic diagram of the structure of a device for automatic code upgrade based on a compiler provided in an embodiment of this disclosure;

Figure 6 is a schematic diagram of the structure of a system for automatic code upgrade based on a compiler, provided in an embodiment of this disclosure.

Detailed Implementation

To provide a more detailed understanding of the features and technical content of the embodiments of this disclosure, the implementation of the embodiments of this disclosure will be described in detail below with reference to the accompanying drawings. The accompanying drawings are for illustrative purposes only and are not intended to limit the embodiments of this disclosure. In the following technical description, for ease of explanation, several details are used to provide a full understanding of the disclosed embodiments. However, one or more embodiments may still be implemented without these details. In other cases, well-known structures and devices may be simplified in their depiction to simplify the drawings.

The terms "first," "second," etc., used in the embodiments of this disclosure are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate for the embodiments of this disclosure described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion.

Unless otherwise stated, the term "multiple" means two or more.

In this embodiment of the disclosure, the character "/" indicates that the objects before and after it are in an "or" relationship. For example, A/B means: A or B.

The term "and/or" describes an association between objects, indicating that three relationships can exist. For example, A and/or B means: A or B, or A and B.

The term "correspondence" can refer to an association or binding relationship. The correspondence between A and B means that there is an association or binding relationship between A and B.

The method, apparatus, device, and storage medium for automatic code upgrade based on compiler provided in this disclosure will now be described with reference to the accompanying drawings.

Figure 1 is a flowchart illustrating a method for automatic code upgrade based on a compiler according to an embodiment of this disclosure. As shown in Figure 1, the method for automatic code upgrade based on a compiler may include:

S01, the front end performs lexical analysis and syntax analysis on the high-level programming language, generates an abstract syntax tree, and performs semantic analysis to generate an intermediate representation;

S02, the backend optimizes the intermediate representation, constructs a new standard syntax rule mapping table, traverses the abstract syntax tree, and queries whether the nodes of the abstract syntax tree can be found in the mapping table. For nodes that are found, the mapped string is output; for nodes that are not found, code that conforms to the node's semantics is output normally.

The lexical analysis includes receiving input source code text, the lexical analyzer reading the source code text, segmenting it into a series of tokens according to the lexical rules of the language, outputting a token sequence, and using the tokens as input for subsequent syntax analysis. The tokens include keywords, identifier type information, and the specific numerical information of the identifier name and literal.

In some embodiments, the above-mentioned syntax analysis includes using a syntax analyzer to construct an abstract syntax tree according to the grammatical rules of the language, using an AST as a tree-like representation of the source code structure to reflect the grammatical structure of the program, the nodes of the abstract syntax tree representing different building blocks of the program, and the abstract syntax tree serving as the basis for subsequent semantic analysis and optimization.

In some embodiments, semantic analysis includes using a semantic analyzer to traverse the AST, checking the semantic correctness of the program, including type checking, scope resolution, and variable binding, to ensure that the program conforms to the semantic rules of the language while being syntactically correct, and outputting an AST with semantic attributes such as type information and scope information, which can be used as necessary semantic information for subsequent optimization and code generation.

In some embodiments, the generation of intermediate representations includes converting the AST into a generic intermediate representation, which is independent of a specific source language or target machine, for use in subsequent optimization and code generation.

In some embodiments, the above-described construction of the syntax rule mapping table for the new standard involves traversing the abstract syntax tree, querying whether a node of the abstract syntax tree can be found in the mapping table, and outputting the mapped string for a found node. For nodes not found, the code conforming to the node's semantics is output normally, including:

For the new standard of programming languages, a mapping table is constructed from the nodes of the abstract syntax tree to the new standard of the high-level programming language. The key in the mapping table is the node of the abstract syntax tree, the value in the mapping table is a specific string, and the specific string is the code of the new standard.

Traverse the abstract syntax tree, query the mapping table of the new standard, and mark the node if it conforms to the new standard. Check whether each node of the abstract syntax tree conforms to the syntax rules of the new standard.

Traverse the matched abstract syntax tree and use a code generator to generate source code that conforms to the new standard. The code generator serializes and formats the nodes in the abstract syntax tree according to the syntax and style requirements of the new standard.

Output the source code under the new standard and output the string generated by the code to a file.

Figure 2 is a schematic flowchart of a front-end provided in an embodiment of this disclosure. The process of front-end execution in Figure 1 will be further described in conjunction with Figure 2.

The front-end workflow, specifically the steps, is as follows:

1. Lexical Analysis: Input source code text, the lexer reads the source code, segments it into a series of tokens according to the language's lexical rules, and outputs a token sequence. Each token contains a type (such as keywords, identifiers, etc.) and possible values (such as the name of the identifier, the specific value of the literal). These tokens serve as input for subsequent syntax analysis.

2. Syntax Analysis: The parser constructs an Abstract Syntax Tree (AST) based on the language's grammatical rules. The AST is a tree-like representation of the source code structure, reflecting the program's grammatical structure. Nodes in the AST represent different building blocks of the program (such as expressions, statements, and declarations). The AST serves as the foundation for subsequent semantic analysis and optimization.

3. Semantic Analysis: The semantic analyzer traverses the Abstract Syntax Tree (AST) to check the semantic correctness of the program, including type checking, scope resolution, and variable binding. It ensures that the program is not only syntactically correct but also conforms to the semantic rules of the language, outputting an AST with semantic attributes such as type and scope information. This enhanced AST provides the necessary semantic information for subsequent optimization and code generation.

4. Intermediate Representation Generation: The AST is converted into a more general intermediate representation (IR), which is independent of the specific source language or target machine, facilitating subsequent optimization and code generation.

Based on the abstract syntax tree generated by the compiler front-end, this invention traverses the abstract syntax tree for a specified new standard. At this time, the nodes of the abstract syntax tree are expressions, statements or declarations that are independent of the specific standard. Each node is combined with the syntax rules of the new standard to generate code that conforms to the new standard.

Figure 3 is a flowchart illustrating another method for automatic code upgrade based on a compiler, provided in an embodiment of this disclosure. The process of front-end execution in Figure 1 will be further described in conjunction with Figure 3.

1. Input the original source code, which is provided by the user for the compiler to use.

2. Front-end processing. The compiler front-end performs lexical analysis and syntax analysis on the source code, generates an abstract syntax tree, and performs semantic analysis to confirm that the code is syntactically and semantically correct.

3. Construct a syntax rule mapping table for the new standard. For the new standard of programming languages, construct a mapping table from nodes of the abstract syntax tree to high-level programming language rules. The keys are nodes of the abstract syntax tree, such as loop statements, variable declarations, assignment expressions, etc. The values are specific strings, which are codes conforming to the new standard.

4. Node Matching. Traverse the abstract syntax tree (AST) and check if each node conforms to the syntax rules of the new standard. Specifically, look up the new standard's mapping table; if a node conforms to the new standard, mark it.

5. Code Generation. Traverse the matched abstract syntax tree and use a code generator to generate source code that conforms to the new standard. The code generator serializes and formats the nodes in the abstract syntax tree according to the syntax and style requirements of the new standard.

6. Output the source code under the new standard. Output the string generated by the code to a file.

This disclosure first performs lexical analysis, syntactic analysis, and semantic analysis on the source code to generate an abstract syntax tree (AST). Then, it constructs a new standard's syntax rule mapping table, traverses the AST, and checks if each node can be found in the mapping table. For found nodes, the mapped string is output; for unfounded nodes, the code conforming to the node's semantics is output normally. By automatically traversing the original code's AST and performing node matching and transformation according to the new standard's syntax rule mapping table, the need for manual intervention is greatly reduced, improving the automation of migrating code from the old standard to the new standard. This not only saves significant manpower and time costs but also reduces migration problems caused by human error. Furthermore, the code of the new standard often has a clearer syntactic structure and more standardized naming conventions; the automatically generated code better meets these requirements, thereby improving code readability and maintainability.

In a specific example, using the C++ programming language and the Clang compiler, the source code is upgraded from the C++98 standard to the C++11 standard. The input source code, main.cpp, is as follows:

The code above uses a for loop to iterate over an array defined within a function and output each member of the array. In C++11, a range-bound for loop can be used to iterate over an array, and the `auto` keyword can be used to automatically infer the type of the loop variable.

According to the method provided by the present invention, a C++11 standard syntax rule mapping table is first constructed, including scoped for loop compilation. For the new feature of scoped for loop compilation, the key is the for loop statement ForStmt in the AST expression, and the value is the corresponding scoped for loop string, in the form of for(auto elem:arr).

Next, lexical analysis and syntax analysis are performed on the code to generate an abstract syntax tree (AST). Semantic analysis is then conducted to confirm that the code is syntactically and semantically correct. The AST generated from the input source code contains nodes such as `ForStmt` (for loop statement), `VarDecl` (variable definition statement), and `InitListExpr` (assignment statement).

The abstract syntax tree (BST) is traversed, and each node is matched. If a corresponding node is found in the C++11 syntax rule map, it is marked as a C++11 standard node. If no corresponding node is found, it is skipped. Here, the BST contains a for loop statement `ForStmt`, and `ForStmt` is also included in the C++11 syntax rule map; therefore, the `ForStmt` node is marked here.

After marking the nodes in the abstract syntax tree, code generation begins. For nodes marked as requiring code generation using the C++11 standard, the string corresponding to ForStmt stored in the syntax rule mapping table is output. For unmarked nodes, code is generated using the standard code generator.

The code output using this invention is shown below:

The for loop statement is changed from a regular for loop to a range for loop. A specific implementation example is shown in Figure 4.

Figure 5 is a schematic diagram of a device for automatic code upgrade based on a compiler according to an embodiment of this disclosure. As shown in Figure 5, the device for automatic code upgrade based on a compiler may include:

The front-end module 501 is used to perform lexical analysis, syntax analysis, generate abstract syntax trees, and perform semantic analysis on high-level programming languages to generate intermediate representations.

Backend module 502 is used to optimize the intermediate representation, build a new standard syntax rule mapping table, traverse the abstract syntax tree, query whether the node of the abstract syntax tree can be found in the mapping table, output the mapped string for the found node, and output the code that conforms to the node semantics for the node that is not found.

The lexical analysis includes receiving input source code text, the lexical analyzer reading the source code text, segmenting it into a series of tokens according to the lexical rules of the language, outputting a token sequence, and using the tokens as input for subsequent syntax analysis. The tokens include keywords, identifier type information, and the specific numerical information of the identifier name and literal.

In some embodiments, the above-mentioned syntax analysis includes using a syntax analyzer to construct an abstract syntax tree according to the grammatical rules of the language, using an AST as a tree-like representation of the source code structure to reflect the grammatical structure of the program, the nodes of the abstract syntax tree representing different building blocks of the program, and the abstract syntax tree serving as the basis for subsequent semantic analysis and optimization.

In some embodiments, semantic analysis includes using a semantic analyzer to traverse the AST, checking the semantic correctness of the program, including type checking, scope resolution, and variable binding, to ensure that the program conforms to the semantic rules of the language while being syntactically correct, and outputting an AST with semantic attributes such as type information and scope information, which can be used as necessary semantic information for subsequent optimization and code generation.

In some embodiments, the generation of intermediate representations includes converting the AST into a generic intermediate representation, which is independent of a specific source language or target machine, for use in subsequent optimization and code generation.

In some embodiments, the above-described construction of the syntax rule mapping table for the new standard involves traversing the abstract syntax tree, querying whether a node of the abstract syntax tree can be found in the mapping table, and outputting the mapped string for a found node. For nodes not found, the code conforming to the node's semantics is output normally, including:

For the new standard of programming languages, a mapping table is constructed from the nodes of the abstract syntax tree to the new standard of the high-level programming language. The key in the mapping table is the node of the abstract syntax tree, the value in the mapping table is a specific string, and the specific string is the code of the new standard.

Traverse the abstract syntax tree, query the mapping table of the new standard, and mark the node if it conforms to the new standard. Check whether each node of the abstract syntax tree conforms to the syntax rules of the new standard.

Traverse the matched abstract syntax tree and use a code generator to generate source code that conforms to the new standard. The code generator serializes and formats the nodes in the abstract syntax tree according to the syntax and style requirements of the new standard.

Output the source code under the new standard and output the string generated by the code to a file.

It should be noted that, for the sake of simplicity, the foregoing method embodiments are all described as a series of actions. However, those skilled in the art should understand that this disclosure is not limited to the described order of actions, because according to this disclosure, some steps can be performed in other orders or simultaneously. Furthermore, those skilled in the art should also understand that the embodiments described in the specification are all optional embodiments, and the actions and modules involved are not necessarily essential to this disclosure.

Referring to Figure 6, this disclosure provides a system 600 for automatic code upgrades based on a compiler, including a processor 604 and a memory 601. Optionally, the system may further include a communication interface 602 and a bus 603. The processor 604, communication interface 602, and memory 601 can communicate with each other via the bus 603. The communication interface 602 can be used for information transmission. The processor 604 can call logical instructions in the memory 601 to execute the method for automatic code upgrades based on a compiler as described in the above embodiment.

Furthermore, the logic instructions in the aforementioned memory 601 can be implemented as software functional units and, when sold or used as independent products, can be stored in a computer-readable storage medium.

The memory 601, as a computer-readable storage medium, can be used to store software programs and computer-executable programs, such as program instructions/modules corresponding to the methods in the embodiments of this disclosure. The processor 604 executes functional applications and data processing by running the program instructions/modules stored in the memory 601, thereby implementing the compiler-based automatic code upgrade method in the above embodiments.

The memory 601 may include a program storage area and a data storage area. The program storage area may store the operating system and applications required for at least one function; the data storage area may store data created based on the use of the terminal device. Furthermore, the memory 601 may include high-speed random access memory and may also include non-volatile memory.

This disclosure provides a computer-readable storage medium storing computer-executable instructions configured to execute a method for automatic code upgrades based on a compiler.

The aforementioned computer-readable storage medium may be a transient computer-readable storage medium or a non-transitory computer-readable storage medium.

The technical solutions of this disclosure can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes one or more instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods of this disclosure. The aforementioned storage medium can be a non-transitory storage medium, including: a USB flash drive, a portable hard drive, a read-only memory (ROM), a random access memory (RAM), a magnetic disk, or an optical disk, and other media capable of storing program code; it can also be a transient storage medium.

The foregoing description and accompanying drawings fully illustrate embodiments of the present disclosure to enable those skilled in the art to practice them. Other embodiments may include structural, logical, electrical, procedural, and other changes. The embodiments represent only possible variations. Individual components and functions are optional unless explicitly required, and the order of operation may vary. Parts and features of some embodiments may be included in or replace parts and features of other embodiments. As used in the description of the embodiments, unless the context clearly indicates otherwise, the singular forms “a,” “an,” and “the” are intended to equally include the plural forms. Similarly, the term “and/or” as used herein means including one or more of the associated listed items and all possible combinations thereof. Additionally, when used in this application, the terms “comprise” and its variations “comprises” and/or “comprising” refer to the presence of stated features, integrals, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integrals, steps, operations, elements, components, and/or groups thereof. Unless otherwise specified, an element defined by the phrase "comprising a..." does not exclude the presence of other identical elements in the process, method, or apparatus that includes that element. In this document, each embodiment may focus on describing the differences from other embodiments, and similar or identical parts between embodiments may be referred to mutually.

For methods, products, etc., disclosed in the embodiments, if they correspond to the method portion disclosed in the embodiments, the relevant details can be found in the description of the method portion.

Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of the embodiments disclosed herein. Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here. The methods and products (including but not limited to devices, equipment, etc.) disclosed in the embodiments herein can be implemented in other ways. For example, the device embodiments described above are merely illustrative. For example, the division of units may only be a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the mutual coupling or direct coupling or communication connection shown or discussed may be through some interfaces, and the indirect coupling or communication connection of devices or units may be electrical, mechanical, or other forms. The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to implement this embodiment according to actual needs. Furthermore, the functional units in the embodiments of this disclosure may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit.

The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to embodiments of the present disclosure. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code, which contains one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions marked in the blocks may occur in a different order than that shown in the drawings. For example, two consecutive blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. In the descriptions corresponding to the flowcharts and block diagrams in the accompanying drawings, the operations or steps corresponding to different blocks may also occur in a different order than disclosed in the description, and sometimes there is no specific order between different operations or steps. For example, two consecutive operations or steps may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. Each block in a block diagram and/or flowchart, and combinations of blocks in a block diagram and/or flowchart, can be implemented using a dedicated hardware-based system that performs the specified function or action, or using a combination of dedicated hardware and computer instructions.

Claims (8)

A method for automatic code upgrade based on a compiler, characterized in that the method includes: a front-end performs lexical analysis and syntax analysis on a high-level programming language to generate an abstract syntax tree, and performs semantic analysis to generate an intermediate representation; The backend optimizes the intermediate representation, constructs a new standard syntax rule mapping table, traverses the abstract syntax tree, and queries whether the nodes of the abstract syntax tree can be found in the mapping table. For nodes that are found, the mapped string is output; for nodes that are not found, code that conforms to the node's semantics is output normally. According to the method of claim 1, the lexical analysis includes receiving input source code text, a lexical analyzer reading the source code text, segmenting it into a series of tokens according to the lexical rules of the language, outputting a token sequence, and using the tokens as input for subsequent syntax analysis, wherein the tokens include keywords, identifier type information, and the specific numerical information of the identifier name and literal. The method according to claim 2 is characterized in that the syntax analysis includes using a syntax analyzer to construct an abstract syntax tree according to the grammatical rules of the language, using an AST as a tree-like representation of the source code structure to reflect the grammatical structure of the program, the nodes of the abstract syntax tree representing different building blocks of the program, and the abstract syntax tree serving as the basis for subsequent semantic analysis and optimization. According to the method described in claim 3, the semantic analysis includes using a semantic analyzer to traverse the AST and check the semantic correctness of the program, including type checking, scope resolution, and variable binding, to ensure that the program conforms to the semantic rules of the language while being syntactically correct, and outputs an AST with semantic attributes such as type information and scope information, which can be used as necessary semantic information for subsequent optimization and code generation. The method according to claim 1 is characterized in that the generation of the intermediate representation includes converting the AST into a general intermediate representation, the general intermediate representation form being independent of a specific source language or target machine, for use in subsequent optimization and code generation. The method according to claim 1, characterized in that, the construction of the new standard syntax rule mapping table involves traversing the abstract syntax tree, querying whether a node of the abstract syntax tree can be found in the mapping table, outputting the mapped string for a found node, and outputting code that conforms to the node's semantics for a node that is not found, including: For the new standard of programming languages, a mapping table is constructed from the nodes of the abstract syntax tree to the new standard of the high-level programming language. The key in the mapping table is the node of the abstract syntax tree, the value in the mapping table is a specific string, and the specific string is the code of the new standard. Traverse the abstract syntax tree, query the mapping table of the new standard, and mark the node if it conforms to the new standard. Check whether each node of the abstract syntax tree conforms to the syntax rules of the new standard. Traverse the matched abstract syntax tree and use the code generator to generate source code that conforms to the new standard. The code generator serializes and formats the nodes in the abstract syntax tree according to the syntax and style requirements of the new standard. Output the source code under the new standard and output the string generated by the code to a file. An apparatus for automatic code upgrade based on a compiler, characterized in that the apparatus includes: a front-end module for performing lexical analysis, syntax analysis, generating an abstract syntax tree, and semantic analysis on a high-level programming language to generate an intermediate representation; The backend module is used to optimize the intermediate representation, select instructions, schedule instructions and registers, and generate executable programs. The backend module is also used to construct a new standard syntax rule mapping table, traverse the abstract syntax tree, query whether the nodes of the abstract syntax tree can be found in the mapping table, output the mapped string for the found nodes, and output the code that conforms to the node semantics for the nodes that are not found. A non-transitory computer-readable storage medium storing computer instructions, characterized in that the computer instructions are used to cause the computer to perform the method according to any one of claims 1 to 6.