CN117785213B - Front-end construction tool and construction method based on Rust development - Google Patents
Front-end construction tool and construction method based on Rust development Download PDFInfo
- Publication number
- CN117785213B CN117785213B CN202311825009.1A CN202311825009A CN117785213B CN 117785213 B CN117785213 B CN 117785213B CN 202311825009 A CN202311825009 A CN 202311825009A CN 117785213 B CN117785213 B CN 117785213B
- Authority
- CN
- China
- Prior art keywords
- files
- file
- compiling
- dependency
- module
- 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
- 238000010276 construction Methods 0.000 title claims abstract description 27
- JEIPFZHSYJVQDO-UHFFFAOYSA-N iron(III) oxide Inorganic materials O=[Fe]O[Fe]=O JEIPFZHSYJVQDO-UHFFFAOYSA-N 0.000 title claims abstract description 22
- 238000011161 development Methods 0.000 title claims abstract description 18
- 238000012545 processing Methods 0.000 claims abstract description 36
- 238000000034 method Methods 0.000 claims abstract description 29
- 230000008569 process Effects 0.000 claims abstract description 18
- 238000004806 packaging method and process Methods 0.000 claims abstract description 15
- 125000004122 cyclic group Chemical group 0.000 claims abstract description 8
- 230000008859 change Effects 0.000 claims description 23
- 238000005457 optimization Methods 0.000 claims description 10
- 238000013507 mapping Methods 0.000 claims description 9
- 230000008676 import Effects 0.000 claims description 8
- 238000006243 chemical reaction Methods 0.000 claims description 5
- 238000012856 packing Methods 0.000 claims description 4
- 238000010845 search algorithm Methods 0.000 claims description 3
- 238000001514 detection method Methods 0.000 claims description 2
- 230000014509 gene expression Effects 0.000 claims description 2
- 238000013519 translation Methods 0.000 claims 1
- 230000018109 developmental process Effects 0.000 description 12
- 230000009471 action Effects 0.000 description 3
- 230000011218 segmentation Effects 0.000 description 2
- 230000006835 compression Effects 0.000 description 1
- 238000007906 compression Methods 0.000 description 1
- 230000001419 dependent effect Effects 0.000 description 1
- 238000010586 diagram Methods 0.000 description 1
- 230000006870 function Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
Landscapes
- Stored Programmes (AREA)
Abstract
The invention relates to the technical field of industrial network security, in particular to a front-end construction tool and a construction method based on Rust development. The tool is applied to a Rust development environment, and the tool comprises: the device comprises a dependence processing module, an increment compiling module and a plurality of compiling and translating modules; the dependency processing module is used for analyzing the files in the file package to generate a dependency graph and processing circular dependencies based on the dependency graph; the compiling and translating modules are connected with the dependency processing module and are used for compiling and packaging files of all types in the file package in parallel based on the dependency graph; the increment compiling module is used for determining all target files depending on the changed files based on the dependency graph when the files in the file package are changed, and calling the compiling and translating modules of corresponding types in sequence based on the types of the changed files and the target files so as to recompile and package the changed files and the target files. The scheme can effectively process complex dependency and cyclic dependency and improve the construction speed.
Description
Technical Field
The embodiment of the invention relates to the technical field of industrial network security, in particular to a front-end construction tool and a construction method based on Rust development.
Background
The build tool is a program that automates the process of generating executable applications from source code (e.g., android app generates apk). Construction includes compiling, concatenating, and packaging the code into a usable or executable form. As the complexity of Web development increases, the performance and efficiency of front-end building tools becomes an important issue.
However, existing build tools are typically written using JavaScript or TYPESCRIPT, the performance of these languages may not meet some high performance requirements. Furthermore, existing build tools may not be able to handle complex dependencies and cyclic dependencies efficiently.
Thus, a new front end building tool is needed.
Disclosure of Invention
In order to solve the problems that the existing construction tool is poor in performance and efficiency and cannot effectively process complex dependency and circular dependency, the embodiment of the invention provides a front-end construction tool and a construction method based on Rust development.
In a first aspect, an embodiment of the present invention provides a front-end building tool based on Rust development, applied to a Rust development environment, the tool including: the device comprises a dependence processing module, an increment compiling module and a plurality of compiling and translating modules; wherein each compiling and translating module processes a type of file correspondingly;
The dependency processing module is used for analyzing the import statement of each file in the file package to generate a dependency graph and processing circular dependencies based on the dependency graph;
the compiling and translating modules are connected with the dependency processing module and are used for compiling and packing files of all types in the file package in parallel based on the dependency graph;
And the increment compiling module is used for determining all target files depending on the changed files based on the dependency graph when the files in the file package are changed, and calling the compiling and translating modules of corresponding types in sequence based on the types of the changed files and the target files so as to recompile and package the changed files and the target files.
In a second aspect, an embodiment of the present invention further provides a method for constructing a construction tool according to any one of the embodiments of the present specification, which is run in a Rust development environment, where the method includes:
analyzing the import statement of each file in the file package by utilizing a dependency processing module, and processing the cyclic dependency based on the initial dependency graph to obtain a dependency graph after obtaining the initial dependency graph;
compiling and packaging all types of files in the file package in parallel by utilizing a compiling and translating module according to the dependency graph;
When the files in the file package are changed, the incremental compiling module determines all target files depending on the changed files based on the dependency graph, and sequentially calls compiling and translating modules of corresponding types based on the changed files and the types of the target files so as to recompile and package the changed files and the target files.
The embodiment of the invention provides a front-end construction tool and a construction method based on Rust development, which use Rust writing, and enable a compiling and translating module to quickly compile and package files by utilizing the high performance and parallel processing capacity of the Rust; the dependency relationship among the files is represented by utilizing the dependency graph, so that complex dependency relationship and cyclic dependency can be effectively processed; and support increment and compile, when the file changes, only need recompile and pack change the file and rely on the goal file of the change file, thus can improve the speed of construction.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below. The drawings in the following description are illustrative of certain embodiments of the invention and other drawings may be made by those skilled in the art without undue burden.
FIG. 1 is a schematic diagram of the components of a front-end build tool developed based on Rust, according to one embodiment of the present invention;
fig. 2 is a flowchart of a construction method according to an embodiment of the present invention.
Reference numerals:
1. a dependent processing module; 2. a set of compiling and translating modules; 3. an increment compiling module; 4. a thermal update module; 5. a source code mapping module; 10. a web browser.
Detailed Description
In order to make the objects, technical solutions and advantages of the embodiments of the present invention more clear, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention. It is apparent that the described embodiments are some, but not all embodiments of the present invention, and that all other embodiments obtained by persons of ordinary skill in the art without making creative efforts based on the embodiments in the present invention are within the protection scope of the present invention.
As previously mentioned, existing build tools are typically written using JavaScript or TYPESCRIPT, in their running environments, only single-threaded processing is supported, and the performance of these languages themselves may not meet some high performance requirements, and in addition, complex dependencies and circular dependencies cannot be handled efficiently.
In order to solve the above technical problems, the inventor considered to develop a new construction tool using the Rust language, which is a high-level language with high efficiency and reliability, the efficiency of which is not limited to development efficiency, but the execution efficiency of which is also very high. Therefore, the scheme can use the high performance and parallel processing capability of Rust to improve the construction speed of the construction tool.
Specific implementations of the above concepts are described below.
Referring to fig. 1, an embodiment of the present invention provides a front-end building tool based on Rust development, applied to a Rust development environment, the tool includes: the device comprises a dependence processing module, an increment compiling module and a plurality of compiling and translating modules; wherein each compiling and translating module processes a type of file correspondingly;
The dependency processing module is used for analyzing the import statement of each file in the file package to generate a dependency graph and processing the circular dependency based on the dependency graph;
the compiling and translating modules are connected with the dependency processing module and are used for compiling and packaging files of all types in the file package in parallel based on the dependency graph;
The increment compiling module is used for determining all target files depending on the changed files based on the dependency graph when the files in the file package are changed, and calling the compiling and translating modules of corresponding types in sequence based on the types of the changed files and the target files so as to recompile and package the changed files and the target files.
In the embodiment of the invention, a Rust writing and constructing tool is used, and the compiling and translating module can quickly compile and package files by utilizing the high performance and parallel processing capacity of the Rust; the dependency relationship among the files is represented by utilizing the dependency graph, so that complex dependency relationship and cyclic dependency can be effectively processed; and support increment and compile, when the file changes, only need recompile and pack change the file and rely on the goal file of the change file, thus can improve the speed of construction.
In some embodiments, the dependency graph in the dependency processing module contains nodes corresponding to the files one by one, and a guide line exists between the nodes and is used for representing the dependency relationship;
the dependency processing module, when executing dependency graph based processing loop dependencies, is configured to:
Invoking a search algorithm to perform circular dependency detection on the dependency graph;
flattening the multiple dependencies, simplifying the dependency relationship, and optimizing the dependency graph;
When the circular dependence is detected, pushing the file information of the circular dependence to alarm.
In this embodiment, when the construction tool processes file dependencies, the dependency processing module first parses the import statement of each file to generate a dependency graph. The dependency graph is a directed graph in which nodes represent files and edges represent dependencies. For example, if file A imported file B, there would be an edge in the dependency graph pointing from node A to node B.
The dependency processing module then detects whether there are circular dependencies in this dependency graph. Circular dependency means that there is a sequence of nodes in the dependency graph, the first and last of which are the same node, and there is an edge between every two adjacent nodes in the sequence. The construction tool can use a depth-first search algorithm (DFS) or a strong connected component algorithm (SCC) to detect the cyclic dependence, then flattening the multiple dependence, simplifying the dependence relationship and optimizing the dependence graph; if a circular dependency is detected, the build tool throws an error and gives detailed information about the circular dependency, e.g., which files make up the circular dependency. In this way, the developer can modify the code based on this information, solving the problem of loop dependency.
In some embodiments, each compiling and translating module, when compiling and packaging each file in parallel, is configured to:
determining files without a dependency relationship based on the dependency graph;
Based on the number of CPU cores, a plurality of threads are constructed to compile and package files without dependency relationship in parallel based on the types of the files.
After the file package is imported, the files in the file package are required to be compiled and packed, and in the compiling and packing process, a plurality of files can be processed in parallel so as to improve the compiling and packing speed. Parallel processing is to increase the build speed by using multiple threads or processes. For example, if there are four CPU cores, four files may be compiled simultaneously, rather than compiling the four files sequentially. And the process needs to consider the dependency relationship among files, and the files with the dependency relationship cannot be processed in parallel. Each thread will process this file and all target files that depend on this file in turn according to the dependency graph.
In some embodiments, the delta compilation module is specifically configured to:
For each file update, performing:
judging the number of changed files in the current file updating;
When the number of the changed files is 1, constructing a single thread to determine all target files depending on the changed files based on the dependency graph, and calling corresponding types of compiling and translating modules in sequence based on the types of the changed files and the target files to recompile and package the changed files and the target files;
when the number of the files is larger than 1, determining whether the changed files have a dependency relationship or not based on the dependency graph;
When the number of the change files without the dependency relationship is smaller than or equal to the number of CPU cores, constructing a plurality of threads with the same number as the change files, and recompiling and packaging each change file and a target file depending on the change file in parallel by utilizing the plurality of threads;
When the number of the change files without the dependency relationship is larger than the number of the CPU cores, a plurality of threads with the number equal to the number of the CPU cores are constructed, and each change file and the target file depending on the change file are recompiled and packaged in parallel in batches.
In this embodiment, delta compilation is when a file changes, only recompiling and packaging this file and other files that rely on this file, and not recompiling and packaging all files. For example, if the A file is modified, only the A file and other files that depend on the A file will be recompiled and packaged, and other files that do not depend on the A file will not be recompiled and packaged, which can greatly reduce the time required for updating. In the incremental compiling process, the modified files with the dependency relationship can be processed in parallel, but the modified files cannot be processed in parallel, so that an incremental compiling strategy is formulated based on the number of the modified files, the dependency relationship among the modified files and the number of CPU cores, and the construction speed is improved to the greatest extent.
In some embodiments, the types of files include at least: javaScript files, TYPESCRIPT files, and CSS files; the compiling and translating modules of the JavaScript file and the TYPESCRIPT file are the same;
the compiling and translating modules corresponding to the JavaScript file and the TYPESCRIPT file are used for, when compiling and packaging the files:
performing lexical analysis on the file by utilizing the swc library so as to divide the file into a plurality of morpheme small files;
Utilizing swc library to make grammar analysis on said file so as to combine every morpheme into an abstract grammar tree according to grammar rule;
carrying out grammar conversion on the abstract grammar tree by utilizing babel plug-in units so that the converted grammar accords with the grammar requirement of the JavaScript environment of the browser;
Performing code optimization on the converted abstract syntax tree by utilizing uglify plugins, wherein the code optimization at least comprises the steps of deleting unused codes, simplifying expressions and compressing codes;
And converting the optimized abstract syntax tree back to the source code by utilizing the swc library to obtain a compiled and packaged file.
In this embodiment, the building tool compiles the packaged file to be run in the web browser, and most of the web browser runs in the JavaScript environment at present, so after the abstract syntax tree is formed, the abstract syntax tree needs to be subjected to syntax conversion, so that the converted syntax meets the syntax requirement of the JavaScript environment of the browser, and finally the source code is converted back, so that the obtained compiled and packaged file can be directly run in the web browser.
In the compiling and translating process, the swc library is utilized to perform lexical analysis on the file, the file is subjected to code segmentation, the file is segmented into a plurality of morpheme small files, and each small file only comprises a part of codes. For example, an application having two pages A and B, the code for page A and the code for page B may be split into two files. Thus, when a user accesses the A page, the browser only needs to load the code of the A page, and does not need to load the code of the B page. Code segmentation may be achieved by dynamic importation ()) or multiple entry points. The packed volume and build speed can be optimized.
In addition, code compression of the translated abstract syntax tree may reduce file size by removing useless spaces, notes, and line breaks, simplifying variable names, and using other optimization techniques. This process does not change the behavior of the code, but can significantly reduce the size of the compiled packaged file.
In this embodiment, a tree (TREE SHAKING) is used to delete unused code. For example, a function is defined in the code, but is not used anywhere, and is deleted. The compile and translate module analyzes the exports and imports of each module, including only the exports that are used.
In some embodiments, the compiling and translating module corresponding to the CSS file is configured to, when compiling and packaging the file:
performing lexical analysis on the file by using the css-parser library to divide the file into a plurality of morpheme small files;
Using css-parser library to make grammar analysis on the file so as to combine each morpheme into an object model according to grammar rule;
converting the grammar of the object model by utilizing postcss plug-in units so that the converted grammar meets the grammar requirement of the JavaScript environment of the browser;
code optimization is carried out on the converted object model by utilizing cssnano plug-ins, wherein the code optimization at least comprises merging rules, deleting unused rules and compressing codes;
and converting the optimized object model back to the source code by utilizing cssom library to obtain the compiled and packaged file.
In this embodiment, the compiling and translating module for CSS files also performs lexical analysis, syntax conversion, code optimization and code generation on the files.
It should be noted that, the file package also has a picture file and a font file, and the picture file and the font file also have corresponding compiling and translating modules, which are not limited in detail herein.
In some embodiments, the building tool further includes a thermal update module, where the thermal update module is connected to the incremental compiling module, and the thermal update module is configured to send an update notification to the client after the incremental compiling module invokes the compiling and translating module to recompile and package the change file and all target files that depend on the change file, and reload and update the corresponding module after the client receives the notification, to implement thermal update.
In some embodiments, the construction tool further includes a source code mapping module, where the source code mapping module is connected to the compiling and translating module and is configured to record a correspondence between source codes and generated codes in the compiling and translating process, so as to load the source codes corresponding to the generated codes through the correspondence when the generated codes are checked.
In this embodiment, the source code mapping may map the compiled, translated, or compressed code back to the original source code. When the generated code output by the compiling and translating module is wrong, a developer can find the position in the original code through source code mapping, so that debugging is convenient.
When generating the source code mapping, the source code mapping module records the corresponding relation between the source code and the generated code in the compiling and translating process. This correspondence will typically be stored in a separate map file or embedded directly into the generated code. In a web browser, when a developer opens a developer tool and views the source code of a file, the browser automatically loads the source code map of the file and displays the original source code, rather than compiled code. When the code has errors, the browser also uses the source code mapping to display the position of the errors in the original source code, thereby facilitating debugging of a developer.
As shown in fig. 2, the present embodiment further provides a method for constructing a tool according to any one of the embodiments of the present disclosure, which operates in a Rust development environment, and the method includes:
Step 200, analyzing the import statement of each file in the file package by utilizing a dependency processing module, and processing the cyclic dependency based on the initial dependency graph to obtain a dependency graph after the initial dependency graph is obtained;
Step 202, compiling each type of file in the package file in parallel according to the dependency graph by utilizing a compiling and translating module;
In step 204, when the files in the file package are changed, the incremental compiling module determines all target files depending on the changed files based on the dependency graph, and sequentially invokes the compiling and translating modules of corresponding types based on the types of the changed files and the target files, so as to recompile and package the changed files and the target files.
The content of the method is based on the same concept as that of the tool embodiment of the present invention, and specific content can be referred to the description of the tool embodiment of the present invention, which is not repeated here.
It is noted that relational terms such as first and second, and the like, are used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Moreover, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus.
Those of ordinary skill in the art will appreciate that: all or part of the steps for implementing the above method embodiments may be implemented by hardware related to program instructions, and the foregoing program may be stored in a computer readable storage medium, where the program, when executed, performs steps including the above method embodiments; and the aforementioned storage medium includes: various media in which program code may be stored, such as ROM, RAM, magnetic or optical disks.
Finally, it should be noted that: the above embodiments are only for illustrating the technical solution of the present invention, and are not limiting; although the invention has been described in detail with reference to the foregoing embodiments, it will be understood by those of ordinary skill in the art that: the technical scheme described in the foregoing embodiments can be modified or some technical features thereof can be replaced by equivalents; such modifications and substitutions do not depart from the spirit and scope of the technical solutions of the embodiments of the present invention.
Claims (8)
1. A Rust development-based front-end build tool, for application in a Rust development environment, the tool comprising: the device comprises a dependence processing module, an increment compiling module and a plurality of compiling and translating modules; wherein each compiling and translating module processes a type of file correspondingly;
The dependency processing module is used for analyzing the import statement of each file in the file package to generate a dependency graph and processing circular dependencies based on the dependency graph;
the compiling and translating modules are connected with the dependency processing module and are used for compiling and packing files of all types in the file package in parallel based on the dependency graph;
The increment compiling module is used for determining all target files depending on the changed files based on the dependency graph when the files in the file package are changed, and calling compiling and translating modules of corresponding types in sequence based on the types of the changed files and the target files so as to recompile and package the changed files and the target files;
the increment compiling module is specifically used for:
For each file update, performing:
judging the number of changed files in the current file updating;
When the number of the changed files is 1, constructing a single thread to determine all target files depending on the changed files based on the dependency graph, and calling compiling and translating modules of corresponding types in sequence based on the types of the changed files and the target files to recompile and package the changed files and the target files;
when the number of the files is larger than 1, determining whether the changed files have a dependency relationship or not based on the dependency graph;
When the number of the change files without the dependency relationship is smaller than or equal to the number of CPU cores, constructing a plurality of threads with the same number as the change files, and recompiling and packaging each change file and a target file depending on the change file in parallel by utilizing the plurality of threads;
When the number of the change files without the dependency relationship is larger than the number of the CPU cores, a plurality of threads with the number equal to the number of the CPU cores are constructed, and each change file and the target file depending on the change file are recompiled and packaged in parallel in batches.
2. The construction tool according to claim 1, wherein the dependency graph in the dependency processing module comprises nodes corresponding to each file one by one, and a guide line exists between the nodes and is used for representing the dependency relationship;
the dependency processing module, when executing the processing of the circular dependency based on the dependency graph, is configured to:
Invoking a search algorithm to perform circular dependency detection on the dependency graph;
Flattening the multiple dependencies, simplifying the dependency relationship, and optimizing the dependency graph;
When the circular dependence is detected, pushing the file information of the circular dependence to alarm.
3. The building tool according to claim 1, wherein each compiling and translating module is configured to, when compiling and packaging each document in parallel:
determining files without a dependency relationship based on the dependency graph;
Based on the number of CPU cores, a plurality of threads are constructed to compile and package files without dependency relationship in parallel based on the types of the files.
4. The build tool of claim 1, wherein the types of files include at least: javaScript files, TYPESCRIPT files, and CSS files; the compiling and translating modules of the JavaScript file and the TYPESCRIPT file are the same;
The compiling and translating modules corresponding to the JavaScript file and TYPESCRIPT file are used for, when compiling and packaging the files:
performing lexical analysis on the file by utilizing the swc library so as to divide the file into a plurality of morpheme small files;
Utilizing swc library to make grammar analysis on said file so as to combine every morpheme into an abstract grammar tree according to grammar rule;
Utilizing babel plug-in units to carry out grammar conversion on the abstract grammar tree so as to enable the converted grammar to meet the grammar requirement of JavaScript environment of a browser;
Performing code optimization on the converted abstract syntax tree by utilizing uglify plugins, wherein the code optimization at least comprises the steps of deleting unused codes, simplifying expressions and compressing codes;
And converting the optimized abstract syntax tree back to the source code by utilizing the swc library to obtain a compiled and packaged file.
5. The build tool of claim 4, wherein the corresponding compiling and translating module of the CSS file is configured to, when compiling and packaging the file:
performing lexical analysis on the file by using the css-parser library to divide the file into a plurality of morpheme small files;
Using css-parser library to make grammar analysis on the file so as to combine each morpheme into an object model according to grammar rule;
Carrying out grammar conversion on the object model by utilizing postcss plug-in units so that the converted grammar accords with the grammar requirement of the JavaScript environment of the browser;
code optimization is carried out on the converted object model by utilizing cssnano plug-ins, wherein the code optimization at least comprises merging rules, deleting unused rules and compressing codes;
and converting the optimized object model back to the source code by utilizing cssom library to obtain the compiled and packaged file.
6. The build tool of claim 1, further comprising a thermal update module, the thermal update module being coupled to the incremental compilation module, the thermal update module configured to send an update notification to the client after the incremental compilation module invokes the compilation and translation module to recompile and package the change file and all target files that rely on the change file, and reload and update the corresponding module to implement the thermal update after the client receives the notification.
7. The build tool of claim 1, further comprising a source code mapping module, coupled to the compiling and translating module, for recording a correspondence between source code and generated code during compiling and translating, such that when the generated code is viewed, the source code corresponding to the generated code is loaded via the correspondence.
8. A method of building based on the build tool of any one of claims 1-7, running in a Rust development environment, the method comprising:
analyzing the import statement of each file in the file package by utilizing a dependency processing module, and processing the cyclic dependency based on the initial dependency graph to obtain a dependency graph after obtaining the initial dependency graph;
compiling and packaging all types of files in the file package in parallel by utilizing a compiling and translating module according to the dependency graph;
When the files in the file package are changed, the incremental compiling module determines all target files depending on the changed files based on the dependency graph, and sequentially calls compiling and translating modules of corresponding types based on the changed files and the types of the target files so as to recompile and package the changed files and the target files.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311825009.1A CN117785213B (en) | 2023-12-27 | 2023-12-27 | Front-end construction tool and construction method based on Rust development |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202311825009.1A CN117785213B (en) | 2023-12-27 | 2023-12-27 | Front-end construction tool and construction method based on Rust development |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN117785213A CN117785213A (en) | 2024-03-29 |
| CN117785213B true CN117785213B (en) | 2024-06-11 |
Family
ID=90385047
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202311825009.1A Active CN117785213B (en) | 2023-12-27 | 2023-12-27 | Front-end construction tool and construction method based on Rust development |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN117785213B (en) |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109766099A (en) * | 2018-12-11 | 2019-05-17 | 浙江口碑网络技术有限公司 | Front end source code Compilation Method, device, storage medium and computer equipment |
| CN115048106A (en) * | 2022-06-22 | 2022-09-13 | 中电信数智科技有限公司 | Source code parallel compiling method and system |
| CN115113876A (en) * | 2022-06-29 | 2022-09-27 | 武汉烽火技术服务有限公司 | Incremental compiling method and device based on source code detection |
| CN115270034A (en) * | 2022-05-10 | 2022-11-01 | 民商数字科技(深圳)有限公司 | Method for using picture processing component for Web site project |
| CN117149209A (en) * | 2023-08-30 | 2023-12-01 | 济南浪潮数据技术有限公司 | Code increment compiling method and device, computer equipment and storage medium |
-
2023
- 2023-12-27 CN CN202311825009.1A patent/CN117785213B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109766099A (en) * | 2018-12-11 | 2019-05-17 | 浙江口碑网络技术有限公司 | Front end source code Compilation Method, device, storage medium and computer equipment |
| CN115270034A (en) * | 2022-05-10 | 2022-11-01 | 民商数字科技(深圳)有限公司 | Method for using picture processing component for Web site project |
| CN115048106A (en) * | 2022-06-22 | 2022-09-13 | 中电信数智科技有限公司 | Source code parallel compiling method and system |
| CN115113876A (en) * | 2022-06-29 | 2022-09-27 | 武汉烽火技术服务有限公司 | Incremental compiling method and device based on source code detection |
| CN117149209A (en) * | 2023-08-30 | 2023-12-01 | 济南浪潮数据技术有限公司 | Code increment compiling method and device, computer equipment and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN117785213A (en) | 2024-03-29 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| KR100311585B1 (en) | System and method for optimizing template object files | |
| US6434742B1 (en) | Symbol for automatically renaming symbols in files during the compiling of the files | |
| WO2013036703A2 (en) | Profile guided jit code generation | |
| US11526433B2 (en) | Data structure allocation into storage class memory during compilation | |
| Wilhelm et al. | Compiler design: syntactic and semantic analysis | |
| Gurfinkel et al. | A context-sensitive memory model for verification of C/C++ programs | |
| CN108595334B (en) | Method and device for calculating dynamic slices of Java program and readable storage medium | |
| US5960197A (en) | Compiler dispatch function for object-oriented C | |
| CN112905447B (en) | Test method and system for block chain virtual machine | |
| KR20120115304A (en) | Efficient immutable syntax representation with incremental change | |
| CN112379917A (en) | Browser compatibility improving method, device, equipment and storage medium | |
| Li et al. | Scalpel: The python static analysis framework | |
| Fritzson et al. | Towards Modelica 4 meta-programming and language modeling with MetaModelica 2.0 | |
| CN116594622A (en) | Python program compiling method and system based on type deduction and data flow analysis | |
| Juričić | Detecting source code similarity using low-level languages | |
| CN113703779A (en) | Cross-platform multi-language compiling method and ultra-light Internet of things virtual machine | |
| CN113849781A (en) | Go language source code obfuscation method, system, terminal and storage medium | |
| Fritzson et al. | Meta-programming and language modeling with MetaModelica 1.0 | |
| CN117032719A (en) | Static compiling method and device for TypeScript | |
| JP2022522880A (en) | How to generate representations of program logic, decompilers, recompile systems and computer program products | |
| CN117785213B (en) | Front-end construction tool and construction method based on Rust development | |
| Fritzson et al. | Metamodelica–a symbolic-numeric modelica language and comparison to julia | |
| CN114912110B (en) | Node. Js code safety detection method and system | |
| US11714609B2 (en) | Automatic generation of source code implementing a regular expression | |
| Nakamaru et al. | Generating fluent embedded domain-specific languages with subchaining |
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 |