WO2018161509A1

WO2018161509A1 - Conditional compilation preprocessing method, terminal and storage medium

Info

Publication number: WO2018161509A1
Application number: PCT/CN2017/099747
Authority: WO
Inventors: 涂钦魁
Original assignee: 百富计算机技术（深圳）有限公司
Priority date: 2017-03-08
Filing date: 2017-08-30
Publication date: 2018-09-13
Also published as: CN106843996A

Abstract

A conditional compilation preprocessing method, comprising: acquiring an original program text to be processed (202), analyzing the original program text, discovering a corresponding matching keyword according to a preset regular expression, and outputting a corresponding label (204), discovering a corresponding matching event according to the label and preset conditional compilation syntax rules (206), determining, according to the current state and the event, a corresponding processing action (208), and performing corresponding processing of the original program text according to the determined processing action, and outputting a processed target program text (210).

Description

Conditional compilation preprocessing method, terminal and storage medium

This application claims the priority of the Chinese Patent Application, filed on March 8, 2017, the application Serial No. .

Technical field

The present application relates to the field of computer processing, and in particular, to a conditional pre-processing method, a terminal, and a storage medium.

Background technique

Traditional POS application development is generally developed in C language. C language is a compiled high-level language. Developers can make full use of conditional compilation features to support multiple soft/hard configurations in the same project, but when the application is cross-platform. It is necessary to separately generate versions under the respective platforms, and it is difficult to develop. Interpretive languages (eg, WMLScript) can be cross-platform, and development is less difficult than C, but interpreted languages do not have conditional compilation.

In a typical POS software project, often the same project needs to support multiple configurations, and the application logic of these models is not very different. With the conditional compilation, the same project can support different configurations, but if you choose an interpreted language as the Development language, because there is no conditional compilation function, when a set of applications to apply a variety of configurations, either copy the code, build the project, or control the program flow through variables. The practice of copying the code will result in high maintenance costs, and the practice of controlling by variables will increase the consumption of resources. Therefore, there is an urgent need to propose a method for enabling an interpreted language to be conditionally compiled.

Summary of the invention

According to various embodiments of the present application, a conditional compilation preprocessing method, a terminal, and a storage medium are provided.

A conditional compilation preprocessing method, including:

Obtain the original program text to be processed;

Parsing the original program text, matching corresponding keywords according to a preset regular expression, and outputting a mark corresponding to the keyword;

Compiling the corresponding event according to the mark and the preset conditional compilation grammar rule;

Determining corresponding processing actions according to the current state and the event; and

The original program text is processed correspondingly according to the determined processing action, and the processed target program text is output.

A terminal comprising a memory and a processor, the memory storing computer readable instructions, the computer readable instructions being executed by the processor such that the processor performs the following steps:

Obtain the original program text to be processed;

One or more non-transitory readable storage mediums storing computer readable instructions, when executed by one or more processors, cause the one or more processors to perform the following steps:

Obtain the original program text to be processed;

Details of one or more embodiments of the present application are set forth in the accompanying drawings and description below. Other features, objects, and advantages of the invention will be apparent from the description and appended claims.

DRAWINGS

In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the drawings to be used in the embodiments or the prior art description will be briefly described below. Obviously, the drawings in the following description are only It is a certain embodiment of the present application, and other drawings can be obtained according to the drawings without any creative work for those skilled in the art.

1 is a block diagram showing the internal structure of a terminal in an embodiment;

2 is a flow chart of a conditional compilation preprocessing method in an embodiment;

3 is a flow chart of a method for determining a corresponding processing action according to a current state and an event in an embodiment;

4 is a flowchart of a method for outputting a processed target program text according to a determined processing action according to a determined processing action;

FIG. 5 is a schematic diagram of implementing conditional compilation preprocessing in one embodiment; FIG.

Figure 6 is a block diagram showing the structure of a terminal in an embodiment.

detailed description

In order to make the objects, technical solutions, and advantages of the present application more comprehensible, the present application will be further described in detail below with reference to the accompanying drawings and embodiments. It is understood that the specific embodiments described herein are merely illustrative of the application and are not intended to be limiting.

As shown in FIG. 1, in one embodiment, the internal structure of the terminal 102 is as shown in FIG. 1, including a processor connected through a system bus, an internal memory, a non-volatile storage medium, a network interface, a display screen, and an input device. . Wherein, the non-volatile storage medium of the terminal 102 stores an operating system and computer readable instructions executable by the processor to implement the terminal 102. A conditional compilation preprocessing method. The processor is used to provide computing and control capabilities to support the operation of the entire terminal. The internal memory in the terminal stores computer readable instructions that, when executed by the processor, cause the processor to perform a conditional compilation preprocessing method. The network interface is used to connect to the network for communication. The display screen of the terminal 102 may be a liquid crystal display or an electronic ink display screen. The input device may be a touch layer covered on the display screen, or may be a button, a trackball or a touchpad provided on the outer casing of the electronic device, or may be An external keyboard, trackpad, or mouse. The terminal can be a POS machine, a tablet computer, a notebook computer, a desktop computer, or the like. A person skilled in the art can understand that the structure shown in FIG. 1 is only a block diagram of a part of the structure related to the solution of the present application, and does not constitute a limitation on the terminal to which the solution of the present application is applied. The specific terminal may include a ratio. More or fewer components are shown in the figures, or some components are combined, or have different component arrangements.

As shown in FIG. 2, in an embodiment, a conditional compilation preprocessing method is proposed, which is applicable to the terminal shown in FIG. 1, and includes the following steps:

Step 202: Acquire original program text to be processed.

In this embodiment, in order to enable the interpretation language (for example, WMLScript) to implement the conditional compilation feature, a preprocessing method suitable for conditional compilation in an interpreted language is proposed by simulating the C language for conditional compilation. Among them, the nature of conditional compilation can be simply understood as: analyzing the original program text, retaining or deleting a certain piece of code according to the "specified condition", and outputting the processed program text, that is, by retaining or deleting a certain piece of code according to the specified condition. Select the target program text that meets the requirements in the program text. In order to filter the original program text, the terminal first needs to obtain the original program text to be processed. The original program text refers to the original program code that is written, that is, the program text before processing.

Step 204: Analyze the original program text, match the corresponding keyword according to the preset regular expression, and output a mark corresponding to the keyword.

After the terminal obtains the original program text to be processed, it is possible to accurately determine whether the "specified condition" is met. First, by analyzing the original program text, matching the corresponding keyword according to the preset regular expression, and then outputting a token corresponding to the matched keyword. Its In the middle, the matching relationship between the regular expression and the keyword and the correspondence between the keyword and the mark are set in advance. In one embodiment, the original program text can be analyzed using a lexical analyzer generated by lex, where lex is a lexical scan code generator that generates a lexical scan code, ie, a lexical analyzer, based on the defined pattern file, the main pattern file. Regular expressions are used to define matching rules, as well as actions that are performed after matching, such as executing a return token. That is, the lexical analyzer can be used to analyze the original program text, match the keyword according to the preset regular expression, and then output the mark corresponding to the keyword.

In another embodiment, the following problems need to be solved when using the lexical analyzer to analyze the original program text. One is to ignore the comments and ignore all the text in the comments. The second is to ignore any data in the string, that is, ignore the string enclosed by the quote "". The third is to record the current line number. The record line number is very important for subsequent processing, because the final processing depends on the line number to process the original program text. The fourth is to return a token corresponding to the keyword, so that the subsequent grammar matching according to the token is facilitated. Among them, the keywords include #if, #ifdef, #ifndef, #elif, #else, #defined, #endif, #define, #undef, etc., the corresponding tags can be set to: IF, IFDEF, IFNDEF, ELIF, ELSE, DEFINED, ENDIF, DEFINE, etc. The fifth is to return the macro name and macro value. When the lexical analyzer matches the #define and #undef keywords, save the corresponding macro name and macro value, and return the tag corresponding to the macro name and macro value: NAME, MACROVALUE, It is convenient for the subsequent parser to perform macro operations according to the matched macro name and value, for example, adding or deleting the corresponding macro definition in the macro definition manager.

Step 206: Compile the corresponding event according to the markup and the preset conditional compilation grammar rule.

In this embodiment, the correspondence between the conditional compilation grammar rules and the event is preset in the terminal. First, the tag is matched to a certain grammar rule, and then the corresponding event is determined according to the matched grammar rule, and the corresponding event is output. The event facilitates subsequent determination of the corresponding processing action based on the event. Among them, an event is a signal that something happens in a program. Specifically, the terminal can match the corresponding event by using a parser to compile the grammar rules according to the mark and the preset condition. In one embodiment, the terminal first launches a parser, and the parser internally calls a lexer that matches the tokens output by the lexer and predefined conditional compilation grammar rules. The corresponding event. Among them, the parser can be implemented by Yacc, which is a parsing code generator that generates a parser based on the defined grammar file. The grammar file uses the Backus-Naur Form to describe the grammar rules. It uses the tokens exported by lex and its own defined grammar rules to match and execute the corresponding actions (for example, executing a piece of C code). As shown in Table 1, an illustration of the event and corresponding conditional compilation syntax rules is shown.

Table 1

Step 208: Determine a corresponding processing action according to the current state and the event.

In this embodiment, after the terminal matches the corresponding event according to the mark and the preset conditional compilation grammar rule, the terminal acquires the current state, and determines a corresponding processing action according to the current state and the event. In an embodiment, a relationship table between the processing action and the current state and the event may be pre-stored, and the corresponding processing action may be determined after the current state and the event are obtained, wherein the processing action may be deleting or retaining a certain piece of code. In another embodiment, it is first necessary to determine the state of the next step based on the current state and the event, and then determine the corresponding processing action according to the state of the next step. Specifically, first, after the terminal matches the event by the parser, the event is output to the state processor, and the state in the state processor is driven to jump, that is, jump from one state to another state. Then according to the jump to another A state determines the corresponding processing action. Among them, the parser, the state processor, etc. are all software implementations inside the terminal. In one embodiment, the state processor compiles the syntax characteristics according to conditions, and the state processor stores and manages the state in a stack (ie, maintains a state stack). As shown in Table 2, the predefined states and corresponding state descriptions are shown. The next state is determined by acquiring the current state and the matched event (refer to Table 3), and then determining the corresponding processing action.

Table 2

Step 210: Perform corresponding processing on the original program text according to the determined processing action, and output the processed target program text.

In this embodiment, after determining the processing action, the terminal performs corresponding processing on the original program text according to the determined processing action, and outputs the processed target program text, and the output target program text is filtered according to the specified condition. The target program code that needs to be used, and then compile the target program text by using the compiler to implement the corresponding conditional compilation function. Specifically, the terminal adds a corresponding processing action to the motion processor's action list according to the next state by the state processor, and then the action processor performs corresponding processing according to the processing action in the action list, for example, deleting the corresponding row or The multi-line code, after which the processed target program text is output, wherein the state processor and the action processor are software implementations inside the terminal, which can be understood as a function implementation module.

In this embodiment, by analyzing the original program text, matching the corresponding keyword according to the preset regular expression and outputting the corresponding mark, and then compiling the corresponding event according to the mark and the preset condition compiling the grammar rule, The corresponding processing action is determined according to the current state and the event, and then the original program text is processed correspondingly according to the determined processing action, and the processed target program text is output. This method preconditions the conditional compilation of the original program text by simulating the conditional compilation process, so that the conditional compilation feature can still be used when developing the interpreted language. When multiple configurations are required, the pre-compilation method is not reduced by using the condition. Maintenance costs and reduced resources Consumption.

As shown in FIG. 3, in one embodiment, the steps of determining a corresponding processing action based on the current state and the event include:

In step 208A, the next state is determined according to the current state and the event.

In this embodiment, after the compiled grammar rules are matched to the corresponding events according to the preset conditions, the current state is obtained, and the next state corresponding to the current state and the event is searched by querying the state table. As shown in Table 3, it is a state table in one embodiment. In column 3, the first column of the vertical axis represents the current state, the horizontal axis is the first behavior event, and the other cells indicate the next state when the current state receives the event. For example, the current state is the initial state, that is, STATE_INITIAL, and the event that occurs is EVENT_IF_TRUE. By querying the state table, that is, Table 3, the corresponding next state is STATE_IF_TRUE (ie, the cell corresponding to the third row and the second column).

table 3

In step 208B, the corresponding processing action is determined according to the next state.

In this embodiment, after the next state is determined, the corresponding processing action is determined according to the next state. Specifically, according to the state of the next step, the action taken in the next step can be distinguished. Pre-defined types of actions, for example, actions are divided into two categories, one is to delete the current line (for example, if, else, elif their own line), the corresponding next state is: STATE_IF_TRUE, STATE_ELSE_TRUE, STATE_ELIF_TRUE, STATE_ENDIF; Is to delete multiple rows, the corresponding next state is: STATE_IF_FALSE, STATE_IF_INHERIT_FALSE, STATE_ELSE_FALSE, STATE_ELIF_FALSE.

As shown in FIG. 4, in an embodiment, the original program text is processed correspondingly according to the determined processing action, and the step of outputting the processed target program text includes:

Step 210A, adding the determined processing action to the action list.

In this embodiment, after determining the corresponding processing action according to the current state and the event, the determined action is added to the action list. Specifically, the terminal first matches the event by the parser, and then the event drives the jump of the state processor, after which the state processor determines the next state according to the current state and the event by querying the state table, and then determines the corresponding according to the next state. The processing action, and then the determined action is added to the action list of the action processor, so that the subsequent action processor performs corresponding processing according to the action in the action list, wherein the parser, the state processor, the action processor, etc. are all Software implementation inside the terminal.

Step 210B: Perform a corresponding processing operation on the original program text according to the action list, and output the processed target program text.

In this embodiment, the terminal adds the processing action to the motion processor through the state processor. After the list is made, there are two ways to process the original program file according to the action list. One is that after all the processing actions are added to the action list, the action processor executes the original program text according to the saved series of processing actions. Corresponding operation; one is that whenever an action is added to the action list, the action processor starts executing the corresponding processing action, and then outputs the processed program text, that is, the target program text. For example, according to the typical conditional compilation process #if true...#else...#endif, the final processing action is 1) delete the #if true line itself; 2) delete #else() to the endif All lines between (inclusive). Considering that the code to be deleted itself has a reference value to the programmer, the action processor does not actually delete the line of code, but adds a line comment "//" before the code. After the terminal completes the processing action, the processed target program text is output. If there is a compiling process later, the output is output to the compiler for processing, thereby implementing conditional compilation.

In one embodiment, the step of compiling the corresponding event according to the markup and the preset conditional compilation grammar rule comprises: matching the grammar rule according to the mark and the preset condition, and when matching the conditional statement containing the macro name, The macro definition manager queries the definition corresponding to the macro name and the corresponding value for conditional judgment, and matches the corresponding event according to the result of the conditional judgment.

In the present embodiment, the macro definition manager is used to manage the macro definition, and the conditional judgment of the conditional compilation sometimes requires content based on the macro definition. When matching the conditional statement containing the macro name, it is necessary to query the macro definition manager for the macro value corresponding to the matched macro name, so as to facilitate the conditional judgment according to the macro value, that is, whether the condition is TRUE or FALSE. Among them, the macro definition contains two major categories, one is the global macro definition -D passed in through the command line parameters, and the other is the macro defined by the file #define. A locally defined macro overrides the global definition and only affects the behavior behind the line in this file, and has no effect on other files. In addition, the information of the macro record records the state of the macro, the macro name, the macro value, and the macro line number in addition to the macro type, that is, the global macro and the local macro. Macro states include available, temporarily disabled, and invalid. Among them, the temporary invalid state applies to the global macro, which means that it is defined with -D but is canceled in a file (#undef). This state only affects the file itself. When another file is processed, -D is still restored. State; invalid state applies to local macros, indicating that they are canceled (#undef) in a file. The macro line number in the macro definition manager is only valid for local macros. It is mainly used to give a warning when the same macro definition is found twice in the same file. The current definition is in which row. When doing the query operation, the local macro is detected first. If it does not exist, the global macro is checked. In one embodiment, when the following statement #ifdef NAME, #ifndef NAME, #if NAME, #elif NAME, #if defined(NAME) is encountered, the macro definition manager needs to be queried to see if the definition and the corresponding value are What, if not found, returns NULL to indicate that the definition could not be found.

In one embodiment, when a definition statement containing a macro name is matched, the corresponding macro definition is added or deleted in the macro definition manager according to the type of the definition statement.

In this embodiment, since the condition determination needs to be based on the macro definition in the macro definition manager, it is first necessary to add a macro definition in the macro definition manager, and if it is found later, it is also required to be in the macro definition. The corresponding macro definition is removed from the manager. Specifically, first, the terminal performs matching according to a preset regular expression by the lexical analyzer, and outputs a corresponding mark, wherein the mark includes a mark representing a macro name. For example, when matching the keyword #define NAME VALUE, #define NAME, or #undef NAME, the name of the macro is returned. That is, when matching the define, undef keyword, the corresponding text is stored (the real macro name is stored) and the tag NAME is returned. Then, the parser performs matching according to the markup and the preset conditional compilation grammar rule. When it matches the definition statement containing the macro name, the corresponding macro definition is added or deleted in the macro definition manager according to the type of the definition statement. Among them, the macro definition statement refers to a statement containing definition words such as #define, #undef. According to the type of the definition statement, the statement is divided into two types: definition and undefine. The statement containing #define represents the statement of the defined type, and the statement containing #undef represents the statement of the undefined type. In one embodiment, the macro definition manager is added to the macro definition manager when it encounters the following statement #define NAME, #define NAME VALUE, and the macro definition manager is deleted when it encounters #undef NAME. By adding or deleting a macro definition in the macro definition manager, it is convenient to subsequently perform conditional judgment by querying the corresponding macro definition when matching to a conditional statement containing a macro name, that is, whether it is TRUE or FALSE.

In one embodiment, the step of analyzing the original program text, matching the corresponding keyword according to the preset regular expression and outputting the corresponding mark includes: analyzing the original program text according to the preset regular expression Match the corresponding keyword, record the line number where the keyword is located, and output The corresponding tag and the corresponding line number.

In this embodiment, in order to facilitate the execution of the determined processing action, after analyzing the original program text and matching the corresponding keywords, not only the token corresponding to the keyword needs to be output, but also each matching is required to be recorded. The line number of the keyword is output and output. Recording the line number is very important for subsequent processing because the action processor ultimately relies on the line number to process the program text. The specific implementation means that by adding a c function for increasing the line number, the lexical analyzer then calls the function to increase the global line number. For example, whenever you encounter "\n", call the c function to increase the global line number.

In an embodiment, the processing of the original program text is performed according to the determined processing action, and the step 210 of outputting the processed target program text includes: performing a corresponding processing action according to the type of the processing action and the corresponding line number, and outputting the processing After the target program text.

In this embodiment, after the terminal adds the corresponding processing action to the action list of the action processor by the state processor, the action processor executes the corresponding processing action according to the type of the processing action and the corresponding line number, and then outputs the processed process. Target program text. The types of processing actions can be divided into two categories: one is to delete the current row; the other is to delete multiple rows. When the action processing is performed, each processing action corresponds to a start line number and an end line number information. The first type of action can be treated as a special case with the same starting line number and ending line number. For the second type of action, since it is not known what the ending line number is when matching the event of deleting multiple lines, the ending line number and the starting line number can be temporarily written to the same value, when the next event generates a new action. , before adding a new action, update the previous end line number to the current line number -1. Specifically, the processing action is corresponding to the next state determined by the state processor. When the next state is: STATE_IF_TRUE, STATE_ELSE_TRUE, STATE_ELIF_TRUE, STATE_ENDIF, the corresponding action is: deleting the current row. When the next state is: STATE_IF_FALSE, STATE_IF_INHERIT_FALSE, STATE_ELSE_FALSE, STATE_ELIF_FALSE, the corresponding action is: delete multiple rows. For example, when the determined next state is STATE_IF_TRUE, then only the current row needs to be deleted, that is, the starting row number and the ending row number are the same. When the determined next state is: STATE_IF_FALSE, it means that multiple rows need to be deleted, but it is not known to delete a few rows, that is, I don't know what the ending line number is. When the next event occurs, assuming that the new event is EVENT_ELSE_TRUE, then the corresponding next state is STATE_ELSE_TRUE, indicating that the current line is deleted, and the current line number is reduced before deleting the current line. Go to 1, as the end line number of the previous event.

As shown in FIG. 5, in one embodiment, the method for implementing the above conditional compilation is specifically performed by a lexical analyzer, a parser, a state processor, an action processor, and a macro definition manager. First, if there is -D in the command line parameter, the main program will add the global macro to the macro definition manager. Next, the main program in the terminal performs the following operations on each original program text, a), the main program Enable the parser, the parser internally calls the lexical analyzer, analyzes the original program text through the lexical analyzer to match the corresponding keyword and outputs the corresponding token, and then the parser uses the token output by the lexical analyzer. (token) and pre-defined grammar rules, corresponding events are generated. In the process, the macro definition manager is added, deleted, and checked according to the matched statement containing the macro name; b) the parser The event is output to the state processor, which drives the jump of the state machine. The state processor determines the corresponding processing action according to the next state, and adds the processing action to the action processor. c) The main program executes the action list in the processor in order, and outputs the processed program text, that is, the target program text. The lexical analyzer, the parser, the state processor, the action processor and the macro definition manager respectively implement preprocessing of the conditional compilation by mutual cooperation, and implement the conditional compiling preprocessor corresponding to the preprocessing method of the conditional compilation. The execution file is only about 36k. It is a lightweight conditional compilation preprocessor. If there is a subsequent compilation process, you only need to add the conditional compilation preprocessor command before the standard compilation process to facilitate integration. In addition, the method is applicable to multiple languages, such as WMLScript, JavaScript, Java, Python, etc. Since different programming languages have different specifications, you can quickly adapt to any language by fine-tuning lexical and grammatical rules files as needed. Therefore, it is also versatile and easy to expand.

The embodiment of the present application provides a terminal. The internal structure of the terminal may correspond to the structure shown in FIG. 1. Each of the following modules may be implemented in whole or in part by software, hardware, or a combination thereof.

In an embodiment, as shown in FIG. 6, the terminal 600 in this embodiment includes:

The obtaining module 602 is configured to obtain the original program text to be processed.

The output module 604 is configured to analyze the original program text, match the corresponding keyword according to the preset regular expression, and output a corresponding mark.

The matching module 606 is configured to match the corresponding event according to the markup and the preset conditional compilation grammar rule.

The determining module 608 is configured to determine a corresponding processing action according to the current state and the event.

The processing module 610 is configured to perform corresponding processing on the original program text according to the determined processing action, and output the processed target program text.

In an embodiment, the determining module is further configured to determine a next state according to the current state and the event, and determine a corresponding processing action according to the next state.

In one embodiment, the processing module is further configured to add the determined processing action to the action list, perform a corresponding processing action on the original program text according to the action list, and output the processed target program text.

In an embodiment, the matching module is further configured to perform matching according to the markup and the preset conditional compilation grammar rule, and when matching the conditional statement containing the macro name, query the macro definition manager to query the definition corresponding to the macro name and corresponding The value is judged by the condition, and the corresponding event is matched according to the result of the conditional judgment.

In an embodiment, the output module is further configured to analyze the original program text, match the corresponding keyword according to the preset regular expression, record the line number where the keyword is located, and output the corresponding mark and the corresponding line number. The processing module is further configured to execute a corresponding processing action according to the type of the processing action and the corresponding line number, and output the processed target program text.

A person skilled in the art can understand that all or part of the process of implementing the above embodiment method can be completed by a computer program to instruct related hardware, and the computer program can be stored in a computer readable storage medium. When executed, the flow of an embodiment of the methods as described above may be included. The storage medium may be a non-volatile storage medium such as a magnetic disk, an optical disk, a read-only memory (ROM), or a random access memory (RAM).

The technical features of the above-described embodiments may be arbitrarily combined. For the sake of brevity of description, all possible combinations of the technical features in the above embodiments are not described. However, as long as there is no contradiction between the combinations of these technical features, All should be considered as the scope of this manual.

The above-mentioned embodiments are merely illustrative of several embodiments of the present application, and the description thereof is more specific and detailed, but is not to be construed as limiting the scope of the claims. It should be noted that a number of variations and modifications may be made by those skilled in the art without departing from the spirit and scope of the present application. Therefore, the scope of the invention should be determined by the appended claims.

Claims

A conditional compilation preprocessing method, including:

Obtain the original program text to be processed;

Parsing the original program text, matching corresponding keywords according to a preset regular expression, and outputting a mark corresponding to the keyword;

Compiling the corresponding event according to the mark and the preset conditional compilation grammar rule;

Determining corresponding processing actions according to the current state and the event; and

The original program text is processed correspondingly according to the determined processing action, and the processed target program text is output.
The method according to claim 1, wherein the determining the corresponding processing action according to the current state and the event comprises:

Determining a next state based on the current state and the event;

Corresponding processing actions are determined according to the next state.
The method according to claim 1, wherein the processing of the original program text according to the determined processing action, and outputting the processed target program text comprises:

Adding the determined processing action to the action list;

Performing a corresponding processing operation on the original program text according to the action list, and outputting the processed target program text.
The method according to claim 1, wherein the matching the corresponding event according to the mark and the preset conditional compilation grammar rule comprises:

Matching according to the mark and the preset conditional compilation grammar rule, when matching the conditional statement containing the macro name, querying the macro definition manager for the definition corresponding to the macro name and the corresponding value for conditional judgment, according to The result of the conditional judgment matches the corresponding event.
The method according to claim 1, wherein the analyzing the original program text, matching corresponding keywords according to a preset regular expression, and outputting corresponding tags include:

Parsing the original program text, matching the corresponding keyword according to the preset regular expression, recording the line number where the keyword is located, and outputting the corresponding mark and the corresponding line number;

Performing corresponding processing on the original program text according to the determined processing action, and outputting the processed target program text includes:

The corresponding processing operation is executed according to the type of the processing operation and the corresponding line number, and the processed target program text is output.
A terminal comprising a memory and a processor, the memory storing computer readable instructions, the computer readable instructions being executed by the processor such that the processor performs the following steps:

Obtain the original program text to be processed;

Parsing the original program text, matching corresponding keywords according to a preset regular expression, and outputting a mark corresponding to the keyword;

Compiling the corresponding event according to the mark and the preset conditional compilation grammar rule;

Determining corresponding processing actions according to the current state and the event; and

The original program text is processed correspondingly according to the determined processing action, and the processed target program text is output.
The terminal according to claim 6, wherein the determining, by the processor, the corresponding processing action according to the current state and the event comprises: determining a next state according to the current state and the event, according to the next The one-step state determines the corresponding processing action.
The terminal according to claim 6, wherein the processor performs corresponding processing on the original program text according to the determined processing action, and outputting the processed target program text comprises: determining The processing operation is added to the action list, and a corresponding processing operation is performed on the original program text according to the action list, and the processed target program text is output.
The terminal according to claim 6, wherein the matching of the corresponding event by the processor according to the mark and the preset conditional compilation grammar rule comprises: compiling the grammar according to the mark and the preset condition The rule is matched. When the conditional statement containing the macro name is matched, the macro definition manager queries the definition corresponding to the macro name and the corresponding value to perform conditional judgment, and the result according to the condition judgment matches the corresponding event. .
The terminal according to claim 6, wherein the analyzing, by the processor, the original program text, matching corresponding keywords according to a preset regular expression, and outputting corresponding tags includes:

Parsing the original program text, matching the corresponding keyword according to the preset regular expression, recording the line number where the keyword is located, and outputting the corresponding mark and the corresponding line number;

Performing corresponding processing on the original program text according to the determined processing action performed by the processor, and outputting the processed target program text includes: performing corresponding processing according to the type of the processing action and the corresponding line number Action, output the processed target program text.
One or more computer readable non-volatile storage media storing computer readable instructions, when executed by one or more processors, cause the one or more processors to perform the steps of:

Obtain the original program text to be processed;

Parsing the original program text, matching corresponding keywords according to a preset regular expression, and outputting a mark corresponding to the keyword;

Compiling the corresponding event according to the mark and the preset conditional compilation grammar rule;

Determining corresponding processing actions according to the current state and the event; and

The original program text is processed correspondingly according to the determined processing action, and the processed target program text is output.
The storage medium according to claim 11, wherein the determining, by the processor, the corresponding processing action according to the current state and the event comprises:

Determining a next state based on the current state and the event;

Corresponding processing actions are determined according to the next state.
The storage medium according to claim 11, wherein the processor performs corresponding processing on the original program text according to the determined processing action, and outputting the processed target program text comprises:

Adding the determined processing action to the action list;

Performing a corresponding processing action on the original program text according to the action list, and outputting the processing Target program text.
The storage medium according to claim 11, wherein the matching, by the processor, the matching of the corresponding event according to the markup and the preset conditional compilation grammar rule comprises:

Matching according to the mark and the preset conditional compilation grammar rule, when matching the conditional statement containing the macro name, querying the macro definition manager for the definition corresponding to the macro name and the corresponding value for conditional judgment, according to The result of the conditional judgment matches the corresponding event.
The storage medium according to claim 11, wherein the processor performs the analysis on the original program text, matches a corresponding keyword according to a preset regular expression, and outputs a corresponding mark. include:

Parsing the original program text, matching the corresponding keyword according to the preset regular expression, recording the line number where the keyword is located, and outputting the corresponding mark and the corresponding line number;

Performing corresponding processing on the original program text according to the determined processing action performed by the processor, and outputting the processed target program text includes:

The corresponding processing operation is executed according to the type of the processing operation and the corresponding line number, and the processed target program text is output.