CN115509607B - Method for transmitting instructions from iOS (internet operating system) end packaging project to packaging script across environments - Google Patents
Method for transmitting instructions from iOS (internet operating system) end packaging project to packaging script across environments Download PDFInfo
- Publication number
- CN115509607B CN115509607B CN202211473455.6A CN202211473455A CN115509607B CN 115509607 B CN115509607 B CN 115509607B CN 202211473455 A CN202211473455 A CN 202211473455A CN 115509607 B CN115509607 B CN 115509607B
- Authority
- CN
- China
- Prior art keywords
- script
- target medium
- packaging
- instruction
- target
- 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
- 238000013515 script Methods 0.000 title claims abstract description 91
- 238000004806 packaging method and process Methods 0.000 title claims abstract description 46
- 238000000034 method Methods 0.000 title claims abstract description 27
- 238000012545 processing Methods 0.000 claims abstract description 19
- 230000004048 modification Effects 0.000 claims description 11
- 238000012986 modification Methods 0.000 claims description 11
- 230000001131 transforming effect Effects 0.000 claims description 3
- 238000012858 packaging process Methods 0.000 claims description 2
- 230000005540 biological transmission Effects 0.000 abstract description 8
- 238000011161 development Methods 0.000 description 13
- 238000004891 communication Methods 0.000 description 5
- 230000008569 process Effects 0.000 description 5
- 238000012856 packing Methods 0.000 description 4
- 230000008859 change Effects 0.000 description 3
- 230000008878 coupling Effects 0.000 description 2
- 238000010168 coupling process Methods 0.000 description 2
- 238000005859 coupling reaction Methods 0.000 description 2
- 230000007547 defect Effects 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 230000002085 persistent effect Effects 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 230000001360 synchronised effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/76—Adapting program code to run in a different environment; Porting
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
Abstract
The invention provides a method for transmitting instructions to a packaging script across environments by an iOS (internet operating system) end packaging project, which comprises the following steps: in the packaging project, a target media file is newly built; formulating a format protocol specification for writing business requirement information of a constraint target medium and writing a constraint script aiming at a reading command of the business requirement information; writing parameters into the target medium according to the format protocol specification; adding a built-in script in the IDE, adding an automatic operation instruction, generating a binding relationship between a target medium and a frame package, and moving to the next processing link along with the frame package; improving scripts of other links, and increasing instruction codes for searching target media; writing a reading logic of a script aiming at a target medium according to a format protocol specification; and modifying scripts of other links, and adding instruction codes for deleting the target medium. According to the invention, after the information is configured, the required information is provided and automatically bound in the frame package without secondary processing, so that the convenience and the accuracy of the instruction transmission can be improved.
Description
Technical Field
The invention relates to the technical field of computers, in particular to a method for transmitting instructions to a packaging script across environments by an iOS (internet operating system) end packaging project.
Background
In the process of packaging the SDK by the iOS platform, the packaging project belongs to the IDE of Xcode, the script belongs to the terminal of terminal, and the two belong to different environments, so the packaging project cannot transmit instructions and parameters to the packaging script. When a packaging project needs to transmit instructions and parameters to a packaging script, the traditional scheme is that according to service requirements, before automation is executed each time, the logic of the script is modified once, namely, the service requirements are implanted in a 'script automation processing' link each time. For the traditional scheme, manual intervention is needed for each automation due to the change of business requirements, and the original automation steps are changed into 'pseudo-automation'; moreover, because the secondary processing logic for the framework package is often determined in the development link, and the development link and the script automation link are usually processed by different programmers in different time periods by using different computers, the development link and the script automation link are independently connected weakly, when a new requirement is met, manual intervention is needed by adopting a traditional scheme, and modification is carried out again, so that when the packaging project needs to transmit instructions and parameters to the packaging script, the convenience is extremely low, the time cost needed to be spent is high, the labor cost is high, and the error rate of the transmitted instructions is also high.
Disclosure of Invention
Aiming at the defects of the prior art, the invention provides a method for transmitting instructions from an iOS end packaging project to a packaging script across environments, which can improve the convenience of transmitting the instructions, reduce the time spent on the work and improve the accuracy of transmitting the instructions.
The technical scheme of the invention is realized as follows:
a method for transmitting instructions to a packaging script across environments by an iOS end packaging project comprises the following steps:
step 1: in the packaging project, a target media file is newly built for transmitting service requirement information;
step 2: formulating a format protocol specification, wherein the specification is used for restricting the writing content of the service requirement information of the target medium and restricting the writing of a script aiming at the reading command of the service requirement information;
and step 3: according to the format protocol specification, writing parameters into the target medium to put the content into the target medium carrier;
and 4, step 4: adding a built-in script in the IDE, adding an automatic operation instruction, generating a binding relationship between a target medium and a frame package, and moving to the next processing link along with the frame package;
and 5: improving scripts of other links, and increasing instruction codes for searching target media;
step 6: writing a reading logic of a script aiming at a target medium according to a format protocol specification;
and 7: and modifying scripts of other links, and adding instruction codes for deleting the target medium.
Preferably, the target medium is a plist file.
Preferably, the script is a shell script.
Preferably, in step 3, according to the format protocol specification, the parameters or instructions required to be carried are added, deleted, and changed according to the service requirements.
Preferably, in step 4, the modification to the built-in script of the IDE includes a command to find a target medium, a command to find a product in the frame package, and a command to move the target medium into the product in the frame package, so that the frame package can carry the target medium no matter which packing link the frame package reaches.
Preferably, in step 5, adding a command code for finding a target medium to the external script, including finding a frame packet command and extracting a plist target medium command, may also be the same logic for multiplexing the path generated in step 4.
Preferably, in step 6, in the modification of the newly added read logic for the external script, the read logic for the automatic matching analysis is written according to the read method strictly agreed by the protocol and the target media content.
Preferably, in step 7, the script of the other link is modified, and an instruction code for deleting the target medium is added, so that the target medium is deleted after being found.
Compared with the prior art, the invention has the following advantages:
in the invention, a file is newly built in a packaging project as a target medium, and the file is used as a medium stored in a hard disk, so that the method has the characteristic of persistently storing contents, and can be maintained together with codes because the file is in the packaging project; meanwhile, writing and reading rules of the target medium are correspondingly formulated, so that in a development link, a development programmer can timely carry out configuration, parameter and instruction addition or modification on the target medium according to new service requirements in real time; the method comprises the steps of setting a script in an IDE (integrated development environment), binding service requirement information in a target medium in a frame package automatically, enabling the service requirement information to follow the frame package to automatically come to a script packaging link, analyzing, reading and executing the service requirement information by logic conforming to a specific format protocol specification, and deleting the target medium which is newly built at first through an added instruction code for deleting the target medium, so that parameters/instructions can be cleared in time after the transmission is finished, and ensuring that the internal file structure of a packaged product is not changed at any time before and after the parameters are transmitted, thereby ensuring the quality of the product package.
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 embodiments or the description of the prior art will be briefly described below, it is obvious that the drawings in the following description are only some embodiments of the present invention, and for those skilled in the art, other drawings can be obtained according to the drawings without creative efforts.
FIG. 1 is a schematic flow chart of the present invention.
Detailed description of the preferred embodiments
The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present invention.
Referring to fig. 1, an embodiment of the present invention discloses a method for transmitting an instruction to a package script across environments by an iOS-side package project, which includes the following steps:
step 1: in the packaging project, a target media file is newly built for transmitting service requirement information; the file is selected as the medium, because the file is used as the medium stored in the hard disk, the file has the characteristic of persistent storage content, and moreover, the new creation of the target medium can ensure that the internal structure of a packaged product, such as a frame package, is not changed, and ensure that the served object is not modified by errors;
step 2: formulating a format protocol specification, wherein the specification is used for restricting the writing content of the service requirement information of the target medium and restricting the writing of a script aiming at the reading command of the service requirement information; because protocol constraints are needed for writing and reading parameters/instructions, command writing format specifications which strictly constrain writing contents and strictly require reading contents are established, and the condition of using errors can be ensured not to occur in both reading and writing parties;
and step 3: according to the format protocol specification, writing parameters into the target medium to put the content (such as configuration, instruction, parameters) into the target medium carrier;
and 4, step 4: adding a built-in script in the IDE, adding an automatic operation instruction, generating a binding relationship between a target medium and a frame package, and moving to the next processing link along with the frame package; selecting a Target object needing to be packaged into a frame package in IDE Xcode, and adding an IDE built-in Script in Build Phases of the Target object by using New Run Script Phase, thereby adding an automation operation instruction aiming at the IDE built-in Script;
and 5: improving scripts of other links, and increasing instruction codes for searching target media; the step is script searching logic for searching the target medium, namely, in the packaging process, when a frame packet is received, the target medium can be searched, and the searching mode is that according to a fixed target medium name, a frame packet path is spliced to be used as a prefix, and the final target medium path is obtained; wherein, the 'script for transforming other links' is not built-in the IDE, but is a script outside the IDE;
step 6: writing a reading logic of a script aiming at a target medium according to a format protocol specification; namely, the reading logic needs to strictly follow the format specification formulated in the step 2, and the rigor of the reading instruction is ensured;
and 7: improving scripts of other links, and adding instruction codes for deleting target media; when the step comes to this link, the instructions/parameters carried by the target medium are read completely, so that the instructions/parameters have no use value, and need to be cleaned in time, so that the internal file structure is not changed before and after the parameters are transmitted to the packed product, and the quality of the product package is ensured.
The new file is established in the packaging project as a target medium to transmit the service requirement information, so that the instruction transmission accuracy can be ensured, and the manual operation cost of a development programmer can be reduced. Therefore, in the development link, a development programmer can timely carry out configuration addition or modification on a target medium according to the new service requirement in real time; the IDE is internally provided with the script, so that the service requirement information in the target medium can be automatically bound in a frame package, the service requirement information automatically comes to a packaging script link along with the frame package and is analyzed, read and executed by logic following a specific format protocol specification, and finally the target medium which is newly built is deleted through an added instruction code for deleting the target medium, so that the parameter/instruction can be cleaned in time after the transmission is finished, the internal file structure of a packaged product is ensured not to be changed any more before and after the transmission of the parameter, the quality of a product package is ensured, the process increases or modifies information by following the specific format specification and automatically binds the new service requirement information in the frame package, the convenience of the transmission instruction can be improved, the working time is reduced, and the accuracy of the transmission instruction is improved.
In this embodiment, the target medium is a plist file.
In the embodiment, the script is a shell script, and reading logic change is performed on the shell script according to a specific format protocol specification; and the script for transforming other links is also the shell script.
In this embodiment, in step 3, according to the format protocol specification, the parameters or instructions required to be carried are added, deleted, and changed according to the service requirement. For example, a specific keyword is used as a mark, the keyword is required to correspond to an array, the array must be a character string element, and each character string element, as a new key value, can access to a new array.
In this embodiment, in step 4, the modification of the script built in the IDE includes a command to find a target medium, a command to find a product in a frame packet, and a command to move the target medium into the product in the frame packet, so that the frame packet can carry the target medium no matter which packing link the frame packet reaches. Meanwhile, because the IDEshell is internally provided with the script, the automatic treatment can be realized without manual operation; the key code of the instruction is as follows:
finding the target medium instruction:
curPath=$(pwd)
PlistFileName=“package.plist”
TargetMediaFilePlist="${curPath}/${PlistFileName}”
find framework product package instruction:
TARGET_NAME=${PROJECT_NAME}
UniversalOutputFolder="${SRCROOT}/Products/"
UniversalOutputFolderFramework="${UniversalOutputFolder}/${TARGET_NAME}.framework”
move target media into frame package instruction:
cp-R"${TargetMediaFilePlist}""${UniversalOutputFolderFramework}/${PlistFileName}”
in this embodiment, in step 5, adding a command code for finding a target medium to an external script, including finding a frame packet command and extracting a plist target medium command, may also be the same logic for multiplexing the path generated in step 4.
In this embodiment, in step 6, in the modification of the newly added read logic for the external script, the read logic for the automatic matching analysis is written for the target media content according to the reading method strictly agreed by the protocol. If the specific keyword is matched, reading in an array structure mode; when the follow-up service requirement is completed, the change is not needed.
In this embodiment, in step 7, the scripts of other links are modified, and instruction codes for deleting the target medium are added, so that the target medium is deleted after being found.
For the purpose of understanding the scheme of the present application, the following description is continued with respect to the scheme of the present application:
in the process of packaging the SDK by the iOS platform, two links of 'compiling and packaging' and 'script automatic processing' exist. The former is responsible for producing frame packages, and the latter is responsible for operations such as checking and confirming, secondary processing, uploading and publishing and the like.
However, there are three reasons why communication is difficult between two links.
One is that because the compiling package belongs to the Xcode environment, and the script automation processing belongs to the Shell environment, a boundary line naturally exists between the two environments, and a communication medium carried by the system is unavailable.
Secondly, because of the automatic processing of the script, an independent environment is often needed for reusability and service decoupling.
And thirdly, the compiling and packaging link and the script automatic processing link are not processed at the same time point.
Based on the above problems, the problem that the 'compiling and packaging' link cannot control the 'script automation processing' is caused, because the latter cannot receive any information or instruction of the former.
Therefore, the steps are separated for the work of controlling script automatic processing according to the business requirements, the business requirements are formulated and implanted into a development link, the business requirements are bound with a frame package and implanted into a compiling and packaging link, and the requirements are read and the embedded script automatic processing link is executed. The three links together complete the goal. The method achieves real full automation, controls the effect of script automatic processing according to business requirements, and simultaneously ensures that products have no difference from the traditional scheme.
In the traditional scheme, in the traditional packing process, a programmer A in charge of an IDE Xcode packing link and a programmer B in charge of subsequent package processing of Shell script need to have close communication and cooperation, for example, if an IDE party modifies configuration, parameters and instructions, the IDE party should be informed of synchronous modification by the Shell party to ensure different products, and different processing schemes are used. If the time processed by the two persons is not uniform, the two persons agree a time, or one of the two persons records clear points first and then executes the processing according to the agreed condition in the subsequent step. In conclusion, the whole process is visible, and depends strongly on cooperative personnel of two parties, and the smoothness of the whole packaging can be ensured only if the other party is modified perfectly and correspondingly when the other party is modified. The two influence each other, namely coupling.
Based on the above problem, this scheme of adoption can be so that: in the past, different persons or even the same person are needed, and communication between two engineering environments is essentially realized, and all the communication is stripped into a set of protocol specifications. Two persons, or two engineering environments, cooperate directly protocol-oriented. Between two engineering environments, IDEXcode faces to the target medium plist, and Shell faces to the target medium plist carried by the received frame packet and the core object. Thus, cooperation is completed through the intermediate, namely decoupling is completed, and the cross-environment instruction transmission can be efficiently completed.
Description of related art terms:
MacOS: a suite of operating systems developed by apple inc, running on apple computers.
IDE: an integrated development environment (integrated development environment) is an application program for providing a program development environment, and generally includes tools such as a code editor, a compiler, a debugger, and a graphical user interface.
Xcode: xcode is an integrated development tool (IDE) running on the operating system MacOS, developed by AppleInc
And (3) SDK: a software development kit.
framework: one existing form of SDK on iOS platforms, typically ends with a.frame suffix. The framework inside contains header file, configuration table, multi-structure document package. There are two types of dynamic libraries and static libraries.
Script language: a programming language for controlling software applications, scripts are typically stored in text (e.g., ASCII) and are interpreted or compiled only when called.
Coupling: refers to the phenomenon that two or more systems or two motion forms interact with each other through interaction so as to be combined.
Decoupling: the common decoupling method is to ignore or simplify one system or motion with less influence on the problem to be researched, and only analyze the main system or motion.
Shell: a command language, and a programming language.
Shell script: namely, shellscript, is a script program written using shell.
Plist document: the attribute table file (Plist) is a file format that is typically used to store user settings and may also be used to store bundled information.
The above description is only for the purpose of illustrating the preferred embodiments of the present invention and is not to be construed as limiting the invention, and any modifications, equivalents, improvements and the like that fall within the spirit and principle of the present invention are intended to be included therein.
Claims (8)
1. A method for transmitting instructions to a packaging script across environments by an iOS end packaging project is characterized by comprising the following steps:
step 1: in the packaging project, a target media file is newly built for transmitting service requirement information;
step 2: formulating a format protocol specification, wherein the specification is used for restricting the writing content of the service requirement information of the target medium and restricting the writing of a script aiming at the reading command of the service requirement information;
and step 3: according to the format protocol specification, writing parameters into the target medium to put the content into the target medium carrier;
and 4, step 4: adding built-in scripts in the IDE, adding automatic operation instructions for binding a Target medium and a frame package and moving the frame package to the next processing link, wherein the operation of the step is mainly that a Target object needing to be packaged out of the frame package is selected in the IDE Xcode, and the built-in scripts of the IDE are added in Build Phases of the Target object by using New Run Script Phase, so that the automatic operation instructions are added aiming at the built-in scripts of the IDE;
and 5: modifying scripts of other links, and adding instruction codes for searching a target medium, wherein the step is the script searching logic for searching the target medium, namely in the packaging process, if a frame packet is received, the target medium can be searched, and the searching mode is that according to a fixed target medium name, the path of the frame packet is spliced as a prefix, and the path is the final path of the target medium; wherein, the 'script for transforming other links' is not built-in the IDE, but is a script outside the IDE;
step 6: writing a reading logic of a script aiming at a target medium according to a format protocol specification;
and 7: and modifying scripts of other links, and adding instruction codes for deleting the target medium.
2. The method for transmitting the instruction from the iOS-side packaging project to the packaging script across the environment according to claim 1, wherein the target medium is a plist file.
3. The method for transmitting the instruction from the iOS-side packaging project to the packaging script across the environment according to claim 1, wherein the script is a shell script.
4. The method for transmitting the instruction from the package project at the iOS end to the package script across the environment according to claim 1, wherein in step 3, the parameters or the instruction to be carried are added, deleted, and changed according to the format protocol specification and the service requirement.
5. The method of claim 1, wherein the modification to the IDE script in step 4 includes a target media finding instruction, a frame product finding instruction, and a move target media to frame product finding instruction, so that the frame package can carry the target media no matter which packaging link the frame package reaches.
6. The method of claim 1, wherein in step 5, adding a target medium finding instruction code to the external script, including finding a frame packet instruction, extracting a plist target medium instruction, and multiplexing the same logic of the path generated in step 4.
7. The method for transmitting the command to the packaging script across the environment at the iOS end packaging project according to claim 1, wherein in step 6, in the modification of the new reading logic for the external script, the reading logic for the automatic matching analysis is written according to the reading method agreed by the protocol strictly and the content of the target media.
8. The method for transmitting the instructions from the iOS-side packaging project to the packaging script across the environment according to claim 1, wherein in step 7, the script of other link is modified, and the instruction code for deleting the target medium is added, so as to delete the target medium after the target medium is found.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
CN202211473455.6A CN115509607B (en) | 2022-11-23 | 2022-11-23 | Method for transmitting instructions from iOS (internet operating system) end packaging project to packaging script across environments |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
CN202211473455.6A CN115509607B (en) | 2022-11-23 | 2022-11-23 | Method for transmitting instructions from iOS (internet operating system) end packaging project to packaging script across environments |
Publications (2)
Publication Number | Publication Date |
---|---|
CN115509607A CN115509607A (en) | 2022-12-23 |
CN115509607B true CN115509607B (en) | 2023-03-21 |
Family
ID=84514266
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
CN202211473455.6A Active CN115509607B (en) | 2022-11-23 | 2022-11-23 | Method for transmitting instructions from iOS (internet operating system) end packaging project to packaging script across environments |
Country Status (1)
Country | Link |
---|---|
CN (1) | CN115509607B (en) |
Families Citing this family (1)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN115658140A (en) * | 2022-12-26 | 2023-01-31 | 易方信息科技股份有限公司 | SDK packaging method, device, terminal and storage medium |
Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN111078278A (en) * | 2019-12-21 | 2020-04-28 | 众能联合数字技术有限公司 | Automatic packaging method supporting Flutter and iOS mixed editing project |
CN112882700A (en) * | 2021-02-09 | 2021-06-01 | 京东方科技集团股份有限公司 | iOS application program construction method and device, electronic equipment and storage medium |
CN115248700A (en) * | 2021-04-25 | 2022-10-28 | 远光软件股份有限公司 | Method and system for automatically constructing mobile installation package by product code |
Family Cites Families (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN108469957A (en) * | 2018-03-08 | 2018-08-31 | 平安科技(深圳)有限公司 | Using packing method for uploading, device, computer equipment and storage medium |
CN113885897A (en) * | 2021-09-29 | 2022-01-04 | 平安国际智慧城市科技股份有限公司 | Packaging method, device and equipment of client installation package and storage medium |
CN114356392A (en) * | 2021-12-21 | 2022-04-15 | 武汉小安科技有限公司 | git information display method and device, electronic equipment and storage medium |
-
2022
- 2022-11-23 CN CN202211473455.6A patent/CN115509607B/en active Active
Patent Citations (3)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
CN111078278A (en) * | 2019-12-21 | 2020-04-28 | 众能联合数字技术有限公司 | Automatic packaging method supporting Flutter and iOS mixed editing project |
CN112882700A (en) * | 2021-02-09 | 2021-06-01 | 京东方科技集团股份有限公司 | iOS application program construction method and device, electronic equipment and storage medium |
CN115248700A (en) * | 2021-04-25 | 2022-10-28 | 远光软件股份有限公司 | Method and system for automatically constructing mobile installation package by product code |
Also Published As
Publication number | Publication date |
---|---|
CN115509607A (en) | 2022-12-23 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US9086931B2 (en) | System for translating diverse programming languages | |
US9965259B2 (en) | System for translating diverse programming languages | |
US7739696B2 (en) | Message translation systems and methods | |
TWI536263B (en) | Projecting native application programming interfaces of an operating system into other programming languages | |
JPS63201834A (en) | Generation of object module | |
US20080046868A1 (en) | Method and system for template-based code generation | |
CN105068927A (en) | Keyword drive-based automatic test method of urban rail drive control units | |
EP2098954B1 (en) | Systems and methods for template reverse engineering | |
CN109918081B (en) | Compiling method and compiler | |
CN115509607B (en) | Method for transmitting instructions from iOS (internet operating system) end packaging project to packaging script across environments | |
JP4638484B2 (en) | Data integrity in data processing equipment | |
CN111427583A (en) | Component compiling method and device, electronic equipment and computer readable storage medium | |
CN110264361A (en) | A kind of data analysis method and device of block chain | |
JP5777837B2 (en) | Program development support apparatus and method | |
EP0520708B1 (en) | Method and apparatus for converting high level form abstract syntaxes into an intermediate form | |
US6381736B1 (en) | Method for compile-time type-checking of arguments for externally-specified format strings | |
CN113419969B (en) | Interface automatic formation power guarantee method based on browser plug-in | |
WO2007027366A1 (en) | Nullable and late binding | |
CN115658140A (en) | SDK packaging method, device, terminal and storage medium | |
EP3005087A1 (en) | Declarative configuration elements | |
US6178547B1 (en) | Method and apparatus for generating non-redundant symbolic debug information in computer programs | |
CN115454438A (en) | Method for converting HLSL shader source code into GLSL shader source code based on comparison table | |
US20130117728A1 (en) | Computer program interface | |
EP2587380A1 (en) | Runtime environment and method for non-invasive monitoring of software applications | |
CN114816435A (en) | Software development method based on reverse technology |
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 |