CN117234465A

CN117234465A - Code generation method, device, equipment and storage medium based on markup language

Info

Publication number: CN117234465A
Application number: CN202210635732.2A
Authority: CN
Inventors: 章天野
Original assignee: Beijing Zitiao Network Technology Co Ltd
Current assignee: Beijing Zitiao Network Technology Co Ltd
Priority date: 2022-06-06
Filing date: 2022-06-06
Publication date: 2023-12-15

Abstract

The embodiment of the disclosure provides a code generation method, a device, equipment and a storage medium based on a markup language, wherein the method comprises the following steps: acquiring a markup language code segment in a preset grammar format input by a user, and determining code elements to be referenced from the markup language code segment; the mark language code segment is used for representing that the source codes corresponding to the code elements are introduced into preset original codes; the code elements characterize the declaration type in the markup language code segment; acquiring source codes corresponding to the code elements; and introducing the source code into a preset original code according to the mark language code segment to generate an object code. The method and the device have the advantages that the code elements in the markup language code segment are determined according to the preset grammar format, the source codes corresponding to the code elements are directly introduced into the original codes, and the code generation efficiency and the code generation precision are improved.

Description

Code generation method, device, equipment and storage medium based on markup language

Technical Field

The embodiment of the disclosure relates to the technical field of computers, in particular to a code generation method, device and equipment based on a markup language and a storage medium.

Background

In the context of writing documents, etc., reference is often made to existing source code located in a code repository. When a developer writes a technical document locally or online, different types, fields, methods and other declaration types are mentioned in the document, and source codes corresponding to the mentioned declaration types are added into preset original codes.

Currently, this method is generally described in text to indicate the type of declaration that needs to be cited, for example, the helloWorld method in com.

However, this approach is not easily structured and can only be used for staff understanding the type of statement that is being introduced. And a worker is required to manually introduce source codes corresponding to the declaration types into the original codes to generate target codes. The labor and time are wasted, and the efficiency and the precision of code generation are low.

Disclosure of Invention

The embodiment of the disclosure provides a code generation method, device and equipment based on a markup language and a storage medium, so as to improve the efficiency and precision of code generation.

In a first aspect, an embodiment of the present disclosure provides a method for generating a code based on a markup language, including:

Acquiring a markup language code segment in a preset grammar format input by a user, and determining code elements to be referenced from the markup language code segment; the mark language code segment is used for representing that the source codes corresponding to the code elements are introduced into preset original codes; the code elements characterize the declaration type in the markup language code segment;

acquiring source codes corresponding to the code elements;

and introducing the source code into a preset original code according to the mark language code segment to generate an object code.

In a second aspect, an embodiment of the present disclosure provides a code generating apparatus based on a markup language, including:

the code element determining module is used for acquiring a markup language code segment in a preset grammar format input by a user and determining code elements to be referenced from the markup language code segment; the mark language code segment is used for representing that the source codes corresponding to the code elements are introduced into preset original codes; the code elements characterize the declaration type in the markup language code segment;

the source code acquisition module is used for acquiring source codes corresponding to the code elements;

and the target code generation module is used for introducing the source code into a preset original code according to the mark language code segment to generate a target code.

In a third aspect, an embodiment of the present disclosure provides an electronic device, including: a processor and a memory;

the memory stores computer-executable instructions;

the processor executes the computer-executable instructions stored in the memory to cause the at least one processor to perform the markup language-based code generation method of the first aspect and the various possible designs of the first aspect as described above.

In a fourth aspect, embodiments of the present disclosure provide a computer-readable storage medium having stored therein computer-executable instructions which, when executed by a processor, implement the markup language-based code generation method according to the above first aspect and the various possible designs of the first aspect.

In a fifth aspect, embodiments of the present disclosure provide a computer program product comprising a computer program which, when executed by a processor, implements the markup language-based code generation method of the first aspect and the various possible designs of the first aspect as described above.

The embodiment provides a code generation method, device, equipment and storage medium based on a markup language. And acquiring a preset source code corresponding to the code field, and inserting the source code into a preset original code to obtain an object code. The method and the device have the advantages that the code elements in the code section of the markup language are determined according to the preset grammar format, the source codes corresponding to the code elements are automatically introduced into the original codes by the description of the code section, the source codes are not required to be manually introduced by staff, the labor and time are saved, and the efficiency and the precision of code generation are improved.

Drawings

In order to more clearly illustrate the embodiments of the present disclosure or the solutions in the prior art, a brief description will be given below of the drawings that are needed in the embodiments or the description of the prior art, it being obvious that the drawings in the following description are some embodiments of the present disclosure, and that other drawings may be obtained from these drawings without inventive effort to a person of ordinary skill in the art.

FIG. 1 is a schematic flow chart of a code generation method based on a markup language according to an embodiment of the present disclosure;

FIG. 2 is a flow chart of a method for generating code based on a markup language according to an embodiment of the present disclosure;

FIG. 3 is a flowchart of a code generation method based on a markup language according to an embodiment of the present disclosure;

FIG. 4 is a flowchart of a code generation method based on a markup language according to an embodiment of the present disclosure;

FIG. 5 is a schematic diagram of a code generating device based on a markup language according to an embodiment of the present disclosure;

fig. 6 is a schematic structural diagram of an electronic device according to an embodiment of the disclosure.

Detailed Description

In order to make the objects, technical solutions and advantages of the present application more apparent, the following detailed description of the embodiments of the present application will be given with reference to the accompanying drawings.

It should be understood that the described embodiments are merely some, but not all, embodiments of the application. All other embodiments, which can be made by those skilled in the art based on the embodiments of the application without making any inventive effort, are intended to be within the scope of the application.

When the following description refers to the accompanying drawings, the same numbers in different drawings refer to the same or similar elements, unless otherwise indicated. The implementations described in the following exemplary examples do not represent all implementations consistent with the application. Rather, they are merely examples of apparatus and methods consistent with certain aspects of the application as detailed in the accompanying claims.

In the description of the present application, it should be understood that the terms "first," "second," "third," and the like are used merely to distinguish between similar objects and are not necessarily used to describe a particular order or sequence, nor should they be construed to indicate or imply relative importance. The specific meaning of the above terms in the present application can be understood by those of ordinary skill in the art according to the specific circumstances. Furthermore, in the description of the present application, unless otherwise indicated, "a plurality" means two or more. "and/or", describes an association relationship of an association object, and indicates that there may be three relationships, for example, a and/or B, and may indicate: a exists alone, A and B exist together, and B exists alone. The character "/" generally indicates that the context-dependent object is an "or" relationship.

It should be noted that the present disclosure is not limited to all the alternative embodiments, and those skilled in the art who review this disclosure will recognize that any combination of the features may be used to construct the alternative embodiments as long as the features are not mutually inconsistent. The following describes each embodiment in detail.

Fig. 1 is a schematic flow chart of a code generating method based on a markup language according to an embodiment of the disclosure. The method of the present embodiment may be applied to a terminal device or a server, as shown in fig. 1, and includes:

s101, acquiring a markup language code segment in a preset grammar format input by a user, and determining code elements to be referenced from the markup language code segment; the mark language code segment is used for representing that the source codes corresponding to the code elements are introduced into the preset original codes; the code elements characterize the declaration types in the markup language code fragments.

Wherein, the grammar format of the mark language code segment is preset, and the grammar format prescribes the representation meaning of each line of codes in the mark language code segment. For example, it may be provided that the first line of code in the markup language code fragment represents the language type of the source code of the code element to be referenced, which may be JAVA or Kotlin, etc. It may also be provided that the second row code represents the code element to be referenced, and that the code element may be represented by its name. The code elements are declaration types referred to in the code, which may be classes, fields, or methods, for example.

The markup language code segment includes code elements entered by a user, for example, the user can write names of the code elements into the markup language code segment. Each code element is pre-corresponding to a section of source code, and the markup language code section is used for representing that the source code corresponding to the code element is introduced into a preset original code, and the code element represents the declaration type in the markup language code section.

The user inputs a markup language code segment in the technical document according to a preset grammar format, wherein the markup language code segment comprises code elements to be referenced input by the user. The technical document may be in the mdx format. Code elements to be referenced are determined from the markup language code segment. For example, the markup language code fragments are:

@class("com.android.demo.Main"){

method("normalMethod"),

}

the markup language code segment is written in a preset grammar format, and according to the preset grammar format, the code element class and the code element method to be referenced can be determined from the markup language code segment. For example, the class is represented after @ class, and the method is represented after method. In the markup language code segment, the class in the code element can be determined to be 'com. Android. Demo. Main', and the method is a 'normal method' method in the class.

S102, acquiring source codes corresponding to the code elements.

Wherein each code element is associated with a segment of source code, which is represented as a particular piece of execution code for the code element. The association relation between each code element and the source code is stored in advance, and after the code element to be referenced is determined, the corresponding source code is determined from the preset association relation.

S103, introducing the source code into a preset original code according to the mark language code segment to generate an object code.

Wherein, the user inputs a markup language code segment in the technical document, and the technical document before inputting the markup language code segment corresponds to a segment of original code. For example, document contents in a technical document of. Mdx may be converted into a form of code in advance, resulting in an original code. The technical document and the original code may be displayed on a visual interface, for example, the technical document in the left half of the page and a preview of the original code in the right half of the page.

After the source code of the code element is determined, the source code is inserted into the original code, that is, the source code is combined with the original code, so as to obtain the target code. For example, the code element to be introduced in the markup language code segment is a normal method in the com.android.remo.main class, and the source code corresponding to the normal method is determined as follows:

The source code may be automatically inserted into the pre-generated original code to obtain the target code. The target code inserted with the source code can be previewed in the visual interface, so that the user can conveniently check and adjust the target code.

The embodiment of the disclosure provides a code generation method based on a markup language, which comprises the steps of obtaining a markup language code segment written by a user in a preset grammar format, and obtaining code elements such as classes, fields or methods to be referred from the markup language code segment. And acquiring a preset source code corresponding to the code field, and inserting the source code into a preset original code to obtain an object code. The method and the device have the advantages that the code elements in the markup language code segments are determined according to the preset grammar format, the source codes corresponding to the code elements are automatically introduced into the original codes through short code segment description, workers are not required to manually determine the source codes, labor and time are saved, and the efficiency and the precision of code generation are improved.

Fig. 2 is a schematic flow chart of a code generating method based on a markup language according to an embodiment of the present disclosure, where the embodiment is an alternative embodiment of the foregoing embodiment.

In this embodiment, determining the code elements to be referenced from the markup language code segment may be refined as: and identifying the code elements to be referenced from the markup language code segment according to a preset grammar format identification rule.

As shown in fig. 2, the method includes:

s201, obtaining a markup language code segment in a preset grammar format input by a user.

S202, identifying code elements to be referenced from the markup language code segments according to a preset grammar format identification rule.

The user writes the markup language code segment according to a preset grammar format, and in order to accurately identify the code elements in the markup language code segment, grammar format identification rules can be preset according to the grammar format. Grammar format recognition rules may be used to identify content in a markup language code segment, determining code elements to be referenced. That is, according to the grammar format recognition rule, the character representing the code element can be rapidly recognized from the markup language code segment or the position of the code element is determined, so that the code element to be referenced is obtained, the source code of the code element is conveniently determined subsequently, and the generation efficiency and the precision of the target code are improved.

For example, each code element is represented by a preset number in a grammar format, and the grammar format recognition rule is that numbers in the markup language code segment are recognized, and the code elements are determined according to the recognized numbers. For another example, in the grammar format, a predetermined symbol is input before the code element, and the grammar format recognition rule may be to recognize the predetermined symbol and determine a character string after the predetermined symbol as the code element. For another example, the grammar format specifies the location of the second line code element, and thus the grammar format recognition rule may be to recognize the location of the second line code in the markup language code segment and determine the character string at the location of the second line code as the code element.

In this embodiment, identifying the code element to be referenced from the markup language code segment according to the preset grammar format identification rule includes: identifying a preset code element identifier from the markup language code segment; code elements in the markup language code segment are determined based on the code element identifiers.

Specifically, the code element identifier is preset, and the user can write the code element identifier into the markup language code segment according to the grammar format. The code element identifier is identified from the markup language code segment, the code element identifier is determined to be the code element, or the position of the code element is determined according to the code element identifier, and the code element is identified at the position of the code element.

For example, the code element identifiers corresponding to the code elements can be preset, after the markup language code segment is obtained, whether the preset code element identifiers can be identified in the markup language code segment is judged, if the code element identifiers exist, the association relationship between the preset code elements and the code element identifiers is determined, and the corresponding code elements are determined; if not, it is determined that the user has not entered a code element in the markup language code segment.

For another example, the code element identifier may be expressed as that a preset number of characters after the code element identifier are code elements, and then the code element identifier may be identified from the markup language code segment, then the preset number of characters after the code element identifier is identified, and the preset number of characters is determined as the code elements.

The method has the advantages that the code elements can be quickly and accurately identified according to the code element identifiers, the standardization of the markup language is improved, the computer is convenient to understand, the source codes of the code elements are automatically determined, and the determination efficiency and accuracy of the target codes are improved.

In this embodiment, the code element identifier includes an element name identifier of the code element; determining code elements in the markup language code segment from the code element identifiers, comprising: the element names of the code elements at the preset element name input positions after the element name identifiers in the markup language code segment are determined.

Specifically, each code element corresponds to an element name of the code element, and when writing a markup language code segment, a user can input the element name of the code element to represent the code element to be referenced.

The code element identifier may include an element name identifier of the code element for indicating an element name of the code element at a preset position after the element name identifier. And setting a preset position behind the element name identifier as an element name input position. That is, the user needs to input the element name at the element name input position after the element name identifier. For example, the element name identifier is a symbol @, the element name input position is a position that is located in the same line as the symbol @ after the symbol @, a character string at the element name input position is recognized, and the recognized character string is determined as the element name of the code element.

The element name identifier may also be @ (") and the position within the double-quote in brackets is the input position of the element name, and thus, the character string within the brackets may be determined as the element name. For example, there is a line of code in a markup language code segment: "com.android.demo.main"), then the element name is com.android.demo.main.

Code elements may include classes, fields, methods, etc., and different element name identifiers may be set for different code elements. In this embodiment, for a code element of a class, the element name identifier may be @ class ("); for code elements of a method, the element name identifier may be method ("); for code elements of a field, the element name identifier may be field ("). For example, the code of the markup language code segment is @ class ("com. Android. Demo. Main"), then the code element may be determined to be a class whose element name is com. Android. Demo. Main.

The beneficial effects of setting up like this are that the user only need the element name of input code element, reduces user's input degree of difficulty greatly, practices thrift manpower and time. By identifying the element name identifier, the determination accuracy and efficiency of the element name are improved, and the determination accuracy and efficiency of the target code are further improved.

S203, acquiring source codes corresponding to the code elements.

Wherein after determining the code element, a source code corresponding to the code element is determined, e.g., a source code corresponding to an element name of the code element may be determined.

In this embodiment, acquiring source code corresponding to a code element includes: and determining the source code corresponding to the element name of the code element according to the association relation between the preset element name and the source code.

Specifically, the association relation between each element name and the source code is preset, and after the element name of the code element is determined, the source code corresponding to the element name is searched from the preset association relation and is used as the source code of the code element. That is, the user can automatically determine the source code by simply inputting the element name.

The method has the advantages that the source codes corresponding to the element names are automatically determined, the workload of a user is reduced, manual input by the user is not needed, labor and time are saved, and the generation efficiency and the accuracy of the target codes are improved.

In this embodiment, the code element identifier includes an element location identifier of the code element; acquiring source codes corresponding to code elements, including: identifying an element location identifier of a code element from the markup language code; determining a target position of the code element according to the element position identifier; and acquiring the source codes of the code elements corresponding to the element names from the target positions according to the association relation between the element names and the source codes in the preset target positions.

Specifically, the code element identifier may further include an element location identifier of the code element, where the element location identifier indicates a node location of the code element in the preset syntax tree. The syntax tree may be an AST (Abstract Syntax Tree ), each node in the syntax tree may represent one code element, e.g. the nodes in the syntax tree may be represented as classes, fields or methods etc. A class may be a parent node of a child class, field, or method, i.e., a child class, field, and method may be child nodes of a class. If the code element is a class, the node position of the code element in the syntax tree can indicate which class the code element is in; if the code element is a field, the node position of the code element in the syntax tree can indicate the class to which the code element belongs and which field under the class the code element belongs; if the code element is a method, the node position of the code element in the syntax tree may indicate the class to which the code element belongs and which method under the class the code element belongs.

Different code elements may have the same element name, and after determining the element name of the code element, there may be a case that an error source code is found, so that the position of the code element in the syntax tree may be determined according to the element position identifier, and a correct source code is obtained. Determining the position of the code element in the syntax tree may be determining a parent node of the code element. For example, a code element is a field, the code element is a node whose element name is "abc", and there are a plurality of fields named "abc" in the syntax tree. The name of the parent node identifying the code element in the markup language code segment according to the element location identifier may be the name of the class to which the code element belongs. A child node named as abc under the node of the class is determined from the syntax tree, and the source code corresponding to the child node is the source code of the code element to be referenced.

That is, from the element location identifier, a target location of the code element may be determined. For example, the code element is a field, and all node positions under the class to which the field belongs may be determined as target positions, where the position of the field is determined. For example, the association relation between each element name under each class and the source code is associated in advance, after the target position is determined, the element name of the code element to be referenced is searched for from the target position, and the source code is determined according to the association relation.

The element position identifier may be used to directly represent the position of the code element, or a character string at an element position input position preset after the element position identifier may be determined as the element position of the code element. For example, presetting element position identifiers corresponding to different element positions, and determining corresponding element positions according to the identified element position identifiers; a fixed element position identifier may also be preset, and a character string located at a preset position after the element position identifier in the markup language code segment is determined as the element position.

By way of example, the markup language code fragments are:

@class("com.android.demo.Main"){

method("normalMethod"),

}

where @ class (") is an element location identifier, and method is an element name identifier, then the source code of the normal method can be found from the com.

The method has the advantages that the source codes of the code elements to be referenced can be accurately found, source code confusion among the code elements with the same element names is avoided, and the generation precision of the target codes is improved.

S204, introducing the source code into a preset original code according to the mark language code segment to generate an object code.

After the object code is generated, if the source code of the referenced code element changes, and the name of the element corresponding to the source code does not change, the user does not need to manually modify the object code, the source code can be automatically updated in the object code, and the updated source code is reintroduced into the object code.

Fig. 3 is a schematic flow chart of a code generating method based on a markup language according to an embodiment of the present disclosure, where the embodiment is an alternative embodiment of the foregoing embodiment.

In this embodiment, the markup language code segment of the preset grammar format input by the user is obtained, which may be refined as follows: acquiring a markup language code segment of a preset grammar format input by a user based on a data file to be edited; the data file to be edited is used to generate the original code and to represent the code logic of the original code.

As shown in fig. 3, the method includes:

s301, acquiring a markup language code segment of a preset grammar format input by a user based on a data file to be edited; the data file to be edited is used to generate the original code and to represent the code logic of the original code.

The data file to be edited may be a technical document written locally or on line, and the data file to be edited may be a file written in a lightweight markup language, for example, a file in a mdx format of a markdown syntax. The user inputs a markup language code segment with a preset grammar format in the data file to be edited, and can preview the target code on a visual interface. Before the markup language code segment is entered, the code of the preview generated by the data file to be edited is the original code. Through the data file to be edited, the user can input the markup language code segment at any time, and the workload of code modification is reduced.

In this embodiment, after obtaining the markup language code segment in the preset grammar format input by the user based on the data file to be edited, the method further includes: the input position of the markup language code segment in the data file to be edited is determined.

Specifically, the user may input the markup language code segment at any position of the data file to be edited, but if the source code corresponding to the markup language code segment is inserted into a different position of the original code, different target codes will be obtained. Therefore, it is necessary to determine the introduction position of the source code in the original code.

The position of introduction of the source code in the original code is related to the position of entry of the markup language code segment in the data file to be edited. The input position of the markup language code segment in the data file to be edited may be determined, for example, what line of the markup language code segment in the data file to be edited may be determined as the input position.

The method has the advantages that the input position of the markup language code segment is favorable for determining the introduction position of the source code, and the generation precision of the target code is improved.

S302, determining code elements to be referenced from the markup language code segment.

S303, acquiring source codes corresponding to the code elements.

S304, introducing the source code into a preset original code according to the mark language code segment to generate an object code.

The source code is introduced into the original code, the introduction position refers to the position of the source code in the target code, the introduction positions are different, and the generated target code is different.

In this embodiment, the step of introducing the source code into the preset original code according to the markup language code segment includes: determining the introduction position of the source code in the original code according to the input position of the mark language code segment in the data file to be edited; the source code is introduced into a preset introduction position of the original code.

Specifically, the input position of the markup language code segment in the data file to be edited is determined, the corresponding position in the original code is found according to the input position, and the found corresponding position is determined as the introduction position. For example, the input position is between the first document and the second document in the data file to be edited, and the lead-in position is between the code converted by the first document and the code converted by the second document in the original code. That is, the logical order expressed by the data file to be edited is made to coincide with the logical order expressed by the object code.

And inserting the source code corresponding to the code element to be introduced into the introduction position, and combining the source code with the original code to obtain the target code.

The method has the advantages that the input position corresponds to the introduction position, so that the target code is generated according to logic of the data file to be edited of the user, and the generation precision of the target code is improved.

Fig. 4 is a schematic flow chart of a code generating method based on a markup language according to an embodiment of the present disclosure, where the embodiment is an alternative embodiment of the foregoing embodiment.

In this embodiment, the code element identifier includes a language type identifier of the code element, and the source code is introduced into the preset original code according to the markup language code segment, which can be thinned as follows: determining a target language type of the code element according to the language type identifier in the markup language code segment; and converting the source codes of the code elements into target language types, and introducing the target language types into preset original codes.

As shown in fig. 4, the method includes:

s401, acquiring a markup language code segment in a preset grammar format input by a user, and determining code elements to be referenced from the markup language code segment; the mark language code segment is used for representing that the source codes corresponding to the code elements are introduced into the preset original codes; the code elements characterize the declaration types in the markup language code fragments.

S402, acquiring source codes corresponding to the code elements.

S403, determining the target language type of the code element according to the language type identifier in the markup language code segment.

The code element identifier may further include a language type identifier of the code element, where the language type identifier is used to determine a language type of the source code when the source code is inserted into the object code. The language types may include JAVA or Kotlin, etc. A language type identifier in the markup language code segment is identified, and a target language type of the code element is determined. For example, language type identifiers corresponding to different language types may be preset, and after the language type identifier is identified, the language type corresponding to the language type identifier may be directly searched for as the target language type.

A fixed language type identifier may also be provided and the user may enter the target language type after the language type is identified. After the language type identifier is identified, the character string after the language type identifier is identified, and the target language type is obtained. For example, if the language type identifier is @ lang ("), and the markup language code segment input by the user includes @ lang (" JAVA "), then the target language type may be determined to be JAVA.

In this embodiment, the language type identifier is located in the first line of the markup language code segment.

Specifically, the syntax format of the markup language is preset, and the language type identifier may be set in the first line. For example, the markup language code fragments are:

the first line of the markup language code segment represents the language type and is JAVA; the second row represents the element position of the code element, in the com. The third line represents the name of the code element, the normal method. The language type identifier is located in the first row and is used for designating the language of the source code, if the source code has only one language, the language type instruction can be omitted, and if the source code has a plurality of language forms, the language type of the source code needs to be designated, so that language confusion is avoided. The root node in the general syntax tree needs to specify a language type when it is a package.

S404, converting the source codes of the code elements into target language types, and introducing the target language types into preset original codes to generate target codes.

After determining the target language type, the source code is inserted into the original code in the form of the target language type, so that consistency of the language type in the target code is ensured, and actual user requirements are met.

Fig. 5 is a schematic structural diagram of a code generating device based on a markup language according to an embodiment of the present disclosure. The device is applied to terminal equipment, a server and the like, and can be realized by software, hardware or a combination of the two. As shown in fig. 5, the apparatus includes: a code element determination module 501, a source code acquisition module 502, and an object code generation module 503.

A code element determining module 501, configured to obtain a markup language code segment in a preset grammar format input by a user, and determine a code element to be referenced from the markup language code segment; the mark language code segment is used for representing that the source codes corresponding to the code elements are introduced into preset original codes; the code elements characterize the declaration type in the markup language code segment;

a source code obtaining module 502, configured to obtain source codes corresponding to the code elements;

and the target code generating module 503 is configured to introduce the source code into a preset original code according to the markup language code segment, and generate a target code.

Optionally, the code element determining module 501 includes:

and the code element identification unit is used for identifying the code element to be referenced from the markup language code segment according to a preset grammar format identification rule.

Optionally, the code element identification unit includes:

a code element identifier identifying subunit, configured to identify a preset code element identifier from the markup language code segment;

and the code element determining subunit is used for determining the code elements in the markup language code segment according to the code element identifiers.

Optionally, the code element identifier comprises an element name identifier of the code element;

and the code element determining subunit is used for determining the element names of the code elements at the preset element name input positions behind the element name identifiers in the markup language code segment.

Optionally, the source code obtaining module 502 is specifically configured to:

and determining the source code corresponding to the element name of the code element according to the association relation between the preset element name and the source code.

Optionally, the code element identifier comprises an element location identifier of the code element;

the source code obtaining module 502 is specifically configured to:

identifying an element location identifier of the code element from the markup language code;

determining a target position of the code element according to the element position identifier;

and acquiring the source code of the code element corresponding to the element name from the target position according to the association relation between the element name and the source code in the preset target position.

Optionally, the code element determining module 501 includes:

the marking language code segment obtaining unit is used for obtaining marking language code segments in a preset grammar format input by a user based on the data file to be edited; the data file to be edited is used for generating an original code and for representing code logic of the original code.

Optionally, the data file to be edited is a file written in a lightweight markup language.

Optionally, the apparatus further comprises:

the input position determining module is used for determining the input position of the markup language code segment in the data file to be edited after acquiring the markup language code segment in the preset grammar format input by the user based on the data file to be edited.

Optionally, the object code generating module 503 is specifically configured to:

determining the introduction position of the source code in the original code according to the input position of the mark language code segment in the data file to be edited;

and introducing the source code to a preset introduction position of the original code.

Optionally, the code element identifier comprises a language type identifier of the code element;

the object code generating module 503 is specifically configured to:

introducing the source code into a preset original code according to the markup language code segment, and further comprising:

determining a target language type of the code element according to the language type identifier in the markup language code segment;

and converting the source codes of the code elements into target language types, and introducing the target language types into preset original codes.

Optionally, the language type identifier is located in a first line of the markup language code segment.

The embodiment provides a code generating device based on a markup language, which acquires a markup language code segment written by a user in a preset grammar format, and acquires code elements such as classes, fields or methods to be referenced from the markup language code segment. And acquiring a preset source code corresponding to the code field, and inserting the source code into a preset original code to obtain an object code. The method and the device have the advantages that the code elements in the markup language code segments are determined according to the preset grammar format, the source codes corresponding to the code elements are automatically introduced into the original codes through short code segment description, workers are not required to manually determine the source codes, labor and time are saved, and the efficiency and the precision of code generation are improved.

The device provided in this embodiment may be used to implement the technical solution of the foregoing method embodiment, and its implementation principle and technical effects are similar, and this embodiment will not be described herein again.

In order to achieve the above embodiments, the embodiments of the present disclosure further provide an electronic device.

Referring to fig. 6, a schematic diagram of a structure of an electronic device 600 suitable for use in implementing embodiments of the present disclosure is shown, the electronic device 600 may be a terminal device or a server. The terminal device may include, but is not limited to, a mobile terminal such as a mobile phone, a notebook computer, a digital broadcast receiver, a personal digital assistant (Personal Digital Assistant, PDA for short), a tablet (Portable Android Device, PAD for short), a portable multimedia player (Portable Media Player, PMP for short), an in-vehicle terminal (e.g., an in-vehicle navigation terminal), and the like, and a fixed terminal such as a digital TV, a desktop computer, and the like. The electronic device shown in fig. 6 is merely an example and should not be construed to limit the functionality and scope of use of the disclosed embodiments.

As shown in fig. 6, the electronic apparatus 600 may include a processing device (e.g., a central processing unit, a graphics processor, etc.) 601 that may perform various appropriate actions and processes according to a program stored in a Read Only Memory (ROM) 602 or a program loaded from a storage device 608 into a random access Memory (Random Access Memory, RAM) 603. In the RAM 603, various programs and data required for the operation of the electronic apparatus 600 are also stored. The processing device 601, the ROM 602, and the RAM 603 are connected to each other through a bus 604. An input/output (I/O) interface 605 is also connected to bus 604.

In general, the following devices may be connected to the I/O interface 605: input devices 606 including, for example, a touch screen, touchpad, keyboard, mouse, camera, microphone, accelerometer, gyroscope, and the like; an output device 607 including, for example, a liquid crystal display (Liquid Crystal Display, LCD for short), a speaker, a vibrator, and the like; storage 608 including, for example, magnetic tape, hard disk, etc.; and a communication device 609. The communication means 609 may allow the electronic device 600 to communicate with other devices wirelessly or by wire to exchange data. While fig. 6 shows an electronic device 600 having various means, it is to be understood that not all of the illustrated means are required to be implemented or provided. More or fewer devices may be implemented or provided instead.

In particular, according to embodiments of the present disclosure, the processes described above with reference to flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program embodied on a computer readable medium, the computer program comprising program code for performing the method shown in the flowcharts. In such an embodiment, the computer program may be downloaded and installed from a network via communication means 609, or from storage means 608, or from ROM 602. The above-described functions defined in the methods of the embodiments of the present disclosure are performed when the computer program is executed by the processing device 601.

It should be noted that the computer readable medium described in the present disclosure may be a computer readable signal medium or a computer readable storage medium, or any combination of the two. The computer readable storage medium can be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or a combination of any of the foregoing. More specific examples of the computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the context of this disclosure, a computer-readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In the present disclosure, however, the computer-readable signal medium may include a data signal propagated in baseband or as part of a carrier wave, with the computer-readable program code embodied therein. Such a propagated data signal may take any of a variety of forms, including, but not limited to, electro-magnetic, optical, or any suitable combination of the foregoing. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: electrical wires, fiber optic cables, RF (radio frequency), and the like, or any suitable combination of the foregoing.

The computer readable medium may be contained in the electronic device; or may exist alone without being incorporated into the electronic device.

The computer-readable medium carries one or more programs which, when executed by the electronic device, cause the electronic device to perform the methods shown in the above-described embodiments.

Computer program code for carrying out operations of the present disclosure may be written in one or more programming languages, including an object oriented programming language such as Java, smalltalk, C ++ and conventional procedural programming languages, such as the "C" programming language or similar programming languages. The program code may execute entirely on the user's computer, partly on the user's computer, as a stand-alone software package, partly on the user's computer and partly on a remote computer or entirely on the remote computer or server. In the case of a remote computer, the remote computer may be connected to the user's computer through any kind of network, including a local area network (Local Area Network, LAN for short) or a wide area network (Wide Area Network, WAN for short), or it may be connected to an external computer (e.g., connected via the internet using an internet service provider).

The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods and computer program products according to various embodiments of the present disclosure. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

The units involved in the embodiments of the present disclosure may be implemented by means of software, or may be implemented by means of hardware. Wherein the names of the units do not constitute a limitation of the units themselves in some cases.

The functions described above herein may be performed, at least in part, by one or more hardware logic components. For example, without limitation, exemplary types of hardware logic components that may be used include: a Field Programmable Gate Array (FPGA), an Application Specific Integrated Circuit (ASIC), an Application Specific Standard Product (ASSP), a system on a chip (SOC), a Complex Programmable Logic Device (CPLD), and the like.

In the context of this disclosure, a machine-readable medium may be a tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. The machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

In a first aspect of the embodiments of the present disclosure, according to one or more embodiments of the present disclosure, there is provided a method for generating a code based on a markup language, including:

acquiring source codes corresponding to the code elements;

According to one or more embodiments of the present disclosure, determining code elements to be referenced from the markup language code segment includes:

and identifying the code elements to be referenced from the markup language code segments according to a preset grammar format identification rule.

According to one or more embodiments of the present disclosure, identifying code elements to be referenced from the markup language code segment according to a preset grammar format recognition rule includes:

Identifying a preset code element identifier from the markup language code segment;

and determining the code elements in the markup language code segment according to the code element identifiers.

According to one or more embodiments of the present disclosure, the code element identifier includes an element name identifier of the code element;

determining the code element in the markup language code segment according to the code element identifier, comprising:

and determining the element names of the code elements at the preset element name input positions behind the element name identifiers in the markup language code segment.

According to one or more embodiments of the present disclosure, obtaining source code corresponding to the code element includes:

According to one or more embodiments of the present disclosure, the code element identifier includes an element location identifier of the code element;

acquiring source codes corresponding to the code elements, including:

According to one or more embodiments of the present disclosure, a markup language code segment of a preset grammar format input by a user is obtained, including:

acquiring a markup language code segment of a preset grammar format input by a user based on a data file to be edited; the data file to be edited is used for generating an original code and for representing code logic of the original code.

According to one or more embodiments of the present disclosure, the data file to be edited is a file written in a lightweight markup language.

According to one or more embodiments of the present disclosure, after obtaining the markup language code segment of the preset syntax format input by the user based on the data file to be edited, further comprising:

and determining the input position of the markup language code segment in the data file to be edited.

According to one or more embodiments of the present disclosure, the introducing the source code into a preset original code according to the markup language code segment includes:

According to one or more embodiments of the present disclosure, the code element identifier includes a language type identifier of the code element;

According to one or more embodiments of the present disclosure, a language type identifier is located on a first line of the markup language code segment.

In a second aspect, according to one or more embodiments of the present disclosure, there is provided a markup language-based code generating apparatus, comprising:

In accordance with one or more embodiments of the present disclosure, a code element determination module 501 includes:

According to one or more embodiments of the present disclosure, a code element identification unit includes:

In accordance with one or more embodiments of the present disclosure, source code acquisition module 502 is specifically configured to:

the source code obtaining module 502 is specifically configured to:

According to one or more embodiments of the present disclosure, the apparatus further comprises:

According to one or more embodiments of the present disclosure, the object code generation module 503 is specifically configured to:

the object code generating module 503 is specifically configured to:

In a third aspect, according to one or more embodiments of the present disclosure, there is provided an electronic device comprising: at least one processor and memory;

the memory stores computer-executable instructions;

the at least one processor executes the computer-executable instructions stored by the memory, causing the at least one processor to perform the markup language-based code generation method of the first aspect and the various possible designs of the first aspect as described above.

In a fourth aspect, according to one or more embodiments of the present disclosure, there is provided a computer-readable storage medium having stored therein computer-executable instructions which, when executed by a processor, implement the markup language-based code generation method according to the above first aspect and the various possible designs of the first aspect.

In a fifth aspect, according to one or more embodiments of the present disclosure, there is provided a computer program product comprising a computer program which, when executed by a processor, implements the markup language-based code generation method according to the above first aspect and the various possible designs of the first aspect.

The foregoing description is only of the preferred embodiments of the present disclosure and description of the principles of the technology being employed. It will be appreciated by persons skilled in the art that the scope of the disclosure referred to in this disclosure is not limited to the specific combinations of features described above, but also covers other embodiments which may be formed by any combination of features described above or equivalents thereof without departing from the spirit of the disclosure. Such as those described above, are mutually substituted with the technical features having similar functions disclosed in the present disclosure (but not limited thereto).

Moreover, although operations are depicted in a particular order, this should not be understood as requiring that such operations be performed in the particular order shown or in sequential order. In certain circumstances, multitasking and parallel processing may be advantageous. Likewise, while several specific implementation details are included in the above discussion, these should not be construed as limiting the scope of the present disclosure. Certain features that are described in the context of separate embodiments can also be implemented in combination in a single embodiment. Conversely, various features that are described in the context of a single embodiment can also be implemented in multiple embodiments separately or in any suitable subcombination.

Although the subject matter has been described in language specific to structural features and/or methodological acts, it is to be understood that the subject matter defined in the appended claims is not necessarily limited to the specific features or acts described above. Rather, the specific features and acts described above are example forms of implementing the claims.

Claims

1. A method for generating code based on a markup language, comprising:

acquiring source codes corresponding to the code elements;

2. The method of claim 1, wherein determining the code element to be referenced from the markup language code segment comprises:

3. The method of claim 2, wherein identifying code elements to be referenced from the markup language code segment according to a preset grammar format recognition rule comprises:

4. A method according to claim 3, wherein the code element identifier comprises an element name identifier of a code element;

5. The method of claim 4, wherein obtaining source code corresponding to the code element comprises:

6. The method of claim 4, wherein the code element identifier comprises an element location identifier of a code element;

Acquiring source codes corresponding to the code elements, including:

7. The method of claim 1, wherein obtaining the markup language code segment in the pre-set grammar format entered by the user comprises:

8. The method of claim 7, wherein the data file to be edited is a file written in a lightweight markup language.

9. The method of claim 7, further comprising, after obtaining the markup language code fragments of the preset syntax format input by the user based on the data file to be edited:

10. The method of claim 9, wherein introducing the source code into a pre-set original code according to the markup language code segment comprises:

11. A method according to claim 3, wherein the code element identifier comprises a language type identifier of a code element;

12. A markup language-based code generation apparatus, comprising:

13. An electronic device, comprising: a processor and a memory;

the memory stores computer-executable instructions;

the processor executing computer-executable instructions stored in the memory, causing the processor to perform the markup language-based code generation method according to any one of claims 1 to 11.

14. A computer readable storage medium having stored therein computer executable instructions which, when executed by a processor, implement the markup language based code generation method of any one of claims 1 to 11.

15. A computer program product comprising a computer program which, when executed by a processor, implements a method of markup language-based code generation according to any one of claims 1 to 11.