CN112667974A - Graphical programming code protection method and device and terminal equipment - Google Patents
Graphical programming code protection method and device and terminal equipment Download PDFInfo
- Publication number
- CN112667974A CN112667974A CN202011475754.4A CN202011475754A CN112667974A CN 112667974 A CN112667974 A CN 112667974A CN 202011475754 A CN202011475754 A CN 202011475754A CN 112667974 A CN112667974 A CN 112667974A
- Authority
- CN
- China
- Prior art keywords
- graphical
- project
- code data
- edited
- item
- 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
- 238000000034 method Methods 0.000 title claims abstract description 48
- 238000004806 packaging method and process Methods 0.000 claims abstract description 11
- 238000004590 computer program Methods 0.000 claims description 21
- 238000006243 chemical reaction Methods 0.000 claims description 6
- 230000008569 process Effects 0.000 description 6
- 238000010586 diagram Methods 0.000 description 5
- 230000006870 function Effects 0.000 description 4
- 230000004044 response Effects 0.000 description 4
- 230000008878 coupling Effects 0.000 description 3
- 238000010168 coupling process Methods 0.000 description 3
- 238000005859 coupling reaction Methods 0.000 description 3
- 230000000007 visual effect Effects 0.000 description 3
- 238000004891 communication Methods 0.000 description 2
- 238000012545 processing Methods 0.000 description 2
- 238000012800 visualization Methods 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000013461 design Methods 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000005538 encapsulation Methods 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000003993 interaction 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
Images
Landscapes
- Stored Programmes (AREA)
Abstract
The application is applicable to the technical field of computers, and provides a graphical programming code protection method, which comprises the following steps: loading a graphical programming project; if the loaded graphical programming project is a project to be edited, graphically editing the project to be edited; converting the edited source code data into intermediate code data; and packaging the intermediate code data to generate a project to be shared, editing the source code data, converting the edited source code data into the intermediate code data, and sharing the project obtained by packaging the intermediate code data, so that other users can only run the project but cannot acquire the source code of the project, and the source code data of the graphical programming project is effectively protected.
Description
Technical Field
The application belongs to the technical field of computers, and particularly relates to a graphical programming code protection method, a graphical programming code protection device and terminal equipment.
Background
With the rapid development of computer technology, software and hardware programming is no longer a full-time job for IT personnel, and programmers may come from various industries in society. In fact, the world of programs remains elusive to most users, and the high difficulty in programming has been to explore the computer world's tripartite stones. The graphical programming language is a programming language which can encapsulate the bottom layer implementation, and a user can complete the corresponding programming task with complex logic only by simply dragging the programming component. For most users who are not computer specialized, the simple and intuitive graphical programming language can bring great convenience to the users.
However, at present, program editing and project operation of graphical programming software are integrated, so that when graphical programming projects are shared by other users, source code data can be packaged and shared out at the same time, and therefore the problem of source code leakage exists.
Disclosure of Invention
The embodiment of the application provides a graphical programming code protection method, a graphical programming code protection device and terminal equipment, and can solve the problem that a source code is leaked when a graphical programming project shares the project at present.
In a first aspect, an embodiment of the present application provides a graphical programming code protection method, including:
loading a graphical programming project;
if the loaded graphical programming project is a project to be edited, graphically editing the project to be edited;
converting the edited source code data into intermediate code data;
and packaging the intermediate code data to generate a project to be shared.
In a possible implementation manner of the first aspect, the graphical programming code protection method further includes:
and if the loaded graphical programming project is a project to be previewed, operating the project to be previewed in the graphical stage area.
In a possible implementation manner of the first aspect, the graphical programming code protection method further includes:
and uploading the edited source code data.
In a possible implementation manner of the first aspect, the graphical programming code protection method further includes:
and uploading the project to be shared while uploading the edited source code data.
In a possible implementation manner of the first aspect, if the loaded graphical programming item is an item to be edited, graphically editing the item to be edited includes:
downloading source code data in the project to be edited;
matching graphical building block definition data according to the source code data in the project to be edited;
and editing the graphical building block definition data through a graphical editor to obtain edited graphical building block definition data.
In a possible implementation manner of the first aspect, if the loaded graphical programming item is an item to be previewed, running the item to be previewed in the graphical stage area includes:
acquiring intermediate code data in the item to be previewed;
executing the intermediate state code data in a graphical virtual machine so that the graphical stage area runs the item to be previewed.
In a possible implementation manner of the first aspect, the graphical programming code protection method further includes:
and sending the intermediate state programming code to a graphical stage area for previewing.
In a second aspect, an embodiment of the present application provides a graphical programming code protection device, including:
the loading module is used for loading the graphical programming project;
the editing module is used for carrying out graphical editing on the project to be edited if the loaded graphical programming project is the project to be edited;
the conversion module is used for converting the edited source code data into intermediate code data;
and the packaging module is used for packaging the intermediate code data to generate a project to be shared.
In a third aspect, an embodiment of the present application provides a terminal device, including: a memory, a processor and a computer program stored in the memory and executable on the processor, the processor implementing the method according to the first aspect when executing the computer program.
In a fourth aspect, the present application provides a computer-readable storage medium, which stores a computer program, and when the computer program is executed by a processor, the computer program implements the method according to the first aspect.
In a fifth aspect, the present application provides a computer program product, which when run on a terminal device, causes the terminal device to execute the method of the first aspect.
It is understood that the beneficial effects of the second aspect to the fifth aspect can be referred to the related description of the first aspect, and are not described herein again.
Compared with the prior art, the embodiment of the application has the advantages that: the shared source code data is converted into an intermediate state language, wherein the intermediate state language is a programming language capable of being executed in a graphical programming virtual machine, and the intermediate state language can be compiled by a visual programming language (such as JSON/XML language of building block graphical programming) and cannot be compiled reversely. Therefore, the shared intermediate language can run but cannot be compiled reversely, and the source code data can be effectively protected from being leaked.
Drawings
In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings needed to be used in the embodiments or the prior art descriptions will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present application, and it is obvious for those skilled in the art to obtain other drawings without creative efforts.
FIG. 1 is a schematic diagram of an implementation flow of sharing and editing of a graphical programming project in the prior art;
FIG. 2 is a schematic flow chart illustrating an implementation of a graphical programming code protection method according to another embodiment of the present application;
FIG. 3 is a flowchart illustrating an implementation of a graphical programming code protection method according to another embodiment of the present application;
FIG. 4 is a schematic structural diagram of a graphical programming code protection device according to an embodiment of the present disclosure;
fig. 5 is a schematic structural diagram of a terminal device according to an embodiment of the present application.
Detailed Description
In the following description, for purposes of explanation and not limitation, specific details are set forth, such as particular system structures, techniques, etc. in order to provide a thorough understanding of the embodiments of the present application. It will be apparent, however, to one skilled in the art that the present application may be practiced in other embodiments that depart from these specific details. In other instances, detailed descriptions of well-known systems, devices, circuits, and methods are omitted so as not to obscure the description of the present application with unnecessary detail.
It will be understood that the terms "comprises" and/or "comprising," when used in this specification and the appended claims, specify the presence of stated features, integers, steps, operations, elements, and/or components, but do not preclude the presence or addition of one or more other features, integers, steps, operations, elements, components, and/or groups thereof.
It should also be understood that the term "and/or" as used in this specification and the appended claims refers to and includes any and all possible combinations of one or more of the associated listed items.
As used in this specification and the appended claims, the term "if" may be interpreted contextually as "when", "upon" or "in response to" determining "or" in response to detecting ". Similarly, the phrase "if it is determined" or "if a [ described condition or event ] is detected" may be interpreted contextually to mean "upon determining" or "in response to determining" or "upon detecting [ described condition or event ]" or "in response to detecting [ described condition or event ]".
Furthermore, in the description of the present application and the appended claims, the terms "first," "second," "third," and the like are used for distinguishing between descriptions and not necessarily for describing or implying relative importance.
Reference throughout this specification to "one embodiment" or "some embodiments," or the like, means that a particular feature, structure, or characteristic described in connection with the embodiment is included in one or more embodiments of the present application. Thus, appearances of the phrases "in one embodiment," "in some embodiments," "in other embodiments," or the like, in various places throughout this specification are not necessarily all referring to the same embodiment, but rather "one or more but not all embodiments" unless specifically stated otherwise. The terms "comprising," "including," "having," and variations thereof mean "including, but not limited to," unless expressly specified otherwise.
The graphical programming language is a programming language which can encapsulate the bottom layer implementation, and a user can complete the corresponding programming task with complex logic only by simply dragging the programming component. Common image-language programming tools include Blokly and Scratch. Blokly is a visual programming tool based on web pages, and an application program (software) can be constructed by dragging several graphic objects. And Scratch is a simple graphical programming tool developed by the massachusetts institute of technology, and programming can be realized by dragging building blocks (graphical objects) as well. Referring to fig. 1, fig. 1 is a schematic flow chart illustrating sharing and editing of a conventional graphical programming project. As shown in fig. 1, a user may upload some graphical programming projects developed by the user to a cloud server and generate corresponding address links, and other users may load the graphical programming projects through the links, load source code data through a graphical editor, and search for matched graphical building block definition data, so that editing operation may be performed on graphical building block definition data (graphical objects) through the graphical editor, and then obtain edited source code data, and after editing is completed, the source code data may be sent to a graphical stage area to be operated, so that an execution result of the graphical programming project may be checked in the graphical stage area. The source code data can also be packaged, then the packaged works are uploaded, and address links corresponding to the works are generated, so that the projects can be shared to other users.
However, since the running data and the shared data are both source code data, the source code data is easily leaked when the project is shared out.
In order to solve the above problem, an embodiment of the present application provides a graphical programming code protection method, which converts shared source code data into an intermediate language, where the intermediate language is a programming language capable of being executed in a graphical programming virtual machine, and the intermediate language is compiled from a visual programming language (e.g. a JSON/XML language of building block graphical programming) and cannot be compiled reversely. Therefore, the shared intermediate language can run but cannot be compiled reversely, and the source code data can be effectively protected from being leaked.
Fig. 2 is a flowchart illustrating a graphical programming code protection method provided by an embodiment of the present application, and as shown in fig. 2, the graphical programming code protection method may include S11 to S14, which are detailed as follows:
s11: the graphical programming items are loaded.
In the embodiment of the application, the graphical programming item corresponding to the link of a certain item can be loaded through the address link of the item.
In a specific application, after a user writes an application program through graphical programming software/tools, the written application program can be published on the internet, that is, graphical programming items of the user are shared on the internet. When the graphical programming item is released to the Internet, a corresponding address link is generated, and the graphical programming item can be searched and loaded through the address link.
S12: and if the loaded graphical programming item is the item to be edited, graphically editing the item to be edited.
In the embodiment of the application, if the loaded graphical programming item is an item to be edited, it indicates that the loaded code data is source code data, and at this time, a user can edit the source code data through a graphical editor of the graphical programming tool.
In an embodiment of the present application, the step of graphically editing the item to be edited may include:
downloading source code data in the project to be edited;
matching graphical building block definition data according to the source code data in the project to be edited;
and editing the graphical building block definition data through a graphical editor to obtain edited graphical building block definition data.
In the embodiment of the application, the graphical building block definition data can be edited through the graphical editor by downloading the source code data in the project to be edited and then correspondingly matching the graphical building block definition data.
In an embodiment of the present application, the source code data may be written based on a visualization programming language (e.g., JSON language/xml language, etc.).
In a specific application, the graphical building block definition data refers to execution data corresponding to each graphical object in the graphical programming project. It should be noted that, editing the graphic building block definition data by the graphic editor may be implemented by dragging a graphic object. Each graphical object has its corresponding graphical building block definition data, and matching source code data.
The edited graphical building block definition data can be compiled into corresponding source code data, namely the edited source code data.
S13: and converting the edited source code data into intermediate code data.
In this embodiment, the intermediate code data is code data that can be executed in a graphical programming virtual machine, and the intermediate code data can be compiled from source code data and cannot be compiled reversely. Such as Common Intermediate Language (CIL).
In the embodiment of the present application, the conversion of the source code data into the intermediate state code data may be realized by an intermediate state converter.
S14: and packaging the intermediate code data to generate a project to be shared.
In the embodiment of the application, when a user needs to share a written project, the corresponding intermediate code data is packaged, and then the project to be shared can be obtained. The user can publish the project to be shared on the internet, and the sharing of works can be achieved.
In summary, the graphical programming code protection method can edit source code data, convert the edited source code data into intermediate code data, and use the intermediate code data to encapsulate the obtained project during sharing, so that other users can only run the project but cannot obtain the source code of the project, thereby effectively protecting the source code data of the graphical programming project.
Referring to fig. 3, in another embodiment of the present application, different from the previous embodiment, the method for protecting a graphic programming code provided in the embodiment of the present application includes steps S21 to S29, which are detailed as follows:
s21: and loading the graphical coding item.
In this embodiment of the present application, the graphical coding item may be an item to be edited or an item to be previewed.
In the embodiment of the present application, when the graphical coding item is an item to be edited, it is stated that the code data loaded into the graphical coding item is source code data. When the graphical coding item is an item to be previewed, the code data loaded into the graphical coding item is intermediate code data.
S22: judging whether the graphical coding item is an item to be edited or an item to be previewed, and if the graphical coding item is the item to be edited, executing S23; if the graphical code item is an item to be previewed, S28 is executed.
In this embodiment of the application, determining whether the graphical coding item is an item to be edited or an item to be previewed may be implemented by determining whether the loaded code data is source code data or intermediate code data, where if the loaded code data is the source code data, it is determined that the graphical coding item is the item to be edited, and if the loaded code data is the intermediate code data, it is determined that the loaded graphical coding item is the item to be previewed.
S23: and carrying out graphical editing on the item to be edited.
In the embodiment of the application, if the loaded graphical programming item is an item to be edited, it indicates that the loaded code data is source code data, and at this time, a user can edit the source code data through a graphical editor of the graphical programming tool.
In an embodiment of the present application, the step of graphically editing the item to be edited may include:
downloading source code data in the project to be edited;
matching graphical building block definition data according to the source code data in the project to be edited;
and editing the graphical building block definition data through a graphical editor to obtain edited graphical building block definition data.
In the embodiment of the application, the graphical building block definition data can be edited through the graphical editor by downloading the source code data in the project to be edited and then correspondingly matching the graphical building block definition data.
In an embodiment of the present application, the source code data may be written based on a visualization programming language (e.g., JSON language/xml language, etc.).
In a specific application, the graphical building block definition data refers to execution data corresponding to each graphical object in the graphical programming project. It should be noted that, editing the graphic building block definition data by the graphic editor may be implemented by dragging a graphic object. Each graphical object has its corresponding graphical building block definition data, and matching source code data.
The edited graphical building block definition data can be compiled into corresponding source code data, namely the edited source code data.
S24: and converting the edited source code data into intermediate code data.
In this embodiment, the intermediate code data is code data that can be executed in a graphical programming virtual machine, and the intermediate code data can be compiled from source code data and cannot be compiled reversely. Such as Common Intermediate Language (CIL).
In the embodiment of the present application, the conversion of the source code data into the intermediate state code data may be realized by an intermediate state converter.
S25: and packaging the intermediate code data to generate a project to be shared.
In the embodiment of the application, when a user needs to share a written project, the corresponding intermediate code data is packaged, and then the project to be shared can be obtained.
S26: and uploading the item to be shared.
In the embodiment of the application, the user can upload the item to be shared to the cloud server, and after uploading, the address link corresponding to the item to be shared is generated. And the user can load the item to be shared corresponding to the intermediate code data through the address link.
S27: and uploading the edited source code data.
In the embodiment of the application, when the item to be shared is uploaded, source code data corresponding to the item to be shared (i.e., edited source code data) can be uploaded at the same time in order to facilitate the user to modify the application program written by the user.
It should be noted that, after uploading the source code data, the cloud server may also generate the corresponding address link.
The user can load the graphical programming item corresponding to the source code data through the address link.
S28: and acquiring intermediate code data in the item to be previewed.
S29: executing the intermediate state code data in a graphical virtual machine so that the graphical stage area runs the item to be previewed.
In the embodiment of the application, if the loaded graphical programming item is an item to be previewed, the loaded code data is the intermediate state code data. Therefore, the intermediate code data in the project to be previewed is downloaded and then executed in a graphical virtual machine (virtual machine VM), so that the intermediate code data can be run in a graphical stage area.
It should be noted that, after S24, if the programmer wants to preview his/her work, the converted intermediate state code data may be sent to the graphical virtual machine for execution, so as to preview the work in the graphical stage area.
According to the graphical programming code protection method provided by the embodiment of the application, edited source code data are converted into intermediate code data to be shared, and the intermediate code data are executed to preview graphical programming projects, so that the safety of the source codes is effectively guaranteed.
It should be understood that, the sequence numbers of the steps in the foregoing embodiments do not imply an execution sequence, and the execution sequence of each process should be determined by its function and inherent logic, and should not constitute any limitation to the implementation process of the embodiments of the present application.
Corresponding to the graphical programming code protection method described in the above embodiments, fig. 4 shows a structural block diagram of a graphical programming code protection device provided in the embodiments of the present application, and for convenience of explanation, only the portions related to the embodiments of the present application are shown.
Referring to fig. 4, the apparatus 10 includes: a loading module 101, an editing module 102, a conversion module 103, and an encapsulation module 104.
The loading module 101 is used for loading graphical programming items;
the editing module 102 is configured to perform graphical editing on the to-be-edited project if the loaded graphical programming project is the to-be-edited project;
the conversion module 103 converts the edited source code data into intermediate code data;
the packaging module 104 packages the intermediate code data to generate a to-be-shared item.
In a possible implementation manner, the apparatus may further include a preview module;
and the preview module is used for operating the item to be previewed in the graphical stage area if the loaded graphical programming item is the item to be previewed.
In a possible implementation manner, the apparatus may further include an uploading module.
The uploading module is used for uploading the edited source code data.
In a possible implementation manner, the uploading module is further configured to upload the item to be shared while uploading the edited source code data.
In one possible implementation, the edited module 102 includes: the device comprises a downloading unit, a matching unit and an editing unit.
The downloading unit is used for downloading the source code data in the project to be edited.
And the matching unit is used for matching the graphical building block definition data according to the source code data in the project to be edited.
The editing unit is used for editing the graphical building block definition data through a graphical editor to obtain edited graphical building block definition data.
In a possible implementation manner, the preview module includes an obtaining unit and an executing unit.
The acquisition unit is used for acquiring the intermediate code data in the item to be previewed.
The execution unit is used for executing the intermediate code data in a graphical virtual machine so as to enable the graphical stage area to run the item to be previewed.
It should be noted that, for the information interaction, execution process, and other contents between the above-mentioned devices/units, the specific functions and technical effects thereof are based on the same concept as those of the embodiment of the method of the present application, and specific reference may be made to the part of the embodiment of the method, which is not described herein again.
It will be apparent to those skilled in the art that, for convenience and brevity of description, only the above-mentioned division of the functional units and modules is illustrated, and in practical applications, the above-mentioned function distribution may be performed by different functional units and modules according to needs, that is, the internal structure of the apparatus is divided into different functional units or modules to perform all or part of the above-mentioned functions. Each functional unit and module in the embodiments may be integrated in one processing unit, or each unit may exist alone physically, or two or more units are integrated in one unit, and the integrated unit may be implemented in a form of hardware, or in a form of software functional unit. In addition, specific names of the functional units and modules are only for convenience of distinguishing from each other, and are not used for limiting the protection scope of the present application. The specific working processes of the units and modules in the system may refer to the corresponding processes in the foregoing method embodiments, and are not described herein again.
Fig. 5 is a schematic structural diagram of a terminal device according to an embodiment of the present application. As shown in fig. 5, the terminal device 5 of this embodiment includes: at least one processor 50 (only one shown in fig. 5), a memory 51, and a computer program 52 stored in the memory 51 and executable on the at least one processor 50, wherein the processor 50 implements the steps of any of the various graphical programming code protection method embodiments described above when executing the computer program 52.
The terminal device 5 may be a desktop computer, a notebook, a palm computer, a cloud server, or other computing devices. The terminal device may include, but is not limited to, a processor 50, a memory 51. Those skilled in the art will appreciate that fig. 5 is only an example of the terminal device 5, and does not constitute a limitation to the terminal device 5, and may include more or less components than those shown, or combine some components, or different components, such as an input-output device, a network access device, and the like.
The Processor 50 may be a Central Processing Unit (CPU), and the Processor 50 may be other general purpose Processor, a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), an off-the-shelf Programmable Gate Array (FPGA) or other Programmable logic device, discrete Gate or transistor logic device, discrete hardware component, etc. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like.
The memory 51 may in some embodiments be an internal storage unit of the terminal device 5, such as a hard disk or a memory of the terminal device 5. The memory 51 may also be an external storage device of the terminal device 5 in other embodiments, such as a plug-in hard disk, a Smart Media Card (SMC), a Secure Digital (SD) Card, a Flash memory Card (Flash Card), and the like, which are provided on the terminal device 5. Further, the memory 51 may also include both an internal storage unit and an external storage device of the terminal device 5. The memory 51 is used for storing an operating system, an application program, a BootLoader (BootLoader), data, and other programs, such as program codes of the computer program. The memory 51 may also be used to temporarily store data that has been output or is to be output.
The embodiments of the present application further provide a computer-readable storage medium, where a computer program is stored, and when the computer program is executed by a processor, the computer program implements the steps in the above-mentioned method embodiments.
The embodiments of the present application provide a computer program product, which when running on a mobile terminal, enables the mobile terminal to implement the steps in the above method embodiments when executed.
The integrated unit, if implemented in the form of a software functional unit and sold or used as a stand-alone product, may be stored in a computer readable storage medium. Based on such understanding, all or part of the processes in the methods of the embodiments described above can be implemented by a computer program, which can be stored in a computer-readable storage medium and can implement the steps of the embodiments of the methods described above when the computer program is executed by a processor. Wherein the computer program comprises computer program code, which may be in the form of source code, object code, an executable file or some intermediate form, etc. The computer readable medium may include at least: any entity or device capable of carrying computer program code to a photographing apparatus/terminal apparatus, a recording medium, computer Memory, Read-Only Memory (ROM), Random Access Memory (RAM), an electrical carrier signal, a telecommunications signal, and a software distribution medium. Such as a usb-disk, a removable hard disk, a magnetic or optical disk, etc. In certain jurisdictions, computer-readable media may not be an electrical carrier signal or a telecommunications signal in accordance with legislative and patent practice.
In the above embodiments, the descriptions of the respective embodiments have respective emphasis, and reference may be made to the related descriptions of other embodiments for parts that are not described or illustrated in a certain embodiment.
Those of ordinary skill in the art will appreciate that the various illustrative elements and 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 implementation. 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.
In the embodiments provided in the present application, it should be understood that the disclosed apparatus/network device and method may be implemented in other ways. For example, the above-described apparatus/network device embodiments are merely illustrative, and for example, the division of the modules or units is only one logical division, and there may be other divisions when actually implementing, for example, a plurality of units or components may be combined or integrated into another system, or some features may be omitted, or not implemented. In addition, the shown or discussed mutual coupling or direct coupling or communication connection may be an indirect coupling or communication connection through some interfaces, devices or units, and may be in an electrical, mechanical or other form.
The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.
The above-mentioned embodiments are only used for illustrating the technical solutions of the present application, and not for limiting the same; although the present application has been described in detail with reference to the foregoing embodiments, it should be understood by those of ordinary skill in the art that: the technical solutions described in the foregoing embodiments may still be modified, or some technical features may be equivalently replaced; such modifications and substitutions do not substantially depart from the spirit and scope of the embodiments of the present application and are intended to be included within the scope of the present application.
Claims (10)
1. A graphical programming code protection method, comprising:
loading a graphical programming project;
if the loaded graphical programming project is a project to be edited, graphically editing the project to be edited;
converting the edited source code data into intermediate code data;
and packaging the intermediate code data to generate a project to be shared.
2. The graphical programming code protection method of claim 1, further comprising:
and if the loaded graphical programming project is a project to be previewed, operating the project to be previewed in the graphical stage area.
3. The graphical programming code protection method of claim 1, further comprising:
and uploading the edited source code data.
4. The graphical programming code protection method of claim 3, further comprising:
and uploading the project to be shared while uploading the edited source code data.
5. The method for protecting graphical programming code according to claim 1, wherein if the loaded graphical programming item is an item to be edited, graphically editing the item to be edited includes:
downloading source code data in the project to be edited;
matching graphical building block definition data according to the source code data in the project to be edited;
and editing the graphical building block definition data through a graphical editor to obtain edited graphical building block definition data.
6. The method for protecting graphical programming code according to claim 2, wherein if the loaded graphical programming item is an item to be previewed, running the item to be previewed in a graphical stage area comprises:
acquiring intermediate code data in the item to be previewed;
executing the intermediate state code data in a graphical virtual machine so that the graphical stage area runs the item to be previewed.
7. The graphical programming code protection method of any of claims 1 to 6, further comprising:
and sending the intermediate state programming code to a graphical stage area for previewing.
8. A graphical programming code protection device, comprising:
the loading module is used for loading the graphical programming project;
the editing module is used for carrying out graphical editing on the project to be edited if the loaded graphical programming project is the project to be edited;
the conversion module is used for converting the edited source code data into intermediate code data;
and the packaging module is used for packaging the intermediate code data to generate a project to be shared.
9. A terminal device comprising a memory, a processor and a computer program stored in the memory and executable on the processor, characterized in that the processor implements the method according to any of claims 1 to 7 when executing the computer program.
10. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, carries out the method according to any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011475754.4A CN112667974A (en) | 2020-12-15 | 2020-12-15 | Graphical programming code protection method and device and terminal equipment |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011475754.4A CN112667974A (en) | 2020-12-15 | 2020-12-15 | Graphical programming code protection method and device and terminal equipment |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112667974A true CN112667974A (en) | 2021-04-16 |
Family
ID=75404557
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011475754.4A Pending CN112667974A (en) | 2020-12-15 | 2020-12-15 | Graphical programming code protection method and device and terminal equipment |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112667974A (en) |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20140359558A1 (en) * | 2013-06-02 | 2014-12-04 | Mark Spencer Chamberlain | System and methods for end-users to graphically program and manage computers and devices |
| CN104503754A (en) * | 2014-12-16 | 2015-04-08 | 江南大学 | Programming and compiling design method in robot graphical programming system |
| CN110134386A (en) * | 2019-04-04 | 2019-08-16 | 成都娄外科技有限公司 | A kind of program editing method and device |
-
2020
- 2020-12-15 CN CN202011475754.4A patent/CN112667974A/en active Pending
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20140359558A1 (en) * | 2013-06-02 | 2014-12-04 | Mark Spencer Chamberlain | System and methods for end-users to graphically program and manage computers and devices |
| CN104503754A (en) * | 2014-12-16 | 2015-04-08 | 江南大学 | Programming and compiling design method in robot graphical programming system |
| CN110134386A (en) * | 2019-04-04 | 2019-08-16 | 成都娄外科技有限公司 | A kind of program editing method and device |
Non-Patent Citations (2)
| Title |
|---|
| 只追昭熙: "C# 图解教程 第⼀章 C#和.NET框架", Retrieved from the Internet <URL:https://www.cnblogs.com/moonache/p/5995866.html> * |
| 左正: "强大软件防盗版控件.NET Reactor", Retrieved from the Internet <URL:http://cnblogs.com/soundcode/p/13753099.html> * |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US7818730B1 (en) | Automatic minimal build dependency determination and building an executable with source code | |
| CN106055368B (en) | application updating method and device | |
| EP3356932B1 (en) | System and method for using ubershader variants without preprocessing macros | |
| CN115237428A (en) | AI application deployment method, and related platform, cluster, medium, and program product | |
| CN111209001A (en) | Method, system, equipment and medium for batch generation of APKs of android channels | |
| CN111985055A (en) | Model packaging method and device and electronic equipment | |
| CN111832014A (en) | Dynamic loading-based Java SDK code encryption and decryption method and terminal | |
| CN111767056A (en) | Source code compiling method, executable file running method and terminal equipment | |
| CN113050940A (en) | Method for previewing small program, related device and computer program product | |
| CN112631649A (en) | Intelligent contract management method, device, terminal equipment and medium | |
| CN113268245A (en) | Code analysis method, device and storage medium | |
| CN109976744B (en) | Visual programming method, system and terminal equipment | |
| CN116301735B (en) | Method, device and storage medium for organizing software elements into software data links | |
| CN110018831B (en) | Program processing method, program processing apparatus, and computer-readable storage medium | |
| CN112667974A (en) | Graphical programming code protection method and device and terminal equipment | |
| CN112764729B (en) | Application software development method, device, computer equipment and readable storage medium | |
| de Carvalho Silva et al. | A platform of scientific workflows for orchestration of parallel components in a cloud of high performance computing applications | |
| CN108460276B (en) | Processing method and device for SO file of dynamic link library of android installation package | |
| CN114721735A (en) | Program dynamic loading method and device and electronic equipment | |
| CN114237769A (en) | Program execution method, device, equipment and storage medium | |
| CN112527320A (en) | Method, device and storage medium for deploying application system based on browser | |
| US8495033B2 (en) | Data processing | |
| CN112445525B (en) | Data processing method, related equipment and computer readable medium | |
| CN111966355B (en) | Project operation method, device, equipment and computer storage medium | |
| CN114185556A (en) | Intelligent contract deployment method, device, equipment and storage medium |
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 |