CN111309308A - Method, device and computer readable storage medium for adding shell to C and C + + compiler - Google Patents
Method, device and computer readable storage medium for adding shell to C and C + + compiler Download PDFInfo
- Publication number
- CN111309308A CN111309308A CN202010125343.6A CN202010125343A CN111309308A CN 111309308 A CN111309308 A CN 111309308A CN 202010125343 A CN202010125343 A CN 202010125343A CN 111309308 A CN111309308 A CN 111309308A
- Authority
- CN
- China
- Prior art keywords
- compiler
- compiling
- command
- program
- executed
- 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.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/37—Compiler construction; Parser generation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/42—Syntactic analysis
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/43—Checking; Contextual analysis
- G06F8/436—Semantic checking
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computational Linguistics (AREA)
- Devices For Executing Special Programs (AREA)
Abstract
The present invention relates to a method, apparatus and computer-readable storage medium for shelling C and C + + compilers. The method comprises the following steps: step 1: calling a make command through a shell adding program, wherein the make command calls a makefile to generate a compiling instruction in real time; step 2: detecting whether a corresponding virtual compiler is generated; and step 3: calling make to execute a compiling command; and 4, step 4: after the compiling command is utilized, the compiling command is really executed; and 5: deleting the generated corresponding virtual compiler. The invention solves the problem of how to monitor the compiler and know the context environment and the reference relation of the compiler when carrying out grammar and semantic analysis, ensures the originality of the compiling script and reduces errors caused by changing the script, is simple and efficient to use, and can meet various service requirements.
Description
Technical Field
The invention relates to the technical field of source code security scanning, in particular to a method and equipment for adding shells to C and C + + compilers and a computer-readable storage medium.
Background
At present, with the development of information technology and the widespread use of networks in modern life, various hacking attacks and network security events are emerging. According to the 2018 network information security incident report issued by world authoritative information security consulting company Gartner, 70% of network attacks are from application level attacks. Therefore, security detection and security protection for application systems have become important in security protection for companies and units. The safety detection of the source code is an important means for ensuring the safety of the application system, the code amount is large, the manual detection is easy to miss, and the safety knowledge of detection personnel is seriously relied on. Code leakage detection by using programs and security detection tools is an indispensable means.
The theoretical basis of the code detection tool is to realize higher-level control flow analysis and data flow analysis according to basic syntax, semantic and context environment analysis. Compilers have natural advantages in grammatical and semantic analysis. Therefore, how to obtain the syntactic and semantic information of the target program by using a compiler is the problem to be solved firstly. The JAVA compiler JDK provides interfaces for syntactic and semantic information, but the C/C + + compilers of the respective versions do not provide interfaces for syntactic and semantic information, and then shell the compiler to obtain the dependencies of system libraries and third packages required for compilation, and various parameters in compilation.
The syntax and semantic parsing of the C/C + + language is one of application methods for shell adding, and the shell adding of the compiler can also be applied to other aspects, such as monitoring the parsing efficiency of the compiler, monitoring which system resources are used by the compiler, causing the compiler to pause or interrupt during the language parsing process, and the like.
Disclosure of Invention
The technical problem to be solved by the present invention is to provide a method, apparatus and computer readable storage medium for shelling C and C + + compilers so that the compiler can be monitored to know its context and reference relationships when performing syntax and semantic analysis.
Specifically, the C/C + + language is known for its efficient operation, and is now widely used in bank core switching systems and a large number of single-chip instruction sets. The security of the C/C + + system is always one of the focuses of information security personnel and system operation and maintenance personnel, and the analysis of security vulnerabilities of source codes is an indispensable work. Developing a professional tool to analyze the security vulnerability of the C/C + + code firstly needs to analyze the syntax and the semantics of the C/C + + code. The context and reference relationships thereof need to be known when performing syntactic and semantic analysis. The monitoring compiler can conveniently know the information about the compiling process of each file. There is a need for a method to monitor a compiler, i.e. a method to shell a compiler.
Technical objects that can be achieved by the present invention are not limited to what has been particularly described above, and other technical objects that are not described herein will be more clearly understood by those skilled in the art from the following detailed description.
The technical scheme for solving the technical problems is as follows:
according to an aspect of the disclosure, the present invention provides a method for shelling C and C + + compilers, characterized in that the method comprises:
step 1: calling a make command through a shell adding program, wherein the make command calls a makefile to generate a compiling instruction in real time;
step 2: detecting whether a corresponding virtual compiler is generated;
and step 3: calling make to execute a compiling command;
and 4, step 4: after the compiling command is utilized, the compiling command is really executed;
and 5: deleting the generated corresponding virtual compiler.
Optionally, in the method as described above, in step 1, after the compiling instruction is generated, the underlying compiler is called again to execute the compiling instruction.
Optionally, in the method as described above, in step 2, if no corresponding virtual compiler is detected, a corresponding virtual compiler is generated in real time, the name of the compiled virtual compiler is the same as the name of the real compiler, the shell application first finds the real compiler under the environment variable of the system, then generates a corresponding script file in the temporary directory, the corresponding script file has all the received parameters, and then passes all the parameters to the shell application.
Optionally, in the method as described above, in step 3, when the compiling command is executed, the compiling command finds the virtual compiler, the virtual compiler passes all commands and parameters into the shell, and the shell obtains all parameters and context of the current compiling command, and performs syntax and semantic processing on the current compiling object.
Optionally, in the method as described above, in step 4, the compiling command continues to be called in JAVA, and the currently executed path is directed to the path where the real compiler is located.
According to an aspect of the present disclosure, the present invention provides an apparatus for shelling C and C + + compilers, comprising: memory, a processor and a computer program stored on the memory and executable on the processor, the computer program when executed by the processor implementing the steps of the method of shelling C and C + + compilers as set forth in any of the above.
According to an aspect of the present disclosure, the present invention provides a computer-readable storage medium, wherein an implementation program for information transfer is stored on the computer-readable storage medium, and when the program is executed by a processor, the program implements the steps of the method for shelling C and C + + compilers according to any one of the above.
The above-described embodiments are only some of the embodiments of the present invention, and those skilled in the art can derive and understand various embodiments including technical features of the present invention from the following detailed description of the present invention.
The technical scheme of the invention has no invasion to the compiler completely, and the content and the path of the original compiler are not changed. The method has no invasion to the compiling script, and does not change the compiling script makefile or make. The method ensures the originality of the compiled script and reduces errors caused by changing the script. The shell adding method has super strong adaptability and can completely adapt to almost all conditions of C/C + +. As the compiler and the script are not changed, the mapping of the simple environment variable is only carried out. And completely controlling the compiling execution process, wherein the compiling instruction enters the shell adding program, the compiling state is suspended, and the suspension time is controlled by a technician. All context and generated intermediate files are in a suspended state. There is sufficient time to analyze the syntax and semantics of the current target file. The technical scheme of the invention is simple to use and high-efficiency, and can meet the requirements of various services. Only the shell adding program needs to be operated, the execution of the compiling script, the generation of the virtual compiler, the acquisition of the compiling instruction and the context environment can be completed, then the service is executed, and finally the compiler is enabled to really execute.
It will be appreciated by persons skilled in the art that the effects that can be achieved by the present invention are not limited to what has been particularly described hereinabove and other advantages of the present invention will be more clearly understood from the following detailed description.
Drawings
The accompanying drawings, which are included to provide a further understanding of the invention, illustrate embodiments of the invention and together with the description serve to explain the principle of the invention.
Fig. 1 is a flowchart of a method for shelling C and C + + compilers according to an embodiment of the present invention.
Fig. 2 is a schematic diagram of a method for shelling C and C + + compilers according to an embodiment of the present invention.
Fig. 3 is a schematic diagram of an apparatus for shelling C and C + + compilers according to an embodiment of the present invention.
Detailed Description
Reference will now be made in detail to exemplary embodiments of the invention, examples of which are illustrated in the accompanying drawings. The detailed description, which will be given below with reference to the accompanying drawings, is intended to explain exemplary embodiments of the present invention, rather than to show the only embodiments that can be implemented according to the present invention. The following detailed description includes specific details in order to provide a thorough understanding of the invention. It will be apparent, however, to one skilled in the art that the present invention may be practiced without these specific details.
In some instances, well-known structures and devices are omitted or shown in block diagram form, focusing on important features of the structures and devices so as not to obscure the concept of the present invention. The same reference numbers will be used throughout the specification to refer to the same or like parts.
The principles and features of this invention are described below in conjunction with the following drawings, which are set forth by way of illustration only and are not intended to limit the scope of the invention.
In the description of the present invention, it is to be understood that the terms "upper", "lower", "center", "inner", "outer", "top", "bottom", and the like, indicate orientations or positional relationships based on the orientations or positional relationships shown in the drawings, and are only for convenience in describing the present invention and simplifying the description, but do not indicate or imply that the device or element referred to must have a particular orientation, be constructed and operated in a particular orientation, and thus, should not be construed as limiting the present invention.
In the description of the present invention, it should be noted that, unless otherwise explicitly specified or limited, the terms "mounted," "connected," and "connected" are to be construed broadly, e.g., as meaning either a fixed connection, a removable connection, or an integral connection; can be mechanically or electrically connected; they may be connected directly or indirectly through intervening media, or they may be interconnected between two elements. The instruction set refers to instructions and commands for directing the machine to work, the program refers to a series of instructions arranged in a certain sequence, and the process of executing the program is the working process of the computer. Grammar refers to a grammar that describes a computer language. Semantic analysis refers to a logic stage of the compiling process, and the task of semantic analysis is to perform context-related property examination and type examination on a structurally correct source program. A compiler refers to a program that translates "one language (typically a high-level language)" into "another language (typically a low-level language)". The C/C + + language is a general programming language oriented to process and abstraction, and is widely applied to bottom-layer development. The C language can compile and process low-level memory in a simple manner. C + + is an inheritance of the C language, and can be used for both procedural programming of the C language, object-based programming featuring abstract data types, and object-oriented programming featuring inheritance and polymorphism. The specific meanings of the above terms in the present invention can be understood in specific cases to those skilled in the art.
Example 1
Fig. 1 is a flowchart illustrating a method for shelling C and C + + compilers according to an embodiment of the present invention. The embodiment of the invention provides a method for adding shells to C and C + + compilers, which comprises the following steps: step 1: calling a make command through a shell adding program, wherein the make command calls a makefile to generate a compiling instruction in real time; step 2: detecting whether a corresponding virtual compiler is generated; and step 3: calling make to execute a compiling command; and 4, step 4: after the compiling command is utilized, the compiling command is really executed; and 5: deleting the generated corresponding virtual compiler. Optionally, in step 1, after the compiling instruction is generated, the underlying compiler is called to execute the compiling instruction. Optionally, in step 2, if the corresponding virtual compiler is not detected, the corresponding virtual compiler is generated in real time, the name of the compiled virtual compiler is the same as the name of the real compiler, the shell adding program first finds the real compiler under the environment variable of the system, then generates a corresponding script file in the temporary directory, the corresponding script file has all the received parameters, and then transmits all the parameters to the shell adding program. Optionally, in step 3, when the compiling command is executed, the compiling command finds the virtual compiler, the virtual compiler transmits all commands and parameters to the shell application, and the shell application obtains all parameters and context of the current compiling command and performs syntax and semantic processing on the current compiling object. Optionally, in step 4, the compiling command is continuously called in JAVA, and the currently executed path is directed to the path where the real compiler is located.
According to the embodiment of the present invention, referring to fig. 2, the technical solution of the present invention is to create a virtual compiler on the target machine, and then direct the path of the system environment variable to the compiler, and the content of the virtual compiler is simply to pass the compiled instruction to the program of the present invention. All compiling instructions and parameters are obtained in the program, and then syntax and semantic analysis can be carried out through the compiling instructions and the parameters. And continuing to run the correct compiling instruction after the analysis is finished by pointing the path of the environment variable to the original path. The shell adding program of the present invention is developed by using JAVA language, in which the script can be directly called or the instruction of the current operating system can be directly executed, and the environment variable of the current instruction can be specified, which provides a good method for replacing the path of the compiler.
As shown in FIG. 2, when a C/C + + project is compiled, the makefile is called by executing the make command (the makefile is the script of the compilation project). Firstly, calling a make command (01) in a shell adding program, calling the make command to a makefile (02), generating a compiling instruction (03) by the makefile in real time, detecting whether a corresponding virtual compiler (04) exists by the shell adding program, if the virtual compiler is not generated in real time, executing the compiling instruction by the shell adding program, and specifying a path from an environment variable of a system to the virtual compiler, transmitting all commands to the shell adding program through the virtual compiler when the compiling instruction (03) is executed, taking all execution parameters and context relations by the shell adding program, and carrying out syntactic and semantic analysis or other predetermined operations on the commands. After the operation is completed, the environment variable of the system is appointed to the position of a real compiler (05), and then the real compiler is really compiled.
More specifically, the actual operation of the method of the present invention can be illustrated with reference to fig. 2, in which a virtual compiler is created on the target computer, so that all the compiling instructions and context information are transferred to the virtual compiler and then transferred to the shell program of the present invention, and the shell program processes or processes the information and then transfers the information to the real compiler for execution. The specific steps are as follows:
1. the method comprises the steps that a command line script is executed through a program, the makefile is a compiling script of a C/C + + language, a compiler provides a make command to execute compiling, the make generates a specific compiling instruction by calling the makefile, and then a bottom compiler is called to execute the compiling instruction.
2. And detecting whether a corresponding virtual compiler is generated or not before the program calls the make command, and if the corresponding virtual compiler is not generated, generating the virtual compiler in real time, wherein the name of the compiled virtual compiler is the same as the name of the real compiler. The program will first find the real compiler, e.g., c + +, xlc, cc, etc., under the system's environment variables, e.g., the/usr/bin, which are all binary execution files. Then, the temporary directory generates corresponding script files, for example, the contents in c.sh, c + +. sh, xlc.sh and cc.sh receive all the parameters, and then all the parameters are transmitted to the program.
3. And calling the make by the program to execute the compiling command, and generating the virtual compiler in the previous step. When a specific compiling command is executed, the command finds a virtual compiler, the virtual compiler transmits all commands and parameters to a shell adding program, the shell adding program obtains all parameters and context environment of the current compiling command, and at the moment, grammar and semantic processing can be carried out on the current compiling object.
4. After the compiling command is used, the compiling command is actually executed by continuing to call the compiling command in JAVA to point the currently executed path to the path of the real compiler, such as/usr/bin/c.
5. After the work to be done is completed, the generated virtual compiler, e.g., c.sh, c + +. sh, xlc.sh, etc., can be deleted.
Example 2
According to an embodiment of the present invention, the present invention provides an apparatus for shelling C and C + + compilers, as shown in fig. 3, including: a memory 10, a processor 12 and a computer program stored on said memory 10 and executable on said processor 12, said computer program when executed by said processor 12 implementing the steps of a method of shelling C and C + + compilers as described in embodiment 1 above.
Example 3
According to an embodiment of the present invention, there is provided a computer-readable storage medium having stored thereon an information delivery implementation program, which when executed by a processor implements the steps of a method of shelling C and C + + compilers as described in embodiment 1 above.
The technical scheme of the invention has no invasion to the compiler completely, and the content and the path of the original compiler are not changed. The method has no invasion to the compiling script, and does not change the compiling script makefile or make. The method ensures the originality of the compiled script and reduces errors caused by changing the script. The shell adding method has super strong adaptability and can completely adapt to almost all conditions of C/C + +. As the compiler and the script are not changed, the mapping of the simple environment variable is only carried out. And completely controlling the compiling execution process, wherein the compiling instruction enters the shell adding program, the compiling state is suspended, and the suspension time is controlled by a technician. All context and generated intermediate files are in a suspended state. There is sufficient time to analyze the syntax and semantics of the current target file. The method is simple to use and efficient, and can meet the requirements of various services. Only the shell adding program needs to be operated, the execution of the compiling script, the generation of the virtual compiler, the acquisition of the compiling instruction and the context environment can be completed, then the service is executed, and finally the compiler is enabled to really execute.
From the above description of the embodiments, it is obvious for those skilled in the art that the present application can be implemented by software and necessary general hardware, and of course, can also be implemented by hardware. Based on such understanding, the technical solutions of the present application may be embodied in the form of a software product, which may be stored in a computer-readable storage medium, such as a floppy disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a FLASH Memory (FLASH), a hard disk or an optical disk of a computer, and includes several instructions for enabling a computer device (which may be a personal computer, a server, or a network device) to execute the methods described in the embodiments of the present application.
As mentioned above, a detailed description of the preferred embodiments of the invention has been given to enable those skilled in the art to make and practice the invention. Although the present invention has been described with reference to exemplary embodiments, those skilled in the art will appreciate that various modifications and changes can be made in the present invention without departing from the spirit or scope of the invention described in the appended claims. Thus, the present invention is not intended to be limited to the particular embodiments shown and described herein but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.
Claims (7)
1. A method of shelling C and C + + compilers, the method comprising:
step 1: calling a make command through a shell adding program, wherein the make command calls a makefile to generate a compiling instruction in real time;
step 2: detecting whether a corresponding virtual compiler is generated;
and step 3: calling make to execute a compiling command;
and 4, step 4: after the compiling command is utilized, the compiling command is really executed;
and 5: deleting the generated corresponding virtual compiler.
2. The method of claim 1, wherein the first and second light sources are selected from the group consisting of,
in step 1, after the compiling instruction is generated, the underlying compiler is called to execute the compiling instruction.
3. The method of claim 1, wherein the first and second light sources are selected from the group consisting of,
the method is characterized in that in step 2, if the corresponding virtual compiler is not detected, the corresponding virtual compiler is generated in real time, the name of the compiled virtual compiler is the same as that of the real compiler, the shell adding program firstly finds the real compiler under the environment variable of the system, then generates a corresponding script file in a temporary directory, the corresponding script file has all received parameters, and then transmits all the parameters to the shell adding program.
4. The method of claim 1, wherein the first and second light sources are selected from the group consisting of,
the method is characterized in that in step 3, when the compiling command is executed, the compiling command finds the virtual compiler, the virtual compiler transmits all commands and parameters to the shell adding program, and the shell adding program obtains all parameters and context environment of the current compiling command and carries out grammar and semantic processing on the current compiling object.
5. The method of claim 1, wherein the first and second light sources are selected from the group consisting of,
in step 4, the compiling command is continuously called in JAVA, and the currently executed path is directed to the path where the real compiler is located.
6. An apparatus for shelling C and C + + compilers, comprising: memory, processor and computer program stored on the memory and executable on the processor, the computer program when executed by the processor implementing the steps of the method of shelling C and C + + compilers according to any of claims 1 to 5.
7. A computer-readable storage medium, having stored thereon an implementation program of information transfer, which when executed by a processor implements the steps of the method of shelling C and C + + compilers as claimed in any of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010125343.6A CN111309308A (en) | 2020-02-27 | 2020-02-27 | Method, device and computer readable storage medium for adding shell to C and C + + compiler |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010125343.6A CN111309308A (en) | 2020-02-27 | 2020-02-27 | Method, device and computer readable storage medium for adding shell to C and C + + compiler |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN111309308A true CN111309308A (en) | 2020-06-19 |
Family
ID=71145306
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010125343.6A Pending CN111309308A (en) | 2020-02-27 | 2020-02-27 | Method, device and computer readable storage medium for adding shell to C and C + + compiler |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111309308A (en) |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6973646B1 (en) * | 2000-07-21 | 2005-12-06 | International Business Machines Corporation | Method for compiling program components in a mixed static and dynamic environment |
| CN101154259A (en) * | 2007-08-27 | 2008-04-02 | 电子科技大学 | General automated shelling engine and method |
| CN101697135A (en) * | 2009-10-28 | 2010-04-21 | 北京东方网力科技有限公司 | Method and device for compiling program |
| CN105094939A (en) * | 2015-07-16 | 2015-11-25 | 南京富士通南大软件技术有限公司 | Method for realizing static analysis of software source files based on Makefile automatic compilation technology |
| CN105164641A (en) * | 2012-12-31 | 2015-12-16 | 微软技术许可有限责任公司 | Extending development environment |
| CN106648681A (en) * | 2016-12-29 | 2017-05-10 | 南京科远自动化集团股份有限公司 | System and method for compiling and loading programmable language |
-
2020
- 2020-02-27 CN CN202010125343.6A patent/CN111309308A/en active Pending
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US6973646B1 (en) * | 2000-07-21 | 2005-12-06 | International Business Machines Corporation | Method for compiling program components in a mixed static and dynamic environment |
| CN101154259A (en) * | 2007-08-27 | 2008-04-02 | 电子科技大学 | General automated shelling engine and method |
| CN101697135A (en) * | 2009-10-28 | 2010-04-21 | 北京东方网力科技有限公司 | Method and device for compiling program |
| CN105164641A (en) * | 2012-12-31 | 2015-12-16 | 微软技术许可有限责任公司 | Extending development environment |
| CN105094939A (en) * | 2015-07-16 | 2015-11-25 | 南京富士通南大软件技术有限公司 | Method for realizing static analysis of software source files based on Makefile automatic compilation technology |
| CN106648681A (en) * | 2016-12-29 | 2017-05-10 | 南京科远自动化集团股份有限公司 | System and method for compiling and loading programmable language |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10698668B1 (en) | Custom code transformations during compilation process | |
| US7032216B1 (en) | Native compilation and safe deployment of virtual machine code | |
| CN113872948A (en) | Method for executing intelligent contract, block chain node and node equipment | |
| CN111736954B (en) | Multi-intelligent contract virtual machine implementation method, multi-intelligent contract virtual machine and system | |
| CA2680315A1 (en) | Optimized code generation through elimination of unused virtual functions | |
| CN101533454B (en) | Compiling method | |
| CN104462943A (en) | Non-intrusive performance monitoring device and method for service system | |
| CN111768187A (en) | Method for deploying intelligent contract, block chain node and storage medium | |
| Liao et al. | Smartdagger: a bytecode-based static analysis approach for detecting cross-contract vulnerability | |
| CN107577609A (en) | A kind of embedded system dynamic module adjustment method of Intrusion Detection based on host end dynamic link | |
| CN111580931A (en) | Matching rule engine supporting combined expression of multiple protocol variables | |
| CN101739280A (en) | System and method for optimizing byte codes for JAVA card | |
| CN113220326B (en) | Intelligent contract upgrading method and block chain system | |
| CN110472411B (en) | Memory overflow processing method, device, equipment and readable storage medium | |
| CN111309308A (en) | Method, device and computer readable storage medium for adding shell to C and C + + compiler | |
| Yeung et al. | Improvements towards formalizing UML state diagrams in CSP | |
| CN116594622A (en) | Python program compiling method and system based on type deduction and data flow analysis | |
| CN113220327B (en) | Intelligent contract upgrading method and block chain system | |
| EP1653344A1 (en) | Embedded detection objects | |
| EP1136910A2 (en) | A method of compiling code in an object oriented programming language | |
| El Fallah Seghrouchni et al. | Claim and sympa: A programming environment for intelligent and mobile agents | |
| CN114707124B (en) | NET platform code protection method and system based on code virtualization | |
| CN115390913B (en) | Log monitoring method and device for zero code intrusion, electronic equipment and storage medium | |
| CN113553059B (en) | Local variable query method, device, server and storage medium | |
| US20060101398A1 (en) | Program output management |
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 |