CN112905153B

CN112905153B - Software parallel construction method and device for software defined satellite

Info

Publication number: CN112905153B
Application number: CN202011431237.7A
Authority: CN
Inventors: 李丹; 赵军锁; 高航
Original assignee: Institute of Software of CAS
Current assignee: Institute of Software of CAS
Priority date: 2020-12-07
Filing date: 2020-12-07
Publication date: 2023-10-27
Anticipated expiration: 2040-12-07
Also published as: CN112905153A

Abstract

The embodiment of the application provides a software parallel construction method and device for a software defined satellite, wherein the software parallel construction method for the software defined satellite comprises the following steps: receiving a plurality of management commands from a developer, wherein the plurality of management commands comprises: project management commands, function management commands, variable management commands, data type management commands, and link commands; acquiring characteristic information carried by various management commands in the various management commands, and providing the characteristic information for a source code data recording device to finish the operation on items or elements, wherein the elements comprise: functions, variables, and data types, the operations comprising: at least one of create, delete, query, and modify; the characteristic information includes: item attributes, query conditions, variable attributes, data type attributes, etc.; and when the state of the function is obtained to change, automatically triggering an increment compiling process.

Description

Software parallel construction method and device for software defined satellite

Technical Field

The application relates to the field of parallel compiling, in particular to a software parallel construction method and device for a software defined satellite.

Background

Existing compilers typically contain several tools that work independently of each other and in a serial fashion, such as preprocessing, compiling, assembling, chaining, etc. For historical reasons, none of these tools often support parallelism, and therefore do not fully utilize the computing and storage capabilities provided by cloud computing. In addition, existing compilers work passively, that is, when a developer makes a local modification to a source file, the compiler does not actively analyze the correctness of the modification, and only when the developer calls the compiler, the compiler acts. Therefore, the error cannot be found at the first time, and a necessary prompt is timely given. The reason for this is that on the one hand, compiling is time consuming, and the developer does not call the compiler once every time a little modification is made; on the other hand, the reason is that the current compiler takes the source file as the minimum compiling unit, so even if a certain source file only has little local change, the changed source file needs to be processed from beginning to end, and the source file directly or indirectly depending on the source file needs to be processed from beginning to end, thus not only being slow in reflection, but also causing great resource waste.

The software-defined satellite is characterized in that the functions of communication, loading and the like which are conventionally realized by a subsystem are realized in a software manner by means of a software-defined radio, a software-defined load, a software-defined data processing computer, a software-defined network and the like by taking calculation as a center and taking software as means, various sensors and executing mechanisms are integrally connected through software, and the software of most satellite functions is finally realized. The software-defined satellite releases the coupling relation between software and hardware of a satellite product, so that satellite software can be independently evolved, loaded and dynamically reconstructed as required, and further more functions can be realized without changing hardware, and more tasks can be completed. The inventor of the application realizes that in the software defined satellite, software occupies a larger proportion, more and more developers participate in the software development of the software defined satellite, and the software serial construction method for the traditional satellite aims at the software of independent individuals or small teams and cannot meet the requirement of multi-user large-scale software parallel development. How to design an efficient source code generation compiler is a technical problem to be solved.

Disclosure of Invention

The embodiment of the application aims to provide a software parallel construction method and device for a software defined satellite, which comprehensively realize the functions of pre-compiling, preprocessing, compiling, linking, static analyzing and the like, wherein the basic compiling unit is reduced from a source file to the level of functions, types, variables, parameters, sentences and local variables, and the flexibility is greatly improved.

In a first aspect, some embodiments of the present application provide a software defined satellite-oriented software parallel construction method, where the software defined satellite-oriented software parallel construction method includes: receiving a plurality of management commands from a developer, wherein the plurality of management commands comprises: project management commands, function management commands, variable management commands, data type management commands, and link commands; acquiring characteristic information carried by various management commands in the various management commands, and providing the characteristic information for a source code data recording device to finish the operation on items or elements, wherein the elements comprise: functions, variables, and data types, the operations comprising: at least one of create, delete, query, and modify; the characteristic information includes: item attributes, query conditions, variable attributes, data type attributes, function parameters and function statements; and automatically triggering an incremental compiling process when the state of the function is acquired to change, wherein the change of the state of the function is caused by the active modification or the indirect modification of the function by the developer, the active modification comprises adding, deleting or modifying the function, and the indirect modification comprises modifying the data structure or global variable used by the function.

The code generating and compiling method of some embodiments of the application effectively overcomes the defect of code storage and compiling modes based on source files in the prior art, comprehensively realizes the functions of pre-compiling, preprocessing, compiling, assembling, linking, static analysis and the like, reduces the basic compiling unit from the source files to the level of functions, types, variables, parameters, sentences and local variables, and greatly improves the flexibility.

In some embodiments, the receiving a plurality of management commands from a developer includes: receiving the project management command from the developer; the step of obtaining the characteristic information carried by various management commands in the plurality of management commands and providing the characteristic information for the source code data recording device to finish the operation of items or elements comprises the following steps: and completing the operation for the project according to the project management command.

Some embodiments of the application facilitate the flow of project operations by code developers through interactive command management.

In some embodiments, the project management command comprises a command message to create a first project, wherein the command message to create a first project comprises a null project command message to create a null project or a template project command message to create a template project from a template; the completing the operation for the project according to the project management command includes: reading the empty project command message or the template project command message; extracting the item attribute in the empty item command message or the template item command message to write the item attribute into an item table of a source code data recording device, wherein the item attribute comprises: a project type, project name, project version, project copyright, project description, user manual path, project source code file path, project executable file path containing test code, project state, test expiration date, and project configuration file path based on the source code language; generating a default configuration file of the project according to a project configuration file template, and writing a path of the default configuration file of the project into the project table; acquiring the relationship between the developer and the project, recording the relationship to a user project relationship table of the source code data recording device, and setting the authority of the developer as an administrator, wherein the relationship is characterized by the following parameters: the system comprises a unique identifier, a project number, a user information identifier type, a user information identifier and a user authority for representing each project relation table; responding to the empty project command message, creating an empty project code library table according to a first naming rule, wherein the content of the empty project code library table is empty; or responding to the template project command message, creating a template project code base table according to a second naming rule, wherein the template project code base table is the content in the target project template table; and sending a response message to the developer.

According to the method and the device, related information required by project management can be extracted from information carried by the interactive command through various steps of the project creation process, and the information is provided to a storage device for storage, so that the project automation management is facilitated.

In some embodiments, the project management command includes a command message to retrieve a first project; the completing the operation for the project according to the project management command includes: reading a command message retrieving the first item; searching target items which meet the search conditions and belong to the participation of the developer according to the search conditions in the first item search command message; providing feature information of the target item, wherein the feature information comprises attributes of the target item, and the attributes of the target item comprise a target item type, a target item name, a target item version, a target item copyright, a target item description, a target item related user manual path, a target item source code file path, a target item executable file path containing test codes, a target item state, a target item test expiration date and a target item configuration file path based on a source code language.

Some embodiments of the present application may extract information of the search item carried by the command message through the search step, and provide the required item attribute information to the searcher.

In some embodiments, the receiving a plurality of management commands from a developer includes: receiving the variable management command from the developer; the step of obtaining the characteristic information carried by various management commands in the plurality of management commands and providing the characteristic information for the source code data recording device to finish the operation of items or elements comprises the following steps: and completing the operation on the variable according to the variable management command.

Some embodiments of the present application provide for extracting variable information and providing such information to a corresponding storage table for storage to enable the elemental storage of code and incremental compilation.

In some embodiments, the variable management command includes a command message to create a first variable; the completing the operation for the variable according to the variable management command includes: reading a command message creating the first variable; confirming that no variables with the same names as the first variables exist; acquiring the variable attribute of the first variable, and providing the variable attribute to a variable table included in a source code data recording device, wherein the variable attribute comprises: variable number, variable type, variable name, variable initial value, variable category, variable group, whether constant, variable remark, creation time, creator, modification time, modifier; acquiring a data type identifier corresponding to the first variable; providing a reference relation corresponding to the first variable and the data type identifier to an element reference table included in the source code data recording device; and returning a response message.

Some embodiments of the application extract variable information and provide this information to a corresponding storage table for storage to enable the elemental storage of code and incremental compilation.

In some embodiments, the variable management command includes a command message to delete a second variable; the completing the operation for the variable according to the variable management command includes: confirming that the developer has management authority on the second variable; inquiring the identification of the second variable in a variable table according to the name of the second variable; confirming that the identification of the second variable does not exist in the element reference table; deleting the second variable in the variable table; and returning a response message.

Some embodiments of the application may at least ensure that variable deletions do not affect existing functions or other elements.

In some embodiments, the variable management command includes a command message to modify a third variable; the completing the operation for the variable according to the variable management command includes: reading a command message modifying the third variable; querying the variable table for information of the third variable (i.e., querying the variable table for specific information of the third variable); confirming that the third variable exists in the variable table; modifying a variable attribute of the third variable, wherein the variable attribute comprises: variable number, variable type, variable name, variable initial value, variable class, variable group, whether constant, variable remark, modification time, modifier.

In some embodiments, before said modifying the property of the third variable, the method further comprises: confirming that the developer has modification rights to the third variable; acquiring the identification of the third variable according to the name of the third variable; and confirming that modifying the third variable does not affect the rest variables with reference relation with the third variable according to the identification of the third variable.

Some embodiments of the application may ensure that variable modifications do not affect the remaining variables that have a referencing relationship with the deleted variable. Some embodiments of the application can at least ensure that a person with modification rights modifies the variable, avoiding adverse effects caused by modification of the variable by a person without management rights.

In some embodiments, the variable management command further includes a command to manage a variable breakpoint.

The variable management of the embodiment of the application also comprises a process for managing the variable breakpoints, thereby facilitating the management process of the variable breakpoints.

In some embodiments, the receiving a plurality of management commands from a developer includes: receiving the data type management command from the developer; the step of obtaining the characteristic information carried by various management commands in the plurality of management commands and providing the characteristic information for the source code data recording device to finish the operation of items or elements comprises the following steps: and completing the operation on the variable according to the data type management command.

Embodiments of the present application also provide a way to accomplish data type management through interactive commands.

In some embodiments, the data type management command includes a command message to create a first data type; the performing the operation on the variable according to the data type management command includes: reading a command message creating the first data type; confirming that the original data type with the same name as the first data type does not exist; acquiring the data type attribute of the first data type, and providing the data type attribute to a data type table and a data type member table which are included in a source code data recording device, wherein the data type attribute comprises a data type number, a data type name, a data type definition, a data type category, a data type group, a data type creation time, a data type creator, a data type last time modification time and a modifier; acquiring a reference relation of the first data type, and providing the reference relation to an element reference table included in the source code data recording device; and returning a response message.

Some embodiments of the present application disclose information that needs to be extracted and stored when creating a data type to enable structured storage of the data type, and further aspects of subsequent retrieval of the data type, etc.

In some embodiments, the data type management command includes a command message to delete a second data type; the performing the operation for the data type according to the data type management command includes: confirming that the developer has administrative rights to the second data type; acquiring an identification of the second data type; confirming that the identification of the second data type does not exist in the element reference table of the source code data recording device; deleting the second data type in the data type table; and returning a response message.

Some embodiments of the present application provide a method for deleting a data type, by which at least a program error can be found at a first time after deleting the data type, and fine-grained version management that can be traced back step by step is supported.

In some embodiments, the data type management command includes a command message modifying a third data type; the performing the operation for the data type according to the data type management command includes: reading a command message modifying the third data type; acquiring a data type number of the third data type; confirming that the third data type exists in a data type table in the source code data recording device according to the data type number; modifying an attribute of the third data type, wherein the data type attribute comprises: data type number, data type name, data type definition, data type category, data type group, last data type modification time, modifier.

Some embodiments of the present application provide a process for modifying a data type, by which a data type to be modified can be searched for and obtained, and the data type to be searched for and obtained can be modified accordingly.

In some embodiments, before said modifying the attribute of the third data type, the method further comprises: confirming that the developer has modification rights to the third data type; acquiring a data type identifier according to the name of the third data type; confirming, from the data type identification, that modifying the third data type does not affect other of the elements associated with the third data type.

Some embodiments of the application provide a validation operation prior to modifying the data type to ensure that modifying the data type does not affect other elements.

In some embodiments, the receiving a plurality of management commands from a developer includes: receiving the function management command from the developer; the step of obtaining the characteristic information carried by various management commands in the plurality of management commands and providing the characteristic information for the source code data recording device to finish the operation of items or elements comprises the following steps: and completing the operation on the variable according to the function management command.

The embodiment of the application also realizes the management operation of the function by means of the interactive command, thereby facilitating the function management.

In some embodiments, the function management command includes a command message to create a first function; the performing the operation on the variable according to the function management command includes: reading a command message for creating the first function; confirming that a function table of the source code data recording device does not have a homonymy function with the same name as the first function; acquiring function attribute information, function parameter information and function statement information of the first function, providing the function attribute information to a function table of the source code data recording device, providing the function parameter information to a function parameter information table of the source code data recording device, and providing the function statement information to a function statement table of the source code data recording device, wherein the function attribute information comprises: function number, return value type, function name, function class, function group, function remark, creation time, creator, modification time, modifier; the function parameter information includes: the function number, the parameter serial number, the parameter type, the parameter name, the parameter default value and the parameter remark; the function statement information includes: the function number, the sentence sequence number, the sentence label, the sentence content, the sentence remarks and the sentence types; acquiring a data type identifier adopted by the first function, and acquiring a variable identifier adopted by the first function; providing the element reference table included in the source code data recording device with the data type adopted by the first function and the variable reference relation of the first function, wherein the data type adopted by the first function is obtained according to the data type identifier adopted by the first function, and the variable reference relation adopted by the first function is obtained according to the variable identifier adopted by the first function; and returning response information.

Some embodiments of the present application provide a method for creating a function, by which various features of a function to be created, such as function parameter information and function statement information, can be extracted, and the features are stored by using tables in a database, so that fine-grained storage of the function is realized, and subsequent addition, deletion, modification, compiling, etc. of the function are facilitated.

In some embodiments, the function management command includes a command message to delete the second function; the performing the operation on the variable according to the function management command includes: reading a command message for deleting the second function, wherein the command message adopts a regular expression to characterize the characteristics of the function to be deleted; acquiring the second function according to the regular expression and confirming that the second function can be managed by the developer; acquiring identification information of the second function; confirming that the identification information of the second function does not exist in the element reference table; determining the function attribute, the function parameter and the function statement related to the second function, so that the source code data recording device deletes the function attribute, the function parameter and the function statement related to the second function from a function table, a function parameter information table and a function body information table; and returning a response message.

Some embodiments of the present application provide a method for deleting a function, by which a user with operation authority can be at least guaranteed to delete the function, and it is determined which tables in a database need to be specifically operated by the deleted function, so that the integrity of the function deleting operation is guaranteed.

In some embodiments, the function management command includes a command message to modify a third function; the completing the operation for the function according to the function management command includes: reading a command message modifying the third function; acquiring the third function information; confirming that the third function exists in a function table of the source code data recording device; modifying the third function.

Some embodiments of the present application provide a method for modifying a function, by which modification of a found function can be accomplished.

In some embodiments, before said modifying said third function, said method further comprises: confirming that the developer has modification rights to the third function; acquiring the identification of the third function according to the name of the third function; and confirming that the identification of the third function does not exist in the element reference table according to the identification of the third function.

Some embodiments of the present application also provide a validation operation prior to modifying a function to ensure that modifying the modified function does not cause an impact on other elements.

In some embodiments, the compiling process of the function is performed when the state of the function is changed, including: confirming information change of a function characterization table, wherein the function characterization table comprises: a function statement table, a function parameter information table, or a function table, the change being caused by modifying or adding information in the function characterization table; reading the changed function characterization table and reading an element reference table; reading referenced element information from the element reference table; updating symbol information and an abstract syntax tree according to the referenced element information; generating a compiling result according to the updated symbol information and the updated abstract syntax tree; and storing the compiling result into a compiling result record table.

Some embodiments of the present application further provide an incremental compiling method, by which the incremental compiling process can be automatically triggered by the background.

In some embodiments, the source code generation and compilation method further comprises: the linking object code obtains executable code.

Some embodiments of the application also provide a technical solution for implementing object code linking through interactive commands.

In a second aspect, some embodiments of the present application provide a software defined satellite-oriented software parallel construction apparatus, including: a receiving module configured to receive a plurality of management commands from a developer, wherein the plurality of management commands includes: project management commands, function management commands, variable management commands, data type management commands, and link commands; the element operation module is configured to acquire characteristic information carried by various management commands in the plurality of management commands and provide the characteristic information for the source code data recording device to finish the operation on the item or the element, wherein the element comprises: functions, variables, and data types, the operations comprising: at least one of create, delete, query, and modify; the characteristic information includes: item attributes, query conditions, variable attributes, data type attributes, function parameters and function statements; and the compiling module is configured to automatically trigger an incremental compiling process when the state of the function is acquired to change, wherein the change of the state of the function is caused by the active modification or the indirect modification of the function by the developer, the active modification comprises adding, deleting or modifying the function, and the indirect modification comprises modifying the data structure or global variable used by the function.

In some embodiments, the element manipulation module comprises: the project management module is configured to acquire project related information based on the project management command and provide the project related information to the source code data recording device so as to realize the addition, deletion, inquiry or modification of the project; a function management module configured to acquire function related information based on the function management command and provide the function related information to the source code data recording device to realize addition, deletion, inquiry or modification of the function; the variable management module is configured to acquire variable related information based on the variable management command and provide the variable related information to the source code data recording device so as to realize addition, deletion, inquiry or modification of the variable; a data type management module configured to acquire data type related information based on the data type management command and provide the data type related information to the source code data recording device to realize addition, deletion, inquiry or modification of the data type; wherein the source code data recording device is configured to store the information through a plurality of data tables.

Some embodiments of the application accomplish management of functions, variables, data types, items through a compiler by further defining functional units of element operations at times.

In some embodiments, the software defined satellite-oriented software parallel building apparatus further comprises: and a linking module configured to link the object code to obtain the executable code.

The compiler of some embodiments of the present application further includes a functional module that implements linking object code via interactive commands to obtain executable code.

In some embodiments, the software defined satellite-oriented software parallel building apparatus is further configured to: when the developer modifies a referenced element, an impact domain of the referenced element is obtained and provided to the developer.

Some embodiments of the present application further provide a technical solution for obtaining an influence domain when modifying an element, so as to ensure that the modification process does not affect other elements that do not need modification.

In some embodiments, the software defined satellite-oriented software parallel building apparatus is further configured to: when the element is created, modified or deleted according to the command message, element information is automatically extracted and element reference information is extracted to obtain a reference relation, wherein the source code data recording device is further configured to store an element data table comprising the element information and store an element reference relation table comprising the reference relation; when receiving the search element command message, extracting the search element in the search element command message, and extracting the required element from the element reference relation table and the element data list to feed back the search result through the response message.

Some embodiments of the present application further provide a preprocessing operation for searching by using the software parallel construction device facing the software defined satellite and a searching process based on the preprocessing result, so that a user can conveniently and interactively program to quickly and accurately search a required code to obtain the required target code.

The software parallel construction device provided by the embodiment of the application can improve the software construction speed of the software-defined satellite and meet the requirement of large-scale multi-user software parallel construction of the software-defined satellite.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings that are needed in the embodiments of the present application will be briefly described below, it should be understood that the following drawings only illustrate some embodiments of the present application and should not be considered as limiting the scope, and other related drawings can be obtained according to these drawings without inventive effort for a person skilled in the art.

FIG. 1 is a block diagram of a software rapid development system for a software defined satellite according to an embodiment of the present application;

FIG. 2 is a schematic diagram of an external interface for project management according to an embodiment of the present application;

FIG. 3 is a block diagram of a module for project management included in a software-defined satellite according to an embodiment of the present application;

FIG. 4 is a schematic diagram of a management interface for creating a project according to an embodiment of the present application;

FIG. 5 is a flow chart of creating an item provided by an embodiment of the present application;

FIG. 6 is a schematic diagram of an external interface of a search term according to an embodiment of the present application;

FIG. 7 is a flow chart of item retrieval provided by an embodiment of the present application;

FIG. 8 is a schematic diagram of an external interface for modifying items according to an embodiment of the present application;

FIG. 9 is a flow chart of a modification project provided by an embodiment of the present application;

FIG. 10 is an external interface diagram of a modification project configuration file according to an embodiment of the present application;

FIG. 11 is a flowchart of a display project configuration file according to an embodiment of the present application;

FIG. 12 is a flowchart of a modification project configuration file provided by an embodiment of the present application;

FIG. 13 is a schematic diagram of an external interface of a variable management module included in a software-defined satellite according to an embodiment of the present application;

FIG. 14 is a schematic diagram of an external interface for creating a new variable according to an embodiment of the present application;

FIG. 15 is a flow chart for creating new variables provided by an embodiment of the present application;

FIG. 16 is a schematic diagram of an external interface for deleting a variable according to an embodiment of the present application;

FIG. 17 is a schematic flow chart of deleting variables according to an embodiment of the present application;

FIG. 18 is a schematic diagram of an external interface for modifying variables according to an embodiment of the present application;

FIG. 19 is one of the flowcharts for modifying variables provided by embodiments of the present application;

FIG. 20 is a second flowchart of modifying variables according to an embodiment of the present application;

FIG. 21 is a schematic diagram of an external interface for retrieving variables according to an embodiment of the present application;

FIG. 22 is a flow chart of a search variable provided by an embodiment of the present application;

FIG. 23 is a schematic diagram of an external interface for managing variable breakpoints according to an embodiment of the present application;

FIG. 24 is a flowchart of managing variable breakpoints provided by an embodiment of the present application;

FIG. 25 is a diagram of an external interface to a data type management module included in a software-defined satellite according to an embodiment of the present application;

FIG. 26 is a block diagram of the modules for data type management according to an embodiment of the present application;

FIG. 27 is a diagram of an external interface for creating new data types provided by an embodiment of the present application;

FIG. 28 is a flow chart for creating new data types provided by an embodiment of the present application;

FIG. 29 is a diagram of an external interface for deleting data types according to an embodiment of the present application;

FIG. 30 is a flowchart of deleting a data type according to an embodiment of the present application;

FIG. 31 is a diagram illustrating an external interface for modifying data types according to an embodiment of the present application;

FIG. 32 is one of the flow charts of modifying data types provided by embodiments of the present application;

FIG. 33 is a second flowchart of a modified data type according to an embodiment of the present application;

FIG. 34 is a diagram of an external interface for retrieving data types according to an embodiment of the present application;

FIG. 35 is a flow chart of retrieving data types provided by an embodiment of the present application;

FIG. 36 is a schematic diagram of an external interface of a function management module included in a software-defined satellite according to an embodiment of the present application;

FIG. 37 is a functional block diagram of function management according to an embodiment of the present application;

FIG. 38 is a diagram of an external interface for creating a new function according to an embodiment of the present application;

FIG. 39 is a schematic diagram of interfaces between the function module and other layers according to an embodiment of the present application;

FIG. 40 is a flow chart for creating a new function provided by an embodiment of the present application;

FIG. 41 is a schematic diagram of an external interface of a delete function according to an embodiment of the present application;

FIG. 42 is a flowchart of a delete function provided by an embodiment of the present application;

FIG. 43 is an external interface diagram of a modification function provided by an embodiment of the present application;

FIG. 44 is a flowchart of one of the modified functions provided by the embodiment of the present application;

FIG. 45 is a second flowchart of a modification function provided by an embodiment of the present application;

FIG. 46 is an external interface diagram of a search function provided by an embodiment of the present application;

FIG. 47 is a flow chart of a search function provided by an embodiment of the present application;

FIG. 48 is a diagram of an external interface for managing function breakpoints according to an embodiment of the present application;

FIG. 49 is a flowchart of a management function breakpoint according to an embodiment of the present application;

FIG. 50 is a schematic diagram of an external interface of a compiling module for a software defined satellite according to an embodiment of the present application;

FIG. 51 is a compiling flow chart according to an embodiment of the application;

FIG. 52 is a schematic diagram of an external interface of a link module included in a software-defined satellite according to an embodiment of the present application;

FIG. 53 is a link flow chart provided by an embodiment of the present application;

fig. 54 is a block diagram of a software parallel construction device for a software defined satellite according to an embodiment of the present application.

Detailed Description

The technical solutions in the embodiments of the present application will be described below with reference to the accompanying drawings in the embodiments of the present application.

It should be noted that: like reference numerals and letters denote like items in the following figures, and thus once an item is defined in one figure, no further definition or explanation thereof is necessary in the following figures. Meanwhile, in the description of the present application, the terms "first", "second", and the like are used only to distinguish the description, and are not to be construed as indicating or implying relative importance.

Referring to fig. 1, fig. 1 is a software parallel construction system for a software-defined satellite, which includes a ten-layer structure, and functions of each layer and information processing procedures between adjacent layers are described one by one. It should be noted that, the seventh layer in the ten-layer structure included in the system in fig. 1 is the software parallel construction device for a software-defined satellite provided by the embodiment of the present application, and the software parallel construction method for a software-defined satellite in the embodiment of the present application is also executed by the software parallel construction device for a software-defined satellite of the seventh layer.

The first layer of fig. 1 includes an interactive terminal 101 for receiving command information input by a developer. For example, the user may issue command messages to the interactive end 101 by means of various means, such as sound, text, etc. As one example, the interactive terminal 101 employs a mobile terminal, and in particular, a developer may issue a command message to a compiler through text through a WeChat client on the mobile terminal.

As one example, each micro-credit user is a legitimate user of the integrated development cloud (i.e., the interactive programming system of embodiments of the present application), i.e., a potential developer. After a micro credit user pays attention to a micro credit public account corresponding to the integrated development cloud, a software parallel construction system facing the software definition satellite creates a private library for the micro credit user and names the micro credit user by micro signals. The system will record each command sent by the developer to the integrated development cloud and each response given by the integrated development cloud. For example, types of command messages that a developer may use include: CD and DC are used to switch working scenarios; new, del, list for creating, deleting and retrieving objects, wherein the objects comprise: data types, variables, functions, classes, macro definitions, etc.; the Set is used for setting or modifying the attribute value of the object; help is used to obtain system Help; debug, test, analyze, build, distribute is used to debug, test, analyze, build and publish source code.

The working scenes of the software parallel construction system facing the software defined satellites of some embodiments of the application are divided into three levels, wherein the first level of working scene is used for creating and managing projects, the second level of working scene is used for managing functions, data types and variables in the projects, and the third level of working scene is used for operating the attributes of the functions, the data types and the variables. Different commands (such as those listed above) may be executed in different scenarios to manipulate different objects.

Each time the developer sends a command to the software parallel building system for the software defined satellite, the compiler 701 will check the legitimacy of the command, execute the command, and feed back the execution result of the command (i.e. a response message) to the user. The software development work is actually that a long series of commands and the compiler 701 interact in real time, and finally the development work of the application program is completed. The software parallel construction system for the software defined satellite, provided by the embodiment of the application, supports large-scale remote collaboration and parallel development.

In one project, the developer is classified into three roles: an administrator, a senior programmer, a primary programmer. An administrator has the right to create, delete, query and modify all objects (i.e., data types, variables, functions, classes, macros, etc.) in a project, can authorize or invite a developer to become a senior programmer and a primary programmer of the project, and can also yield its administrator identity to a senior programmer in a project development team. The high-level programmer has the right to create, delete, query and modify objects created by himself as well as objects created by the primary programmer. The primary programmer can only create, delete, query and modify objects that he creates himself.

The second layer includes an authentication and message forwarding device 201, where the authentication and message forwarding device 201 is configured to provide registration, identity authentication, payment, channel encryption, message forwarding, broadcast, and other functions.

The third layer includes a message parsing device 301, where on the one hand, the message parsing device 301 is configured to aggregate and parse command messages input by a user submitted by a developer through the interaction end 101 and the authentication and message forwarding device 201, and write the parsed command messages into the fourth layer parsing message and response message recording device 401. The message parsing device 301 is further configured to read the response message given by the compiler 701 from the parsing message and response message recording device 401, and distribute the response message to the interactive terminal 101 via the authentication and message forwarding device 201.

The fourth layer includes a parsing message and response message recording device 401, and the parsing message and response message recording device 401 may store the parsed message based on a relational database, a real-time database, a NoSQL database, or the like. The fourth layer parsing message and response message recording device 401 may write the parsed command message to the message parsing device 301, or may read the response message of the compiler 701 from the fifth layer command normalization and task scheduling device 501.

The fifth layer comprises command normalization and task scheduling means 501 for normalizing and task scheduling the command message read from the parse message and answer message recording means 401.

The sixth layer comprises command recording means 601. That is, the command recording apparatus 601 includes, as one example: project management command recording means, function management command recording means, variable management command recording means, data type management command recording means, and link command recording means, which can store various management commands based on a relational database, a real-time database, a NoSQL database, or the like. On the one hand, the command recording device 601 allows the command normalization and task scheduler 501 to write a command message and read a response message. Command recording means 601 on the other hand may be provided for the compiler 701 of fig. 1 to read command messages and write reply messages.

The seventh layer contains a compiler 701 (i.e., the software parallel building apparatus for a software defined satellite according to the embodiment of the present application). Compiler 701 of fig. 1 includes, as one example: the system comprises a project management unit, a function management unit, a variable management unit, a data type management unit, a compiling unit and a linking unit, wherein the units can provide services such as source code generation, construction, analysis, simulation and simulation execution. The various compiling units of the seventh layer of fig. 1 correspond to the respective kinds of command recording devices of the sixth layer, and are linked with the 8 th layer source code data recording device 801, respectively.

For example, the compiling unit of the seventh layer generates the object code from the intermediate code and the element information (data type, variable, function (class, macro definition, etc.)), and the linking unit generates the executable file from the object code, and stores the object code and the executable file to the source code data recording apparatus 801. It should be noted that, the target program is an executable file, and the target program may be directly accessed through the operating system.

The eighth layer includes a source code data recording device 801, which is a data recording device (may be based on a relational database, a real-time database, a NoSQL database, and other storage functions, variables, and the like) for storing source codes of item libraries or private libraries, and providing creation, deletion, query, and modification services for the compiling units of the seventh layer.

It should be noted that, the source code of an item in the embodiment of the present application corresponds to a set of a plurality of data type definitions, a plurality of variable definitions, and a plurality of function definitions, where the data type, the variable, and the function are objects having different attributes respectively. When the source code data recording apparatus 801 employs a structured database, the source code in one item appears as a set of data tables in the database. For example, the storage modes of the data types include: a data type table (e.g., the table may further include a data type number, name, definition, category, group, creation time, creator, last time modified, modifier, remark), a data type member table (e.g., the table may further include a data type number, a member type, a member name, a member default, a member sequence number, a member remark), a data type whitelist table (e.g., the table may include a data type number, a function number, an available flag); the manner of depositing the variables includes a variable table (e.g., the table may include: variable number, variable type, variable name, variable initial value, variable category, variable group, whether constant, variable remark, creation time, creator, modification time, modifier) and a variable whitelist table (e.g., the table may include: variable number, function number, whether reading is allowed, whether writing is allowed); the storage mode of the function comprises the following steps: a function table (e.g., the table may include a function number, a return value type, a function name, a function category, a function group, a function remark, a creation time, a creator, a modification time, a modifier), a function parameter table (e.g., the table may include a function number, a parameter type, a parameter name, a parameter default, a parameter remark), a local variable table (e.g., the table may include a function number, a variable type, a variable name, a variable initial value, a variable remark), a function statement table (e.g., the table may include a function number, a statement content, a statement type), or a function whitelist table (e.g., the table may include a function number, a call permission flag), wherein the function whitelist is used to characterize the visible domain of the function and may be called.

The ninth layer includes the code search device 901 of fig. 1, which is a code search device responsible for analyzing the source code stored in the source code data recording device 801, and writing the code and related data to the corresponding source code data recording device 801 after searching the code and related data from the reusable code recording device 1001 as necessary.

The tenth layer includes a reusable code recording device 1001, which is a data recording device (may be based on a relational database, a real-time database, a NoSQL database, etc.), in which reusable code resources and data resources are stored, and the code retrieving device 901 of the ninth layer may retrieve and access relevant codes according to the needs of different developers.

The structure of a seventh layer of software-defined satellite-oriented software parallel building apparatus (otherwise known as a compiler) is further illustratively described below in conjunction with fig. 2-54.

As shown in fig. 2, some embodiments of the present application provide a software-defined satellite-oriented software parallel construction method implemented by a seventh layer of a compiler, including: s101, receiving various management commands from a developer, wherein the various management commands comprise: project management commands, function management commands, variable management commands, data type management commands, and link commands; s102, acquiring characteristic information carried by various management commands in the various management commands, and providing (or submitting) the characteristic information to a source code data recording device to finish the operation (or operation record) on items or elements, wherein the elements comprise: functions, variables, and data types, the operations comprising: at least one of create, delete, query, and modify; the characteristic information includes: item attributes, query conditions (query conditions: including element name, element creation time, element modification time, etc.), variable attributes, data type attributes, function parameters, and function statements; and S103, automatically triggering an increment compiling process when the state of the function is acquired to change, wherein the change of the state of the function is caused by the active modification or the indirect modification of the function by the developer, the active modification comprises adding, deleting or modifying the function, and the indirect modification comprises modifying the data structure or global variables used by the function.

The following is an exemplary description of the project management (or project operations) involved by the software-defined satellite-oriented software parallel building method, in conjunction with fig. 3-13.

In some embodiments of the application, S101, receiving the project management command from the developer; s102, finishing project operation according to the project management command. As shown in fig. 3, S101 and S102 are executed by a project management module included in the software-defined satellite-oriented software parallel building apparatus.

It can be seen from fig. 3 that the project management module of the seventh layer is respectively connected with the user project relation table, the project template library table, the project code library (the project code library comprises a project related variable table, a data type member table, a function parameter information table and a function statement table), the file storage and the code template list in the eighth layer source code data recording device, and meanwhile, the project management module is also connected with the interactive terminal 101 of the first layer to receive a project management command input by a user through the interactive terminal 101 or return a project management related response message to the interactive terminal 101. The user project relation table of fig. 3 may receive the user project relation information output by the project management module, and the user project relation table may also feed back the user authority and the project number information to the project management module; the project table of fig. 3 is used for receiving project table information (in the form of project records), project attribute information and project configuration file path information extracted from the project management command by the project management module and sending the project table information, the project attribute information and the project configuration file path information to the eighth layer of user project relation table for storage, and the project table is also used for sending project numbers and project table contents required by the project management module to the project management module; the project template library table of fig. 3 is used for feeding back template content to the project management module so that the project management module creates template projects according to the modules; the project code library of fig. 3 is used for receiving the template content from the project management module, so that the content in the specific project template library selected by the user is stored in the project code library, wherein the project code library comprises a variable table, a data type member table, a function parameter information table and a function statement table related to the project; the file storage of fig. 3 is used for receiving the project configuration file generated by the project management module, or the file storage table is used for sending a default project configuration file to the project management module, so that a user can fill in the project configuration file according to the default project configuration file, and store the project configuration file; the code template list of fig. 3 is used to send a template number to the project management module so that the user can select a particular project template.

Fig. 4 illustrates main functional modules included in the item management module of fig. 3, that is, the item management module of fig. 3 includes: a new item module (for executing an item management command to create a new item), a search item module (for executing an item management command to search for an item), and a modify item attribute (for executing an item management command to modify an item) module.

FIG. 5 provides a schematic diagram of the external interface of the add-on item of FIG. 4. As can be seen in conjunction with fig. 5, in order to execute the project management command for creating a project, the newly added project module of fig. 4 is respectively connected with the interactive terminal of the first layer to receive the command for creating a blank project or creating a project according to a template input by the developer through the interactive terminal 101, and is further connected with the user project table, the file storage table, the code template list, the project template library table and the project code library table in the eighth layer source code data recording apparatus.

The flow of creating an item is exemplarily described below in conjunction with fig. 5 and 6.

As shown in fig. 6, in some embodiments of the present application, the project management command includes a command message to create a first project, wherein the command message to create the first project includes a null project command message to create a null project or a template project command message to create a template project from a template; reading the empty item command message or the template item command message, that is, reading an item management command of creating an empty item command or creating an item command according to a template in a user message list; extracting the item attribute in the empty item command message or the template item command message to write the item attribute into an item table of a source code data recording device (that is, filling in an item attribute value carried in an item management command into the item table), wherein the item attribute comprises: a project type, project name, project version, project copyright, project description, user manual path, project source code file path, project executable file path containing test code, project state, test expiration date, and project configuration file path based on the source code language; generating a default configuration file of the project according to a project configuration file template, and writing a path of the default configuration file of the project into the project table; acquiring a relationship between the developer and the project (for example, receiving, by the interaction end 101, content in a user project relationship table filled by the developer) so as to record the relationship to a user project relationship table of the source code data recording device, and setting authority of the developer as an administrator, where the relationship is characterized by the following parameters: the system comprises a unique identifier, a project number, a user information identifier type, a user information identifier and a user authority for representing each project relation table; responding to the empty project command message, creating an empty project code library table according to a first naming rule, wherein the content of the empty project code library table is empty; or responding to the template project command message, creating a template project code base table according to a second naming rule, wherein the template project code base table is the content in the target project template table; and sending a response message to the developer.

It should be noted that, the first item generally refers to any one of requests submitted by a developer through the interaction end 101 to create a new item. Sending a reply message to the developer may include feeding back a command message that the project was successfully created, or a message that the project was not created, to the developer through the interactive terminal 101.

FIG. 7 provides a schematic diagram of connection between the search term module of FIG. 4 and other layer modules, and it can be seen from FIG. 7 that the search term module is respectively connected to the interactive terminal 101 to receive the term management information of the search term command from the user message table or the response message of the search result fed back to the interactive terminal 101; the search item module of fig. 7 is further connected to the eighth layer of user item relation table to receive the item number and the user authority fed back by the user item relation table according to the search request, and is further connected to the eighth layer and the item table to receive the item table content information fed back by the item table according to the search request.

The flow of item retrieval is exemplarily described below in conjunction with fig. 8.

As shown in fig. 8, in some embodiments of the application, the project management command includes a command message to retrieve a first project; s101, reading a search item command, for example, reading a command message for searching the first item, wherein the first item is any item; searching for a target item which meets the search condition and belongs to the participation of the developer according to the search condition in the first item searching command message, namely searching for a item which meets the condition and participates in the user according to the search condition in the user message; providing feature information of the target item, wherein the feature information comprises attributes of the target item, and the attributes of the target item comprise a target item type, a target item name, a target item version, a target item copyright, a target item description, a target item related user manual path, a target item source code file path, a target item executable file path containing test codes, a target item state, a target item test expiration date and a target item configuration file path based on a source code language.

It should be noted that, in some embodiments of the present application as shown in fig. 8, the number of candidate items obtained by searching may also be determined, if one target item is obtained by searching, all attribute values of the target item (i.e. contents in the feedback item table) may be returned through a command box message, and if multiple target items are obtained by searching, the item name and the user authority (i.e. contents in the feedback user item relationship table) may be returned through a command message.

FIG. 9 is a schematic diagram of an interface between the modified project property module of FIG. 4 and other layer modules. The modified item attribute module of fig. 9 is connected to the first layer interaction end 101 to receive a command for modifying the item attribute in the user message table or a response message for feeding back a modification result to the interaction end; the module of fig. 9 for modifying the item attributes is also coupled to the user item relationship table and the item table included in the eighth layer to receive the item numbers and user rights from the user item relationship table or to send item attribute information to be modified to the item table.

As shown in fig. 10, the method of modifying an item includes: reading a command satisfying all of the following conditions: 1) the message category is "edit box message", 2) the context is "PRO" (i.e., shorthand for project), 3) the message content is project attribute; inquiring whether the authority of the user in the user project relation table (namely, the user project relation table feeds back the user authority to the seventh layer) is an administrator, if the user authority is the administrator, uniformly modifying the corresponding project attribute information, otherwise, prohibiting modification of the project attribute; and feeding back a response message to the interaction end.

Fig. 11 is a schematic diagram showing interfaces between the filling/modifying project configuration file module and other layers included in the seventh-layer project management module. It can be seen from fig. 11 that the filling/modification project configuration file module may read the message of the modification project configuration file command in the user message table through the interaction terminal 101, and feed back the response message of the modification result to the user message response table of the interaction terminal; the fill/modify project profile module of FIG. 11 also communicates with a user project relationship table included in the eighth tier to obtain user rights, communicates with the project table to write a project profile path to the project table, communicates with the file storage table to receive a default project profile fed back by the file storage table or sends the project profile to the file storage table.

FIG. 12 is a flow chart for modifying project profiles, the flow specifically comprising: reading a modification project configuration file command; judging whether the project configuration file path in the project table is empty or not, if so, reading a default configuration file, and if not, reading the configuration file according to the configuration file path; the content of the configuration file is fed back to the user message response table, so that the user can acquire the content of the configuration file through the interaction end 101.

Fig. 13 is a flow of filling out a project configuration file, the flow comprising: reading a command satisfying all of the following conditions: 1) the message category is "edit box message", 2) the context is "PRO", 3) the message content is the project configuration file; inquiring whether the authority of the user in the user project relation table is an administrator or not, if so, saving the project configuration file, filling the file name into the project table, and if not, directly feeding back a response message.

FIG. 14 is a schematic diagram illustrating interfaces between a variable management module and other layers of the seventh layer of the present application for performing variable management operations. The variable management module of fig. 14 is connected with the interactive terminal 101 to receive a variable management class command in the user message table, or write a response message into the user message response table of the interactive terminal; the variable management module of fig. 14 is further connected to the variable table, the data type table, the element reference table, and the user item relationship table of the eighth layer to receive the variable number or the variable information from the variable table or write the extracted variable information to the variable table, or receive the data type information from the data type table, or receive the element referencing the variable from the element reference table or send its extracted element reference record to the element reference table, or receive the user authority information from the user item relationship table.

In some embodiments of the present application, the variable management module is configured to perform variable management operations, and S101 includes: receiving the variable management command from the developer; s102 includes: and completing the operation on the variable according to the variable management command.

Fig. 15 is a schematic diagram of receiving a create variable (or a new variable) module, as shown in fig. 15, where the new variable module is connected to the interactive terminal 101 to receive a new variable command message, a project number to which the new variable belongs, and a user number in a user message table, or write a response message into a user message response table of the interactive terminal. The newly added variable module of fig. 15 is further connected to a variable table included in the eighth layer to write the extracted variable information to the variable table, connected to a data type table of the eighth layer to receive the data type information from the data type table, and connected to an element reference table of the eighth layer to write the element reference record acquired by the newly added variable module to the element reference table.

In some embodiments of the application, the variable management command includes a command message to create a first variable; the completing the operation for the variable according to the variable management command includes: reading a command message creating the first variable; confirming that no variables with the same names as the first variables exist; acquiring the variable attribute of the first variable, and providing the variable attribute to a variable table included in a source code data recording device, wherein the variable attribute comprises: variable number, variable type, variable name, variable initial value, variable category, variable group, whether constant, variable remark, creation time, creator, modification time, modifier; acquiring a data type identifier corresponding to the first variable (for example, by inquiring and acquiring the data type identifier corresponding to the first variable from a source code data recording device); providing a reference relation corresponding to the first variable and the data type identifier to an element reference table included in the source code data recording device; and returning a response message. For example, as shown in fig. 16, the process of adding a variable may include the steps of: reading a newly added variable command; and determining whether the variables with the same name exist, if the variables with the same name exist, directly feeding back a response message for refusing to create the new variables, otherwise, writing the newly created variables into a variable table, inquiring the data type number in a data type table, adding a reference relation record of the variables and the data type in an element reference table, and returning a response message for successful creation.

Fig. 17 is an interface schematic diagram of a module for deleting a variable operation and other layers, where the deleting variable module of fig. 17 is connected to the interaction end 101 to read an item number, a user number, and a specific command for deleting a variable in a user message table (a command message for deleting a second variable in the following embodiment of the present application includes the item number, the user number, and specific command information for deleting the variable), or a response message for feeding back a result of the deleting operation to a user message response table of the interaction end. The delete variable module of FIG. 17 is also coupled to the eighth layer user item relationship table to receive user rights from the user item relationship table, to the eighth layer variable table to receive variable numbers from the variable table or to write variable information for a variable to be deleted to the variable table, and to the eighth layer element reference table to receive elements from the element reference table that reference the variable.

In some embodiments of the application, the variable management command includes a command message to delete the second variable; the completing the operation for the variable according to the variable management command includes: confirming that the developer has management authority on the second variable; inquiring the identification of the second variable in a variable table according to the name of the second variable; confirming that the identification of the second variable does not exist in the element reference table; deleting the second variable in the variable table; and returning a response message. Specifically, as shown in fig. 18, the delete variable command is read; inquiring whether the user permission in the user project relation table is the project manager or whether the variable in the query variable table is all of the user, if the user does not have the operation permission, feeding back a response message of failure of the variable deleting command to the interactive terminal, and if the user has the management permission of the variable deleting, executing the deleting operation, wherein the deleting operation comprises the following steps: inquiring the variable number in a variable table according to the variable name; inquiring whether the variable number exists in the element reference table, deleting the variable in the variable table if the variable number exists, otherwise, feeding back the response message.

The module of fig. 19 for modifying variables is used to perform operations for modifying variables, and fig. 19 provides interface relationships of the module of modifying variables with other layers. The modification variable module as in 19 is connected to the interactive terminal 101 to receive the user number, the item number and the modification variable command specific information (these three information correspond to the command message for modifying the third variable hereinafter) in the user message table, or to feed back the response information to the interactive terminal 101. The modification variable module of fig. 19 is further connected with the variable table of the eighth layer to receive the variable number from the variable table or send the variable information obtained by the modification variable module to the variable table, and connected with the element reference table to feed back the element referring to the variable to the modification variable module, so that the influence of modifying the element on other elements can be avoided.

That is, in some embodiments of the present application, the variable management command includes a command message for modifying the third variable, and it should be noted that the third variable is not specific to a certain variable or a certain type of variable only for convenience of description. S102: reading a command message modifying the third variable; inquiring information of the third variable in the variable table (namely, information in the table corresponding to the third variable); confirming that the third variable exists in the variable table; modifying a variable attribute of the third variable, wherein the variable attribute comprises: variable number, variable type, variable name, variable initial value, variable class, variable group, whether constant, variable remark, modification time, modifier. In some embodiments, before said modifying the property of the third variable, the method further comprises: confirming that the developer has modification rights to the third variable; acquiring the identification of the third variable according to the name of the third variable; and confirming that modifying the third variable does not affect the rest variables with reference relation with the third variable according to the identification of the third variable. As an example, the process of modifying the variables may refer specifically to fig. 20 and 21. As shown in fig. 20, the method of modifying variables includes: a command to read the modification variable; inquiring variable information in a variable table; judging whether the variable exists or not, if not, feeding back a response message of failure to delete the variable, and if the variable to be deleted exists, returning the variable attribute by adopting an edit box message. As shown in fig. 21, a command satisfying the following conditions is read: 1) the message category is "edit box message", 2) the context is "VAR" (i.e., shorthand for variable), 3) the message content has no variable attribute; inquiring whether the user permission in the project relation table is the project manager or whether the variable in the query variable table is the user, if the user has no operation permission, directly feeding back a response message that the variable cannot be modified, and if the user has the operation permission, executing the following operations: inquiring the variable number in a variable table according to the variable name; inquiring whether the element reference table has a variable number, if the element reference table has the variable number, confirming that the variable information to be modified does not influence the variable reference, modifying the variable information in the variable table, and otherwise, feeding back response information.

The search variable module of fig. 22 is used to perform operations of searching variables, and it can be seen in connection with fig. 22 that the interfaces of the module of searching variables with other layers of fig. 1 include interfaces with the interactive terminal 101 and interfaces with the data table included in the eighth layer. The search variable module of fig. 22 is connected to the interactive terminal 101 to read the item numbers in the user message table and the specific message of the search variable command, and feeds back a response message of the search variable result to the interactive terminal. The retrieve variable module of fig. 22 is also connected to a variable table included in the eighth layer to receive variable information from the variable table or to a data type table to receive data type information from the data type table.

As shown in fig. 23, a process of retrieving a variable is provided, where the process of retrieving a variable specifically includes: reading a search variable command; inquiring variable information in a variable table according to the item numbers and the index variable command parameters, and inquiring data type information of the variables in a data type table; obtaining a search result; and determining the number of variables included in the search result, feeding back response information of search failure if the number of variables is zero, returning all attribute values of the variables by adopting the command box information if the number of the variables obtained by search is 1, and returning a variable list and response information by adopting the command box information if the number of the variables obtained by search is greater than 1.

The management breakpoint module of fig. 24 is used to manage variable breakpoints, and interfaces with other layers of fig. 1 as in fig. 24. As can be seen from fig. 24, the management breakpoint module is connected to the interactive terminal 101 to receive a command message of setting/deleting/displaying variable breakpoints inputted by a user from the interactive terminal, or to feed back a response message to the interactive terminal. The management breakpoint module of fig. 24 is further connected to a variable table included in the eighth layer, so as to receive variable name information from the variable table or send breakpoint identification information extracted by the management breakpoint module to the variable table.

Fig. 25 is a flowchart of a variable breakpoint management method executed by a management breakpoint module, where the variable breakpoint management includes: reading a management breakpoint command; confirming that the command type of variable breakpoint management belongs to a breakpoint setting operation, inquiring whether the user permission in a project relation table is the project manager or whether the variable in the variable table is owned by the user, if so, setting the breakpoint identification of the variable in the variable table as yes, otherwise, returning a response message; or confirming that the command type of variable breakpoint management belongs to the operation of deleting the breakpoint, inquiring whether the user permission in the project relation table is the project manager or whether the variable in the query variable table is all of the user, if so, setting the breakpoint identification of the variable in the variable table as no, otherwise, returning a response message; or confirming that the command type of variable breakpoint management belongs to a display breakpoint, inquiring whether the user authority in the project relation table is the project manager, if so, inquiring the variable name with the breakpoint identification being yes in the variable table, otherwise, inquiring the variable name with the user number being the current user and the breakpoint identification being yes in the variable table, and returning a response message.

The data type management module of fig. 26 is used for executing commands related to data type management operations, and it can be seen in conjunction with fig. 26 that the data type management module is connected to the interactive terminal 101, so as to receive a data type management command in a user message input by a user through the interactive terminal, or feed back a response message to a user message response table of the interactive terminal. The data type management module of fig. 26 is further connected to a data type table, a data type member table, an element reference table, and a user item relationship table, wherein the data type management module is connected to the data type table to receive a data type number and data type information from the data type table, or to receive the data type information acquired by the data type management module and store the data type information to the data type table; the data type management module is connected with the data type member table, and can send data type number information to the data type member table (for example, the data type member table comprises a data type ID, a member type, a member name, a member default value, a member serial number and a description) through the connection of the data type member table, and can feed back the data type member information to the data type management module through the connection of the data type member table; the data type management module is connected with the element reference table to receive the element using the data type from the element reference table or send the element reference record acquired by the data type management module to the element reference table; the data type management module is connected with the user project relation table to receive the user authority information from the user project relation table.

Fig. 27 provides further functional units included in the data type management module of fig. 26, specifically, the data type management module includes: a new add data type module (or referred to as a create data type module) for creating a data type, a delete data type module for deleting a data type, a modify data type module for modifying a data type, and a retrieve data type module for retrieving a data type.

In some embodiments of the application, S101 includes: receiving the data type management command from the developer; s102 includes: and completing the operation on the variable according to the data type management command.

Fig. 28 provides an interface schematic of the new data type module, and the new data type module of fig. 28 is connected to the interactive terminal 101 to obtain a new data type command, a project number, and a user number in the user message table (these three contents correspond to the following command message for creating the first data type, that is, the command message for creating the first data type includes these three contents), or feedback response information to the user message response table of the interactive terminal. The newly added data type module of fig. 28 is connected with the data type table, the data type member table and the element reference table of the eighth layer, wherein the newly added data type module sends data type information acquired by the newly added data type module from the creation data type command information to the data type table through the connection or sends a data type number to the newly added data type module from the data type table; the newly added data type module sends the data type member information acquired by the newly added data type to the data type member list through connection; the newly added data type module sends the element reference record acquired by the newly added data type module to the element reference table through the connection.

In some embodiments of the application, the data type management command includes a command message to create a first data type; the performing the operation on the variable according to the data type management command includes: reading a command message creating the first data type; confirming that the original data type with the same name as the first data type does not exist; acquiring the data type attribute of the first data type, and providing the data type attribute to a data type table and a data type member table which are included in a source code data recording device, wherein the data type attribute comprises a data type number, a data type name, a data type definition, a data type category, a data type group, a data type creation time, a data type creator, a data type last time modification time and a modifier; acquiring a reference relation of the first data type, and providing the reference relation to an element reference table included in the source code data recording device; and returning a response message. As one example, as shown in fig. 29, a method of creating a data type includes: reading a newly added data type command; and confirming whether the same-name data type exists, if the same-name data type does not exist, writing the data type into a data type table (and a data type member table), adding a reference relation record of the data type and the data type into an element reference table, and if the same-name data type exists, directly returning a response message.

The delete data type module of fig. 30 is for performing a delete data type operation, and the delete data type module of fig. 30 is connected to the interactive terminal 101 to read a delete data type command, a project number, and a user number (these three contents correspond to a command message of the next Wen Shanchu second data type) from the user message table of the interactive terminal, and feeds back a response message to the user message response table of the interactive terminal through the connection. The module for deleting data types of fig. 30 is further connected to a user item relationship table, a data type member table and an element reference table included in the eighth layer, where the module for deleting data types is connected to the user item relationship table to obtain user rights from the user item relationship table; the deleting data type module is connected with the data type table to acquire a data type number from the data type table or transmits the data type information acquired by the deleting data type module to the data type table through connection; the deleting data type module is connected with the data member table to provide the data member table with the data type number acquired by the deleting data type module; the delete data type module interfaces with the element reference table to receive element information from the element reference table that uses the data type.

In some embodiments of the application, the data type management command includes a command message to delete a second data type; the performing the operation for the data type according to the data type management command includes: confirming that the developer has administrative rights to the second data type; acquiring an identification of the second data type; confirming that the identification of the second data type does not exist in the element reference table of the source code data recording device; deleting the second data type in the data type table; and returning a response message. It should be noted that the second data type belongs to any data type, and is not particularly limited to a certain kind of data type. As an example, as shown in fig. 31, the method of deleting a data type includes: reading a command to delete a data type; inquiring whether the user permission in the project relation table is the project manager or whether the data type in the inquiry data type table is the user, if not, returning a response message, and if so, executing the operation of deleting the data type, specifically: inquiring the number of the data type in a data type table according to the name of the data type; and inquiring whether the data type exists in the element reference table, if so, returning a response message, and if not, deleting the data type in the data type table and the data type member table, and returning the response message.

The modified data type module of fig. 32 is used to perform the data type modification operation, and the modified data type module of fig. 32 is connected to the interactive terminal to receive a modified data type command, an item number, and a user number (these three items correspond to the command message for modifying the third data type below) of the user message table received by the interactive terminal, or to return a response message to the interactive terminal. The modified data type module of fig. 32 is connected with the data type table, the data type member table and the element reference table, wherein the modified data type module sends data type information acquired by the modified data type module according to the modified data type command to the data type table through the connection, or receives the data type number from the data type table through the connection; the module for modifying the data type sends the data type member information to the data type member list through connection; the module that modifies the data type receives an element from the element reference table that uses the data type through the connection.

In some embodiments of the application, the data type management command includes a command message modifying a third data type; the performing the operation for the data type according to the data type management command includes: reading a command message modifying the third data type; acquiring a data type number of the third data type; confirming that the third data type exists in a data type table in the source code data recording device according to the data type number; modifying an attribute of the third data type, wherein the data type attribute comprises: data type number, data type name, data type definition, data type category, data type group, last data type modification time, modifier. In some embodiments, before said modifying the attribute of the third data type, the method further comprises: confirming that the developer has modification rights to the third data type; acquiring a data type identifier according to the name of the third data type; confirming, from the data type identification, that modifying the third data type does not affect other of the elements associated with the third data type.

As one example, as shown in fig. 33, a method of modifying a data type includes: reading a modified data type command; querying a data type table (and a data type member table) for data type information; judging whether the data type exists, if so, returning the data type information by the edit box information, and if not, returning the response information. As shown in fig. 34, the method of modifying a data type further includes: reading a command satisfying the following conditions: 1) the message category is "edit box message", 2) the context is "TYPE", 3) the message content has no data TYPE attribute; querying whether the user authority in the project relation table is the project manager or whether the data type in the query data type table is the user, if not, returning a response message, and if so, executing the following modification operation: inquiring the number of the data type in a data type table according to the name of the data type; querying whether the data type exists in the element reference table, if the data type exists, confirming that the data type information needing to be modified does not affect other elements or if the data type does not exist, modifying the data type in the data type table (and the data type member table), and returning a response message.

The search data type module of fig. 35 is used for performing a data type search operation, and the search data type module is connected to the interactive terminal 101 to receive a search data type command and an item number in the user message table, or to feed back response information to the user message response table of the interactive terminal 101. The retrieve data type module of fig. 35 is connected to the data type table and the data type member table of the eighth layer, wherein the retrieve data type module receives the data type information from the data type table through the connection or receives the data type member information from the data type member table through the connection.

As shown in fig. 36, the method of retrieving a data type includes: reading a search data type command; inquiring data type information in a data type table (and a data type member table) according to the project number and the search data type command parameter; confirming the number of the retrieved data types meeting the conditions, returning a response message of retrieval failure if the number is zero (namely, the data types meeting the conditions are not retrieved), returning all attribute values of the data types through the command box message and returning the response message if the number is 1, and returning the data type list and returning the response message through the command box message if the number is greater than 1.

The function management module of fig. 37 is configured to execute a function management command, and the function management module of fig. 37 interfaces with other layers of fig. 1, including an interface with an interaction end, and an interface with an eighth layer. Specifically, the function management module is connected to the interactive terminal 101 to receive a function management class command in the user message table, or returns a response message to the user message response table of the interactive terminal. The function management module is connected with the function table, the function parameter information table, the function statement table, the variable table, the data type table, the element reference table and the user item relation table of the eighth layer, wherein the function management module can receive the function information, the function number and the data type number through the connection with the function table; the function parameter information can be transmitted in two directions through the connection with the function parameter information table; the function statement information can be transmitted in a bidirectional way through connection with the function statement table; the variable number can be obtained through the connection with the variable table; acquiring a data type number and data type information through connection with a data type table; obtaining an element calling the function from the element reference table through connection with the element reference table or sending an element reference record obtained by the function management module to the element reference table; and acquiring the user permission through the relation table with the user item.

FIG. 38 provides functional modules further including a function management module, as shown in FIG. 38, including a new function module, a delete function module, a modify function module, a retrieve function module, and a manage function breakpoint module.

In some embodiments of the application, S101 includes: receiving the function management command from the developer; s102 includes: and completing the operation on the variable according to the function management command.

FIG. 39 provides an interface schematic of a newly added function module (i.e., create function operation) with other layers, the newly added function module of FIG. 39 being connected to a function table, a function parameter information table, a function statement table, a variable table, a data type table, and an element reference table to receive a function number from the function table, a variable number from the variable table, and a data type number from the data type table, or to provide function information obtained from a command to create a function to the function table, function parameter information obtained from a command to create a function to the function parameter information table, and element reference record information obtained from a command to create a function to the element reference table.

In some embodiments of the application, the function management command includes a command message to create a first function; the performing the operation on the variable according to the function management command includes: reading a command message for creating the first function; confirming that a function table of the source code data recording device does not have a homonymy function with the same name as the first function; acquiring function attribute information, function parameter information and function statement information of the first function, providing the function attribute information to a function table of the source code data recording device, providing the function parameter information to a function parameter information table of the source code data recording device, and providing the function statement information to a function statement table of the source code data recording device, wherein the function attribute information comprises: function number, return value type, function name, function class, function group, function remark, creation time, creator, modification time, modifier; the function parameter information includes: the function number, the parameter serial number, the parameter type, the parameter name, the parameter default value and the parameter remark; the function statement information includes: the function number, the sentence sequence number, the sentence label, the sentence content, the sentence remarks and the sentence types; acquiring a data type identifier adopted by the first function, and acquiring a variable identifier adopted by the first function; providing the element reference table included in the source code data recording device with the data type adopted by the first function and the variable reference relation of the first function, wherein the data type adopted by the first function is obtained according to the data type identifier adopted by the first function, and the variable reference relation adopted by the first function is obtained according to the variable identifier adopted by the first function; and returning response information.

As one example, as shown in fig. 40, a method of creating a function includes: reading a new function command; confirming that the function with the same name does not exist, and writing the function into a function table, a function parameter information table and a function statement table; inquiring the data type number in the data type information table and inquiring the variable number in the variable table; and adding the reference relation between the function and the data type and the reference relation between the function and the variable in the element reference table, and returning a response message. It should be noted that if it is confirmed that there is a function having the same name as the function to be created, a response message is directly returned.

FIG. 41 is a diagram showing the connection of a delete function module for performing function deletion to other layers, the delete function module of FIG. 41 being connected to the interactive side to read the delete function command, item number, and user number (these three items correspond to the following command message for deleting the second function) in the user message table, or to provide answer information to the user message answer table of the interactive side; the module for deleting the function is also connected with the compiling result record table to send the function number and the project number to the compiling result record (to realize incremental compiling); the deleting function module is connected with the user project relation table, the function parameter information table, the function statement table and the element reference table to send the function information acquired by the deleting function module from the deleting command to the function table, provide the function parameter information acquired by the deleting function module from the deleting command to the function parameter information table, provide the function body information acquired by the deleting function module from the deleting command to the function statement table, or receive the user authority from the user project relation table, the function number from the function table and the element information from the element reference table for calling the function.

In some embodiments of the application, the function management command includes a command message to delete the second function; the performing the operation on the variable according to the function management command includes: reading a command message for deleting the second function, wherein the command message adopts a regular expression to characterize the characteristics of the function to be deleted; acquiring the second function according to the regular expression and confirming that the second function can be managed by the developer; acquiring identification information of the second function; confirming that the identification information of the second function does not exist in the element reference table; determining the function attribute, the function parameter and the function statement related to the second function, so that the source code data recording device deletes the function attribute, the function parameter and the function statement related to the second function from a function table, a function parameter information table and a function body information table; and returning a response message.

As an example, as shown in fig. 42, a method of deleting a function includes: reading a delete function command; querying all functions which meet the regular expression and can be operated by the user according to the regular expression; confirming a function which meets the condition, and inquiring the function number in a variable table according to the function name; and if the function number exists in the element reference table, returning a response message of deletion failure. If there is no function meeting the condition, the response message is returned directly.

Fig. 43 includes a modification function module for performing a function modification, which is connected to the interactive terminal 101 to obtain a modification function command, an item number, and a user number (these three items correspond to command messages for modifying the third function hereinafter) from the user message table, or to feed back a response message to the user message response table. The modification function module of fig. 43 is connected to the function table, the function parameter information table, the function body statement table, and the element reference table of the eighth layer to transmit the function information acquired by the modification function module from the function modification command to the function parameter information table, transmit the function parameter information acquired by the modification function module from the function modification command to the function body statement table, transmit the function body information acquired by the modification function module from the function modification command to the function body statement table, or receive the function number from the function table, the element calling the function from the element reference table.

In some embodiments of the application, the function management command includes a command message to modify a third function; the completing the operation for the function according to the function management command includes: reading a command message modifying the third function; acquiring the third function information; confirming that the third function exists in a function table of the source code data recording device; modifying the third function. In some embodiments, before said modifying said third function, said method further comprises: confirming that the developer has modification rights to the third function; acquiring the identification of the third function according to the name of the third function; and confirming that the identification of the third function does not exist in the element reference table according to the identification of the third function.

As an example, as illustrated in fig. 44 and 45, a method of modifying a function includes: reading a modification function command; inquiring function information in a function table (a function parameter information table and a function body information table); if the function does not exist, a response message of failure modification is fed back, and if the function does exist, function information is returned by using an edit box message. Specifically, as shown in fig. 45, a command satisfying the following condition is read: 1) the message category is "edit box message", 2) the context type is not "FUNC", 3) the message content is a function attribute; confirming that the user permission in the query user project relation table is the project manager or the function in the query function table is all functions of the user, and executing the following modification operation: inquiring the function number in a function table according to the function name; and if the function number exists in the element reference table, the function information in the function table (the function parameter table and the parameter body information table) is required to be confirmed, and the function information in the function table (the function parameter table and the parameter body information table) is modified after the element reference is not influenced by the information of the function is confirmed to be confirmed, and a function modification response message is returned. It should be noted that, if the user does not have the operation authority, a response message of the modification failure is directly returned.

FIG. 46 includes a search function module that implements function search that interfaces with the interactive side to obtain item numbers from the user message table and search function commands to feed back response information to the user message response table. The retrieval function module of fig. 46 is connected with the function table, the function parameter information table, the function statement table and the data type table of the eighth layer to acquire the function information from the function table, acquire the function parameter information from the function parameter information table, and acquire the function statement information from the function statement table and the data type information from the data type table.

A method of function retrieval is exemplarily described below in conjunction with fig. 47, the method comprising: reading a search function command; inquiring function information in a function table (a function parameter information table and a function body information table) according to the project numbers and the retrieval function command parameters; and confirming the number of the retrieved functions meeting the conditions, directly feeding back response information of the related functions if the target functions are not retrieved, returning all attribute values of the functions by the command box information if the number of the target functions is 1, returning the function list by the command box information if the number of the target functions is greater than 1, and returning the response information.

The module for managing function breakpoints provided in fig. 48 is used for function breakpoint management, and the module for managing function breakpoints is connected with the interactive terminal to read the set/delete/display function (body) breakpoint command message from the user message table, or to feed back response information from the user message response table through connection. The module for managing the function breakpoints of fig. 28 is connected with the function table and the function statement table of the eighth layer, so as to acquire the breakpoint identification from the function table and the function body from the function statement table, and send the breakpoint identification to the function table and the breakpoint identification to the function statement table.

FIG. 49 is a functional breakpoint management method, including: reading a management breakpoint command; confirming that the command for managing the breakpoint belongs to the command for setting the breakpoint, inquiring whether the user authority is the project manager or whether the function of the query function table is owned by the user in the project relation table, if so (namely, the user has the manager authority or the function belongs to the user), executing the breakpoint identification of the function in the function table to be set as yes or filling the breakpoint identification in the function table, and returning a response message; confirming that the command type is a command for deleting the breakpoint, inquiring whether the user permission in the project relation table is the project manager or whether the function in the query function table is owned by the user, if so, executing the steps of setting the breakpoint identification of the function in the function table to be no or updating breakpoint identification information (deleting the line number) in the function table, and if not, returning a response message; confirming that the command type belongs to a display breakpoint command; inquiring whether the user authority in the user project relation table is the project manager or not, if yes (namely, confirming that the user authority is the manager), executing a function name with a break point mark in the inquiry function table as yes or executing a function body with a break point mark not being empty in the inquiry function body information table, extracting a corresponding line number, and if not, executing a function name with a user number of a current user and a break point mark as yes in the inquiry function table or executing a function body with a user number of the current user and a break point mark not being empty in the inquiry function body information table, providing a corresponding line number, and returning a response message.

The compiling service module of fig. 50 is used for executing the function of incremental compiling, and the compiling service module of fig. 50 is connected with the function table, the function parameter information table, the function statement table and the file storage table of the eighth layer, so as to receive the function information stored in the function table, the function parameter information stored in the function parameter information table, the function statement information stored in the function statement table, the symbol information and the abstract syntax tree from the file storage table, or send the symbol information, the abstract syntax tree information and the target file acquired by the compiling service module to the file storage table. The compiling service module of fig. 50 is also connected with the compiling result record table of the eighth layer to send compiling result information (for example, compiling the resulting object code) to the table. The symbol information and the information of the abstract syntax tree information bidirectional transmission correspond to the original information and the new information after incremental modification respectively.

In some embodiments of the present application, the compiling process for the function is performed when the state of the function is changed, including: confirming information change of a function characterization table, wherein the function characterization table comprises: a function statement table, a function parameter information table, or a function table, the change being caused by modifying or adding information in the function characterization table; reading the changed function characterization table and reading an element reference table; reading referenced element information from the element reference table; updating symbol information and an abstract syntax tree according to the referenced element information; generating a compiling result according to the updated symbol information and the updated abstract syntax tree; and storing the compiling result into a compiling result record table.

As an example, as shown in fig. 51, the incremental compiling method according to the embodiment of the application includes: confirming that the function statement table of the eighth layer generates a variable (for example, confirming a newly added function statement or modifying an existing function statement), or confirming that the function parameter information table of the eighth layer generates a change (for example, confirming a parameter related to a newly added or modified function), or confirming that the function table of the eighth layer generates a change (for example, a newly added or modified function), reading the changed function table, the function statement table and the function parameter table, and reading the element reference table; reading the information of the referenced elements in the element reference table; updating symbol information and abstract syntax tree; reading symbol information in an eighth-layer file storage table and an abstract syntax tree; updating and compiling to generate a compiling result; and writing the compiling result information into a compiling result record table of the eighth layer.

The link service module of fig. 52 is for executing a link command in the command message, and interfaces of the link service module with other layers of fig. 1 include: the link service module receives a connection service request input by a user through the interactive terminal 101 (specifically, the link service module reads the link service request from the interactive terminal from the link service request table of the sixth layer), the link service request module is connected with the compiling result record table of the eighth layer to receive the target file path and the test code identifier, the link service request module is connected with the file storage record table of the eighth layer to receive the target file, the link service request module is connected with the executable file record table of the eighth layer to send the executable file record to the executable file record table, and the link service request module is connected with the file storage table of the eighth layer to send the executable file to the file storage table. That is, in some embodiments of the present application, the source code generating and compiling method further includes: the linking object code obtains executable code.

Fig. 53 is a linking method performed by the linking service module of fig. 52, the linking method including: confirming that the unprocessed request exists in the link service request table; confirming that the user number is zero and using the test code, the following steps are performed: retrieving all target files (records containing test code identifiers) under the item from a compiling result record table, linking to generate an executable file, filling a file path into the executable file record table, and judging whether the test code item is contained or not; confirming that the user number is zero and the test code is not used, executing the following steps: retrieving all target files (records not containing test code identifiers) under the item from a compiling result record table, linking to generate an executable file, filling a file path into the executable file record table, and judging whether the test code item is contained or not; confirming that the user number is not zero and using the test code, executing the following steps: searching a target file (containing a record of a test code identifier) of the current user from a compiling result record table, linking to generate an executable file, filling a file path into the executable file record table, wherein whether the test code item is contained or not is yes; confirming that the user number is not zero and the test code is not used, executing the following steps: and searching a target file (which does not contain a record of the test code identifier) of the current user from the compiling result record table, linking to generate an executable file, filling a file path into the executable file record table, and judging whether the test code item is contained or not.

Referring to fig. 54, fig. 54 shows a software parallel construction device for a software-defined satellite according to an embodiment of the present application, and it should be understood that the software parallel construction device for a software-defined satellite (or called a compiler) corresponds to the method embodiment of fig. 2, and is capable of executing the steps related to the method embodiment, and specific functions of the compiler may be referred to the above description, and detailed descriptions thereof are omitted herein for avoiding repetition. A compiler comprising at least one software functional module capable of being stored in memory in the form of software or firmware or being solidified in an operating system of a device, the compiler comprising: the receiving module 711 is configured to receive a plurality of management commands from a developer, wherein the plurality of management commands include: project management commands, function management commands, variable management commands, data type management commands, and link commands; an element operation module 712, configured to obtain feature information carried by various management commands in the plurality of management commands, and provide the feature information to the source code data recording device to complete an operation on an item or element, where the element includes: functions, variables, and data types, the operations comprising: at least one of create, delete, query, and modify; the characteristic information includes: item attributes, query conditions, variable attributes, data type attributes, function parameters and function statements; a compiling module 713 configured to automatically trigger an incremental compiling process upon acquiring a change in the state of the function, wherein the change in the state of the function is caused by the developer actively modifying or indirectly modifying the function, the actively modifying including adding, deleting or modifying the function, and the indirectly modifying including modifying the data structure or global variables used by the function. The code generating and compiling method of some embodiments of the application effectively overcomes the defect of code storage and compiling modes based on source files in the prior art, comprehensively realizes the functions of pre-compiling, preprocessing, compiling, assembling, linking, static analysis and the like, reduces the basic compiling unit from the source files to the level of functions, types, variables, parameters, sentences and local variables, and greatly improves the flexibility.

In some embodiments of the application, element manipulation module 712 includes: a project management module (not shown in the figure) configured to acquire project related information based on the project management command and provide the project related information to the source code data recording apparatus to implement addition, deletion, inquiry or modification of the project; a function management module (not shown in the figure) configured to acquire function related information based on the function management command and provide the function related information to the source code data recording device to implement addition, deletion, inquiry or modification of the function; a variable management module (not shown in the figure) configured to acquire variable related information based on the variable management command and provide the variable related information to the source code data recording device to implement addition, deletion, inquiry or modification of the variable; a data type management module (not shown in the figure) configured to acquire data type related information based on the data type management command and provide the data type related information to the source code data recording device to implement addition, deletion, inquiry or modification of the data type; wherein the source code data recording device is configured to store the information through a plurality of data tables. Some embodiments of the application accomplish management of functions, variables, data types, items through a compiler by further defining functional units of element operations at times.

In some embodiments of the application, the compiler further comprises: a linking module (not shown) configured to link the object code to obtain the executable code.

In some embodiments of the application, the compiler is further configured to: when the developer modifies a referenced element, an impact domain of the referenced element is obtained and provided to the developer. Some embodiments of the present application further provide a technical solution for obtaining an influence domain when modifying an element, so as to ensure that the modification process does not affect other elements that do not need modification.

In some embodiments of the application, the compiler is further configured to: when the element is created, modified or deleted according to the command message, element information is automatically extracted and element reference information is extracted to obtain a reference relation, wherein the source code data recording device is further configured to store an element data table comprising the element information and store an element reference relation table comprising the reference relation; when receiving the search element command message, extracting the search element in the search element command message, and extracting the required element from the element reference relation table and the element data list to feed back the search result through the response message. Some embodiments of the present application further provide a preprocessing operation for searching by using a compiler and a process for searching based on a preprocessing result, so that a user can conveniently and interactively program to quickly and accurately search a required code to obtain the required target code.

It will be clear to those skilled in the art that, for convenience and brevity of description, the specific working process of the compiler described above may refer to the corresponding process in the method of fig. 2, and will not be described in detail herein.

In the several embodiments provided in the present application, it should be understood that the disclosed apparatus and method may be implemented in other manners. The apparatus embodiments described above are merely illustrative, for example, of the flowcharts and block diagrams in the figures that illustrate the architecture, functionality, and operation of possible implementations of apparatus, methods and computer program products according to various embodiments of the present application. In this regard, each block in the flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams and/or flowchart illustration, and combinations of blocks in the block diagrams and/or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

In addition, functional modules in the embodiments of the present application may be integrated together to form a single part, or each module may exist alone, or two or more modules may be integrated to form a single part.

The functions, if implemented in the form of software functional modules and sold or used as a stand-alone product, may be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application may be embodied essentially or in a part contributing to the prior art or in a part of the technical solution, in the form of a software product stored in a storage medium, comprising several instructions for causing a computer device (which may be a personal computer, a server, a network device, etc.) to perform all or part of the steps of the method according to the embodiments of the present application. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a Read-Only Memory (ROM), a random access Memory (RAM, random Access Memory), a magnetic disk, or an optical disk, or other various media capable of storing program codes.

The above description is only an example of the present application and is not intended to limit the scope of the present application, and various modifications and variations will be apparent to those skilled in the art. Any modification, equivalent replacement, improvement, etc. made within the spirit and principle of the present application should be included in the protection scope of the present application. It should be noted that: like reference numerals and letters denote like items in the following figures, and thus once an item is defined in one figure, no further definition or explanation thereof is necessary in the following figures.

The foregoing is merely illustrative of the present application, and the present application is not limited thereto, and any person skilled in the art will readily recognize that variations or substitutions are within the scope of the present application. Therefore, the protection scope of the present application shall be subject to the protection scope of the claims.

It is noted that relational terms such as first and second, and the like are used solely to distinguish one entity or action from another entity or action without necessarily requiring or implying any actual such relationship or order between such entities or actions. Moreover, the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one … …" does not exclude the presence of other like elements in a process, method, article, or apparatus that comprises the element.

Claims

1. The software parallel construction method for the software-defined satellites is characterized by comprising the following steps of:

receiving a plurality of management commands from a developer, wherein the plurality of management commands comprises: project management commands, function management commands, variable management commands, data type management commands, and link commands;

acquiring characteristic information carried by various management commands in the various management commands, and providing the characteristic information for a source code data recording device to finish the operation on items or elements, wherein the elements comprise: functions, variables, and data types, the operations comprising: at least one of create, delete, query, and modify; the characteristic information includes: item attributes, query conditions, variable attributes, data type attributes, function parameters and function statements;

when the state of the function is obtained to change, automatically triggering an incremental compiling process, wherein the change of the state of the function is caused by the active modification or the indirect modification of the function by the developer, the active modification comprises adding, deleting or modifying the function, and the indirect modification comprises modifying a data structure or a global variable used by the function;

When the state of the function is obtained to change, automatically triggering an increment compiling process, wherein the increment compiling process comprises the following steps:

confirming information change of a function characterization table, wherein the function characterization table comprises: a function statement table, a function parameter information table, or a function table, the change being caused by modifying or adding information in the function characterization table;

reading the changed function characterization table and reading an element reference table;

reading referenced element information from the element reference table;

updating symbol information and an abstract syntax tree according to the referenced element information;

generating a compiling result according to the updated symbol information and the updated abstract syntax tree;

and storing the compiling result into a compiling result record table.

2. The method for software-defined satellite-oriented software parallel construction according to claim 1,

the receiving of the plurality of management commands from the developer includes: receiving the project management command from the developer;

the step of obtaining the characteristic information carried by various management commands in the plurality of management commands and providing the characteristic information for the source code data recording device to finish the operation of items or elements comprises the following steps: and finishing project operation according to the project management command.

3. The software-defined satellite-oriented software parallel construction method of claim 2 wherein the project management command includes a command message to create a first project, wherein the command message to create a first project includes a null project command message to create a null project or a template project command message to create a template project from a template;

the completing the operation for the project according to the project management command includes:

reading the empty project command message or the template project command message;

extracting the item attribute in the empty item command message or the template item command message to write the item attribute into an item table of a source code data recording device, wherein the item attribute comprises: a project type, project name, project version, project copyright, project description, user manual path, project source code file path, project executable file path containing test code, project state, test expiration date, and project configuration file path based on the source code language;

generating a default configuration file of the project according to a project configuration file template, and writing a path of the default configuration file of the project into the project table;

Acquiring the relationship between the developer and the project, recording the relationship to a user project relationship table of the source code data recording device, and setting the authority of the developer as an administrator, wherein the relationship is characterized by the following parameters: the user information identification system comprises a unique identification, a project number, a user information identification type, a user information identification and a user authority for representing each user project relation table;

responding to the empty project command message, creating an empty project code library table according to a first naming rule, wherein the content of the empty project code library table is empty; or responding to the template project command message, creating a template project code base table according to a second naming rule, wherein the template project code base table is the content in the target project template table;

and sending a response message to the developer.

4. The software defined satellite oriented software parallel construction method of claim 2 wherein the project management command includes a command message to retrieve a first project;

reading a command message retrieving the first item;

Searching target items which meet the search conditions and belong to the participation of the developer according to the search conditions in the first item search command message;

providing feature information of the target item, wherein the feature information comprises attributes of the target item, and the attributes of the target item comprise a target item type, a target item name, a target item version, a target item copyright, a target item description, a target item related user manual path, a target item source code file path, a target item executable file path containing test codes, a target item state, a target item test expiration date and a target item configuration file path based on a source code language.

5. The method for software-defined satellite-oriented software parallel construction according to claim 1,

the receiving of the plurality of management commands from the developer includes: receiving the variable management command from the developer;

the step of obtaining the characteristic information carried by various management commands in the plurality of management commands and providing the characteristic information for the source code data recording device to finish the operation of items or elements comprises the following steps: and completing the operation on the variable according to the variable management command.

6. The software defined satellite oriented software parallel building method according to claim 5 wherein the variable management command includes a command message to create a first variable;

the completing the operation for the variable according to the variable management command includes:

reading a command message creating the first variable;

confirming that no variables with the same names as the first variables exist;

acquiring the variable attribute of the first variable, and providing the variable attribute to a variable table included in a source code data recording device, wherein the variable attribute comprises: variable number, variable type, variable name, variable initial value, variable category, variable group, whether constant, variable remark, creation time, creator, modification time, modifier;

acquiring a data type identifier corresponding to the first variable;

providing a reference relation corresponding to the first variable and the data type identifier to an element reference table included in the source code data recording device;

and returning a response message.

7. The software-defined satellite-oriented software parallel building method according to claim 5, wherein the variable management command includes a command message to delete the second variable;

confirming that the developer has management authority on the second variable;

inquiring the identification of the second variable in a variable table according to the name of the second variable;

confirming that the identification of the second variable does not exist in the element reference table;

deleting the second variable in the variable table;

and returning a response message.

8. The software-defined satellite-oriented software parallel building method according to claim 5, wherein the variable management command includes a command message to modify a third variable;

reading a command message modifying the third variable;

inquiring information of the third variable in a variable table;

confirming that the third variable exists in the variable table;

modifying a variable attribute of the third variable, wherein the variable attribute comprises: variable number, variable type, variable name, variable initial value, variable class, variable group, whether constant, variable remark, modification time, modifier.

9. The software-defined satellite-oriented software parallel building method according to claim 8, wherein before modifying the attribute of the third variable, the method further comprises:

Confirming that the developer has modification rights to the third variable;

acquiring the identification of the third variable according to the name of the third variable;

and confirming that modifying the third variable does not affect the rest variables with reference relation with the third variable according to the identification of the third variable.

10. The software-defined satellite-oriented software parallel building method according to claim 5, wherein the variable management command further comprises a command to manage a variable breakpoint.

11. The method for software-defined satellite-oriented software parallel construction according to claim 1,

the receiving of the plurality of management commands from the developer includes: receiving the data type management command from the developer;

the step of obtaining the characteristic information carried by various management commands in the plurality of management commands and providing the characteristic information for the source code data recording device to finish the operation of items or elements comprises the following steps: and completing the operation on the variable according to the data type management command.

12. The software defined satellite oriented software parallel construction method of claim 11 wherein the data type management command includes a command message creating a first data type;

The performing the operation on the variable according to the data type management command includes:

reading a command message creating the first data type;

confirming that the original data type with the same name as the first data type does not exist;

acquiring the data type attribute of the first data type, and providing the data type attribute to a data type table and a data type member table which are included in a source code data recording device, wherein the data type attribute comprises a data type number, a data type name, a data type definition, a data type category, a data type group, a data type creation time, a data type creator, a data type last time modification time and a modifier;

acquiring a reference relation of the first data type, and providing the reference relation to an element reference table included in the source code data recording device;

and returning a response message.

13. The software defined satellite oriented software parallel construction method of claim 11 wherein the data type management command includes a delete second data type command message;

the performing the operation for the data type according to the data type management command includes:

Confirming that the developer has administrative rights to the second data type;

acquiring an identification of the second data type;

confirming that the identification of the second data type does not exist in the element reference table of the source code data recording device;

deleting the second data type in the data type table;

and returning a response message.

14. The software defined satellite oriented software parallel construction method of claim 11 wherein the data type management command includes a command message modifying a third data type;

reading a command message modifying the third data type;

acquiring a data type number of the third data type;

confirming that the third data type exists in a data type table in the source code data recording device according to the data type number;

modifying an attribute of the third data type, wherein the data type attribute comprises: data type number, data type name, data type definition, data type category, data type group, last data type modification time, modifier.

15. The software defined satellite oriented software parallel construction method according to claim 14 wherein prior to modifying the attribute of the third data type, the method further comprises:

confirming that the developer has modification rights to the third data type;

acquiring a data type identifier according to the name of the third data type;

confirming, from the data type identification, that modifying the third data type does not affect other of the elements associated with the third data type.

16. The method for software-defined satellite-oriented software parallel construction according to claim 1,

the receiving of the plurality of management commands from the developer includes: receiving the function management command from the developer;

the step of obtaining the characteristic information carried by various management commands in the plurality of management commands and providing the characteristic information for the source code data recording device to finish the operation of items or elements comprises the following steps: and completing the operation on the variable according to the function management command.

17. The software defined satellite oriented software parallel construction method according to claim 16 wherein the function management command includes a command message to create a first function;

The performing the operation on the variable according to the function management command includes:

reading a command message for creating the first function;

confirming that a function table of the source code data recording device does not have a homonymy function with the same name as the first function;

acquiring function attribute information, function parameter information and function statement information of the first function, providing the function attribute information to a function table of the source code data recording device, providing the function parameter information to a function parameter information table of the source code data recording device, and providing the function statement information to a function statement table of the source code data recording device, wherein the function attribute information comprises: function number, return value type, function name, function class, function group, function remark, creation time, creator, modification time, modifier; the function parameter information includes: the function number, the parameter serial number, the parameter type, the parameter name, the parameter default value and the parameter remark; the function statement information includes: the function number, the sentence sequence number, the sentence label, the sentence content, the sentence remarks and the sentence types;

Acquiring a data type identifier adopted by the first function, and acquiring a variable identifier adopted by the first function;

providing the element reference table included in the source code data recording device with the data type adopted by the first function and the variable reference relation of the first function, wherein the data type adopted by the first function is obtained according to the data type identifier adopted by the first function, and the variable reference relation adopted by the first function is obtained according to the variable identifier adopted by the first function;

and returning response information.

18. The software defined satellite oriented software parallel construction method of claim 16 wherein the function management command includes a command message to delete a second function;

reading a command message for deleting the second function, wherein the command message adopts a regular expression to characterize the characteristics of the function to be deleted;

acquiring the second function according to the regular expression and confirming that the second function can be managed by the developer;

acquiring identification information of the second function;

Confirming that the identification information of the second function does not exist in the element reference table;

determining the function attribute, the function parameter and the function statement related to the second function, so that the source code data recording device deletes the function attribute, the function parameter and the function statement related to the second function from a function table, a function parameter information table and a function body information table;

and returning a response message.

19. The software defined satellite oriented software parallel construction method according to claim 16 wherein the function management command includes a command message modifying a third function;

the completing the operation for the function according to the function management command includes:

reading a command message modifying the third function;

acquiring the third function information;

confirming that the third function exists in a function table of the source code data recording device;

modifying the third function.

20. The software defined satellite oriented software parallel construction method according to claim 19 wherein prior to modifying the third function, the method further comprises:

confirming that the developer has modification rights to the third function;

Acquiring the identification of the third function according to the name of the third function;

and confirming that the identification of the third function does not exist in the element reference table according to the identification of the third function.

21. A software defined satellite oriented software parallel construction method according to claim 1 or 20, wherein the method further comprises: the linking object code obtains executable code.

22. A software defined satellite-oriented software parallel construction device, characterized in that the software defined satellite-oriented software parallel construction device comprises:

a receiving module configured to receive a plurality of management commands from a developer, wherein the plurality of management commands includes: project management commands, function management commands, variable management commands, data type management commands, and link commands;

the element operation module is configured to acquire characteristic information carried by various management commands in the plurality of management commands and provide the characteristic information for the source code data recording device to finish the operation on the item or the element, wherein the element comprises: functions, variables, and data types, the operations comprising: at least one of create, delete, query, and modify; the characteristic information includes: item attributes, query conditions, variable attributes, data type attributes, function parameters and function statements;

A compiling module configured to automatically trigger an incremental compiling process when a change in the state of the function is obtained, wherein the change in the state of the function is caused by the developer actively modifying or indirectly modifying the function, the active modification comprises adding, deleting or modifying the function, and the indirect modification comprises modifying a data structure or a global variable used by the function;

wherein the compiling module is configured to:

reading referenced element information from the element reference table;

and storing the compiling result into a compiling result record table.

23. The software-defined satellite-oriented software parallel building apparatus according to claim 22, wherein said element operation module comprises:

The project management module is configured to acquire project related information based on the project management command and provide the project related information to the source code data recording device so as to realize the addition, deletion, inquiry or modification of the project;

a function management module configured to acquire function related information based on the function management command and provide the function related information to the source code data recording device to realize addition, deletion, inquiry or modification of the function;

the variable management module is configured to acquire variable related information based on the variable management command and provide the variable related information to the source code data recording device so as to realize addition, deletion, inquiry or modification of the variable;

a data type management module configured to acquire data type related information based on the data type management command and provide the data type related information to the source code data recording device to realize addition, deletion, inquiry or modification of the data type;

wherein the source code data recording device is configured to store the information through a plurality of data tables.

24. The software defined satellite oriented software parallel construction device according to claim 23, wherein the software defined satellite oriented software parallel construction device further comprises: and a linking module configured to link the object code to obtain the executable code.

25. The software defined satellite oriented software parallel construction device of claim 22, wherein the software defined satellite oriented software parallel construction device is further configured to: when the developer modifies a referenced element, an impact domain of the referenced element is obtained and provided to the developer.

26. The software defined satellite oriented software parallel construction device of claim 22, wherein the software defined satellite oriented software parallel construction device is further configured to:

when creating, modifying or deleting the element according to the command message, automatically extracting element information and extracting element reference information to obtain a reference relationship, wherein the source code data recording device is further configured to store an element data table including the element information and store an element reference relationship table including the reference relationship;

when receiving the search element command message, extracting the search element in the search element command message, and extracting the required element from the element reference relation table and the element data list to feed back the search result through the response message.