CN112231068B - Custom logic method, system and readable medium using domain specific language - Google Patents
Custom logic method, system and readable medium using domain specific language Download PDFInfo
- Publication number
- CN112231068B CN112231068B CN202011499549.1A CN202011499549A CN112231068B CN 112231068 B CN112231068 B CN 112231068B CN 202011499549 A CN202011499549 A CN 202011499549A CN 112231068 B CN112231068 B CN 112231068B
- Authority
- CN
- China
- Prior art keywords
- typescript
- original code
- user
- error
- preset
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/31—Programming languages or programming paradigms
- G06F8/313—Logic programming, e.g. PROLOG programming language
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/31—Programming languages or programming paradigms
- G06F8/315—Object-oriented languages
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
- G06F9/45533—Hypervisors; Virtual machine monitors
- G06F9/45558—Hypervisor-specific management and integration aspects
- G06F2009/45562—Creating, deleting, cloning virtual machine instances
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computing Systems (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
A custom logic method, system, and computer readable medium using a domain specific language are provided. The method comprises the following steps: receiving an original code input by a user and a return type of the original code, wherein the original code uses a preset domain-specific language based on a TypeScript language, and the grammar of the preset domain-specific language comprises a first preset grammar and a second preset grammar; registering the TypeScript declaration file in a compiler; converting the original code into an abstract syntax tree; verifying the original code according to the TypeScript declaration file; verifying whether the return type of the abstract syntax tree is consistent with the return type of the original code input by the user or not according to the second preset syntax; converting the abstract syntax tree according to a first preset syntax; and outputting the executable script according to the abstract syntax tree. The method can realize the customized complex logic with lower learning cost of the user and is suitable for a system with larger scale.
Description
Technical Field
The present application relates generally to the field of computer technology, and more particularly, to a method, system, and computer readable medium for custom logic using domain specific languages.
Background
When users use functions in the system, the problem that the default processing flow or logic of the system cannot meet the requirements of the users is often encountered. In this case, the user needs to implement the functions required by the user through the custom logic, but there is a limit to the functions that can be customized in the system. Therefore, the system divides the whole logic into an inseparable minimum logic unit for the user to use, and the user realizes the personalized demand by freely combining the logic. Therefore, logical organization refers to the user rearranging the combinational logic units according to the needs of the user based on the customized functions provided by the system.
In the prior art, there are typically 2 methods for a user to implement custom logic. The most common processing method is realized by a general programming language, such as Java, JavaScript, C # and other programming languages, and the system only needs to provide one library for the user to call. The common programming language approach enables the definition of complex logic. However, the learning cost of the general-purpose programming language is high for the general-purpose user. The user also needs to learn a programming language in order to use the system, which is too difficult to use.
Another approach is to implement logical orchestration through visualization, such as a flow chart. This way of visualizing custom logic has become more popular in recent years in order to solve the problem of too high a hand cost in general purpose programming languages. In one example, the graphical layout can abstract parameter processing, service calls, result processing, etc. into one processor, and then the user can use if, while, etc. logical statements to implement the flow of the custom processor. However, the way of graphically customizing logic is difficult to realize complex logic arrangement. And as the system scale increases to a certain extent, the use cost of the user will rapidly increase along with the increase of the system functions, and at this time, the continuous use of the graphical mode will require higher use cost than the programming mode.
Therefore, those skilled in the art need a logic customization method, which can implement customized complex logic with low user learning cost, and is suitable for large-scale systems, where the user cost does not rise rapidly with the expansion of the system scale.
Disclosure of Invention
The technical problem to be solved by the application is to provide a method, a system and a computer readable medium for customizing logic by using a domain-specific language, which can realize customized complex logic with lower user learning cost and is suitable for a system with larger scale.
In order to solve the above technical problem, the present application provides a custom logic method using a domain specific language, which runs in a JavaScript virtual machine, and includes: receiving an original code input by a user and a return type of the original code, wherein the original code uses a preset domain-specific language based on a TypeScript language, syntax of the preset domain-specific language comprises a first preset syntax and a second preset syntax, the first preset syntax is used for restoring asynchronous operation, the second preset syntax is used for judging the return type, and the return type of the original code is a condition type, a calculation type or an action type; registering a TypeScript declaration file into a TypeScript compiler, wherein the TypeScript declaration file contains grammar rules of the preset domain-specific language, the TypeScript declaration file including any one or more of: the system logic unit declaration file, the tool logic unit declaration file and the first custom logic unit declaration file; converting the original code into a corresponding abstract syntax tree; verifying the original code according to the TypeScript declaration file based on the TypeScript compiler, and outputting error information and ending if the verification fails; verifying whether the return type of the abstract syntax tree is consistent with the return type of the original code input by the user or not according to the second preset syntax, if not, outputting error information and ending, wherein the return type of the abstract syntax tree is judged according to a return statement; converting the abstract syntax tree according to the first preset syntax; outputting a corresponding executable JavaScript script and a second custom logic unit statement file according to the converted abstract syntax tree; and adding the second custom logic unit declaration file into the first custom logic unit declaration file.
In an embodiment of the application, the grammar of the preset domain-specific language further includes a preset translation grammar, and the method further includes: and translating the converted abstract syntax tree according to the preset translation syntax, and outputting a translation result for a user to check.
In an embodiment of the application, the converting the abstract syntax tree according to the first preset syntax is performed by a Babel compiler; the converting the abstract syntax tree according to the first preset syntax includes: traversing all functions in the abstract syntax tree and judging whether each function is an asynchronous function, if so, adding an await keyword for the function, otherwise, not adding the await keyword for the function; and adding a corresponding packaging function body for the abstract syntax tree, and judging whether each function in the abstract syntax tree is added with the await keywords, if so, adding the async keywords for the function, and if not, not adding the async keywords for the function.
In an embodiment of the application, the verifying whether the return type of the abstract syntax tree is consistent with the return type of the original code input by the user according to the second preset syntax is performed by a Babel compiler; the verifying whether the return type of the abstract syntax tree is consistent with the return type of the original code input by the user according to the second preset syntax includes: searching a return statement through a traversal module of the Babel compiler, and judging the return type of the original code input by the user; when the return type of the original code input by the user is a condition type, if the return statement cannot be found, the verification is not passed, if the return statement is found, whether the parameter of the return statement is a Boolean type or not is judged, if the parameter is the Boolean type, the verification is passed, and if the parameter is not the Boolean type, the verification is not passed; when the return type of the original code input by the user is a calculation type, if the return statement cannot be found, the verification is passed, and if the return statement is found, the verification is not passed; and when the return type of the original code input by the user is the action type, if the return statement is found, the verification is passed, and if the return statement is not found, the verification is not passed.
In an embodiment of the application, the method further runs in a TypeScript editor, wherein the TypeScript editor comprises an edit box; the receiving of the original code input by the user and the return type of the original code are receiving the original code input by the user and the return type of the original code sent by the TypeScript editor; the method further comprises the following steps: registering the TypeScript declaration file in the TypeScript editor; responding to an input request of a user, and loading the edit box; receiving an original code input in the edit box by a user and a return type of the original code; converting the original code into a corresponding abstract syntax tree; verifying the abstract syntax tree according to the TypeScript declaration file, and outputting error information and ending if the abstract syntax tree is not verified; and responding to a saving request of a user, and sending the original code, the return type of the original code and the TypeScript declaration file to the TypeScript compiler.
In an embodiment of the present application, the method further includes: and when the original code is input into the edit box by the user, matching in the TypeScript declaration file according to the content currently input by the user, and displaying a matching result in the edit box to perform logic unit prompting on the user.
In an embodiment of the application, the TypeScript editor includes a first error reporting function and a second error reporting function, where the first error reporting function is an error reporting function of the TypeScript editor, and the second error reporting function is a preset custom error reporting function, and is configured to determine whether an error is related to the second preset syntax according to the error information; the method further comprises the following steps: when the error information appears, calling the second error reporting function to judge whether the error is related to the second preset grammar according to the error information; if so, eliminating the error information; and if the error message is not relevant, calling the first error reporting function and sending the error message to the first error reporting function.
In an embodiment of the present application, the error information includes an error prompt message and error location information, where the error prompt message is used to prompt a user that an error occurs in the edit box, and the error location information is used to prompt a location of the error where the user is located in the edit box.
In an embodiment of the application, before the registering the TypeScript declaration file in the TypeScript compiler, the method further includes: and receiving the TypeScript declaration file sent by the TypeScript editor.
In order to solve the above technical problem, the present application further provides a custom logic system using a domain specific language, including: a memory for storing instructions executable by the processor; and a processor for executing the instructions to implement the method as described above.
To solve the above technical problem, the present application also provides a computer readable medium storing computer program code, which when executed by a processor implements the method as described above.
Compared with the prior art, the user-defined logic method, the system and the computer readable medium of the application, which use the domain-specific language, realize the user-defined logic by using the DSL language, so that common users can realize the user-defined of complex logic with lower learning cost. Moreover, when the system scale is enlarged to a certain degree, the DSL language still has higher use efficiency, and the use cost of a user cannot rapidly rise along with the enlargement of the system scale, so that the DSL language is very suitable for a system with a larger scale.
Drawings
The accompanying drawings, which are included to provide a further understanding of the application and are incorporated in and constitute a part of this application, illustrate embodiment(s) of the application and together with the description serve to explain the principle of the application. In the drawings:
FIG. 1 is a flow diagram illustrating a custom logic method using a domain-specific language according to one embodiment of the present application;
FIG. 2 is a flow chart illustrating a method for implementing step 105 according to an embodiment of the present application;
FIG. 3 is a flowchart illustrating a method for implementing step 106 according to an embodiment of the present application;
FIGS. 4 and 5 are flow diagrams illustrating a method for custom logic using a domain-specific language according to another embodiment of the present application;
FIG. 6 is an interface diagram illustrating logical unit prompting according to an embodiment of the present application;
FIG. 7 is a schematic diagram illustrating an error reporting flow of a custom logic method using a domain-specific language according to an embodiment of the present application;
FIG. 8 is a system block diagram illustrating a custom logic system using a domain-specific language according to one embodiment of the present application.
Detailed Description
In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings used in the description of the embodiments will be briefly introduced below. It is obvious that the drawings in the following description are only examples or embodiments of the application, from which the application can also be applied to other similar scenarios without inventive effort for a person skilled in the art. Unless otherwise apparent from the context, or otherwise indicated, like reference numbers in the figures refer to the same structure or operation.
As used in this application and the appended claims, the terms "a," "an," "the," and/or "the" are not intended to be inclusive in the singular, but rather are intended to be inclusive in the plural unless the context clearly dictates otherwise. In general, the terms "comprises" and "comprising" merely indicate that steps and elements are included which are explicitly identified, that the steps and elements do not form an exclusive list, and that a method or apparatus may include other steps or elements.
The relative arrangement of the components and steps, the numerical expressions, and numerical values set forth in these embodiments do not limit the scope of the present application unless specifically stated otherwise. Meanwhile, it should be understood that the sizes of the respective portions shown in the drawings are not drawn in an actual proportional relationship for the convenience of description. Techniques, methods, and apparatus known to those of ordinary skill in the relevant art may not be discussed in detail but are intended to be part of the specification where appropriate. In all examples shown and discussed herein, any particular value should be construed as merely illustrative, and not limiting. Thus, other examples of the exemplary embodiments may have different values. It should be noted that: like reference numbers and letters refer to like items in the following figures, and thus, once an item is defined in one figure, further discussion thereof is not required in subsequent figures.
Flow charts are used herein to illustrate operations performed by systems according to embodiments of the present application. It should be understood that the preceding or following operations are not necessarily performed in the exact order in which they are performed. Rather, various steps may be processed in reverse order or simultaneously. Meanwhile, other operations are added to or removed from these processes.
The application provides a user-defined logic method using a domain-specific language, which runs in a JavaScript virtual machine. FIG. 1 is a flow diagram illustrating a method for custom logic using a domain-specific language according to one embodiment of the present application. As shown in fig. 1, the method for customizing a domain-specific language of the present embodiment includes the following steps 101-108:
105, verifying whether the return type of the abstract syntax tree is consistent with the return type of the original code input by the user or not according to a second preset syntax, and if not, outputting error information and ending, wherein the return type of the abstract syntax tree is judged according to a return statement;
and 108, adding the second custom logic unit declaration file into the first custom logic unit declaration file.
Step 101 and step 108 described above are executed in a JavaScript virtual machine, which in an example may be node. js, where node. js is a JavaScript runtime based on Chrome V8 engine. The following describes the steps 101-108 in detail:
in step 101, a user uses a preset domain-specific language based on the TypeScript language to input original code, and inputs a return type of the original code, and then the custom logic system receives the original code input by the user and the return type of the original code.
Domain-Specific Language (DSL), also known as Domain-Specific Language, refers to a computer Language that is dedicated to a certain application Domain. Unlike the common cross-domain general-purpose computer language (GPL), domain-specific languages are used in only certain specific domains. Such as HTML for displaying web pages, and the Emac LISP language used by Emacs. The DSL language mentioned in the present application is a DSL language which is specially designed in advance for a specific scenario and a specific system, taking TypeScript as a basic language, removing some grammars that are difficult to understand and grasp by a general user (referring to a person without professional programming ability), and adding a grammar rule that can be conveniently used by the general user. It should be noted that those skilled in the art can design DSL languages suitable for other specific scenarios and specific systems without departing from the spirit of the present application, which is not limited herein.
The syntax of the preset domain specific language in this embodiment at least includes a first preset syntax and a second preset syntax, where the first preset syntax is used to restore the asynchronous operation in the subsequent step, and the second preset syntax is used to determine the return type in the subsequent step.
In step 102, the system registers the TypeScript declaration file in the TypeScript compiler. The TypeScript declaration file contains a part of grammar rules of the preset domain-specific language and does not contain the first preset grammar and the second preset grammar. The TypeScript declaration file includes any one or more of: a system logical unit declaration file, a tool logical unit declaration file, and a first custom logical unit declaration file. A logical unit refers to the smallest indivisible logic that can be executed, and is part of the syntax. That is, the grammar rules of the preset domain-specific language may be saved in the TypeScript declaration file in the form of logical units. The TypeScript Declaration File is a d.ts File (TypeScript Declaration File) and is a definition File in TypeScript. Accordingly, the system logical unit declaration file, the tool logical unit declaration file, and the first custom logical unit declaration file may be a system.d.ts file, a tools.d.ts file, and a custom.d.ts file, respectively.
The system logical unit refers to a logical unit unique to a specific system, and all the system logical units can be all stored in a system logical unit declaration file. The tool logic unit refers to common tool logic, the tool logic can be applied to other systems, not only is used in a specific system, but also all the tool logic units can be all stored in a tool logic unit declaration file. The custom logic unit is a logic unit generated by the user custom logic, and all the custom logic units can be stored in a custom logic unit declaration file. After the three logic units are stored in the TypeScript declaration file and registered in the TypeScript compiler, the grammar rules in the logic units are used as a part of the grammar rules of the preset domain-specific language for the user to use directly, and the user does not need to import (import) nor define. By dividing the logic units into the above three categories, the logic units can be managed and used simply and quickly.
In step 103, the system converts the original code into a corresponding abstract syntax tree. The system cannot verify whether the original code conforms to the first preset syntax or the second preset syntax, so that the original code needs to be converted into a corresponding abstract syntax tree and then subjected to the first preset syntax verification or the second preset syntax verification.
In step 104, the system verifies the original code according to the TypeScript declaration file based on the TypeScript compiler, and outputs error information if the verification fails and ends. Because the TypeScript declaration document contains a portion of the grammar rules of the pre-set domain-specific language, the system needs to verify that the original code conforms to the grammar contained in the TypeScript declaration document. If the verification is passed, namely the original code conforms to the grammar contained in the TypeScript declaration file, the system continues to execute the next step; if the verification is not passed, namely the original code does not conform to the grammar contained in the TypeScript declaration file, the system does not continue to execute the next step, but outputs error information and ends. The order of step 103 and step 104 may be interchanged, that is, step 104 may be performed before step 103, which is not limited in this application.
In step 105, the second preset syntax is used to determine the return type of the code, and the system verifies whether the return type of the abstract syntax tree is consistent with the return type of the original code input by the user according to the second preset syntax of the preset DSL language. If the verification is consistent, the return type of the original code input by the user can be confirmed to be correct, and the system continues to execute the next step; if the verification is inconsistent, the return type of the original code input by the user can be confirmed to be wrong, and the system does not continue to execute the next step, but outputs error information and ends.
In an embodiment of the present application, step 105 may be performed by a Babel compiler. Fig. 2 is a flowchart illustrating an implementation method of step 105 according to the present embodiment. As shown in fig. 2, the step 105 of verifying whether the return type of the abstract syntax tree is consistent with the return type of the original code input by the user according to the second preset syntax may include the following steps 201 and 204:
The traversal module can be used in the Babel compiler to verify whether the return type of the abstract syntax tree is consistent with the return type input by the user through the above step 201-. The order of steps 201 and 202 may be interchanged, and this application is not intended to limit this.
In step 106, the first preset syntax is used to restore the asynchronous operation, and the system converts the abstract syntax tree according to the first preset syntax and obtains the converted abstract syntax tree. Generally, asynchronous operations in JavaScript need to use callback or async/wait, but it is difficult for ordinary users to grasp the usage of asynchronous operations, and the learning cost of ordinary users is high. Therefore, by using the first preset grammar for restoring the asynchronous operation, the common user can directly use the asynchronous operation without mastering the keywords of the asynchronous operation, the learning cost of the user is greatly reduced, and the efficiency of user-defined logic is improved.
In an embodiment of the present application, step 106 may be performed by a Babel compiler. Fig. 3 is a flowchart illustrating an implementation method of step 106 according to an embodiment of the present application. As shown in fig. 3, the step 106 of converting the abstract syntax tree according to the first preset syntax may include the following steps 301 and 302:
and 302, adding a corresponding packaging function body to the abstract syntax tree, and judging whether each function in the abstract syntax tree is added with an await keyword, if so, adding an async keyword to the function, and if not, not adding an async keyword to the function.
The above steps 301-302 are described as a specific example. The code shown below is a piece of original code entered by the user:
let title, body, to;
const item = dataPoint.getItem();
title = item.isUpdated() 
`SAE Added!! ` :
`SAE Updated!!! `;
body = generateBody(item);
switch (subject.environmentId) {
case '4028e43d5b7f3ff9015b7f422e100001':
to = "user_dev@mdsol.com";
break;
default:
to = "user_any@mdsol.com";
}
context.sendEmailToAddress([to], title, body);
the above-mentioned original code is converted into a corresponding abstract syntax tree in step 103. It should be noted that, the execution object in steps 301-302 is an abstract syntax tree, not the original code. For reading and understanding, the abstract syntax tree corresponding to the original code segment is omitted, and the code is directly used to replace the abstract syntax tree to schematically illustrate the conversion performed by the first preset syntax.
The code shown below is the code after the first preset syntax conversion:
async function SAEEmail(){
let title, body, to;
const item = dataPoint.getItem();
title = item.isUpdated()
`SAE Added!! ` :
`SAE Updated!!! `;
body = await generateBody(item);
switch (subject.environmentId) {
case '4028e43d5b7f3ff9015b7f422e100001':
to = "user_dev@mdsol.com";
break;
default:
to = "user_any@mdsol.com";
}
await context.sendEmailToAddress([to], title, body);
}
as can be seen from the code converted by the first preset syntax, the system determines that context, sendemail toaddress ([ to ], title, body) is an asynchronous function, and adds an await keyword in front of the function; the system adds a corresponding packing function body in the code, and the function name in the packing function body can be a name self-defined by a user; and the system judges that the function is added with the await and adds an async keyword to the function.
In step 107, the system outputs the corresponding executable JavaScript script and the second custom logic unit declaration file according to the converted abstract syntax tree. The JavaScript script is used to execute the logic defined by the original code by the user. The second custom logic unit declaration file contains the logic unit defined by the original code.
In step 108, the system adds the second custom logical unit declaration file to the first custom logical unit declaration file. And if the TypeScript declaration file does not comprise the first custom logic unit declaration file, newly establishing the first custom logic unit declaration file, and then adding the second custom logic unit declaration file into the first custom logic unit declaration file. And adding a second custom logic unit declaration file generated by the original code into the first custom logic unit declaration file, so that the first custom logic unit declaration file contains the logic unit defined by the original code by a user. That is to say, the logic unit customized by the user can be stored for the next direct use without redefining again, thereby simplifying the use mode of the customized logic and improving the efficiency of the customized logic.
To sum up, in the step 101-108, the user-defined logic method using the domain-specific language of the present application implements user-defined logic by using the DSL language, so that a common user can implement user-definition of complex logic with a low learning cost. Moreover, when the system scale is enlarged to a certain degree, the DSL language still has higher use efficiency, and the use cost of a user cannot rapidly rise along with the enlargement of the system scale, so that the DSL language is very suitable for a system with a larger scale.
In another embodiment of the present application, a custom logic method using a domain-specific language is run in a TypeScript compiler and a TypeScript editor, and the method may further include the following steps 401 and 415 as shown in fig. 4 and 5:
The above steps 401 and 406 are run in a TypeScript editor, wherein the TypeScript editor comprises an edit box for receiving user input. The steps 407 and 415 are executed in the JavaScript compiler. The "original code and return type of original code received input by the user" in step 407 is the type of original code and return type of original code received input by the TypeScript editor and sent by the TypeScript compiler. The steps 407 and 414 can refer to the description of the steps 101 and 108 in the embodiment of fig. 1, and are not described herein again.
in step 401, the custom logic system registers the TypeScript declaration file in the TypeScript editor. By registering the TypeScript declaration file in the TypeScript editor, the TypeScript editor can acquire various types of logic units in the TypeScript declaration file.
In step 402, in response to a user input request, the system loads an edit box. The user may make an input in the edit box.
In step 403, the system receives the original code entered by the user in the edit box and the return type of the original code.
In step 404, the system validates the original code against the TypeScript declaration file based on the TypeScript compiler.
In step 405, if the verification is passed, the system continues to execute the next step; and if the verification fails, outputting error information and ending. For a specific verification method, reference may be made to the detailed description of step 104 in the embodiment of fig. 1, which is not described herein again.
In step 406, in response to the user's save request, the system sends the original code, the return type of the original code, and the TypeScript declaration file to the TypeScript compiler. By sending the original code to the TypeScript compiler, the TypeScript compiler can receive the original code and the return type of the original code input by the user to perform the subsequent steps 407-415. By sending the TypeScript declaration file to the TypeScript compiler along with the original code, the TypeScript compiler can receive the TypeScript declaration file associated with the original code at the same time the original code is received. In this way, when the TypeScript compiler needs to serve a plurality of TypeScript editors as the front end at the same time as the back end, it can be determined which TypeScript declaration files each piece of original code is respectively related to.
In an embodiment of the present application, the method further comprises: when the user enters the original code in the edit box, the system matches in the TypeScript declaration file according to what the user is currently entering. When the names of one or more logic units in the TypeScript declaration file can be matched with the content part currently input by the user, the logic units are considered as the current matching result, and the matching result is displayed in the edit box to prompt the user about the logic units, so that the user can accurately and quickly input the original codes according to the prompt of the logic units. Fig. 6 is an interface diagram of the logical unit hint shown according to the present embodiment. As shown in FIG. 6, the user enters two letters "da" in the edit box, and the editor can match in the TypeScript declaration file based on the two letters "da" and present the current match in the drop-down box.
In an embodiment of the present application, the TypeScript editor may include a first error reporting function and a second error reporting function. The first error reporting function can be an error reporting function carried by a TypeScript editor; the second error reporting function may be a predefined custom error reporting function for determining whether the error is associated with the second predefined syntax according to the error information. A method for customizing logic using a domain-specific language may further include the following steps 701 and 703 as shown in fig. 7:
In one example, the TypeScript Editor can be a Monaco Editor and the first error-reporting function can be setModelMarkers within the Monaco Editor. The second error reporting function may be a user-defined error reporting function setModelMarkers 'preset by the user, and the second error reporting function setModelMarkers' may be capable of determining whether the error is related to the second preset syntax according to the error information, that is, whether the error meets the rule of the second preset syntax. In general, the error reporting function of the editor can only judge the error which does not conform to the syntax of the general programming language, but cannot judge the error which does not conform to the syntax of the general programming language but conforms to the syntax of the DSL language. When the error information occurs, the system determines whether the error is related to the second preset syntax by calling the second error reporting function setModelMarkers'. If the error information is related to the second preset grammar, the error accords with the grammar of the DSL language, and the system eliminates the error information; if not, the system calls a first error reporting function, sends an error message to the first error reporting function and transmits the error parameter to the first error reporting function. By using the second error reporting function to judge the error information which does not conform to the general programming language grammar but conforms to the DSL language grammar, the error information caused by the error conforming to the DSL language grammar can be avoided, thereby realizing accurate error reporting when the DSL language is used.
In an embodiment of the present application, the error information may include an error prompt message and error location information, where the error prompt message is used to prompt a user of an error in the edit box, and the error location information is used to prompt the user of a location of the error in the edit box. In one example, the system may prompt the user for an error by marking the error in the form of a red, underlined wavy line in the edit box based on the error prompt information and the error location information.
In an embodiment of the present application, prior to "register TypeScript declaration file in TypeScript compiler" at step 408, a custom logic method using a domain-specific language may further include: the system receives the TypeScript declaration file sent by the TypeScript editor. By receiving the TypeScript declaration file sent by the TypeScript editor, the system can know the TypeScript declaration file used by the TypeScript editor. In this way, when the system has a plurality of different, mutually independent TypeScript editors, it can be determined which TypeScript declaration files each TypeScript editor is respectively associated with.
In step 415, the grammar of the preset domain-specific language further includes a preset translation grammar, and the system translates the converted abstract grammar tree according to the preset translation grammar and outputs the translation result for the user to view. And translating the converted abstract syntax tree corresponding to the original code to output a translation result which is easy to read and understand, so that a user who cannot directly understand the original code can know the logic defined by the original code through the translation result. In one example, the preset translation grammar can include the following five types of translation rules:
1. translating IF: if { condition } the n { branch one } else { branch two } translates to { branch one } if { condition } then { branch two } otherwise;
2. translation of BinaryExpression: > translate to greater than, = translate to equal, < translate to less, + translate to plus, -translate to minus, # translate to multiply,/translate to divide, | translate to or, & translate to and;
3. translation UnaryExpression: | translation is not;
4. translation CallExpression: the call is in the form of call (param 1, param 2) and translates into calling "custom function call with parameters param1, param 2";
5. translation isReturnStatement: the form of return is return ret, which is translated into a result or judgment returned to ret;
the present application further provides a custom logic system using a domain specific language, comprising: a memory for storing instructions executable by the processor; and a processor for executing the instructions to implement the custom logic method using a domain-specific language as described above.
FIG. 8 illustrates a system block diagram of a custom logic system using a domain-specific language, shown in accordance with an embodiment of the present application. Custom logic system 800 using a domain-specific language may include internal communication bus 801, Processor (Processor) 802, Read Only Memory (ROM) 803, Random Access Memory (RAM) 804, and communication port 805. When implemented on a personal computer, the custom logic system using a domain specific language may also include a hard disk 807. Internal communication bus 801 may enable data communication between custom logic system 800 components using a domain specific language. The processor 802 may make the determination and issue the prompt. In some embodiments, the processor 802 may be comprised of one or more processors. The communication port 805 may enable the custom logic system 800 to communicate data with the outside using a domain-specific language. In some embodiments, custom logic system 800 using a domain specific language can send and receive information and data from a network through communication port 805. The custom logic system 800, which may be implemented using a domain-specific language, may also include various forms of program storage units and data storage units, such as a hard disk 807, Read Only Memory (ROM) 803 and Random Access Memory (RAM) 804, capable of storing various data files used in computer processing and/or communications, as well as possibly program instructions for execution by the processor 802. The processor executes these instructions to implement the main parts of the method. The results processed by the processor are communicated to the user device through the communication port and displayed on the user interface.
The above-described custom logic method using a domain-specific language may be implemented as a computer program stored on the hard disk 807 and executable by the processor 802 to implement any of the custom logic methods using a domain-specific language in the present application.
The present application also provides a computer readable medium having stored thereon computer program code which, when executed by a processor, implements a custom logic method using a domain-specific language as described above.
When implemented as a computer program using a custom logic method in a domain-specific language, may also be stored as an article of manufacture in a computer-readable storage medium. For example, computer-readable storage media can include but are not limited to magnetic storage devices (e.g., hard disk, floppy disk, magnetic strips), optical disks (e.g., Compact Disk (CD), Digital Versatile Disk (DVD)), smart cards, and flash memory devices (e.g., electrically Erasable Programmable Read Only Memory (EPROM), card, stick, key drive). In addition, various storage media described herein can represent one or more devices and/or other machine-readable media for storing information. The term "machine-readable medium" can include, without being limited to, wireless channels and various other media (and/or storage media) capable of storing, containing, and/or carrying code and/or instructions and/or data.
It should be understood that the above-described embodiments are illustrative only. The embodiments described herein may be implemented in hardware, software, firmware, middleware, microcode, or any combination thereof. For a hardware implementation, the processing units may be implemented within one or more Application Specific Integrated Circuits (ASICs), Digital Signal Processors (DSPs), Digital Signal Processing Devices (DSPDs), Programmable Logic Devices (PLDs), Field Programmable Gate Arrays (FPGAs), processors, controllers, micro-controllers, microprocessors, and/or other electronic units designed to perform the functions described herein, or a combination thereof.
Having thus described the basic concept, it will be apparent to those skilled in the art that the foregoing disclosure is by way of example only, and is not intended to limit the present application. Various modifications, improvements and adaptations to the present application may occur to those skilled in the art, although not explicitly described herein. Such modifications, improvements and adaptations are proposed in the present application and thus fall within the spirit and scope of the exemplary embodiments of the present application.
Also, this application uses specific language to describe embodiments of the application. Reference throughout this specification to "one embodiment," "an embodiment," and/or "some embodiments" means that a particular feature, structure, or characteristic described in connection with at least one embodiment of the present application is included in at least one embodiment of the present application. Therefore, it is emphasized and should be appreciated that two or more references to "an embodiment" or "one embodiment" or "an alternative embodiment" in various places throughout this specification are not necessarily all referring to the same embodiment. Furthermore, some features, structures, or characteristics of one or more embodiments of the present application may be combined as appropriate.
Aspects of the present application may be embodied entirely in hardware, entirely in software (including firmware, resident software, micro-code, etc.) or in a combination of hardware and software. The above hardware or software may be referred to as "data block," module, "" engine, "" unit, "" component, "or" system. The processor may be one or more Application Specific Integrated Circuits (ASICs), Digital Signal Processors (DSPs), digital signal processing devices (DAPDs), Programmable Logic Devices (PLDs), Field Programmable Gate Arrays (FPGAs), processors, controllers, microcontrollers, microprocessors, or a combination thereof. Furthermore, aspects of the present application may be represented as a computer product, including computer readable program code, embodied in one or more computer readable media. For example, computer-readable media may include, but are not limited to, magnetic storage devices (e.g., hard disk, floppy disk, magnetic strips … …), optical disks (e.g., Compact Disk (CD), Digital Versatile Disk (DVD) … …), smart cards, and flash memory devices (e.g., card, stick, key drive … …).
Similarly, it should be noted that in the preceding description of embodiments of the application, various features are sometimes grouped together in a single embodiment, figure, or description thereof for the purpose of streamlining the disclosure aiding in the understanding of one or more of the embodiments. This method of disclosure, however, is not intended to require more features than are expressly recited in the claims. Indeed, the embodiments may be characterized as having less than all of the features of a single embodiment disclosed above.
Although the present application has been described with reference to the present specific embodiments, it will be recognized by those skilled in the art that the foregoing embodiments are merely illustrative of the present application and that various changes and substitutions of equivalents may be made without departing from the spirit of the application, and therefore, it is intended that all changes and modifications to the above-described embodiments that come within the spirit of the application fall within the scope of the claims of the application.
Claims (11)
1. A self-defining logic method using a domain-specific language runs in a JavaScript virtual machine, and comprises the following steps:
receiving an original code input by a user and a return type of the original code, wherein the original code uses a preset domain-specific language based on a TypeScript language, syntax of the preset domain-specific language comprises a first preset syntax and a second preset syntax, the first preset syntax is used for restoring asynchronous operation, the second preset syntax is used for judging the return type, and the return type of the original code is a condition type, a calculation type or an action type;
registering a TypeScript declaration file into a TypeScript compiler, wherein the TypeScript declaration file contains grammar rules of the preset domain-specific language, the TypeScript declaration file including any one or more of: the system logic unit declaration file, the tool logic unit declaration file and the first custom logic unit declaration file;
converting the original code into a corresponding abstract syntax tree;
verifying the original code according to the TypeScript declaration file based on the TypeScript compiler, and outputting error information and ending if the verification fails;
verifying whether the return type of the abstract syntax tree is consistent with the return type of the original code input by the user or not according to the second preset syntax, if not, outputting error information and ending, wherein the return type of the abstract syntax tree is judged according to a return statement;
converting the abstract syntax tree according to the first preset syntax;
outputting a corresponding executable JavaScript script and a second custom logic unit statement file according to the converted abstract syntax tree; and
and adding the second custom logic unit declaration file into the first custom logic unit declaration file.
2. The method of claim 1, wherein the grammar of the predetermined domain-specific language further comprises a predetermined translation grammar, the method further comprising: and translating the converted abstract syntax tree according to the preset translation syntax, and outputting a translation result for a user to check.
3. The method of claim 1, wherein the transforming the abstract syntax tree according to the first preset syntax is performed by a Babel compiler; the converting the abstract syntax tree according to the first preset syntax includes:
traversing all functions in the abstract syntax tree and judging whether each function is an asynchronous function, if so, adding an await keyword for the function, otherwise, not adding the await keyword for the function; and adding a corresponding packaging function body for the abstract syntax tree, and judging whether each function in the abstract syntax tree is added with the await keywords, if so, adding the async keywords for the function, and if not, not adding the async keywords for the function.
4. The method of claim 1, wherein the verifying according to the second preset syntax whether the return type of the abstract syntax tree is consistent with the return type of the original code input by the user is performed by a Babel compiler; the verifying whether the return type of the abstract syntax tree is consistent with the return type of the original code input by the user according to the second preset syntax includes:
searching a return statement through a traversal module of the Babel compiler, and judging the return type of the original code input by the user;
when the return type of the original code input by the user is a condition type, if the return statement cannot be found, the verification is not passed, if the return statement is found, whether the parameter of the return statement is a Boolean type or not is judged, if the parameter is the Boolean type, the verification is passed, and if the parameter is not the Boolean type, the verification is not passed;
when the return type of the original code input by the user is a calculation type, if the return statement cannot be found, the verification is passed, and if the return statement is found, the verification is not passed; and
and when the return type of the original code input by the user is the action type, if the return statement is found, the verification is passed, and if the return statement cannot be found, the verification is not passed.
5. The method of claim 1, wherein the method further runs in a TypeScript editor, wherein the TypeScript editor comprises an edit box;
the receiving of the original code input by the user and the return type of the original code are receiving the original code input by the user and the return type of the original code sent by the TypeScript editor;
the method further comprises the following steps:
registering the TypeScript declaration file in the TypeScript editor;
responding to an input request of a user, and loading the edit box;
receiving an original code input in the edit box by a user and a return type of the original code;
converting the original code into a corresponding abstract syntax tree;
verifying the abstract syntax tree according to the TypeScript declaration file, and outputting error information and ending if the abstract syntax tree is not verified; and
and sending the original code, the return type of the original code and the TypeScript declaration file to the TypeScript compiler in response to a save request of a user.
6. The method of claim 5, further comprising:
and when the original code is input into the edit box by the user, matching in the TypeScript declaration file according to the content currently input by the user, and displaying a matching result in the edit box to perform logic unit prompting on the user.
7. The method of claim 5, wherein the TypeScript editor comprises a first error-reporting function and a second error-reporting function, wherein the first error-reporting function is an error-reporting function of the TypeScript editor, and the second error-reporting function is a predefined custom error-reporting function for determining whether an error is associated with the second predefined syntax according to the error information;
the method further comprises the following steps:
when the error information appears, calling the second error reporting function to judge whether the error is related to the second preset grammar according to the error information;
if so, eliminating the error information; and
if not, the first error reporting function is called, and the error message is sent to the first error reporting function.
8. The method of claim 5, wherein the error information comprises an error prompt message for prompting a user for an error in the edit box and error location information for prompting a user for a location of the error in the edit box.
9. A method as recited in claim 5, wherein, prior to the registering the TypeScript declaration file in the TypeScript compiler, the method further comprises:
and receiving the TypeScript declaration file sent by the TypeScript editor.
10. A custom logic system using a domain-specific language, comprising:
a memory for storing instructions executable by the processor; and a processor for executing the instructions to implement the method of any one of claims 1-9.
11. A computer-readable medium having stored thereon computer program code which, when executed by a processor, implements the method of any of claims 1-9.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011499549.1A CN112231068B (en) | 2020-12-18 | 2020-12-18 | Custom logic method, system and readable medium using domain specific language |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011499549.1A CN112231068B (en) | 2020-12-18 | 2020-12-18 | Custom logic method, system and readable medium using domain specific language |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112231068A CN112231068A (en) | 2021-01-15 |
| CN112231068B true CN112231068B (en) | 2021-03-16 |
Family
ID=74124901
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011499549.1A Active CN112231068B (en) | 2020-12-18 | 2020-12-18 | Custom logic method, system and readable medium using domain specific language |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112231068B (en) |
Families Citing this family (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112748988A (en) * | 2021-01-26 | 2021-05-04 | 浙江太美医疗科技股份有限公司 | Custom function operation method and system based on domain-specific language |
| CN114879962B (en) * | 2021-02-05 | 2024-06-04 | 华为技术有限公司 | Method and device for realizing batch system call |
| CN113986889B (en) * | 2021-12-28 | 2022-04-05 | 天津南大通用数据技术股份有限公司 | Method and system for realizing intelligent expansion of database function |
| CN116501303B (en) * | 2023-06-25 | 2023-11-14 | 北京长亭科技有限公司 | Automatic API code generation method and device |
Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20160350086A1 (en) * | 2015-05-29 | 2016-12-01 | International Business Machines Corporation | Obtaining correct compile results by absorbing mismatches between data types representations |
| CN106970802A (en) * | 2017-04-25 | 2017-07-21 | 北京航天飞行控制中心 | The method and device of integrated programming script in the language-specific of field |
| CN110502897A (en) * | 2018-05-16 | 2019-11-26 | 南京大学 | A kind of identification of webpage malicious JavaScript code and antialiasing method based on hybrid analysis |
| CN111813381A (en) * | 2020-06-22 | 2020-10-23 | 北京字节跳动网络技术有限公司 | Method, device, medium and electronic equipment for generating executable program in cross-platform mode |
-
2020
- 2020-12-18 CN CN202011499549.1A patent/CN112231068B/en active Active
Patent Citations (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20160350086A1 (en) * | 2015-05-29 | 2016-12-01 | International Business Machines Corporation | Obtaining correct compile results by absorbing mismatches between data types representations |
| CN106970802A (en) * | 2017-04-25 | 2017-07-21 | 北京航天飞行控制中心 | The method and device of integrated programming script in the language-specific of field |
| CN110502897A (en) * | 2018-05-16 | 2019-11-26 | 南京大学 | A kind of identification of webpage malicious JavaScript code and antialiasing method based on hybrid analysis |
| CN111813381A (en) * | 2020-06-22 | 2020-10-23 | 北京字节跳动网络技术有限公司 | Method, device, medium and electronic equipment for generating executable program in cross-platform mode |
Non-Patent Citations (2)
| Title |
|---|
| 基于PMD和Jacoco的代码分析系统的设计与实现;李煜超;《中国优秀硕士学位论文全文数据库信息科技辑》;20190731(第7期);全文 * |
| 蓟门桥译文集团.译文：Static TypeScript，TypeScript 的一种静态编译器实现.《https://vlambda.com/wz_7irzu5n77is.html》.2020,全文. * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112231068A (en) | 2021-01-15 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN112231068B (en) | Custom logic method, system and readable medium using domain specific language | |
| CN106919434B (en) | Code generation method and device | |
| US20110145799A1 (en) | Path-sensitive dataflow analysis including path refinement | |
| CN109710260B (en) | Multi-platform-based applet code conversion method | |
| CN111813680B (en) | Method and device for generating test script, computer equipment and storage medium | |
| CN109460220A (en) | The predefined code generating method of message, device, electronic equipment and storage medium | |
| CN109753658B (en) | Interaction method and device | |
| CN115455166A (en) | Method, device, medium and equipment for detecting abnormality of intelligent dialogue system | |
| CN107766036B (en) | Module construction method and device and terminal equipment | |
| CN116166236A (en) | Code recommendation method, device, computer equipment and storage medium | |
| CN112181924A (en) | File conversion method, device, equipment and medium | |
| CN115599359A (en) | Code generation method, device, equipment and medium | |
| CN112748988A (en) | Custom function operation method and system based on domain-specific language | |
| CN112181411A (en) | Menu generation method, menu generation device and diagnosis equipment | |
| CN114327492A (en) | Code translation method, device and equipment | |
| CN115859121A (en) | Text processing model training method and device | |
| CN114896269A (en) | Structured query statement detection method and device, electronic equipment and storage medium | |
| CN113900657A (en) | Method for reading data rule, electronic device and storage medium | |
| CN114358596A (en) | Index calculation method and device | |
| CN109783134B (en) | Front-end page configuration method and device and electronic equipment | |
| CN113779311A (en) | Data processing method, device and storage medium | |
| CN117075912B (en) | Method for program language conversion, compiling method and related equipment | |
| CN112230895A (en) | EL expression analysis method, device, equipment and storage medium | |
| CN108255802B (en) | Universal text parsing architecture and method and device for parsing text based on architecture | |
| CN111401020A (en) | Interface loading method and system and computing equipment |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |