Application generation method, device and equipment

Abstract

The embodiment of the present invention discloses an application generation method, device and equipment, the method comprising receiving a graphical configuration operation of an application component by a user in an application development platform; determining a layer of source code mapping between the graphical configuration operation and a predefined code, and generating a target code corresponding to the graphical configuration operation based on the layer of source code mapping; performing code parsing processing on the target code, determining a second layer of source code mapping between the target code and a syntax tree, and generating a target syntax tree corresponding to the target code based on the second layer of source code mapping; performing code conversion processing on the target syntax tree, determining a third layer of source code mapping between the syntax tree and a source code, and translating the target syntax tree according to the three-layer source code mapping to obtain a target object; and generating a target application corresponding to the graphical configuration operation according to the target object.

Description

Technical Field

[0001] The present invention relates to the field of computer technology, and in particular to an application generation method, device and equipment. Background Art

[0002] With the rapid development of Internet technology, service providers can develop multiple different applications based on users' business needs. To improve the efficiency of application development, service providers can quickly develop applications through low-code platforms. Among them, low-code platforms can quickly generate applications with a small amount of code.

[0003] However, due to the large differences in the underlying technologies and frameworks of different components under different applications, to complete a complete application modeling, it is necessary to use different modeling methods to model each component separately. Different modeling methods bring a large workload to the application modeling work, resulting in low application development efficiency. Therefore, a technical solution to improve application development efficiency is needed. Summary of the invention

[0004] The purpose of the embodiments of this specification is to provide a technical solution to improve the efficiency of application development.

[0005] In order to implement the above technical solution, the embodiments of this specification are implemented as follows:

[0006] An application generation method provided in an embodiment of the present specification includes: receiving a graphical configuration operation of an application component by a user in an application development platform; parsing the graphical configuration operation to determine a layer of source code mapping between the graphical configuration operation and a predefined code, and generating a target code corresponding to the graphical configuration operation based on the layer of source code mapping; parsing the target code to determine a second layer of source code mapping between the target code and a syntax tree, and generating a target syntax tree corresponding to the target code based on the second layer of source code mapping, wherein the target syntax tree includes at least an application element domain sublanguage having application element programming semantics; performing code conversion on the target syntax tree to determine a third layer of source code mapping between the syntax tree and source code, and translating the target syntax tree according to the third layer of source code mapping to obtain a target object; and generating a target application corresponding to the graphical configuration operation according to the target object.

[0007] An application generation device provided in an embodiment of the present specification includes: an operation receiving module for receiving a graphical configuration operation of an application component by a user in an application development platform; a first mapping module for parsing the graphical configuration operation, determining a layer of source code mapping between the graphical configuration operation and a predefined code, and generating a target code corresponding to the graphical configuration operation based on the layer of source code mapping; a second mapping module for performing code parsing on the target code, determining a layer of source code mapping between the target code and a syntax tree, and generating a target syntax tree corresponding to the target code based on the layer of source code mapping, wherein the target syntax tree includes at least an application element domain sublanguage having application element programming semantics; a third mapping module for performing code conversion on the target syntax tree, determining a layer of source code mapping between the syntax tree and a source code, and translating the target syntax tree according to the layer of source code mapping to obtain a target object; and an application generation model for generating a target application corresponding to the graphical configuration operation according to the target object.

[0008] An application generation device provided in an embodiment of the present specification includes: a processor; and a memory arranged to store computer executable instructions, wherein when the executable instructions are executed, the processor: receives a graphical configuration operation of an application component by a user in an application development platform; performs parsing processing on the graphical configuration operation to determine a layer of source code mapping between the graphical configuration operation and a predefined code, and generates a target code corresponding to the graphical configuration operation based on the layer of source code mapping; performs code parsing processing on the target code to determine a second layer of source code mapping between the target code and a syntax tree, and generates a target syntax tree corresponding to the target code based on the second layer of source code mapping, wherein the target syntax tree includes at least an application element domain sublanguage having application element programming semantics; performs code conversion processing on the target syntax tree to determine a third layer of source code mapping between the syntax tree and a source code, and translates the target syntax tree according to the third layer of source code mapping to obtain a target object; and generates a target application corresponding to the graphical configuration operation according to the target object.

[0009] The embodiments of the present specification also provide a storage medium, which is used to store computer-executable instructions, and the executable instructions implement the following process when executed by a processor: receiving a graphical configuration operation of a user for an application component in an application development platform; parsing the graphical configuration operation to determine a layer of source code mapping between the graphical configuration operation and a predefined code, and generating a target code corresponding to the graphical configuration operation based on the layer of source code mapping; performing code parsing on the target code to determine a second layer of source code mapping between the target code and a syntax tree, and generating a target syntax tree corresponding to the target code based on the second layer of source code mapping, wherein the target syntax tree includes at least an application element domain sublanguage having application element programming semantics; performing code conversion on the target syntax tree to determine a third layer of source code mapping between the syntax tree and the source code, and translating the target syntax tree according to the three-layer source code mapping to obtain a target object; and generating a target application corresponding to the graphical configuration operation according to the target object.

[0010] The embodiments of the present specification also provide a computer program product, including a computer program, which implements the following process when executed by a processor: receiving a graphical configuration operation of a user for an application component in an application development platform; parsing the graphical configuration operation to determine a layer of source code mapping between the graphical configuration operation and a predefined code, and generating a target code corresponding to the graphical configuration operation based on the layer of source code mapping; performing code parsing on the target code to determine a second layer of source code mapping between the target code and a syntax tree, and generating a target syntax tree corresponding to the target code based on the second layer of source code mapping, wherein the target syntax tree includes at least an application element domain sublanguage having application element programming semantics; performing code conversion on the target syntax tree to determine a third layer of source code mapping between the syntax tree and source code, and translating the target syntax tree according to the three-layer source code mapping to obtain a target object; and generating a target application corresponding to the graphical configuration operation according to the target object. BRIEF DESCRIPTION OF THE DRAWINGS

[0011] In order to more clearly illustrate the technical solutions in the embodiments of this specification or the prior art, the drawings required for use in the embodiments or the prior art description will be briefly introduced below. Obviously, the drawings described below are only some embodiments recorded in this specification. For those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative labor.

[0012] Figure 1 This is an embodiment of an application generation method of this specification;

[0013] Figure 2 Another embodiment of the application generation method of this specification is provided;

[0014] Figure 3 A schematic diagram of a development model framework for this specification;

[0015] Figure 4 A schematic diagram of an application generation process of this specification;

[0016] Figure 5 This is an embodiment of an application generation device of this specification;

[0017] Figure 6 This is an embodiment of an application generation device in this specification. DETAILED DESCRIPTION

[0018] The embodiments of this specification provide an application generation method, apparatus, and device.

[0019] In order to enable those skilled in the art to better understand the technical solutions in this specification, the technical solutions in the embodiments of this specification will be clearly and completely described below in conjunction with the drawings in the embodiments of this specification. Obviously, the described embodiments are only part of the embodiments of this specification, not all of the embodiments. Based on the embodiments in this specification, all other embodiments obtained by ordinary technicians in this field without creative work should fall within the scope of protection of this specification.

[0020] The embodiments of this specification provide an application generation method, device and equipment. With the rapid development of Internet technology, service providers can develop multiple different applications according to the business usage needs of users. To improve the development efficiency of applications, service providers can quickly develop applications through low-code platforms. Among them, low-code platforms can quickly generate applications through a small amount of code. However, due to the large differences in the underlying technologies and frameworks of different components under different applications, to complete a complete application modeling, it is necessary to use different modeling methods to model each component separately. Different modeling methods bring a large workload to the application modeling work, resulting in low application development efficiency. Therefore, a technical solution to improve the efficiency of application development is needed. In this solution, the user's graphical configuration operation for the application component in the application development platform can be received, the graphical configuration operation is parsed, a layer of source code mapping between the graphical configuration operation and the predefined code is determined, and based on the layer of source code mapping, the target code corresponding to the graphical configuration operation is generated, the target code is parsed, the second layer of source code mapping between the target code and the syntax tree is determined, and based on the second layer of source code mapping, a target syntax tree corresponding to the target code is generated, wherein the target syntax tree may at least include an application element domain sublanguage with application element programming semantics, the target syntax tree is code converted, the three layers of source code mapping between the syntax tree and the source code are determined, and the target syntax tree is translated according to the three layers of source code mapping to obtain the target object, and the target application corresponding to the graphical configuration operation is generated according to the target object. In this way, firstly, a full coverage description of each element of the low-code application can be achieved through a unified syntax definition, shielding the differences in the underlying technologies of different elements and the diversity of modeling methods, providing a basis for unifying the discrete and diverse modeling methods of low-code applications. Secondly, with the target syntax tree as the core, through three source code mappings (i.e., first-layer source code mapping, second-layer source code mapping, and third-layer source code mapping), the mapping transformation from application modeling graphical configuration to target code, from target code to target syntax tree, and from target syntax tree to target object is completed, thereby realizing the unification of low-code application modeling methods and effectively improving the development efficiency of the application program. For specific processing, please refer to the specific content in the following embodiment.

[0021] like Figure 1 As shown, the embodiment of this specification provides an application generation method, and the execution subject of the method can be a server, wherein the server can be an independent server, or a server cluster composed of multiple servers. The method can specifically include the following steps:

[0022] In step S102, a graphical configuration operation of an application component by a user in an application development platform is received.

[0023] Among them, the application development platform can be a low-code platform. The low-code platform can be a development platform that quickly generates applications through a small amount of code. It can develop applications through a visual programming language, so that developers with different experience levels can create applications through a graphical user interface using drag-and-drop components and model-driven logic. The low-code platform's complete description of an application includes the encapsulation of components and capabilities such as visual pages, data models, business rules, processes, permissions, interfaces, etc.

[0024] In implementation, users can perform application modeling by graphical dragging and dropping in the visual editor of the application development platform, and publish the application after completing the modeling. At this time, the server can obtain the user's graphical configuration operations for the application components in the application development platform.

[0025] In step S104, the graphical configuration operation is parsed to determine a layer of source code mapping between the graphical configuration operation and the predefined code, and based on the layer of source code mapping, a target code corresponding to the graphical configuration operation is generated.

[0026] Among them, the predefined code can be the code corresponding to the domain specific language (Low Code Domain Specific Language, LCDSL) for low-code application modeling.

[0027] In implementation, the server can parse the graphical configuration operation through a visual editor (Web IDE), determine a layer of source code mapping between the graphical configuration operation and the predefined code, and generate a target code corresponding to the graphical configuration operation based on the layer of source code mapping.

[0028] The visual editor may include a visual page editor, a data model editor, a process editor, and a business rule editor, which are used to provide visual modeling capabilities for visual pages, data models, processes, and business rules, respectively. The visual editor may generate LCDSL code (i.e., target code) in real time for graphical configuration operations.

[0029] In step S106, code parsing is performed on the target code to determine a two-layer source code mapping between the target code and the syntax tree, and based on the two-layer source code mapping, a target syntax tree corresponding to the target code is generated.

[0030] The target syntax tree at least includes an application element domain sublanguage having application element programming semantics.

[0031] In implementation, the target syntax tree may also include a basic language with basic programming semantics, wherein the basic language may include basic programming semantics such as types, variables, logic, and namespaces. Type programming semantics may provide definitions of atomic types, paradigms, and composite types. Variable programming semantics may provide definitions of variables and constants. Logic programming semantics may provide definitions of input parameters, output parameters, functions, expressions, and statements. Namespace programming semantics may provide definitions of system namespaces and user namespaces.

[0032] Specifically, type programming semantics may include type annotations, data structures, and enumerations. Variable programming semantics may include variables and constants. Logic programming semantics may include functions, input parameters, output parameters, and expressions. Namespace programming semantics may include system namespaces and user namespaces.

[0033] The server can determine the two-layer source code mapping between the target code and the syntax tree through the lexical analysis, syntax analysis and semantic analysis capabilities provided by the semantic parser, and parse the LCDSL code into the target syntax tree based on the two-layer source code mapping.

[0034] In step S108, the target syntax tree is subjected to code conversion processing, a three-layer source code mapping between the syntax tree and the source code is determined, and the target syntax tree is translated according to the three-layer source code mapping to obtain a target object.

[0035] In implementation, the server can translate the target syntax tree into source code (ie, target object) of a common language such as JavaScript, Java, etc. through a code generator.

[0036] In step S110 , a target application corresponding to the graphical configuration operation is generated according to the target object.

[0037] In implementation, the server can render the source code into source files such as JavaScript, Java, etc. through the template engine, and run the rendered source files with the help of the underlying common language running facilities (such as Java Virtual Machine (JVM), browser, etc.) to run the LCDSL language on the computer and generate a target application corresponding to the user's graphical configuration operation.

[0038] The embodiment of this specification provides an application generation method, which can receive a graphical configuration operation of an application component by a user in an application development platform, parse the graphical configuration operation, determine a layer of source code mapping between the graphical configuration operation and a predefined code, and based on the layer of source code mapping, generate a target code corresponding to the graphical configuration operation, perform code parsing on the target code, determine a second layer of source code mapping between the target code and a syntax tree, and based on the second layer of source code mapping, generate a target syntax tree corresponding to the target code, wherein the target syntax tree can at least include an application element domain sublanguage having application element programming semantics, perform code conversion on the target syntax tree, determine a third layer of source code mapping between the syntax tree and the source code, and translate the target syntax tree according to the three layers of source code mapping to obtain a target object, and generate a target application corresponding to the graphical configuration operation according to the target object. In this way, firstly, a full coverage description of each element of a low-code application can be achieved through a unified syntax definition, shielding the differences in the underlying technologies of different elements and the diversity of modeling methods, providing a basis for unifying the discrete and diverse modeling methods of low-code applications. Secondly, with the target syntax tree as the core, through three source code mappings (i.e., first-layer source code mapping, second-layer source code mapping, and third-layer source code mapping), the mapping transformation from application modeling graphical configuration to target code, from target code to target syntax tree, and from target syntax tree to target object is completed, thereby realizing the unification of low-code application modeling methods and effectively improving the development efficiency of applications.

[0039] In actual applications, the application element domain sub-language can at least include low-code application element programming semantics such as data model sub-language, process sub-language, visualization page sub-language, and business rule sub-language.

[0040] For the data model sub-language, it can provide definitions of data sources, data entities, entity fields, entity indexes, and data queries; for the process sub-language, it can provide definitions of process templates, process nodes, process components, judgment results, and handlers; for the visual page sub-language, it can provide definitions of pages, page elements, element attributes, element styles, element events, and element instructions; for the business rule sub-language, it can provide definitions of expressions, conditional branches, loop branches, selection branches, and calling interfaces.

[0041] Specifically, the visual page sub-language may include page elements ViewElement, element attributes BindAttribute, element binding styles BindStyle, element instructions BindDirective, and element binding events BindEvent. The process sub-language may include process elements ProcessElement, process components ProcessComponent, judgment results ProcessOutcome, and assignees. The data model sub-language may include data models DataModel and data queries DataQuery. The data model DataModel may include data sources DataSource, entities Entiy, entity fields EntiyProperty, and entity indexes EntiyIndex. The data query DataQuery may include query aggregation methods QueryAggregateExpression, query fields QueryFieldExpression, query from expressions QueryFormExpression, query groups QueryGroupByExpression, and query selection clauses QuerySelectExpressio. The business rule Rule sub-language may include start nodes Start, end nodes End, conditional scores IfStatement, selection branches SwitchStatement, and call interfaces Callnterface.

[0042] In practical applications, in the above step S106, the target code is parsed to determine the two-layer source code mapping between the target code and the syntax tree, and based on the two-layer source code mapping, a target syntax tree corresponding to the target code is generated. There are many ways to do this. The following is an optional processing method, such as Figure 2 As shown, the processing may specifically include the following steps S1062 to S1066.

[0043] In step S1062, the target code is subjected to lexical analysis to perform symbol segmentation on the target code to obtain a symbol table corresponding to the target code.

[0044] In step S1064, a syntax analysis process is performed on the symbol table corresponding to the target code to obtain a two-layer source code mapping between the target code and the syntax tree, and based on the two-layer source code mapping, a first syntax tree corresponding to the target code is generated.

[0045] In step S1066, semantic analysis is performed on the first syntax tree to perform type conversion on semantic nodes in the first syntax tree to obtain a target syntax tree corresponding to the target code.

[0046] In implementation, Figure 3 As shown, the semantic parser can use a finite state machine algorithm to perform lexical analysis on the generated LCDSL code (ie, target code) to divide the LCDSL code into symbols one by one and establish a symbol table based on these symbols.

[0047] Then, the semantic parser can use context-free grammar analysis to perform grammatical analysis on the generated symbol table and establish a Source Map (i.e., a two-layer source code mapping) of the LCDSL code and syntax tree. The two-layer source code mapping can be used to record the corresponding information between each symbol and the semantic node in the syntax tree. The LCDSL syntax tree (i.e., the first syntax tree) can be generated through the two-layer source code mapping.

[0048] Finally, the semantic parser can perform static semantic analysis on the generated LCDSL syntax tree, such as using a depth-first algorithm to traverse the semantic nodes in the LCDSL syntax tree and perform type conversion on the semantic nodes to obtain a labeled syntax tree, namely, a target syntax tree.

[0049] In practical applications, in the above step S108, the target syntax tree is subjected to code conversion processing, and there are many ways to determine the three-layer source code mapping between the syntax tree and the source code. The following is an optional processing method, such as Figure 3 As shown, the processing may specifically include the following steps S1082 to S1084.

[0050] In step S1082, the visualization page sub-language in the target syntax tree is transcoded to determine the first source code, and the data model sub-language, process sub-language, and business rule sub-language in the target syntax tree are transcoded to determine the second source code.

[0051] In step S1084, a three-level source code mapping between the syntax tree and the source code is determined according to the first source code and the second source code.

[0052] In actual applications, the target object may include a front-end sub-object corresponding to the first source code, and a back-end sub-object corresponding to the second source code.

[0053] In implementation, the code generator can receive the annotated syntax tree generated by the semantic parser, and according to the semantic specification and version specification, convert the page sub-language into JavaScript code (i.e., the first source code) through the front-end translator, and convert the data model sub-language, process sub-language, and business rule sub-language into Java code (i.e., the second source code) through the back-end translator.

[0054] Then, a Source Map (i.e., a three-layer source code map) of the annotated syntax tree and the Java / JavaScript source code can be established. The three-layer source code map can be used to record the file name, class name, and line number registration information of the Java and / or JavaScript source code corresponding to the semantic node in the annotated syntax tree. According to the three-layer source code map, the annotated syntax tree can be translated into a corresponding Java object (i.e., a back-end sub-object corresponding to the second source code) through a back-end translator, and translated into a corresponding JavaScript object (i.e., a front-end sub-object corresponding to the first source code) through a front-end translator.

[0055] The server can render the generated Java objects and JavaScript objects into Java source files based on the Spring framework and JS source files based on the React framework through the template engine. The Java source files and JS source files can be compiled and executed by the JVM and the browser at runtime.

[0056] In this way, three source code mappings (i.e., first-layer source code mapping, second-layer source code mapping, and third-layer source code mapping) can be established through the visual editor, semantic parser, and code generator to achieve the mapping transformation from application modeling graphical configuration to target code, from target code to target syntax tree, and from target syntax tree to target object, and finally run on JVM and browser. The low-code application development model based on LCDSL can help low-code developers complete application development using a unified visual modeling language, effectively reducing the development difficulty and workload, and improving the development efficiency of applications.

[0057] Among them, the low-code application development model based on LCDSL can take the LCDSL syntax tree as the core, and through the effective coordination of the visual editor, semantic parser, and code generator, after three-layer source code mapping in development state, compilation state, and running state, it can achieve the unification of modeling methods of different elements of low-code applications, effectively improve the efficiency of low-code application development, and reduce the difficulty of application development.

[0058] In practical applications, the target code can be stored in JSON format, and the syntax of the target code can be constructed based on semantic nodes, sub-nodes, attributes of semantic nodes, and attribute values.

[0059] LCDSL syntax tree can use JSON as storage format, and the basic syntax can be: concept{attr0val0, attr1 val1, children {concept {attr2 val2}}. concept can be a semantic node, children can be a child node, attr and val are the attributes and attribute values ​​of the semantic node respectively. Semantic nodes can be nested layer by layer according to the semantic abstraction level. Low-order domain semantic nodes can be child nodes of high-order domain semantic nodes, and basic semantic nodes can be leaf nodes. When attr is equal to children, the attribute value val corresponding to attr can be the child node recursively included in the current element.

[0060] An example LCDSL syntax tree is as follows:

[0061] {

[0062] "concept": "App",#Semantic node App (application)

[0063] "name": "test",#property name

[0064] "dataSources": [{#child nodes

[0065] "concept": "DataSource",#Semantic node DataSource (data source)

[0066] "entities": [{#child nodes

[0067] "concept": "Entity",#Semantic node Entity

[0068] "properties": [{#child nodes

[0069] "concept": "EntityProperty",#Semantic node EntityProperty (entity property)

[0070] "typeAnnotation": {#child nodes

[0071] "concept": "TypeAnnotation"#Semantic node TypeAnnotation (type annotation)

[0072] },

[0073] "isLeaf": true#Leaf node annotation

[0074] }]

[0075] }]

[0076] }],

[0077] "structures": [{#child nodes

[0078] "concept": "Structure",#Semantic node Structure (data structure)

[0079] "properties": [{#child nodes

[0080] "concept": "StructureProperty",#Semantic node Structure (data structure field)

[0081] "typeAnnotation": {#child nodes

[0082] "concept": "TypeAnnotation"#Semantic node TypeAnnotation (type annotation)

[0083] },

[0084] "isLeaf": true

[0085] }]

[0086] }],

[0087] "frontends": [{#child nodes

[0088] "concept": "Frontend",#Semantic node Frontend (front end)

[0089] "name": "pc",

[0090] "views": [{#child nodes

[0091] "concept": "View",#Semantic node View (page)

[0092] "name": "login",

[0093] "elements": [{#child nodes

[0094] "concept": "ViewElement",#Semantic node ViewElement (page element)

[0095] "bindAttrs": [{#child nodes

[0096] "concept": "BindAttribute"#Semantic nodeBindAttribute (binding attribute)

[0097] }],

[0098] "children": [{#child nodes

[0099] "concept": "ViewElement",#Semantic node ViewElement (page element)

[0100] "bindAttrs": [{#child nodes

[0101] "concept": "BindAttribute"#Semantic nodeBindAttribute (binding attribute)

[0102] }],

[0103] "children": [{#child nodes

[0104] "concept": "ViewElement",#Semantic node ViewElement (page element)

[0105] "children": [{#child nodes

[0106] "concept": "ViewElement",#Semantic node ViewElement (page element)

[0107] "bindAttrs": [{#child nodes

[0108] "concept": "BindAttribute"#Semantic nodeBindAttribute (binding attribute)

[0109] }],

[0110] "bindEvents": [],

[0111] "bindDirectives": [],

[0112] "bindRoles": [],

[0113] "bindStyles": [],

[0114] "children": []

[0115] }]

[0116] }]

[0117] }]

[0118] }]

[0119] }]

[0120] }]

[0121] }

[0122] The LCDSL syntax tree can be parsed and accessed in the syntax format of {namespace}.{concept plural}.{name}.{concept plural}.{name}. The system namespace can be defined as lcdsl, and the user namespace definition can be app. For example, app.views.A.elements.B can be used to represent page element node B under page node A in the user space.

[0123] In this way, through the LCDSL syntax tree defined by the basic language and the application element domain sub-language, a full coverage description of low-code applications from top to bottom can be achieved, which can provide a basis for unifying the discrete and diverse modeling methods of low-code applications.

[0124] The embodiment of this specification provides an application generation method, which can receive a graphical configuration operation of an application component by a user in an application development platform, parse the graphical configuration operation, determine a layer of source code mapping between the graphical configuration operation and a predefined code, and based on the layer of source code mapping, generate a target code corresponding to the graphical configuration operation, perform code parsing on the target code, determine a second layer of source code mapping between the target code and a syntax tree, and based on the second layer of source code mapping, generate a target syntax tree corresponding to the target code, wherein the target syntax tree can at least include an application element domain sublanguage having application element programming semantics, perform code conversion on the target syntax tree, determine a third layer of source code mapping between the syntax tree and the source code, and translate the target syntax tree according to the three layers of source code mapping to obtain a target object, and generate a target application corresponding to the graphical configuration operation according to the target object. In this way, firstly, a full coverage description of each element of a low-code application can be achieved through a unified syntax definition, shielding the differences in the underlying technologies of different elements and the diversity of modeling methods, providing a basis for unifying the discrete and diverse modeling methods of low-code applications. Secondly, with the target syntax tree as the core, through three source code mappings (i.e., first-layer source code mapping, second-layer source code mapping, and third-layer source code mapping), the mapping transformation from application modeling graphical configuration to target code, from target code to target syntax tree, and from target syntax tree to target object is completed, thereby realizing the unification of low-code application modeling methods and effectively improving the development efficiency of applications.

[0125] The above is an application generation method provided in the embodiment of this specification. Based on the same idea, the embodiment of this specification also provides an application generation device, such as Figure 5 shown.

[0126] The application generating device comprises: an operation receiving module 501, a first mapping module 502, a second mapping module 503, a third mapping module 504 and an application generating module 505, wherein:

[0127] An operation receiving module 501 is used to receive a user's graphical configuration operation for an application component in an application development platform;

[0128] A first mapping module 502 is used to parse the graphical configuration operation, determine a layer of source code mapping between the graphical configuration operation and a predefined code, and generate a target code corresponding to the graphical configuration operation based on the layer of source code mapping;

[0129] A second mapping module 503 is used to perform code parsing processing on the target code, determine a two-layer source code mapping between the target code and the syntax tree, and generate a target syntax tree corresponding to the target code based on the two-layer source code mapping, wherein the target syntax tree at least includes an application element domain sublanguage having application element programming semantics;

[0130] The third mapping module 504 is used to perform code conversion processing on the target syntax tree, determine the three-layer source code mapping between the syntax tree and the source code, and translate the target syntax tree according to the three-layer source code mapping to obtain a target object;

[0131] The application generation model 505 is used to generate a target application program corresponding to the graphical configuration operation according to the target object.

[0132] In the embodiment of this specification, the application element domain sub-language includes at least a data model sub-language, a process sub-language, a visualization page sub-language, and a business rule sub-language.

[0133] In the embodiment of this specification, the second mapping module 503 is used to:

[0134] Performing lexical analysis on the target code to perform symbol segmentation on the target code to obtain a symbol table corresponding to the target code;

[0135] Performing syntax analysis on the symbol table corresponding to the target code to obtain a two-layer source code mapping between the target code and the syntax tree, and generating a first syntax tree corresponding to the target code based on the two-layer source code mapping;

[0136] The first syntax tree is subjected to semantic analysis processing to perform type conversion processing on semantic nodes in the first syntax tree to obtain a target syntax tree corresponding to the target code.

[0137] In the embodiment of this specification, the third mapping module 504 is used to:

[0138] Performing code conversion processing on the visualization page sub-language in the target syntax tree to determine a first source code, and performing code conversion processing on the data model sub-language, the process sub-language, and the business rule sub-language in the target syntax tree to determine a second source code;

[0139] A three-layer source code mapping between the syntax tree and the source code is determined according to the first source code and the second source code.

[0140] In the embodiment of this specification, the target object includes a front-end sub-object corresponding to the first source code, and a back-end sub-object corresponding to the second source code.

[0141] In the embodiments of this specification, the target code is stored in JSON format, and the syntax of the target code is constructed according to semantic nodes, sub-nodes, attributes of the semantic nodes, and attribute values.

[0142] The embodiment of this specification provides an application generation device, which can receive the graphical configuration operation of the user for the application component in the application development platform, parse the graphical configuration operation, determine the first layer of source code mapping between the graphical configuration operation and the predefined code, and generate the target code corresponding to the graphical configuration operation based on the first layer of source code mapping, perform code parsing on the target code, determine the second layer of source code mapping between the target code and the syntax tree, and generate the target syntax tree corresponding to the target code based on the second layer of source code mapping, wherein the target syntax tree can at least include the application element domain sublanguage with the application element programming semantics, perform code conversion on the target syntax tree, determine the third layer of source code mapping between the syntax tree and the source code, and translate the target syntax tree according to the three layers of source code mapping to obtain the target object, and generate the target application corresponding to the graphical configuration operation according to the target object. In this way, firstly, a full coverage description of each element of the low-code application can be achieved through a unified syntax definition, shielding the differences in the underlying technologies of different elements and the diversity of modeling methods, and providing a basis for unifying the discrete and diverse modeling methods of low-code applications. Secondly, with the target syntax tree as the core, through three source code mappings (i.e., first-layer source code mapping, second-layer source code mapping, and third-layer source code mapping), the mapping transformation from application modeling graphical configuration to target code, from target code to target syntax tree, and from target syntax tree to target object is completed, thereby realizing the unification of low-code application modeling methods and effectively improving the development efficiency of applications.

[0143] The above is an application generation device provided in the embodiment of this specification. Based on the same idea, the embodiment of this specification also provides an application generation device, such as Figure 6 shown.

[0144] The application generating device may provide a terminal device or a server, etc. for the above-mentioned embodiments.

[0145] The application generation device may have relatively large differences due to different configurations or performances, and may include one or more processors 601 and memory 602, and the memory 602 may store one or more storage applications or data. Among them, the memory 602 may be a short-term storage or a persistent storage. The application stored in the memory 602 may include one or more modules (not shown in the figure), and each module may include a series of computer executable instructions in the application generation device. Furthermore, the processor 601 may be configured to communicate with the memory 602 and execute a series of computer executable instructions in the memory 602 on the application generation device. The application generation device may also include one or more power supplies 603, one or more wired or wireless network interfaces 604, one or more input and output interfaces 605, and one or more keyboards 606.

[0146] Specifically, in this embodiment, the application generation device includes a memory and one or more programs, wherein the one or more programs are stored in the memory, and the one or more programs may include one or more modules, and each module may include a series of computer executable instructions in the application generation device, and the one or more programs are configured to be executed by one or more processors, including computer executable instructions for performing the following:

[0147] Receiving graphical configuration operations of the user on the application development platform for application components;

[0148] Parsing the graphical configuration operation to determine a layer of source code mapping between the graphical configuration operation and a predefined code, and generating a target code corresponding to the graphical configuration operation based on the layer of source code mapping;

[0149] Performing code parsing processing on the target code to determine a two-layer source code mapping between the target code and a syntax tree, and generating a target syntax tree corresponding to the target code based on the two-layer source code mapping, wherein the target syntax tree at least includes an application element domain sublanguage having application element programming semantics;

[0150] Performing code conversion processing on the target syntax tree, determining a three-layer source code mapping between the syntax tree and the source code, and translating the target syntax tree according to the three-layer source code mapping to obtain a target object;

[0151] A target application corresponding to the graphical configuration operation is generated according to the target object.

[0152] Each embodiment in this specification is described in a progressive manner, and the same or similar parts between the embodiments can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the application generation device embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and the relevant parts can be referred to the partial description of the method embodiment.

[0153] The embodiments of this specification provide an application generation device, which generates semantic target text data through a preset comparison relationship between text structure and coding value. On the one hand, it can simplify encryption operations, reduce dependence on third-party encryption software, and improve encryption efficiency. On the other hand, since the generated target text data is semantic, it has a high degree of concealment during data transmission and is not easily detected by malicious third parties, thereby improving the security of the data transmission process.

[0154] Furthermore, based on the above Figures 1 to 4 In one embodiment, the present specification further provides a storage medium for storing computer executable instruction information. In a specific embodiment, the storage medium may be a USB flash drive, an optical disk, a hard disk, etc. When the computer executable instruction information stored in the storage medium is executed by the processor, the following process can be implemented:

[0155] Receiving graphical configuration operations of the user on the application development platform for application components;

[0156] Parsing the graphical configuration operation to determine a layer of source code mapping between the graphical configuration operation and a predefined code, and generating a target code corresponding to the graphical configuration operation based on the layer of source code mapping;

[0157] Performing code parsing processing on the target code to determine a two-layer source code mapping between the target code and a syntax tree, and generating a target syntax tree corresponding to the target code based on the two-layer source code mapping, wherein the target syntax tree at least includes an application element domain sublanguage having application element programming semantics;

[0158] Performing code conversion processing on the target syntax tree, determining a three-layer source code mapping between the syntax tree and the source code, and translating the target syntax tree according to the three-layer source code mapping to obtain a target object;

[0159] A target application corresponding to the graphical configuration operation is generated according to the target object.

[0160] Each embodiment in this specification is described in a progressive manner, and the same or similar parts between the embodiments can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the above-mentioned storage medium embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and the relevant parts can be referred to the partial description of the method embodiment.

[0161] The embodiment of this specification provides a storage medium, which can receive the graphical configuration operation of the user on the application component in the application development platform, parse the graphical configuration operation, determine the first layer of source code mapping between the graphical configuration operation and the predefined code, and generate the target code corresponding to the graphical configuration operation based on the first layer of source code mapping, perform code parsing on the target code, determine the second layer of source code mapping between the target code and the syntax tree, and generate the target syntax tree corresponding to the target code based on the second layer of source code mapping, wherein the target syntax tree can at least include the application element domain sublanguage with the application element programming semantics, perform code conversion on the target syntax tree, determine the third layer of source code mapping between the syntax tree and the source code, and translate the target syntax tree according to the three layers of source code mapping to obtain the target object, and generate the target application corresponding to the graphical configuration operation according to the target object. In this way, firstly, a full coverage description of each element of the low-code application can be achieved through a unified syntax definition, shielding the differences in the underlying technologies of different elements and the diversity of modeling methods, and providing a basis for unifying the discrete and diverse modeling methods of low-code applications. Secondly, with the target syntax tree as the core, through three source code mappings (i.e., first-layer source code mapping, second-layer source code mapping, and third-layer source code mapping), the mapping transformation from application modeling graphical configuration to target code, from target code to target syntax tree, and from target syntax tree to target object is completed, thereby realizing the unification of low-code application modeling methods and effectively improving the development efficiency of applications.

[0162] Furthermore, based on the above Figures 1 to 4 In one or more embodiments of the present specification, a computer program product is provided, including a computer program. When the computer program in the computer program product is executed by a processor, the following process can be implemented:

[0163] Receiving graphical configuration operations of the user on the application development platform for application components;

[0164] Parsing the graphical configuration operation to determine a layer of source code mapping between the graphical configuration operation and a predefined code, and generating a target code corresponding to the graphical configuration operation based on the layer of source code mapping;

[0165] Performing code parsing processing on the target code to determine a two-layer source code mapping between the target code and a syntax tree, and generating a target syntax tree corresponding to the target code based on the two-layer source code mapping, wherein the target syntax tree at least includes an application element domain sublanguage having application element programming semantics;

[0166] Performing code conversion processing on the target syntax tree, determining a three-layer source code mapping between the syntax tree and the source code, and translating the target syntax tree according to the three-layer source code mapping to obtain a target object;

[0167] A target application corresponding to the graphical configuration operation is generated according to the target object.

[0168] Each embodiment in this specification is described in a progressive manner, and the same or similar parts between the embodiments can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the above-mentioned computer program product embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and the relevant parts can be referred to the partial description of the method embodiment.

[0169] The embodiments of this specification provide a computer program product that can receive a user's graphical configuration operation for an application component in an application development platform, parse the graphical configuration operation, determine a layer of source code mapping between the graphical configuration operation and a predefined code, and based on the layer of source code mapping, generate a target code corresponding to the graphical configuration operation, perform code parsing on the target code, determine a second layer of source code mapping between the target code and a syntax tree, and based on the second layer of source code mapping, generate a target syntax tree corresponding to the target code, wherein the target syntax tree may at least include an application element domain sublanguage having application element programming semantics, perform code conversion on the target syntax tree, determine a third layer of source code mapping between the syntax tree and the source code, and translate the target syntax tree according to the three layers of source code mapping to obtain a target object, and generate a target application corresponding to the graphical configuration operation according to the target object. In this way, firstly, a unified syntax definition can be used to achieve a full coverage description of each element of a low-code application, shielding the differences in the underlying technologies of different elements and the diversity of modeling methods, providing a basis for unifying discrete and diverse modeling methods for low-code applications. Secondly, with the target syntax tree as the core, through three source code mappings (i.e., first-layer source code mapping, second-layer source code mapping, and third-layer source code mapping), the mapping transformation from application modeling graphical configuration to target code, from target code to target syntax tree, and from target syntax tree to target object is completed, thereby realizing the unification of low-code application modeling methods and effectively improving the development efficiency of applications.

[0170] The above is a description of a specific embodiment of the specification. Other embodiments are within the scope of the appended claims. In some cases, the actions or steps recorded in the claims can be performed in an order different from that in the embodiments and still achieve the desired results. In addition, the processes depicted in the drawings do not necessarily require the specific order or continuous order shown to achieve the desired results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

[0171] In the 1990s, it was very clear whether the improvement of a technology was hardware improvement (for example, improvement of the circuit structure of diodes, transistors, switches, etc.) or software improvement (improvement of the method flow). However, with the development of technology, many improvements of the method flow today can be regarded as direct improvements of the hardware circuit structure. Designers almost always obtain the corresponding hardware circuit structure by programming the improved method flow into the hardware circuit. Therefore, it cannot be said that the improvement of a method flow cannot be implemented with a hardware entity module. For example, a programmable logic device (PLD) (such as a field programmable gate array (FPGA)) is such an integrated circuit whose logical function is determined by the user's programming of the device. Designers can "integrate" a digital system on a PLD by programming themselves, without having to ask chip manufacturers to design and make dedicated integrated circuit chips. Moreover, nowadays, instead of manually making integrated circuit chips, this kind of programming is mostly implemented by "logic compiler" software, which is similar to the software compiler used when developing and writing programs, and the original code before compilation must also be written in a specific programming language, which is called hardware description language (HDL). There is not only one kind of HDL, but many kinds, such as ABEL (Advanced Boolean Expression Language), AHDL (Altera Hardware Description Language), Confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), Lava, Lola, MyHDL, PALASM, RHDL (Ruby Hardware Description Language), etc. The most commonly used ones are VHDL (Very-High-Speed ​​Integrated Circuit Hardware Description Language) and Verilog. Those skilled in the art should also know that it is only necessary to program the method flow slightly in the above-mentioned hardware description languages ​​and program it into the integrated circuit, and then it is easy to obtain the hardware circuit that implements the logic method flow.

[0172] The controller may be implemented in any suitable manner, for example, the controller may take the form of a microprocessor or processor and a computer-readable medium storing a computer-readable program code (such as software or firmware) executable by the (micro)processor, a logic gate, a switch, an application-specific integrated circuit (ASIC), a programmable logic controller, and an embedded microcontroller. Examples of controllers include, but are not limited to, the following microcontrollers: ARC 625D, Atmel AT91SAM, Microchip PIC18F26K20, and Silicone Labs C8051F320. The memory controller may also be implemented as part of the control logic of the memory. It is also known to those skilled in the art that, in addition to implementing the controller in a purely computer-readable program code manner, the controller may be implemented in the form of a logic gate, a switch, an application-specific integrated circuit, a programmable logic controller, and an embedded microcontroller by logically programming the method steps. Therefore, such a controller may be considered as a hardware component, and the devices for implementing various functions included therein may also be considered as structures within the hardware component. Or even, the devices for implementing various functions may be considered as both software modules for implementing the method and structures within the hardware component.

[0173] The systems, devices, modules or units described in the above embodiments may be implemented by computer chips or entities, or by products with certain functions. A typical implementation device is a computer. Specifically, the computer may be, for example, a personal computer, a laptop computer, a cellular phone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.

[0174] For the convenience of description, the above devices are described in terms of functions and are divided into various units. Of course, when implementing one or more embodiments of this specification, the functions of each unit can be implemented in the same or multiple software and / or hardware.

[0175] Those skilled in the art will appreciate that the embodiments of this specification may be provided as methods, systems, or computer program products. Therefore, one or more embodiments of this specification may take the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware. Moreover, one or more embodiments of this specification may take the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program codes.

[0176] The embodiments of this specification are described with reference to flowcharts and / or block diagrams of methods, devices (systems), and computer program products according to the embodiments of this specification. It should be understood that each process and / or box in the flowchart and / or block diagram, as well as the combination of processes and / or boxes in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable fraud case serial and parallel device to produce a machine, so that the instructions executed by the processor of the computer or other programmable fraud case serial and parallel device generate instructions for implementing the processes in the process. Figure 1 A process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.

[0177] These computer program instructions may also be stored in a computer readable memory capable of directing a computer or other programmable fraud case serial and parallel device to operate in a specific manner, so that the instructions stored in the computer readable memory produce an article of manufacture including an instruction device, which implements the process Figure 1 A process or multiple processes and / or boxes Figure 1 A function specified in one or more boxes.

[0178] These computer program instructions may also be loaded onto a computer or other programmable device so that a series of operating steps are executed on the computer or other programmable device to produce a computer-implemented process, whereby the instructions executed on the computer or other programmable device provide for implementing the process. Figure 1 A process or multiple processes and / or boxes Figure 1 The steps for the functions specified in one or more boxes.

[0179] In a typical configuration, a computing device includes one or more processors (CPU), input / output interfaces, network interfaces, and memory.

[0180] Memory may include non-permanent storage in a computer-readable medium, random access memory (RAM) and / or non-volatile memory in the form of read-only memory (ROM) or flash RAM. Memory is an example of a computer-readable medium.

[0181] Computer readable media include permanent and non-permanent, removable and non-removable media that can be implemented by any method or technology to store information. Information can be computer readable instructions, data structures, program modules or other data. Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disk read-only memory (CD-ROM), digital versatile disk (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices or any other non-transmission media that can be used to store information that can be accessed by a computing device. As defined in this article, computer readable media does not include temporary computer readable media (transitory media), such as modulated data signals and carrier waves.

[0182] It should also be noted that the terms "include", "comprises" or any other variations thereof are intended to cover non-exclusive inclusion, so that a process, method, commodity or device including a series of elements includes not only those elements, but also other elements not explicitly listed, or also includes elements inherent to such process, method, commodity or device. In the absence of more restrictions, the elements defined by the sentence "comprises a ..." do not exclude the existence of other identical elements in the process, method, commodity or device including the elements.

[0183] Those skilled in the art will appreciate that the embodiments of this specification may be provided as methods, systems or computer program products. Therefore, one or more embodiments of this specification may be in the form of a complete hardware embodiment, a complete software embodiment or an embodiment combining software and hardware. Furthermore, one or more embodiments of this specification may be in the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program code.

[0184] One or more embodiments of the present specification may be described in the general context of computer-executable instructions executed by a computer, such as program modules. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform specific tasks or implement specific abstract data types. One or more embodiments of the present specification may also be practiced in distributed computing environments where tasks are performed by remote processing devices connected through a communication network. In a distributed computing environment, program modules may be located in local and remote computer storage media, including storage devices.

[0185] Each embodiment in this specification is described in a progressive manner, and the same or similar parts between the embodiments can be referred to each other, and each embodiment focuses on the differences from other embodiments. In particular, for the system embodiment, since it is basically similar to the method embodiment, the description is relatively simple, and the relevant parts can be referred to the partial description of the method embodiment.

[0186] The above description is only an embodiment of this specification and is not intended to limit this document. For those skilled in the art, this specification may have various changes and variations. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of this specification should be included in the scope of the claims of this specification.

Claims

1. An application generation method, characterized in that: The method comprises: Receiving graphical configuration operations of the user on the application development platform for application components; Parsing the graphical configuration operation to determine a layer of source code mapping between the graphical configuration operation and a predefined code, and generating a target code corresponding to the graphical configuration operation based on the layer of source code mapping; Performing code parsing processing on the target code, determining a two-layer source code mapping between the target code and a syntax tree, and generating a target syntax tree corresponding to the target code based on the two-layer source code mapping, wherein the target syntax tree includes at least an application element domain sub-language having application element programming semantics, and the application element domain sub-language includes at least a data model sub-language, a process sub-language, a visualization page sub-language, and a business rule sub-language; Performing code conversion processing on the target syntax tree, determining a three-layer source code mapping between the syntax tree and the source code, and translating the target syntax tree according to the three-layer source code mapping to obtain a target object, wherein the target object includes a front-end sub-object corresponding to the first source code and a back-end sub-object corresponding to the second source code, the first source code being a source code obtained by performing code conversion processing on the visual page sub-language in the target syntax tree in the three-layer source code mapping, and the second source code being a source code obtained by performing code conversion processing on the data model sub-language, the process sub-language, and the business rule sub-language in the target syntax tree; A target application corresponding to the graphical configuration operation is generated according to the target object.

2. The method according to claim 1, characterized in that: The code parsing process is performed on the target code to determine a two-layer source code mapping between the target code and a syntax tree, and based on the two-layer source code mapping, a target syntax tree corresponding to the target code is generated, including: Performing lexical analysis on the target code to perform symbol segmentation on the target code to obtain a symbol table corresponding to the target code; Performing syntax analysis on the symbol table corresponding to the target code to obtain a two-layer source code mapping between the target code and the syntax tree, and generating a first syntax tree corresponding to the target code based on the two-layer source code mapping; The first syntax tree is subjected to semantic analysis processing to perform type conversion processing on semantic nodes in the first syntax tree to obtain a target syntax tree corresponding to the target code.

3. The method according to claim 1, characterized in that The code conversion process is performed on the target syntax tree to determine a three-layer source code mapping between the syntax tree and the source code, including: Performing code conversion processing on the visualization page sub-language in the target syntax tree to determine the first source code, and performing code conversion processing on the data model sub-language, the process sub-language, and the business rule sub-language in the target syntax tree to determine the second source code; A three-layer source code mapping between the syntax tree and the source code is determined according to the first source code and the second source code.

4. The method according to claim 1, characterized in that: The target code is stored in JSON format, and the syntax of the target code is constructed according to semantic nodes, sub-nodes, attributes of the semantic nodes and attribute values.

5. An application generating device, characterized in that: The device comprises: An operation receiving module, used for receiving a user's graphical configuration operation for an application component in an application development platform; A first mapping module, configured to parse the graphical configuration operation, determine a layer of source code mapping between the graphical configuration operation and a predefined code, and generate a target code corresponding to the graphical configuration operation based on the layer of source code mapping; A second mapping module is used to perform code parsing processing on the target code, determine a two-layer source code mapping between the target code and a syntax tree, and generate a target syntax tree corresponding to the target code based on the two-layer source code mapping, wherein the target syntax tree at least includes an application element domain sub-language with application element programming semantics, and the application element domain sub-language at least includes a data model sub-language, a process sub-language, a visualization page sub-language, and a business rule sub-language; a third mapping module, configured to perform code conversion processing on the target syntax tree, determine a three-layer source code mapping between the syntax tree and the source code, and translate the target syntax tree according to the three-layer source code mapping to obtain a target object, wherein the target object includes a front-end sub-object corresponding to the first source code and a back-end sub-object corresponding to the second source code, wherein the first source code is a source code obtained by performing code conversion processing on the visual page sub-language in the target syntax tree in the three-layer source code mapping, and the second source code is a source code obtained by performing code conversion processing on the data model sub-language, the process sub-language, and the business rule sub-language in the target syntax tree; The application generation model is used to generate a target application corresponding to the graphical configuration operation according to the target object.

6. An application generation device, characterized in that: The invention comprises a processor, a memory and a computer program stored in the memory and executable on the processor, wherein the computer program implements the steps of the application generation method according to any one of claims 1 to 4 when executed by the processor.

7. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores a computer program, and when the computer program is executed by a processor, the steps of the application generation method according to any one of claims 1 to 4 are implemented.

8. A computer program product, characterized in that The invention comprises a computer program, which implements the steps of the application generation method according to any one of claims 1 to 4 when being executed by a processor.

Images