WO2022033229A1

WO2022033229A1 - Software code compiling method and system

Info

Publication number: WO2022033229A1
Application number: PCT/CN2021/104177
Authority: WO
Inventors: 董逢华; 江俊; 胡瑞璟; 何涛
Original assignee: 武汉天喻信息产业股份有限公司; 武汉天喻聚联科技有限公司
Priority date: 2020-08-12
Filing date: 2021-07-02
Publication date: 2022-02-17
Also published as: CN112052006B; CN112052006A

Abstract

A software code compiling method and system, relating to the technical field of computers. The method comprises the following steps: receiving an input code, extracting a word stream corresponding to the input code, generating a grammar tree according to pre-set grammar rules, and conducting semantic analysis to obtain a target code (S1), the input code comprising an application package code and a reference package code, and the target code comprising an application package target code and a reference package target code; according to data for implementing an application function in the application package target code, generating an application package bytecode file (S2); according to data for implementing an interface call in the reference package target code, generating a reference package bytecode file (S3); according to the application package bytecode file and the reference package bytecode file, generating a download file (S4). The present method pre-compiles the code and generates the download file that facilitates parsing, thereby reducing resource demands in embedded development, ensuring that the performance requirements in embedded development are met, and meeting a requirement for the download file being executable across platforms.

Description

Method and system for compiling software code

technical field

The present invention relates to the technical field of computers, in particular to a software code compilation method and system.

Background technique

In embedded development, security modules have the characteristics of limited resources and high performance requirements, but traditional language systems cannot meet the changing user usage scenarios of embedded modules, and cannot meet high performance with limited resources. requirements, and cannot meet the requirements that the same software code can run on different embedded modules.

Therefore, in order to solve the existing technical problems, a code compilation technology is required to meet the technical requirements of current embedded development.

SUMMARY OF THE INVENTION

Embodiments of the present application provide a method and system for compiling software code, which pre-compiles the code to generate a download file that is easy to parse, reduces resource requirements in embedded development, and provides guarantee for performance requirements in embedded development , and at the same time, it can meet the requirements that the downloaded file can be executed across platforms.

In a first aspect, a software code compilation method is provided, and the method includes the following steps:

Receive an input code, extract the word stream corresponding to the input code, generate a syntax tree according to a preset grammar rule, and perform semantic analysis to obtain a target code, the input code includes an application package code and a reference package code, the target code including the application package target code generated by the application package code and the reference package target code generated by the reference package code, the application package code and the application package target code both include the code corresponding to the runtime environment interface;

Generate an application package bytecode file according to the data implementing the application function in the application package target code;

Generate a reference package bytecode file according to the data implementing the interface call in the reference package target code;

A download file is generated according to the application package bytecode file and the reference package bytecode file.

Specifically, the receiving the input code, extracting the word stream corresponding to the input code, generating a syntax tree according to a preset grammar rule, and performing semantic analysis to obtain the target code, specifically includes the following steps:

Receive the input code, and parse to obtain the corresponding word stream;

According to preset grammar rules, identify the language category of the word stream, and perform corresponding grammar check to generate a corresponding grammar tree;

Semantically analyze the data in the syntax tree, and classify and record;

Generate object codes according to the classified and recorded data.

Further, before receiving the input code, the method further includes the following steps:

Create a constant pool;

The constant pool is used to store programming general characters, programming language keywords, general application programming interface keywords and runtime environment interface keywords supported by the method in terms of entries respectively;

The constant pool is also used to store the variables and methods declared in the header file referenced by the input code, the variables and methods in the input code in turn in units of entries when the word stream corresponding to the input code is extracted. Defined variables and custom methods are stored in the constant pool in units of entries respectively;

When any of the entry corresponding to the word stream already exists in the constant pool, it is not stored in the constant pool, and the entry includes the string name, character string corresponding to each word in the word stream String properties and string categories.

Specifically, the reference package bytecode file includes a binary bytecode file and a binary output mapping file, and the binary output mapping file includes version information corresponding to the reference package bytecode file, application identification data and all Contains description information for the method.

Specifically, the application package bytecode file includes a method component subfile, a memory component subfile, a runtime method component subfile, and a shared interface component subfile.

Specifically, the method component subfile of the application package bytecode file includes the bytecodes of all methods in the application package, which are arranged in sequence according to the declaration order of each method in the source code of the application package. The storage location and method name of the method in the application package are recorded in the constant pool in a one-to-one correspondence; the memory component subfile records the size and initial value of the global non-volatile space in the corresponding application package and the global The size of the volatile space;

The runtime method component subfile includes an offset value of the runtime environment interface of the corresponding application package, which is used for invoking the corresponding application package during installation, deletion, activation, and deactivation;

The shared interface component subfile includes the number of shared interfaces declared by the corresponding application package and the offset value of each interface method.

Specifically, generating the download file according to the application package bytecode file and the reference package bytecode file specifically includes the following steps:

According to the application package bytecode file and the reference package bytecode file, the method component, the memory component, the runtime method component and the shared interface component are obtained by parsing, and combined with the preset data package and application identification data, according to the preset Format to generate download files.

In a second aspect, a software code compilation system is provided, the system comprising:

A software code compiling unit, which is used for receiving an input code, extracting a word stream corresponding to the input code, generating a syntax tree according to a preset grammar rule, and performing semantic analysis to obtain a target code, where the input code includes an application package code and a Reference package code, the target code includes application package target code generated by the application package code and reference package target code generated by the reference package code, both the application package code and the application package target code include running The code corresponding to the time environment interface;

an application package generation unit, which is used for generating an application package bytecode file according to the data implementing the application function in the application package target code;

A reference package generation unit, which is used to generate a reference package bytecode file according to the data that implements the interface call in the reference package target code;

A download file generating unit, configured to generate a download file according to the application package bytecode file and the reference package bytecode file.

Specifically, the software code compiling unit is specifically used for:

Receive the input code, and parse to obtain the corresponding word stream;

Semantically analyze the data in the syntax tree, and classify and record;

Generate object codes according to the classified and recorded data.

Further, the system is configured with a constant pool;

The constant pool is used to store the programming general characters, programming language keywords, general application programming interface keywords and runtime environment interface keywords supported by the system respectively in terms of entries;

The constant pool is also used to sequentially store the variables and methods declared in the header file referenced by the input code, The self-defined variables and self-defined methods in the above input code are stored in the constant pool in terms of entries respectively;

Specifically, the method component subfile of the application package bytecode file includes the bytecodes of all methods in the application package, which are arranged in sequence according to the declaration order of each method in the source code of the application package. The storage location and method name of the method in the application package are recorded in the constant pool in one-to-one correspondence;

The memory component subfile records the size and initial value of the global non-volatile space and the size value of the global volatile space in the corresponding application package;

Specifically, the download file generating unit is specifically configured to parse and obtain a method component, a memory component, a runtime method component and a shared interface component according to the application package bytecode file and the reference package bytecode file, And combined with the preset data package and application identification data, the download file is generated according to the preset format.

The beneficial effects brought by the technical solution provided by this application include:

The present application provides a method and system for compiling software code. The code is pre-compiled according to preset grammar rules, and a download file that is easy to be parsed is generated. It provides guarantees for the performance requirements of the downloaded files and meets the requirements that the downloaded files can be executed across platforms.

Description of drawings

In order to illustrate the technical solutions in the embodiments of the present application more clearly, the following briefly introduces the drawings that are used in the description of the embodiments. Obviously, the drawings in the following description are only some embodiments of the present application. For those of ordinary skill in the art, other drawings can also be obtained from these drawings without creative effort.

1 is a flowchart of steps of a software code compiling method provided in Embodiment 1 of the present application;

2 is a flowchart of the software code compiling system provided by the first embodiment of the present application when compiling code;

3 is a flowchart of the software code compilation system provided in Embodiment 1 of the present application when a download file is generated;

FIG. 4 is a schematic block diagram of the runtime of a virtual machine in the software code compilation system provided by Embodiment 1 of the present application;

5 is a structural block diagram of a software code compiling system provided by Embodiment 2 of the present application;

Reference number:

1. Software code compilation unit; 2. Application package generation unit; 3. Reference package generation unit; 4. Download file generation unit.

detailed description

In order to make the purposes, technical solutions and advantages of the embodiments of the present application clearer, the technical solutions in the embodiments of the present application will be described clearly and completely below with reference to the drawings in the embodiments of the present application. Obviously, the described embodiments It is a part of the embodiments of this application, but not all of the embodiments. Based on the embodiments in the present application, all other embodiments obtained by those of ordinary skill in the art without creative work shall fall within the protection scope of the present application.

The embodiments of the present invention will be described in further detail below with reference to the accompanying drawings.

Embodiments of the present invention provide a method and system for compiling software code, which pre-compiles the code according to preset grammar rules, and generates a download file that is easy to parse. The performance requirements in the file are guaranteed to meet the requirements that the downloaded files can be executed across platforms.

In order to achieve the above-mentioned technical effect, the general idea of the application is as follows:

A software code compilation method, the method includes the following steps:

S1. Receive an input code, extract a word stream corresponding to the input code, generate a syntax tree according to a preset grammar rule, and perform semantic analysis to obtain a target code, the input code includes an application package code and a reference package code, and the target code includes the application package code. The application package target code generated by the code and the reference package target code generated by the reference package code, the application package code and the application package target code include the code corresponding to the runtime environment interface;

S2. Generate an application package bytecode file according to the data implementing the application function in the application package target code;

S3. Generate a reference package bytecode file according to the data in the reference package target code that implements the interface call;

S4. Generate a download file according to the application package bytecode file and the reference package bytecode file.

Example 1

Referring to FIGS. 1 to 4, an embodiment of the present invention provides a software code compilation method, and the method includes the following steps:

In the embodiment of the present application, the input code is first received, and the specific workflow is performed:

1) Perform lexical analysis on the input code, that is, parse the input code to obtain its corresponding word stream,

2) Syntax analysis is performed on the word stream, that is, according to the preset grammar rules, the corresponding grammar category is identified from the word stream, the grammar check is performed, and the corresponding grammar check is performed to generate a corresponding grammar tree,

3) Semantically analyze the results of the syntax analysis, generate the corresponding intermediate code, record various declarations to the symbol table, record the declaration type, record the expression type, etc.,

4) Code generation is performed according to the result of semantic analysis, and the target code is finally obtained,

The input code includes the application package code and the reference package code, the target code includes the application package target code generated by the application package code and the reference package target code generated by the reference package code, and both the application package code and the application package target code include the runtime The code corresponding to the environment interface,

In practice, when performing grammatical analysis, the input code is scanned according to the coding order, and the acquired words are added to the preset constant pool according to certain rules. Each entry in the constant pool contains the corresponding word of the word. String name, attribute, category and other information,

When performing syntax analysis, it is the analysis of the global declaration level, including the analysis of global variables, enumeration types, functions, etc.

When performing semantic analysis, it is the analysis at the statement level, and the syntax and semantics of other parts of the code in the function except the declaration are analyzed.

The object code generation process is to analyze the expression level, analyze various expressions in the program, and generate corresponding bytecode expressions.

Among them, the source file, that is, the output of the compilation of the input code, that is, the target code is the application package bytecode file and the reference package bytecode file, which implements the runtime environment interface (process, select, deselect, install, uninstall, getSccLibInterface ) applications will generate corresponding application package bytecode files, while pure method packages (no runtime environment interface) and applications with shared interfaces will generate reference package bytecode files, each source file correspondingly generates a byte code file.

In the embodiment of the present application, the code is pre-compiled according to the preset grammar rules, and a download file that is easy to parse is generated. In the embedded development, the demand for resources is reduced, and the performance demand in the embedded development is guaranteed to meet the requirements. Download files can perform cross-platform requirements.

When compiling the input code, multi-level processing can be performed, that is,

(1) Common single character (ASCII code);

(2) Keywords supported by the code encoding language;

(3) API keywords supported by embedded modules;

(4) Apply custom variables and methods;

(5) Common expressions;

In the specific operation, during the pre-compilation process, the characters in (1) to (3) are added to the constant pool in order. When the supported keywords and APIs are certain, the constant pool data in this part is fixed, and then in the code The characters in (4) are added to the constant pool in order during compilation.

The string corresponding to each member in the constant pool is unique, and the sequence ID, complete string information and verification compression value of the string are marked in the member structure, which is used for the subsequent encoding of the read string. Compare and verify.

Among them, API keywords can be upgraded. During the upgrade, the newly added API keywords are added to the original API keywords in the constant pool, and they are arranged in the order of upgrade. The higher version of the API can be compatible with the lower version of the API. Ensure backward compatibility of compilation results before and after the upgrade.

It should be noted that the file that implements the runtime environment interface in the input code and the target code is the application package. The embedded module can call the runtime environment interface of the application package to select the function of activating and running the application package. Because the firewall security requires the application package Common methods and variables in can only be accessed in the current package, and different application packages can access each other's shared interface methods;

The files in the input code and the object code that do not implement the runtime environment interface are reference packages. The reference packages provide a mapping to the outside so that their methods can be called by different application packages.

The download file obtained by the embodiment of the present application needs to rely on the virtual machine system and the runtime environment system during practical application,

The virtual machine system is used to process the downloaded file, parse the bytecode in the downloaded file, and execute the corresponding application package code function. The runtime environment system is used to manage the life cycle of the application, access the runtime environment interface of the application, and manage the firewall when the application is running.

In the runtime environment system, each source file that implements the runtime environment interface is regarded as a package, which is instantiated as an application applet. The main functions of the runtime environment interface are:

Activate according to the selection instruction to deactivate the specified application;

Distribute the received instruction to the current application, that is, call the entry function of the application;

Firewall management to prevent applications under different packages from accessing each other.

The core of the virtual machine system is the virtual machine bytecode. The basic principle of the virtual machine system is that the bytecode, the stack and the interpreter work together. The bytecode is responsible for the implementation of the syntax operators of the program, and the stack is responsible for the parameters, variables and temporary operations. The storage of numbers and other data, the interpreter parses the bytecode obtained in the program pointer, and the three together realize the expression of the programming language.

When generating a download file, you can use a download file conversion tool, which is used to convert the application package bytecode file into a GP download script.

First generate a hexadecimal GP file, then extract each component data in feature 8 from the application package bytecode file, and add each component to the GP file in turn according to the component ID, length and TLV format of the data. According to the description of point 2 above, the runtime environment system introduces the concept of package and application, so in the download file conversion tool, the developer can input the package of the current source file and the AID of the application as required, in each embedded module system , the AIDs of packages and applications are unique, and the runtime environment system can find the corresponding application according to the AID.

It should be noted that an application package code contains code corresponding to the runtime environment interface, and similarly, an application package target code contains code corresponding to the runtime environment interface;

The input code includes at least one application package code, and may contain one, more or no reference package code. Similarly, the target code includes at least one application package object code, and may contain one, more or no reference package object code;

In actual application, one application package code may need to use multiple reference package codes, and similarly, one application package object code may need to use multiple reference package object codes in actual application.

Specifically, before receiving the input code, the method further includes the following steps:

Create a constant pool;

The constant pool is used to store the programming general characters, programming language keywords, general application programming interface keywords and runtime environment interface keywords supported by the method in terms of entries;

The constant pool is also used to store the variables and methods declared in the header file referenced by the input code, the custom variables and custom methods in the input code in terms of terms, respectively, when the word stream corresponding to the input code is extracted. The unit is stored in the constant pool;

When any entry corresponding to the word stream already exists in the constant pool, it is not stored in the constant pool. The entry contains the string name, string attribute and string category corresponding to each word in the word stream.

It should be noted that when compiling software code, a constant pool will be created. The constant pool is the basis of lexical analysis. Each ID in the constant pool represents a word in the word stream, and its basic structure is identified by the word, compressed and encoded. , word name, word length, word type, used identifier, and method offset identifier, where the word identifier represents the position of the word in the constant pool, the compression encoding is the compression encoding representing the word string, and the word name is the word The original string description, the word length is the string length of the word, the word type indicates the function type of the word, the used flag indicates whether the word is called in the source program, the method offset flag indicates that when the word is a function, the function is in bytes. The offset value in the code method component;

The offset value specifically refers to the data storage location.

Specifically, in actual operation, the composition of the constant pool:

1. Common keywords of programming languages supported by the compiler;

2. Runtime environment interface of embedded module application;

3. Common API interfaces for embedded module applications;

4. The shared method interface entered in the external reference package;

5. Newly declared words searched when parsing source files and header files, including new macro definitions, header file function declarations, variable declarations, etc. Since all words in C language are the rules of first declaration and then calling, so in When searching for a statement, first check whether the statement is in the constant pool, if not, add the word to the constant pool, where the word identifier is a fixed value, indicating that the constant pool member is a string;

6. For the constant pool members described in

points

2 and 3 above, the word identifier is a fixed value, indicating that the member is a string;

7. For the constant pool member described in point 1 above, the word identifier is the ordinal position in the general keyword enumeration;

8. The general keyword enumeration is arranged in the order of type, programming language keyword and operator, and the starting value of the word identifier is 128;

9. The types in point 8 above include numbers, functions, system functions, shared functions, global variables, local variables, etc., indicating the type meaning of each constant pool member;

10. For the declaration of a single character, use its corresponding ASCII code as the word identification value, and its range is 0 to 127. For the declaration of multiple characters, define its word identification value according to the descriptions of 1 to 8 above;

11. The compression encoding of the constant pool member is the compression encoding of the string name of the word. For members whose word ID is less than 128, the compression encoding is 0. The compression encoding of other members is a hash value of the ASCII codes of all characters of the word. operation;

12. The word name and word length of the constant pool member is the complete string description of its word;

13. The word type of the constant pool member is the type represented by the word, as shown in 9 above; especially when the word is a function input by referencing the package bytecode file, its type is a shared function;

14. The used identification attribute of the constant pool member indicates whether the word is used by the source file. If it is not used, it will not be considered in the final link, which can speed up the link speed and optimize the use space;

15. The method offset identification attribute of the constant pool member indicates that when the word is a function method, the offset value of the bytecode corresponding to the function in the bytecode interval, that is, the offset position, that is, the storage location, when the function is called After finding the corresponding member through the constant pool, use the method offset value to jump.

Since there are multiple API interfaces, there is an API interface set, which internally stores multiple API interfaces in sequence.

In the actual operation process, the function of the constant pool is to mark the keywords supported by the current compilation environment, as well as the variables, macro definitions, and function declarations of source files and header files, which are used to read words when parsing the source file code. Semantic Analysis.

In addition, the word string corresponding to each member in the constant pool is unique, but because the string composition and length of the word are uncontrollable, simply using string comparison will waste performance and space. Therefore, the embodiments of the present application provide A matching method with greatly improved performance and memory overhead is proposed, which is divided into three steps. The operation process is as follows:

The first level is the word identification comparison, which can search for all single character words and programming language keyword words, and the word identification of these words is unique;

The second level is compression encoding comparison, which can search for words corresponding to all unique word identifiers in the constant pool;

The third level is the word name comparison, which can completely match the words in the constant pool;

Among them, the basic order of matching is 1, 2, 3, and the third-level full string comparison is performed only when the word identifier is not unique.

In the embodiment of the present application, the code compilation is parsed according to the actual coding order. The specific conditions are as follows:

1. Establish a constant pool table, and add programming language keywords, runtime environment system functions, and common system APIs to the constant pool;

2. Read the input source file in the order from top to bottom and left to right;

3. When the word read in the source file is a header file, first look for the header file in the directory where the source file is located. If it does not exist, look for the header file from the compiler's installation directory; in the header file from above Go to the next to get the relevant word, search whether the word obtained is in the constant pool, if not, add the word to the constant pool;

4. When the word read in the source file is a function, search whether the word is in the constant pool, if not, add the word to the constant pool;

5. Record the line number of the first line of code in the function in the source file, parse each statement in the function in sequence, and generate the corresponding bytecode of the function statement according to the virtual machine bytecode defined in the virtual machine system. The bytecodes are arranged in the order declared in the source file to form a bytecode range;

6. The offset value of each function in the bytecode interval is recorded in the method offset identification attribute of the constant pool member corresponding to the word;

7. When parsing to a function call, first search the index of the word in the constant pool. If the word type is a system function, the bytecode is set to a system function call; if it is a shared function, search the shared function list to find the The method offset value of the function in the shared package; if it is a normal function, the method offset identification parameter in the constant pool is directly used as the method offset value.

Specifically, there are 4 types of basic functions in programming code:

1) The runtime environment interface is used for runtime environment selection and switching. Other functions cannot call the runtime environment interface;

2) API interface, that is, the general embedded module API interface function, whose implementation method declaration and order are fixed in the API interface set, and can be called in the application;

3) Reference package shared function, that is, an external custom function package. This function package has its own AID and method list. After the source file is referenced, the shared function in the package can be called;

4) The function defined by the source file can be called freely by the application.

Among them, the constant pool word type of the runtime environment interface and API interface is a system function, and the word identifier value corresponding to each function is fixed and unique; the type of the reference package function is a shared function, and the word of the source file custom function The type type is an ordinary function, and its word identification value is a string type;

The API interface is in the order declared in the API interface set, and each function corresponds to an ID, which is used for the input of the bytecode of the system function call in the virtual machine system;

The above steps implement the basic compilation process of the embedded module application, and the output is the application package bytecode file.

Specifically, the reference package bytecode file includes a binary bytecode file and a binary output mapping file, and the binary output mapping file includes version information corresponding to the reference package bytecode file, application identification data, and description information of the included methods. .

It should be noted that the sub-files here do not represent the relationship between the upper and lower levels, but there are multiple parts in the application package bytecode file, namely the method component part, the memory component part, the runtime method component part and the shared interface. Component parts, here for describing aspects, are called subfiles.

Among them, the method component subfile of the application package bytecode file includes the bytecodes of all methods in the application package, which are arranged in order according to the declaration order of each method in the source code of the application package, and the storage location of each method in the application package and the method name are recorded in the constant pool in one-to-one correspondence;

The memory component subfile records the size and initial value of the global non-volatile space (NVM, Non-volatile Memory) and the size value of the global volatile space (RAM, Random Access Memory) in the corresponding application package;

The runtime method component subfile includes the offset value of the runtime environment interface of the corresponding application package, which is used for invoking the corresponding application package during installation, deletion, activation, and deactivation;

Specifically, generating a download file according to the application package bytecode file and the reference package bytecode file specifically includes the following steps:

According to the application package bytecode file and the reference package bytecode file, the method components, memory components, runtime method components and shared interface components are obtained by parsing, and combined with the preset data package and application identification data, the download is generated according to the preset format document.

Here, the virtual machine system in practical application is described:

The virtual machine system is implemented on the embedded module, which can download the bytecode file corresponding to the virtual machine and execute the corresponding bytecode process in the card;

The stack, RAM (volatile storage space), and NVM (non-volatile storage space) resources when the virtual machine is running are all uniformly addressed. The address structure distribution diagram of the virtual machine system defines the resources as follows:

Virtual machine stack: including analog registers, operation stacks and program stacks;

RAM: RAM space applied for in the application;

NVM resources:

Static NVM: The space occupied by the application package bytecode file downloaded to the card, the global NVM resource of a given size defined by the application, and other personalized resources;

Dynamic NVM: NVM resources dynamically applied for during application running;

Different virtual machine system implementations can allocate the proportion of each resource according to the actual situation.

Here, the runtime environment system in actual application is explained:

The runtime management system is responsible for managing the life cycle of cards and applications, application selection and firewall protection, etc., where:

The life cycle of an application consists of five methods corresponding to the runtime environment structure. The install method is responsible for the private instantiation of the application during installation, the select method is responsible for application activation, and the process method is the entry for application processing commands, responsible for receiving and processing APDU commands, deselect The method is responsible for application deactivation, the uninstall method is responsible for the private de-instantiation operation when the application is deleted, and each function corresponds to a life cycle stage of the application;

Because there are multiple application scenarios on the embedded module, the required application must be selected before executing the command. The application selection is executed through the logical channel management and selection file commands. These two commands are used by the runtime environment system to specify an An activated application instance in a session of a logical channel, once an instance is selected, this application instance will receive all subsequent private commands distributed to that logical channel until the application instance becomes deselected.

The protection provided by the runtime environment system's firewall avoids the most frequent foreseeable security breaches: developer mistakes and design omissions that result in sensitive data being leaked to other applications. An application can gain access to other source files from a publicly accessible interface. Firewalls also provide protection against incorrect code. If incorrect code is loaded onto the card, the firewall can still protect existing data from being accessed by this malicious code.

On the basis of the firewall, the runtime environment system also provides a mechanism that allows different applications to interact, that is, the shared interface mechanism. The shared interface defines the set of all interface methods that can be shared in the application. These methods can be used in different contexts. (package and application) environment.

Here, the download file conversion tool in practical application is described:

The input of the download file conversion tool includes the package AID of the source file and the input application package bytecode file path;

The output of the download file conversion tool includes a fixed format download script file;

The basic principle is to extract the data of method components, memory components, runtime method components, and shared interface method components in the application package bytecode file, and organize it into a fixed-format download file together with the input package AID.

Based on the same inventive concept, the present application provides an embodiment of the system corresponding to Embodiment 1. For details, please refer to Embodiment 2

Embodiment 2

Referring to Fig. 5, an embodiment of the present invention provides a software code compilation system, the system includes:

A software code compiling unit 1, which is used for receiving input codes, extracting word streams corresponding to the input codes, generating syntax trees according to preset grammar rules, and performing semantic analysis to obtain target codes, and the input codes include application package codes and reference package codes , the target code includes the application package target code generated by the application package code and the reference package target code generated by the reference package code, and both the application package code and the application package target code include the code corresponding to the runtime environment interface;

An application package generation unit 2, which is used to generate an application package bytecode file according to the data that realizes the application function in the application package target code;

A reference package generation unit 3, which is used to generate a reference package bytecode file according to the data that realizes the interface call in the reference package target code;

The download file generating unit 4 is configured to generate a download file according to the application package bytecode file and the reference package bytecode file.

In the embodiment of the present application, first the software code compiling unit 1 receives the input code, and performs a specific workflow:

Among them, the source file, that is, the output of the compilation of the input code, that is, the target code is the application package bytecode file and the reference package bytecode file, which implements the runtime environment interface (process, select, deselect, install, uninstall, getSccLibInterface ) application will generate the corresponding application package bytecode file, while the reference package (no runtime environment interface) and the application with shared interface will generate the reference package bytecode file, each source file correspondingly generates a binary byte code file (application package bytecode file or reference package bytecode file).

(1) Common single character (ASCII code);

(2) Keywords supported by the code encoding language;

(3) API (Application Programming Interface) keywords supported by the embedded module;

(4) Apply custom variables and methods;

(5) Common expressions;

It should be noted that the file that implements the runtime environment interface in the input code and the target code is the application package. The embedded module can call the runtime environment interface of the application package to choose to activate and run the application package function. Because the firewall security requires the application package Common methods and variables in can only be accessed in the current package, and different application packages can access each other's shared interface methods;

In the runtime environment system, each source file that implements the runtime environment interface is regarded as a package, which is instantiated as an application applet. The main functions of the runtime environment system are:

The core of the virtual machine system is the virtual machine bytecode. The basic principle of the virtual machine system is that the bytecode, the stack and the interpreter work together. The bytecode is responsible for the implementation of the syntax operators of the program, and the stack is responsible for the parameters, variables and temporary operations. The storage of data such as numbers, the interpreter parses the bytecode obtained from the program pointer, and the three together realize the expression of the programming language.

When generating the download file, a download file conversion tool can be used specifically, the function of which is to convert the application package bytecode file and the reference package bytecode file into a standard GP (GP, GlobalPlatform, Global Platform International Standards Organization) download script.

Specifically, the system is configured with a constant pool;

The constant pool is used to store the programming general characters, programming language keywords, general application programming interface keywords and runtime environment interface keywords supported by the system in terms of entries;

The constant pool is also used to store the variables and methods declared in the header file referenced by the input code, the custom variables in the input code, and the custom methods in the unit of entry when the software code compilation unit extracts the word stream corresponding to the input code. The entries are stored in the constant pool respectively;

It should be noted that when compiling software code, a constant pool will be created. The constant pool is the basis of lexical analysis. Each ID in the constant pool represents a word in the word stream, and its basic structure is identified by the word, compressed and encoded. , word name, word length, word type, used ID, and method offset ID, where the word ID indicates the position of the word in the constant pool, the compression encoding is the compression encoding for the word string, and the word name is the word The original string description, the word length is the string length of the word, the word type indicates the function type of the word, the used flag indicates whether the word is called in the source program, the method offset flag indicates that when the word is a function, the function is in bytes. The offset value in the code method component;

The offset value specifically refers to the data storage location.

In the actual operation process, the function of the constant pool is to mark the keywords supported by the current compilation environment, as well as the variables, macro definitions, and function declarations of the source file and header file, which are used to read the words when parsing the source file code. Semantic Analysis.

In addition, the word string corresponding to each member in the constant pool is unique, but since the string composition and length of the word are uncontrollable, simply using string comparison will waste performance and space. Therefore, the embodiments of the present application provide A matching method with greatly improved performance and memory overhead is proposed. It is divided into three steps. The operation process is as follows:

Specifically, the download file generation unit 4 is specifically configured to parse and obtain the method component, the memory component, the runtime method component and the shared interface component according to the application package bytecode file and the reference package bytecode file, and combine the preset The data package and application identification data are generated according to the preset format to download the file.

The above descriptions are only specific embodiments of the present application, so that those skilled in the art can understand or implement the present application. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the generic principles defined herein may be implemented in other embodiments without departing from the spirit or scope of the present application. Therefore, this application is not intended to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features claimed herein.

Claims

A method for compiling software code, characterized in that the method comprises the following steps:

Receive an input code, extract the word stream corresponding to the input code, generate a syntax tree according to a preset grammar rule, and perform semantic analysis to obtain a target code, the input code includes an application package code and a reference package code, the target code including the application package target code generated by the application package code and the reference package target code generated by the reference package code, the application package code and the application package target code both include the code corresponding to the runtime environment interface;

Generate an application package bytecode file according to the data implementing the application function in the application package target code;

Generate a reference package bytecode file according to the data implementing the interface call in the reference package target code;

A download file is generated according to the application package bytecode file and the reference package bytecode file.
The software code compiling method according to claim 1, characterized in that, the input code is received, the word stream corresponding to the input code is extracted, a syntax tree is generated according to a preset syntax rule, and semantic analysis is performed to obtain the target code , including the following steps:

Receive the input code, and parse to obtain the corresponding word stream;

According to preset grammar rules, identify the language category of the word stream, and perform corresponding grammar check to generate a corresponding grammar tree;

Semantically analyze the data in the syntax tree, and classify and record;

Generate object codes according to the classified and recorded data.
The method for compiling software code according to claim 1, wherein before receiving the input code, the method further comprises the following steps:

Create a constant pool;

The constant pool is used to store programming general characters, programming language keywords, general application programming interface keywords and runtime environment interface keywords supported by the method in terms of entries respectively;

The constant pool is also used to store the variables and methods declared in the header file referenced by the input code, the variables and methods in the input code in turn in units of entries when the word stream corresponding to the input code is extracted. Defined variables and custom methods are stored in the constant pool in units of entries respectively;

When any of the entry corresponding to the word stream already exists in the constant pool, it is not stored in the constant pool, and the entry includes the string name, character string corresponding to each word in the word stream String properties and string categories.
software code compiling method as claimed in claim 1, is characterized in that:

The reference package bytecode file includes a binary bytecode file and a binary output mapping file, and the binary output mapping file includes version information corresponding to the reference package bytecode file, application identification data, and included methods. description information.
software code compiling method as claimed in claim 3, is characterized in that:

The application package bytecode file includes a method component subfile, a memory component subfile, a runtime method component subfile, and a shared interface component subfile.
software code compiling method as claimed in claim 5, is characterized in that:

The method component subfile of the application package bytecode file includes the bytecodes of all methods in the application package, and is arranged in sequence according to the declaration order of each method in the source code of the application package, and each method is described in The storage locations and method names in the application package are recorded in the constant pool in a one-to-one correspondence; the memory component subfile records the size and initial value of the global non-volatile space and the global volatile space in the corresponding application package size value;

The runtime method component subfile includes an offset value of the runtime environment interface of the corresponding application package, which is used for invoking the corresponding application package during installation, deletion, activation, and deactivation;

The shared interface component subfile includes the number of shared interfaces declared by the corresponding application package and the offset value of each interface method.
The software code compiling method according to claim 1, wherein the generating a download file according to the application package bytecode file and the reference package bytecode file specifically includes the following steps:

According to the application package bytecode file and the reference package bytecode file, the method component, the memory component, the runtime method component and the shared interface component are obtained by parsing, and combined with the preset data package and application identification data, according to the preset Format to generate download files.
A software code compilation system, characterized in that the system comprises:

A software code compiling unit, which is used for receiving an input code, extracting a word stream corresponding to the input code, generating a syntax tree according to a preset grammar rule, and performing semantic analysis to obtain a target code, and the input code includes an application package code and Reference package code, the target code includes application package target code generated by the application package code and reference package target code generated by the reference package code, both the application package code and the application package target code include running The code corresponding to the time environment interface;

an application package generation unit, which is used for generating an application package bytecode file according to the data implementing the application function in the application package target code;

A reference package generation unit, which is used to generate a reference package bytecode file according to the data that implements the interface call in the reference package target code;

A download file generating unit, configured to generate a download file according to the application package bytecode file and the reference package bytecode file.
The software code compiling system according to claim 8, wherein the software code compiling unit is specifically used for:

Receive the input code, and parse to obtain the corresponding word stream;

According to preset grammar rules, identify the language category of the word stream, and perform corresponding grammar check to generate a corresponding grammar tree;

Semantically analyze the data in the syntax tree, and classify and record;

Generate object codes according to the classified and recorded data.
The software code compiling system of claim 8, wherein:

The system is configured with a constant pool;

The constant pool is used to store the programming general characters, programming language keywords, general application programming interface keywords and runtime environment interface keywords supported by the system respectively in terms of entries;

The constant pool is also used to sequentially store the variables and methods declared in the header file referenced by the input code, The self-defined variables and self-defined methods in the input code are respectively stored in the constant pool in terms of entries;

When any of the entry corresponding to the word stream already exists in the constant pool, it is not stored in the constant pool, and the entry includes the string name, character string corresponding to each word in the word stream String properties and string categories.
The software code compiling system of claim 8, wherein:

The reference package bytecode file includes a binary bytecode file and a binary output mapping file, and the binary output mapping file includes version information corresponding to the reference package bytecode file, application identification data, and included methods. description information.
The software code compiling system of claim 10, wherein:

The application package bytecode file includes a method component subfile, a memory component subfile, a runtime method component subfile, and a shared interface component subfile.
The software code compiling system of claim 12, wherein:

The method component subfile of the application package bytecode file includes the bytecodes of all methods in the application package, and is arranged in sequence according to the declaration order of each method in the source code of the application package, and each method is described in The storage locations and method names in the application package are recorded in the constant pool in a one-to-one correspondence;

The memory component subfile records the size and initial value of the global non-volatile storage space and the size value of the global volatile storage space in the corresponding application package;

The runtime method component subfile includes an offset value of the runtime environment interface of the corresponding application package, which is used for invoking the corresponding application package during installation, deletion, activation, and deactivation;

The shared interface component subfile includes the number of shared interfaces declared by the corresponding application package and the offset value of each interface method.
The software code compiling system of claim 12, wherein:

The download file generation unit is specifically configured to parse and obtain the method component, the memory component, the runtime method component and the shared interface component according to the application package bytecode file and the reference package bytecode file, and combine the pre- According to the preset data package and application identification data, the download file is generated according to the preset format.