CN114840250B - Code conflict merging method and system, electronic equipment and readable storage medium - Google Patents
Code conflict merging method and system, electronic equipment and readable storage medium Download PDFInfo
- Publication number
- CN114840250B CN114840250B CN202210776325.3A CN202210776325A CN114840250B CN 114840250 B CN114840250 B CN 114840250B CN 202210776325 A CN202210776325 A CN 202210776325A CN 114840250 B CN114840250 B CN 114840250B
- Authority
- CN
- China
- Prior art keywords
- merging
- code
- modified version
- instruction
- area
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/72—Code refactoring
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/73—Program documentation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/75—Structural analysis for program understanding
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Library & Information Science (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a code conflict merging method, a system, electronic equipment and a readable storage medium, which relate to the technical field of data processing and comprise the following steps: adding mark information containing a merging strategy instruction in the original version, the first modified version and the second modified version; analyzing the three marked versions through a tree structure to obtain respective text merging structure trees; carrying out code merging after hierarchically folding nested sub-levels in the text merging structure tree, and carrying out code merging on an area with code conflict according to a merging strategy instruction; and after the codes are combined, obtaining a combined result, wherein the combined result is the combined result after the modification of the first modified version is completely accepted, or the combined result after the modification of the second modified version is completely accepted. The frequency and the number of code conflict combination processed manually by developers are reduced, the capability of automatically processing code conflicts is improved, and the burden of the developers is lightened.
Description
Technical Field
The present invention relates to the field of data processing technologies, and in particular, to a code conflict merging method and system, an electronic device, and a readable storage medium.
Background
In the code development process, the three-way merging algorithm refers to: and respectively carrying out two different editing revisions based on the code of the same version, respectively comparing the line number of the two revisions which has difference relative to the common original version according to the text lines, aligning the two differences, and combining the two different versions into a new version code.
At this time, if an area exists and is simultaneously modified by the two different editing revisions, the area is judged to be a code conflict, and a developer manually processes the code conflict area; otherwise, only two differences need to be automatically combined to complete the combination.
Due to the complexity of the actual service, two situations that the code content is changed due to the fact that the service module is visually edited and then the code is generated and the code function is manually modified by a developer may be met at the same time, and code conflict is difficult to avoid. Then, in such a business scenario, if a traditional three-way merge algorithm is used, developers frequently encounter situations that require manual handling of code conflict merges.
In addition, because the conventional three-way merging algorithm is based on the common original version for comparison, if no additional processing is needed, merging when code conflict occurs each time needs to be performed again after the conflict which is processed in the past is processed, and the development progress is influenced when complex pages and services are developed.
Disclosure of Invention
In order to solve the above problems, the present invention provides a code conflict merge method, system, electronic device and readable storage medium, which reduces the frequency and number of code conflict merges processed manually by developers, improves the capability of automatically processing code conflicts, and reduces the burden of developers.
In order to achieve the purpose, the invention adopts the following technical scheme:
in a first aspect, the present invention provides a code conflict merging method, including:
adding mark information containing a merging strategy instruction in the original version, the first modified version and the second modified version;
analyzing the three marked versions through a tree structure to obtain respective text merging structure trees;
carrying out code merging after hierarchically folding nested sub-levels in the text merging structure tree, and carrying out code merging on an area with code conflict according to a merging strategy instruction;
and obtaining a merging result after the code merging is finished, wherein the merging result is the merging result after the modification of the first modified version is completely accepted, or the merging result after the modification of the second modified version is completely accepted.
As an alternative embodiment, the process of tree structure resolution includes: and scanning an annotation line containing a merging strategy instruction, and constructing a tree structure by the push and pop of the @ begin/@ end instruction.
As an alternative embodiment, @ begin and @ end are paired structures, supporting multiple levels of nesting, for marking the beginning and end of a region.
As an alternative embodiment, a merge policy instruction is added in the annotation line at the beginning of the marker region.
As an alternative embodiment, the hierarchy in the merged result is folded and the sub-hierarchies are recursively expanded by the region identifier.
As an alternative embodiment, the folding is to fold all root level nodes under the current node to be merged into one reference instruction; the expansion is to dereference the reference instruction according to the area identifier.
As an alternative embodiment, the modifications of both the first modified version and the second modified version are all accepted for areas where there is no code conflict.
In a second aspect, the present invention provides a code conflict merge system, including:
the marking module is configured to add marking information containing the merging strategy instruction in the original version, the first modified version and the second modified version;
the analysis module is configured to analyze the three marked versions through a tree structure to obtain respective text merging structure trees;
the merging module is configured to perform code merging after hierarchically folding nested sub-levels in the text merging structure tree, and perform code merging according to a merging strategy instruction on an area with code conflict;
and the output module is configured to obtain a merging result after the code merging is completed, wherein the merging result is a merging result obtained after the modification of the first modified version is completely accepted or a merging result obtained after the modification of the second modified version is completely accepted.
In a third aspect, the present invention provides an electronic device comprising a memory and a processor, and computer instructions stored on the memory and executed on the processor, wherein when the computer instructions are executed by the processor, the method of the first aspect is performed.
In a fourth aspect, the present invention provides a readable storage medium for storing computer instructions which, when executed by a processor, perform the method of the first aspect.
Compared with the prior art, the invention has the following beneficial effects:
the invention provides a code conflict merging method, a system, electronic equipment and a readable storage medium, which can automatically merge codes in an area with code conflict through a preset merging strategy, reduce the frequency and the number of developers for manually processing code conflict merging, improve the capability of automatically processing code conflict and reduce the burden of the developers. And automatically processing code conflicts, avoiding repeatedly processing the merged contents each time when conflicts occur, and avoiding unnecessary merging conflicts.
Advantages of additional aspects of the invention will be set forth in part in the description which follows, and in part will be obvious from the description, or may be learned by practice of the invention.
Drawings
The accompanying drawings, which are incorporated in and constitute a part of this specification, are included to provide a further understanding of the invention, and are incorporated in and constitute a part of this specification, illustrate exemplary embodiments of the invention and together with the description serve to explain the invention and not to limit the invention.
Fig. 1 is a flowchart of a code conflict merging method provided in embodiment 1 of the present invention.
Detailed Description
The invention is further described with reference to the following figures and examples.
It is to be understood that the following detailed description is exemplary and is intended to provide further explanation of the invention as claimed. Unless defined otherwise, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this invention belongs.
It is noted that the terminology used herein is for the purpose of describing particular embodiments only and is not intended to be limiting of exemplary embodiments according to the invention. As used herein, the singular forms "a", "an", and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise, and it should be understood that the terms "comprises" and "comprising", and any variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.
The embodiments and features of the embodiments of the present invention may be combined with each other without conflict.
Example 1
The embodiment provides a code conflict merging method, which comprises the following steps:
adding mark information containing a merging strategy instruction in the original version, the first modified version and the second modified version;
analyzing the three marked versions through a tree structure to obtain respective text merging structure trees;
carrying out code merging after hierarchically folding nested sub-levels in the text merging structure tree, and carrying out code merging on an area with code conflict according to a merging strategy instruction;
and obtaining a merging result after the code merging is finished, wherein the merging result is the merging result after the modification of the first modified version is completely accepted, or the merging result after the modification of the second modified version is completely accepted.
In the embodiment, the merging strategy under a specific scene is preset according to different service scenes, and when code conflict occurs, code merging is automatically performed according to the merging strategy, so that the frequency of manually solving the conflict is reduced.
Because the whole structure of the code is relatively fixed and does not change greatly, the mark information can be inserted into the code while the execution effect of the code is not influenced, and the mark information comprises a merging strategy instruction under a specific scene so as to identify in the merging process of the code and automatically merge;
for example:
/* @begin --option identifier */
// code within region
/* @end */
Where the @ begin annotation line is denoted as mark region start, -or-start is denoted as specified instruction parameter (e.g. -merge, which is a merge policy parameter, where codes in the region are merged upon code conflict according to a specified merge policy), and the instruction parameter may carry a location parameter (such as a global unique identifier of the region); the @ end annotation line is expressed as the end of a marked region, and the @ end and the @ begin form a pairwise paired structure and support multi-level nesting.
Alternatively, the marking information may be recorded in a separate file or database, instead of being directly added to the code.
In the embodiment, an original version P1, a first modified version F1 and a second modified version P2 are obtained; wherein, the original version P1 is the version released last time and is used as the reference of comparison; the second modified version P2 is a currently released version, and the currently released version is modified compared with the last released version; the first modified version F1 is a current actual version, such as an actual version used after a developer manually modifies a code, and the developer modifies the actual version based on the last final version.
And comparing the first modified version F1 and the second modified version P2 with the original version P1, judging whether a region with code conflict exists or not, carrying out difference alignment merging on the region without code conflict, carrying out code merging on the region with code conflict by adopting a preset merging strategy, and generating a new version for release.
In this embodiment, the preset merging strategy involves three outputs, namely: whether a CONFLICT CONFLICT which cannot be combined, a combination result Mf obtained by completely accepting the modification of the first modified version F1 and a combination result Mp obtained by completely accepting the modification of the second modified version P2 are detected;
specifically, the differences align (diff (P1, F1), diff (P1, P2)) between the first modified version F1 and the second modified version P2 and the original version P1 are aligned to obtain an alignment result list [ (Sp 1_0, sf1_0, sp2 _0), …, (Sp 1_ i, sf1_ i, sp2_ i), … ], each of which is a block of three versions aligned, and the sequence in the alignment result list is the precedence sequence in the original version;
if there is an area, there is a code collision for this area if and only if Sp1_ i ≠ Sf1_ i and Sp1_ i ≠ Sp2_ i;
for example, if there is an area 1, the second modified version P2 is not modified, and the first modified version F1 is modified, the area is modified by the first modified version F1 after combination; if the region 2 exists, the second modified version P2 is modified, and the first modified version F1 is not modified, the region is modified by the second modified version P2 after combination; for example, if there is a region 3, and both the second modified version P2 and the first modified version F1 have modifications, then there is a code conflict in the region 3.
Traversing the alignment result list, and generating two different outputs after code combination for the area with code conflict, namely, adopting the modification of a first modification version F1 and the modification of a second modification version P2; areas without code conflicts are directly adopted with differentiated versions.
Then, the output of each region is spliced to obtain two merging results, namely a merging result Mf obtained by receiving all the modifications of the first modified version F1 and a merging result Mp obtained by receiving all the modifications of the second modified version P2;
for example, if the original version P1 has an area 1, an area 2, and an area 3, the area 1 and the area 3 are modified in the second modified version P2, and the area 2 and the area 3 are modified in the first modified version F1, mp indicates that the area 1 and the area 3 are modified by the second modified version P2, and the area 2 is modified by the first modified version F1, and at this time, the modifications of the second modified version P2 are all accepted.
Another merging result Mf is a modification of the area 2 and the area 3 with the first modified version F1, and a modification of the area 1 with the second modified version P2, at which time the modifications of the first modified version F1 are all accepted.
In this embodiment, when the differences between the first modified version F1 and the second modified version P2 and the original version P1 are aligned, if there is no area of code CONFLICT (confict = false), the differences are directly merged, and the modifications of the first modified version F1 and the second modified version P2 are all accepted.
In this embodiment, after the merging strategy, if there is still a code CONFLICT (confict = true) that cannot be automatically merged, the processing is performed manually, and a manual processing result is written in; the method avoids directly processing the code conflict by manpower, and reduces the number of manual processing by the manpower only when the code conflict which can not be automatically solved still exists.
In this embodiment, as shown in fig. 1, the code conflict merging method based on the merging policy includes:
(1) Acquiring an original version P1, a first modified version F1 and a second modified version P2, and adding mark information containing a merging strategy instruction in three version codes; according to the code structure, the three marked versions are respectively analyzed into tree structures to obtain respective text merging structure trees;
specifically, the process of parsing the tree structure includes: and scanning and identifying the annotation line containing the merging strategy instruction by adopting a global method, and directly pressing and popping the @ begin/end instruction to construct a tree structure.
(2) Performing hierarchical folding on all nested sub-levels in the text merging structure tree, and converting the text merging structure tree of each of the three versions into a text intermediate structure after the text merging structure tree is subjected to hierarchical folding;
three paths of merging are carried out on the text intermediate structure, whether a region with code conflict exists or not is judged, and code merging is carried out on the region with the code conflict according to a merging strategy instruction;
after the codes are combined, a combined result is obtained; that is, the merged result Mf with the modifications of the first modified version F1 accepted in their entirety, or the merged result Mp with the modifications of the second modified version P2 accepted in their entirety.
(3) After the codes are merged, whether CONFLICT CONFLICT which cannot be merged exists is judged, if yes, the area where the CONFLICT exists has code difference which cannot be automatically processed, and the code difference is manually processed by developers.
(4) And folding the hierarchy in the combined result, and recursively expanding the sub-hierarchies through the region identifiers to finally obtain all the results.
Wherein, the folding is to fold all root level nodes under the current node to be merged into a reference instruction @ reference, such as a tree:
piece_0
/* @begin node_0 */
piece_1
/* @begin node_1 */
piece_2
/* @end */
piece_3
/* @end */
piece_4
folding into an array:
piece_0
/* @reference node_0 */
piece_4
the expansion, in turn, dereferences the @ reference instruction by region identifier and turns the array back into a tree.
In this embodiment, most common code conflicts in a service scenario can be automatically resolved without manual resolution, and according to a pre-insertion merging policy, merging is automatically performed according to a merging policy in an area where the code conflicts occur, that is, how the service code is merged is written into the code in advance, so that the frequency of manual processing is reduced.
Example 2
The present embodiment provides a code conflict merge system, including:
the marking module is configured to add marking information containing the merging strategy instruction in the original version, the first modified version and the second modified version;
the analysis module is configured to analyze the three marked versions through a tree structure to obtain respective text merging structure trees;
the merging module is configured to perform code merging after hierarchically folding nested sub-levels in the text merging structure tree, and perform code merging according to a merging strategy instruction on an area with code conflict;
and the output module is configured to obtain a merging result after the code merging is completed, wherein the merging result is a merging result obtained after the modification of the first modified version is completely accepted or a merging result obtained after the modification of the second modified version is completely accepted.
It should be noted that the modules correspond to the steps described in embodiment 1, and the modules are the same as the corresponding steps in the implementation examples and application scenarios, but are not limited to the disclosure in embodiment 1. It should be noted that the modules described above as part of a system may be implemented in a computer system such as a set of computer-executable instructions.
In further embodiments, there is also provided:
an electronic device comprising a memory and a processor and computer instructions stored on the memory and executed on the processor, the computer instructions when executed by the processor performing the method of embodiment 1. For brevity, no further description is provided herein.
It should be understood that in this embodiment, the processor may be a central processing unit CPU, and the processor may also be other general purpose processors, digital signal processors DSP, application specific integrated circuits ASIC, off-the-shelf programmable gate arrays FPGA or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components, and so on. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like.
The memory may include both read-only memory and random access memory, and may provide instructions and data to the processor, and a portion of the memory may also include non-volatile random access memory. For example, the memory may also store device type information.
A readable storage medium storing computer instructions which, when executed by a processor, perform the method of embodiment 1.
The method in embodiment 1 may be directly implemented by a hardware processor, or implemented by a combination of hardware and software modules in the processor. The software modules may be located in ram, flash, rom, prom, or eprom, registers, among other storage media as is well known in the art. The storage medium is located in a memory, and a processor reads information in the memory and completes the steps of the method in combination with hardware of the processor. To avoid repetition, it is not described in detail here.
Those of ordinary skill in the art will appreciate that the various illustrative elements, i.e., algorithm steps, described in connection with the embodiments disclosed herein may be implemented as electronic hardware or combinations of computer software and electronic hardware. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the technical solution. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present application.
Although the embodiments of the present invention have been described with reference to the accompanying drawings, it is not intended to limit the scope of the present invention, and it should be understood by those skilled in the art that various modifications and variations can be made without inventive efforts by those skilled in the art based on the technical solution of the present invention.
Claims (9)
1. A method for merging code conflicts, comprising:
according to different service scenes, a merging strategy under a specific scene is preset, and mark information containing merging strategy instructions is added in the original version, the first modified version and the second modified version; the marking information is:
/* @begin --option identifier */
// code within label area
/* @end */
The @ begin annotation line is represented as the beginning of the marked region, the @ end annotation line is represented as the end of the marked region, the-beginning is represented as a specified instruction parameter, and the identifier is a position parameter and represents a globally unique identifier of the marked region;
analyzing the three marked versions through a tree structure to obtain respective text merging structure trees; the process of tree structure resolution comprises the following steps: scanning an annotation line containing a merging strategy instruction, and constructing a tree structure through the push and pop of an @ begin/end instruction;
carrying out code merging after hierarchically folding nested sub-levels in the text merging structure tree, and carrying out code merging on an area with code conflict according to a merging strategy instruction;
and obtaining a merging result after the code merging is finished, wherein the merging result is the merging result after the modification of the first modified version is completely accepted, or the merging result after the modification of the second modified version is completely accepted.
2. The code conflict merge method of claim 1, wherein @ begin and @ end are pair structures supporting multi-level nesting for marking the beginning and end of a region.
3. A code conflict merge method according to claim 2, characterized in that in the comment line starting at the mark area, a merge strategy instruction is added.
4. The method as claimed in claim 1, wherein the hierarchical fold part in the merged result is recursively expanded into sub-hierarchies by means of the region identifiers.
5. The method as claimed in claim 4, wherein the folding is to fold all root level nodes under the current node to be merged into one reference instruction; the expansion is to dereference the reference instruction according to the area identifier.
6. A code conflict merge method according to claim 1, wherein the modifications of the first modified version and the second modified version are all accepted for areas without code conflict.
7. A code conflict merge system, comprising:
the marking module is configured to preset a merging strategy in a specific scene according to different service scenes, and mark information containing merging strategy instructions is added in the original version, the first modified version and the second modified version; the marking information is:
/* @begin --option identifier */
// code within the marked area
/* @end */
The @ begin annotation line is represented as the beginning of the mark area, the @ end annotation line is represented as the end of the mark area, the-beginning is represented as a specified instruction parameter, and the identifier is a position parameter and represents a globally unique identifier of the mark area;
the analysis module is configured to analyze the three marked versions through a tree structure to obtain respective text merging structure trees; the process of tree structure resolution comprises the following steps: scanning an annotation line containing a merging strategy instruction, and constructing a tree structure through the push and pop of an @ begin/end instruction;
the merging module is configured to perform code merging after hierarchically folding nested sub-levels in the text merging structure tree, and perform code merging according to a merging strategy instruction on an area with code conflict;
and the output module is configured to obtain a merging result after the code merging is completed, wherein the merging result is a merging result obtained after the modification of the first modified version is completely accepted or a merging result obtained after the modification of the second modified version is completely accepted.
8. An electronic device comprising a memory and a processor and computer instructions stored on the memory and executed on the processor, the computer instructions when executed by the processor performing the method of any of claims 1-6.
9. A readable storage medium storing computer instructions which, when executed by a processor, perform the method of any one of claims 1 to 6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210776325.3A CN114840250B (en) | 2022-07-04 | 2022-07-04 | Code conflict merging method and system, electronic equipment and readable storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210776325.3A CN114840250B (en) | 2022-07-04 | 2022-07-04 | Code conflict merging method and system, electronic equipment and readable storage medium |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN114840250A CN114840250A (en) | 2022-08-02 |
| CN114840250B true CN114840250B (en) | 2022-10-04 |
Family
ID=82574843
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202210776325.3A Active CN114840250B (en) | 2022-07-04 | 2022-07-04 | Code conflict merging method and system, electronic equipment and readable storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN114840250B (en) |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1987796A (en) * | 2005-12-22 | 2007-06-27 | 国际商业机器公司 | Methods and apparatus for detecting deadlock in multithreading programs |
| CN106681708A (en) * | 2016-11-16 | 2017-05-17 | 中国科学院软件研究所 | Automatic source code annotation generation method based on data mining |
Family Cites Families (11)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8375373B2 (en) * | 2010-04-19 | 2013-02-12 | Microsoft Corporation | Intermediate language support for change resilience |
| US20200067861A1 (en) * | 2014-12-09 | 2020-02-27 | ZapFraud, Inc. | Scam evaluation system |
| CN105183789A (en) * | 2015-08-21 | 2015-12-23 | 福建天晴数码有限公司 | File merging method and system based on git source code confliction |
| KR20240025702A (en) * | 2016-06-07 | 2024-02-27 | 일루미나, 인코포레이티드 | Bioinformatics systems, apparatus, and methods for performing secondary and/or tertiary processing |
| US20200027096A1 (en) * | 2017-11-07 | 2020-01-23 | Jason Ryan Cooner | System, business and technical methods, and article of manufacture for utilizing internet of things technology in energy management systems designed to automate the process of generating and/or monetizing carbon credits |
| US20190306173A1 (en) * | 2018-04-02 | 2019-10-03 | Ca, Inc. | Alert smart contracts configured to manage and respond to alerts related to code |
| CN110109659A (en) * | 2019-04-28 | 2019-08-09 | 广东三维家信息科技有限公司 | A kind of system that realizing front end applications scaffold and server |
| CN110471694A (en) * | 2019-07-11 | 2019-11-19 | 平安普惠企业管理有限公司 | Annotation information processing method, device, computer equipment and storage medium |
| CN111176983B (en) * | 2019-10-18 | 2021-10-22 | 华为技术有限公司 | Code conflict resolution system, method, device, equipment and medium |
| US11232097B1 (en) * | 2020-06-08 | 2022-01-25 | Sprint Communications Company L.P. | Ordering commits of code in multi-branch parallel development projects |
| CN113900630A (en) * | 2021-09-28 | 2022-01-07 | 交控科技股份有限公司 | Code development method and device, electronic equipment and readable storage medium |
-
2022
- 2022-07-04 CN CN202210776325.3A patent/CN114840250B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN1987796A (en) * | 2005-12-22 | 2007-06-27 | 国际商业机器公司 | Methods and apparatus for detecting deadlock in multithreading programs |
| CN106681708A (en) * | 2016-11-16 | 2017-05-17 | 中国科学院软件研究所 | Automatic source code annotation generation method based on data mining |
Also Published As
| Publication number | Publication date |
|---|---|
| CN114840250A (en) | 2022-08-02 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10698682B1 (en) | Computerized software development environment with a software database containing atomic expressions | |
| US20070169008A1 (en) | External programmatic interface for IOS CLI compliant routers | |
| CN113508385B (en) | Method and system for formal language processing using subroutine graph | |
| CN114840250B (en) | Code conflict merging method and system, electronic equipment and readable storage medium | |
| CN116431127A (en) | Low code development method, system, equipment and readable storage medium | |
| US20020174135A1 (en) | Schema-based file conversion | |
| CN114661298A (en) | Automatic public method generation method, system, device and medium | |
| CN112612915B (en) | Picture labeling method and device | |
| CN115221047A (en) | Automatic test case generation method and electronic equipment | |
| CN114296738A (en) | Method for determining compiled directory, computer equipment and storage medium | |
| Oldevik et al. | Confluence in domain-independent product line transformations | |
| JP3584204B2 (en) | Automatic source program converter | |
| CN114416104B (en) | Structured data file processing method and device | |
| JP2001290655A (en) | Compiler, computer system, optimization method, optimizing program, storage medium and program transmitter | |
| CN116880826B (en) | Visualized code generation method | |
| CN113448923B (en) | File generation method, device and terminal | |
| CN110765159B (en) | Object analysis method, device, storage medium and equipment | |
| CN113343157B (en) | Content editing method and device based on domain-specific language | |
| CN115600156B (en) | Semantic map fusion method, device, equipment and medium based on minimum tree | |
| McMillan | Graph Neural Networks in Software Mining | |
| Nordmark | Optimizing the Process of Handling Road Network Data | |
| Somogyi | Merging textual representations of software models | |
| CN114003557A (en) | Standard file naming method and device | |
| Stephens | From models to implementations-distributed algorithms using maude | |
| CN118838603A (en) | Data processing method, device, equipment and medium applied to cross compiling |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |