CN112463149B - Software-defined satellite-oriented reusable code library construction method and device - Google Patents

Abstract

The embodiment of the application provides a method and a device for constructing a reusable code base for a software defined satellite, wherein the method for constructing the reusable code base for the software defined satellite comprises the steps of acquiring project information, element information and element relation information of an object to be stored, wherein the element information comprises at least one of variable information, function information, data type information, class definition information, macro definition information, function statement information and header file information, the element relation information comprises an element reference relation and a source code organization relation, and the object to be stored comprises a source code file or one or more rows of programming commands; and storing the object to be stored by using the acquired fine-grained information, wherein the fine-grained information comprises element information and element relation information. Some embodiments of the application can facilitate incremental compilation of the code by a compiler through fine-grained element storage of the code, and facilitate parallel software development of a user.

Description

Software-defined satellite-oriented reusable code library construction method and device

Technical Field

The application relates to the field of source code storage, in particular to a method and a device for constructing a reusable code base for a software defined satellite.

Background

A software project will often contain many source files. When compiling an entire project, an existing compiler compiles each source file in turn according to the dependency relationship between the source files (that is, each source file is processed separately), but does not treat all the source files as a whole. The working mode or habit of the compiler puts high requirements on the developer to write each source file and organize the whole source code tree, and not only needs to ensure that the information of each source file is complete (incomplete and can not be compiled correctly), but also needs to ensure that the information of each source file is consistent (inconsistent and can not be connected correctly). Therefore, how to scientifically and reasonably organize the source code tree becomes a great problem for developers, and the larger the source code scale is, the greater the difficulty is. No matter how scientific demonstration and elaborate design are carried out, a large-scale software project inevitably forms a source code tree which is interwoven together and has complex dependency relationship, so that the maintenance cost of the source code tree is increased year by year and greatly climbed. With the help of tools this can be alleviated, but the problem is not essentially solved. Such a source code tree structure with complex dependencies interleaved together is not only difficult to maintain. The backward organization mode of the source code and the compiler form a tight coupling relation of mutual restriction, one party is not changed, and the other party is not changed; together with compatibility issues, this field has been developing slowly over decades.

The software defined satellite is characterized in that the software defined satellite is centered on calculation, software is used as means, functions of communication, load and the like which are realized by subsystems in the prior art are realized in a software mode through means of software defined radio, software defined load, software defined data processing computer, software defined network and the like, all sensors and execution mechanisms are connected into a whole through software, and finally software of most satellite functions is realized. The software defined satellite removes the coupling relation between software and hardware of a satellite product, so that the satellite software can be independently evolved, loaded as required and dynamically reconstructed, thereby realizing more functions and completing more tasks under the condition of not changing the hardware. In the software-defined satellite, software occupies a greater proportion, more and more developers participate in software development of the software-defined satellite, and the software serial construction method for the traditional satellite is directed to software of independent individuals or small teams and cannot meet the requirement of multi-user large-scale software parallel development.

The traditional code management mode is a mode of managing codes of the whole project based on files, wherein the support for the concurrent development of a plurality of persons is little, and a great amount of time and manpower are needed in the aspects of synchronous management, version iteration and code integration of the codes.

The existing source code organization mode is quite backward, so that the existing integrated development environment is also quite backward. Therefore, a more efficient code storage manner is designed to facilitate the compiler to compile more quickly, which is a technical problem to be solved urgently.

Disclosure of Invention

The embodiment of the application aims to provide a method and a device for constructing a reusable code base for a software-defined satellite.

In a first aspect, some embodiments of the present application provide a method for constructing a reusable code base for a software-defined satellite, where the method for constructing a reusable code base for a software-defined satellite includes obtaining item information, element information, and element relationship information of an object to be stored, where the element information includes at least one of variable information, function information, data type information, class definition information, macro definition information, function declaration information, and header information, the element relationship information includes an element reference relationship, a source code organization relationship, and the object to be stored includes a source code file or one or more rows of programming commands; and storing the object to be stored by using the acquired fine-grained information, wherein the fine-grained information comprises element information and element relation information.

Some embodiments of the application can facilitate incremental compilation of the code by a compiler and parallel software development for a user by storing the code with fine-grained elements.

In some embodiments, the fine-grained information is stored by one of a relational database, a real-time database, and a NoSQL database. The fine-grained information is stored, for example, by multi-class data tables in a relational database.

Some embodiments of the application realize fine-grained storage of codes in multiple ways, improve the compiling efficiency of a compiler, and facilitate users to find errors in the code development process in time.

In some embodiments, the data table comprises: an item table for storing the item information, a variable table for storing the variable information, a function table for storing the function information, a function parameter table, and a function statement table, a data type table for storing the data type information, a macro definition table for storing the macro definition information, a class table for storing the class definition information, a function declaration table for storing the function declaration information, or a header table for storing the header information; the acquiring of the item information, the element information and the element relationship information of the object to be stored includes: performing semantic syntax analysis on the object to be stored to acquire the element information; carrying out project engineering analysis on the object to be stored to acquire the project information; the storing the object to be stored with the acquired fine-grained information includes: storing the element information to the variable table, the function parameter table, the function statement table, the data type table, the macro definition table, the class table, the function declaration table, and the header file table; and storing the project information to the project table.

Some embodiments of the present application obtain fine-grained elements in a code by parsing and perform tabular structure storage to implement incremental compilation by a compiler.

In some embodiments, the data tables further include a dependency table, a file table, and a file directory table; the acquiring of the project information, the element information and the element relationship information of the object to be stored includes: analyzing and splitting a code structure of a file organization of the object to be stored into code element units, expressing a reference relation of the elements in a file structure based on a relation of the code element units in a database, and storing the element reference relation into the dependency relation table, the file table and the file directory table; the dependency relationship table comprises a reference element type, a reference element number, an item number to which the reference element belongs, a referenced element type, an item number to which the referenced element belongs, a creation time of the reference element, a change time of the reference element and a validity identifier of the reference element.

Some embodiments of the present application further include reference information stored in the dependency relationship table, which facilitates a compiler to implement the compiling of the source code.

In some embodiments, the variable table variable comprises: the method comprises the following steps of (1) setting a variable number, a variable type, a variable name, a variable definition, a variable initial value, a variable category, a variable group, whether a constant is present or not, describing the variable, a variable belonging item number, a variable belonging file number, a variable belonging class number, variable validity, a locking local record identifier, a variable starting line in a file, a variable ending line in the file, a variable total line number, whether the variable is externally available, variable creating time, a variable creating person, variable modifying time and at least part of variable modifying persons; the data type table includes: the method comprises the following steps of data type number, data type name, unique value of data type MD5, data type definition, member type, data type description, data type creation time, data type modification time, item number to which the data type belongs, file number to which the data type belongs, class number to which the data type belongs, data type effective identification and locking local variable record identification, wherein the data type is at the beginning row in a file, and the data type is at least part of items in the ending row and the total row of the data type in the file; the function table includes: the method comprises the steps of function number, unique value of MD5 corresponding to a function, function definition, function name, function category, function prototype, function description, whether the function is available to the outside, function creation time, function modification time, item number of the function, file number of the function, class number of the function, constraint type of the function, whether the function is effective, locking at least partial items in function record identification, function position information and total line number, wherein the function position information is determined by a start line and an end line of the function in a file.

Some embodiments of the present application may implement at least structured storage of variable information by defining storage fields in a variable table.

In some embodiments, the macro definition table comprises: macro numbers, macro definitions, macro names, macro item numbers, macro file numbers, macro creation time, macro update time, macro validity, macro start row numbers, macro end row numbers, macro total row numbers, MD5 unique values corresponding to macros, and locking at least partial items in macro definition record identifications, wherein the macro start rows and the macro end rows are start rows and end rows of the macros in files to which the macros belong; the class table includes: the method comprises the steps of identifying a file in a file, wherein the file comprises a class number, a class name, an MD5 unique value corresponding to the class, a class definition, a file number to which the class belongs, an item number to which the class belongs, a class description, whether the class is valid, a starting position of the class in the file, an ending position of the class in the file, a class creation time, a class update time and at least part of a lock-in class record identifier.

Some embodiments of the present application may implement at least structured storage of macro and class related information by defining the macro definition table and the storage fields in the class table.

In some embodiments, the plurality of data tables further includes a code tree table and an item leaf table; wherein the code tree table comprises: at least part of items in the upper-level function identification number, the lower-level function identification number, whether the upper-level function identification number is a head node or not, whether the upper-level function identification number is a leaf node or not, the item identification number, the code tree node creation time and the code tree node update time; the item leaf function table includes: the leaf function number, the leaf function file number, the leaf function number, the leaf function name, the project leaf function record creation time and the project leaf function record updating time are at least part of items in the project leaf function validity identification.

Some embodiments of the present application may implement at least a structured storage of this type of information by defining storage fields in the code tree table and the item leaf table, so that the compiler user provides more convenient and accurate development assistance functions.

In some embodiments, the obtaining the item information, the element information, and the element relationship information of the object to be stored includes: acquiring project code package information, input/output interface information and source code organization relation information; the plurality of data tables further includes: and the system comprises a project package information table used for storing the project code package information, an application input and output table used for storing the input and output interface information, and a file object table and a file table used for storing the source code organization relation information.

Some embodiments of the present application implement analysis and sorting of key information of the entire project code information by defining project code package information, input/output interface information, and code file organization structure information, thereby assisting a user in performing code editing, project modification, code transplantation, and the like.

In some embodiments, the package information table comprises: the method comprises the following steps of determining at least partial items in an item identification number, an item package dependent dynamic library name, an item package dependent static library name, an item package dynamic library storage position, an item package static library storage position, item package information table creation time, item package information table updating time and an item package validity identification of an item package.

Some embodiments of the present application enable structured storage of package information by defining fields of a package information table.

In some embodiments, the application input output table comprises: the interface type identification number, the interface name, the output position, the resource number, the function number to which the interface belongs, the file number to which the interface belongs, the project number of the interface, the interface record creation time, the interface record update time and at least part of the interface validity. The fields of interface record creation time, interface record update time and interface validity are needed when the software version is updated.

Some embodiments of the present application enable structured storage of input output interface information by defining fields of an application input output table.

In some embodiments, the file directory table includes at least some of a file directory name, a previous directory number, a next directory number, an item number to which the file directory belongs, a file directory validity, a file directory record creation time, a file directory record update time, and a file directory md5 unique value; the file table includes: the method comprises the following steps of file name, directory number of a file to which the file belongs, item number of the file, directory number of the upper level of the file, file type, file validity characteristic, unique value of MD5 corresponding to the file, file path, file version, file table record creation time, update time and locking at least partial items in file record identification.

Some embodiments of the present application enable structured storage of file related information by defining file directory tables and fields of file tables. In a second aspect, some embodiments of the present application provide a source code storage processing apparatus, the code storage apparatus including an obtaining module configured to obtain item information, element information, and element relationship information of an object to be stored, the element including a variable, a function, and a data type, the element information including at least one of class definition information, macro definition information, function declaration information, and header information, the element relationship information including an element reference relationship and a source code organization relationship, the object to be stored including a source code file or one or more lines of programming commands; a storage module configured to store the fine-grained information with the fine-grained information.

In a third aspect, some embodiments of the present application provide a source code analysis and extraction method, including: obtaining elements and element relations in the codes by analyzing the source code file; analyzing a function call relation and refining a project leaf function based on the elements in the code and the element relation; analyzing a function call path based on the element in the code and the element relation, and drawing a code call tree of the project; and analyzing and tracking a parameter transmission path by combining the function call path and the assignment of the parameters in the function body based on the elements in the code and the element relation.

In a fourth aspect, some embodiments of the present application provide a source code analyzing and extracting apparatus, including: the analysis module is configured to analyze a source code packet to be analyzed, convert a code organization relation corresponding to the source code packet expressed in a file form into a source code organization relation expressed by code elements and element relations; the refining module is configured to analyze a function call relation and refine a project leaf function based on the elements in the code and the element relation; the drawing module is configured to analyze a function call path and draw a code call tree of a project based on the elements in the code and the element relation; and the tracking module is configured to analyze a tracking parameter transmission path based on the elements in the code and the element relation and by combining the function call path and the assignment of the parameters in the function body.

In summary, the source code analyzing and extracting apparatus in some embodiments of the present application analyzes the project codes stored in the file format, and stores all the code elements and the code element relationships represented by the file in the database in the form of the database table. The traditional code storage mode and management mode are broken. Therefore, the concurrent completion of multiple users is supported in the development of the whole project code, and the management mode of the source code is realized on the basis of the data table. Some embodiments of the present application use powerful concurrent processing of databases to enable a user to write code elements for the same file, the same function, etc. Specifically, some embodiments of the present application record modifications of a user to a basic code element, and complete fine-grained version management of a project. The analysis work of the code from the file to the code elements is completed, all the code elements are stored in the form of a relational database table, and the analysis and utilization of the functions are supported more conveniently and rapidly under the support of a mass code data table, so that a better code analysis auxiliary function, a stronger and faster code retrieval function and a more efficient and higher-quality reusable code base can be provided for a user.

Drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the drawings that are required to be used 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 therefore should not be considered as limiting the scope, and that those skilled in the art can also obtain other related drawings based on the drawings without inventive efforts.

Fig. 1 is a schematic composition diagram of a software rapid development system for a software-defined satellite according to an embodiment of the present application;

fig. 2 is a flowchart of a method for constructing a reusable code base for a software-defined satellite according to an embodiment of the present disclosure;

FIG. 3 is a flowchart of a source code file processing and storing method according to an embodiment of the present disclosure;

fig. 4 is a block diagram illustrating a reusable code library constructing apparatus for a software-defined satellite according to an embodiment of the present disclosure;

fig. 5 is a second flowchart of a method for constructing a reusable code base for a software-defined satellite according to an embodiment of the present application;

fig. 6 is a block diagram of an apparatus corresponding to the method in fig. 5 according to an embodiment of the present disclosure.

Detailed Description

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

It should be noted that: like reference numbers and letters refer to like items in the following figures, and thus, once an item is defined in one figure, it need not be further defined and explained in subsequent figures. Meanwhile, in the description of the present application, the terms "first", "second", and the like are used only for distinguishing the description, and are not to be construed as indicating or implying relative importance.

The code base construction method for the software defined satellite supports multi-user concurrent completion in the development of the whole project code, and the management mode of the source code is realized based on a data table. Some embodiments of the present application use powerful concurrent processing of databases to enable a user to write code elements for the same file, the same function, etc. Some embodiments of the application record modification of a user for a basic code element, complete fine-grained version management of a project, complete analysis work of a code from a file to the code element, store all code elements in a relational database table form, and support analysis and utilization of functions more conveniently and quickly based on the database table, so that a better code analysis auxiliary function can be provided for the user, a stronger and faster code retrieval function can be realized, and a reusable code base with higher efficiency and higher quality can be provided.

That is, some embodiments of the present application provide a more advanced source code organization and storage apparatus (i.e., an apparatus obtained according to the software-defined satellite-oriented code library building method provided in some embodiments of the present application), and on the basis of this storage structure, at least an integrated development cloud capable of supporting massively parallel compilation and supporting ex-situ collaboration and interactive programming is provided.

Referring to fig. 1, fig. 1 is a software rapid development system for a software defined satellite, which includes a ten-layer structure, and the functions of each layer and the information processing process between adjacent layers are described one by one. It should be noted that, the eighth layer in fig. 1 is an apparatus obtained by using the method for constructing a reusable code base for a software-defined satellite according to some embodiments of the present application.

The first layer includes an interactive terminal 101 for receiving command information input by a developer. It should be noted that the user can issue the command message to the interactive terminal 101 by means of voice, text, and other various manners. As an example, the interactive terminal 101 is a mobile terminal, and specifically, the developer may issue a command message to the compiler through a WeChat client on the mobile terminal by text.

As an example, each of the micro-credited users is a legitimate user, i.e., a potential developer, of the integrated development cloud (i.e., the interactive programming system of the embodiments of the present application). When a micro credit user pays attention to a micro credit public account corresponding to the integrated development cloud, the system creates a private library for the micro credit user and names the micro credit user by using the micro signal of the private library. The system will record every command that the developer sends to the integrated development cloud, and every response that the integrated development cloud gave. For example, the types of command messages that a developer may use include: the CD and the DC are used for switching working scenes; new, del, list is used to create, delete, and retrieve objects, wherein the objects include: data type, variables, functions, classes, macro definitions, etc.; set is used for setting or modifying the attribute value of the object; help is used for obtaining system Help; debug, test, analyze, build, distribute are used to Debug, test, analyze, build, and publish source code.

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

For each command sent by the developer to the interactive programming system, the compiler 701 checks the validity of the command, executes the command, and feeds back the execution result (i.e., response message) of the command to the user. The software development work is actually real-time interaction with the compiler 701 through a long string of commands, and finally the development work of the application program is completed. The interactive programming system of the embodiment of the application supports large-scale allopatric collaboration and parallel development.

It should be noted that, in a project of software rapid development system development for software defined satellites provided based on the embodiments of the present application, developers have three roles: administrator, senior programmer, junior programmer. Administrators, who have the right to create, delete, query, and modify all objects (i.e., data types, variables, functions, classes, macro definitions, headers, etc.) in a project, may authorize or invite a developer to become a high-level programmer and a low-level programmer for the project, and may give the administrator the identity of the administrator to a high-level programmer in a project development team. The senior programmers have the right to create, delete, query and modify objects created by themselves as well as objects created by junior programmers. The junior programmer can only create, delete, query and modify objects created by itself.

The second layer includes an authentication and message forwarding device 201, and the authentication and message forwarding device 201 is used for providing functions of registration, identity authentication, payment, channel encryption, message forwarding, broadcasting, and the like.

The third layer includes a message parsing device 301, on one hand, the message parsing device 301 is configured to aggregate and parse the command message input by the user and submitted by the developer through the interactive terminal 101 and the authentication and message forwarding device 201, and write the parsed command message into the fourth layer parsing message and response message recording device 401. It should be noted that the message parsing apparatus 301 is further configured to read the response message from the parsed message and response message recording apparatus 401, and distribute the response message to the interactive terminal 101 via the authentication and message forwarding apparatus 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 be a relational database, a real-time database, a NoSQL database, or the like. The fourth layer of the parsing message and response message recording device 401 may be used for the message parsing device 301 to write the parsed command message, or may be used for reading the response message of the compiler 701 from the fifth layer of the command normalization and task scheduling device 501.

The fifth layer comprises a command normalization and task scheduling means 501, the command normalization and task scheduling means 501 is used for normalizing and task scheduling the command message read from the parsing message and response message recording means 401.

The sixth layer comprises command recording means 601. That is, the command recording apparatus 601 as an example includes: an item management command recording device, a function management command recording device, a variable management command recording device, a data type management command recording device, and a link command recording device, which may be a relational database, a real-time database, a NoSQL database, or the like. On the one hand, the command recording device 601 is used for the command normalization and task scheduling device 501 to write the command message and read the response message. On the other hand, the command recorder 601 reads the command message and writes the response message separately from the compiler 701 of fig. 1.

The seventh layer includes a compiler 701. That is, the compiler 701 of fig. 1 as an example includes: 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 respectively correspond to the respective kinds of command recording means of the sixth layer, and are linked with the source code data recording means 801 of the layer 8.

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

The eighth layer includes a source code data recording device 801 (corresponding to the code library device oriented to the software defined satellite according to the embodiment of the present application), which is a data recording device (which may be a relational database, a real-time database, a NoSQL database, etc.) for storing the source code of the project library or the private library, and providing the creating, deleting, querying and modifying services for the compiling unit of the seventh layer.

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

The tenth layer includes a reusable code recording device 1001, which is a data recording device (which may be a relational database, a real-time database, a NoSQL database, or the like), in which reusable code resources and data resources are stored, and is retrieved and accessed as needed by a code retrieving device 901 of the ninth layer.

It should be noted that the source code of an item in the embodiment of the present application is equal to a plurality of data type definitions, a plurality of variable definitions, a plurality of function definitions, a plurality of macro definitions, a plurality of class definitions, and a plurality of header definition sets, where the data type, the variable, the function, the macro definition, the class, and the header are objects having different attributes respectively. When the source code data recording apparatus 801 employs a structured database, the source code in an item is represented in the database as a set of data tables. For example, the data types may be stored in a manner that includes: a data type table (e.g., the table may further include a data type number, name, definition, category, group, creation time, creator, last modification time, 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 value, a member serial 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 storage mode of the variable comprises a variable table (for example, the table can comprise a variable number, a variable type, a variable name, a variable initial value, a variable category, a variable group, whether constant is constant or not, a variable remark, creation time, a creator, modification time and a modifier) and a variable white list table (for example, the table can comprise the variable number, the function number, whether reading is allowed or not and whether writing is allowed or not); the storage mode of the function comprises the following steps: the function table (for example, 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 (for example, the table may include a function number, a parameter sequence number, a parameter type, a parameter name, a parameter default value, a parameter remark), a function statement table (for example, the table may include a function number, a statement sequence number, a statement label, statement content, a statement remark, a statement type), or a function whitelist table (for example, the table may include a function number, a flag of whether to allow calling), wherein the function whitelist table is used for characterizing a visible field of the function and whether to call. It should be noted that the creation time and the update time in each database table refer to the creation time and the update time of that record of the table.

How to implement fine-grained storage of code (i.e., how to implement source code for an item is equal to tabular storage of data type definitions, variable definitions, and function definitions) is illustratively set forth below in connection with the associated figures.

As shown in fig. 2, some embodiments of the present application provide a code library construction method for a software-defined satellite, performed by a code library construction apparatus for a software-defined satellite, the code library construction method for a software-defined satellite including: s101, acquiring project information, element information and element relation information of an object to be stored, wherein the element information comprises at least one of variable information, function information, data type information, class definition information, macro definition information, function statement information and header information, the element relation information comprises an element reference relation and a source code organization relation, and the object to be stored comprises a source code file or one-line or multi-line programming commands; s102, storing the object to be stored with the acquired fine-grained information, wherein the fine-grained information includes the item information, the element information and the element relation information. The fine-grained information is stored, for example, by one of a relational database, a real-time database, and a NoSQL database.

It should be noted that specific meanings of the variable information, the function information, the class information, the macro definition information, the function declaration information, the data type information, and the data type information may be determined with reference to information stored in a related table such as a variable table, a function table, or a macro definition table, hereinafter. For example, the following variable tables include: the variable information includes information such as variable number, variable type, variable name, initial value of variable, variable category, variable group, whether constant is set, variable remark, and the like.

In some embodiments of the present application, the fine-grained information is stored by one of a relational database, a real-time database, and a NoSQL database. The fine-grained information is stored, for example, by multi-class data tables in a relational database.

To implement element-level storage of code, in some embodiments of the present application, the relational database includes a plurality of data tables to store the fine-grained information, the data tables including: a variable table for storing the variable information, a function table for storing the function information, a function parameter table and a function statement table, a data type table for storing the data type information, a macro definition table for storing the macro definition information, a class table for storing the class definition information, a function declaration table for storing the function declaration information, or a header table for storing the header information; s101 includes: performing semantic syntax analysis on the object to be stored to acquire the element information, and performing project engineering analysis on the object to be stored to acquire the project information; s102 comprises the following steps: storing the element information to the variable table, the function parameter table, the function statement table, the data type table, the macro definition table, the class table, the function declaration table, and the header file table; and storing the project information to the project table.

In order to implement the structured storage of the dependency relationships, in some embodiments of the present application, the data tables further include a dependency relationship table, a file table, and a file directory table; s101 comprises the following steps: resolving a code structure of a file organization of the object to be stored into code element units, expressing a reference relation of the elements in a file structure based on a relation of the code element units in a database, and storing the element reference relation into the dependency relation table S102; the dependency relationship table comprises at least partial items of a reference element type, a reference element number, the item number of a reference element, a referenced element type, an item number to which a referenced element belongs, a creation time of a reference element, a change time of the reference element and a reference validity identifier.

In some embodiments of the present application, the data table further comprises a function declaration table and a header file table, the variable table comprising: the method comprises the following steps of variable number, variable type, variable name, variable definition, initial value of variable, variable category, variable group, whether constant is present or not, variable description, item number to which the variable belongs, file number to which the variable belongs, type number to which the variable belongs, variable validity, variable record mark locking, starting line of the variable in a file, ending line of the variable in the file, total line of the variable, whether the variable is available to the outside, variable creation time, variable creation person, variable modification time and at least part of items of the variable modifier; the data type table includes: the method comprises the following steps of firstly, obtaining a data type number, a data type name, a unique value of a data type MD5, a data type definition, a member type, a data type description, a data type creating time, a data type modifying time, a data type affiliated item number, a data type affiliated file number, a data type affiliated class number, a data type effective identifier, a data type record identifier of a locking piece, a starting line of the data type in a file, and at least part of a finishing line of the data type in the file and a total line of the data type; the function table includes: the method comprises the steps of function number, unique value of MD5 corresponding to a function, function definition, function name, function category, function prototype, function description, whether the function is available to the outside, function creation time, function modification time, item number of the function, file number of the function, class number of the function, constraint type of the function, whether the function is effective, locking at least partial items in function record identification, function position information and total line number, wherein the function position information is determined by a start line and an end line of the function in a file. The function declaration table includes: the function declaration comprises a function declaration number, a function declaration head file number, a function name and a function declaration definition body, wherein the function declaration comprises a starting line number in a file, a function declaration comprises an ending line number in the file, a function declaration comprises an item number, a function declaration record creation time and at least partial items of a function declaration record modification time, the function declaration starting line and the function declaration ending line are the starting line and the ending line of the function declaration in the file to which the function declaration belongs; the header file table includes: the number of the header file, the number of the header file in the file table, the content of the header file, the record creation time of the header file and the record modification time of the header file.

In some embodiments of the present application, the macro definition table comprises: macro number, macro definition body, macro name, macro item number, macro file number, macro creation time, macro update time, macro validity, macro start line number, macro end line number, macro total line number, MD5 unique value corresponding to macro and at least part of items in the macro definition record identification are locked, wherein the macro start line and the macro end line are the start line and the end line of the macro in the file to which the macro belongs; the class table includes: the method comprises the following steps of identifying a file in a file, wherein the file comprises a class number, a class name, an MD5 unique value corresponding to the class, a class definition, a file number to which the class belongs, an item number to which the class belongs, a class description, whether the class is valid, a starting position and an ending position of the class in the file, class creation time, class update time and at least part of a lock-in class record identifier.

In some embodiments of the present application, the plurality of data tables further includes a code tree table and an item leaf table; wherein the code tree table comprises: at least part of items in the upper-level function identification number, the lower-level function identification number, whether the upper-level function identification number is a head node or not, whether the upper-level function identification number is a leaf node or not, the item identification number, the code tree node creation time and the code tree node update time; the item leaf function table includes: the leaf function number, the leaf function file number, the leaf function number, the leaf function name, the project leaf function record creation time, the project leaf function record update time and at least part of the project leaf function validity identification.

In some embodiments of the present application, the obtaining item information, element information, and element relationship information of the object to be stored includes: acquiring project code package information, input/output interface information and source code organization relation information; the plurality of data tables further includes: and the system comprises a project package information table used for storing the project code package information, an application input and output table used for storing the input and output interface information, and a file object table and a file table used for storing the source code organization relation information.

In some embodiments of the present application, the package information table includes: the method comprises the following steps of determining at least partial items in an item identification number, an item package dependent dynamic library name, an item package dependent static library name, an item package dynamic library storage position, an item package static library storage position, item package information table creation time, item package information table updating time and an item package validity identification of an item package.

In some embodiments of the present application, the application input output table includes: the interface type identification number, the interface name, the output position, the resource number, the function number to which the interface belongs, the file number to which the interface belongs, the project number of the interface, the interface record creation time, the interface record update time and at least part of the interface validity. The fields of interface record creation time, interface record update time and interface validity are needed when the software version is updated.

In some embodiments of the present application, the file directory table includes at least some of a file directory name, a previous directory number, a next directory number, an item number to which the file directory belongs, a file directory validity, a file directory record creation time, a file directory record update time, and a file directory md5 unique value; the file table includes: the method comprises the following steps of file name, directory number of the file to which the file belongs, item number of the file, directory number of the upper level of the file, file type, file validity characteristic, unique value of MD5 corresponding to the file, file path, file version, file table record creation time, update time and locking at least partial items in the file record identification.

The following describes an exemplary code storage processing method of the present application with reference to fig. 3 by taking an object to be stored as a source code file as an example.

As shown in fig. 3, when the object requiring fine-grained storage is a source code file, the following steps need to be performed when storing the file codes to the eighth layer:

s201, reading all source codes.

S202, analyzing the whole package organization file, and writing the analysis result into the project package information table.

For example, the entire package organization file includes: the profile file, makefile, file dependent on the third party library, etc. may write the analysis result into the package information table.

As an example, the elements in the package information table are shown in table 1 below.

Table 1 item packet information table

And S203, analyzing the output and input interfaces in the whole project code, and storing the analysis result in an application input and output table.

The input output table is applied as an example as table 2.

Table 2 application input output table

S204, analyzing the file directory organization structure of the whole code packet, and storing the analysis result into a database table related to the file directory tree.

As an example of the present application, a database table related to a file directory tree may include: file directory table, file table. For example, the storage elements in the file object table are shown in table 3 below.

Table 3 file object table

As an example of the present application, the storage elements in the file table are shown in table 4.

TABLE 4

S205, analyzing a source code file, carrying out syntactic and semantic analysis on the source code, analyzing and splitting to extract basic code elements in the file, analyzing and splitting a code structure organized by the file into basic code element units, organizing the relationship among the code elements in a relational database form, and writing the organization relationship of the basic code elements, the elements in the file, the calling dependency relationship among the elements and the reference relationship into a related database table.

As one example, the basic code elements, the organizational relationships of the elements in a file, the call dependencies between elements, reference relationships may be written to a variable table, a data type table, a macro definition table, a function table, a class table, a function declaration table, a header file table, a dependency relationship table, a code tree table, an item leaf function table.

As an example of the present application, the variable table is shown in table 5.

TABLE 5 VARIABLE-METER

As an example of the present application, the data type table is shown in table 6.

Table 6 data type table

As an example of the present application, the macro definition table is shown in table 7.

TABLE 7 macro definition table

As an example, the function table is shown in table 8.

Table 8 function table

As an example of the present application, the class table is shown in table 9.

TABLE 9 type Table

As an example of the present application, the dependency table is shown in table 10.

Table 10 dependency table

As an example of the present application, the item leaf function table is shown in table 11.

Table 11 item leaf function table

As an example of the present application, the code tree table is shown in table 12.

TABLE 12 code Tree Table

Referring to fig. 4, fig. 4 shows a code storage processing apparatus provided in an embodiment of the present application, and it should be understood that the code storage processing corresponds to the method embodiment of fig. 2 or fig. 3, and can perform various steps related to the method embodiment, and specific functions of the code storage processing may be referred to the description above, and a detailed description is appropriately omitted here to avoid repetition. The code storage processing device comprises at least one software functional module which can be stored in a memory in the form of software or firmware or solidified in an operating system of the code storage processing device, and comprises: an obtaining module 410 configured to obtain item information, element information, and element relationship information of an object to be stored, where the element information includes at least one of variable information, function information, macro definition information, data type information, class definition information, function declaration information, and header information, the element relationship information includes an element reference relationship and a source code organization relationship, and the object to be stored includes a source code file or one or more lines of programming commands; a storage module 420 configured to store the fine-grained information with the fine-grained information.

It can be clearly understood by those skilled in the art that, for convenience and simplicity of description, the specific working process of the code storage and processing device described above may refer to the corresponding process in the method of fig. 2 or fig. 3, and redundant description is not repeated here.

Some embodiments of the present application provide a source code analysis and extraction method, including: s501, obtaining elements and element relations in the codes by analyzing the source code file; s502, analyzing a function call relation based on the elements in the code and the element relation, and refining a project leaf function; s503, analyzing a function call path based on the element in the code and the element relation, and drawing a code call tree of the project; s504, analyzing and tracking a parameter transmission path based on the element in the code and the element relation and combining the function call path and the assignment of the parameter in the function body.

As shown in fig. 6, some embodiments of the present application provide a reusable code library constructing apparatus for a software-defined satellite, including: the analysis module is configured to analyze a source code packet to be analyzed, convert a code organization relation corresponding to the source code packet expressed in a file form into a source code organization relation expressed by code elements and the code relation; the refining module is configured to analyze a function call relation and refine a project leaf function based on the elements in the code and the element relation; the drawing module is configured to analyze a function call path and draw a code call tree of a project based on the elements in the code and the element relation; and the tracking module is configured to analyze a tracking parameter transmission path based on the elements in the code and the element relation and in combination with the function call path and the assignment of the parameters in the function body.

For details of the specific implementation of the reusable code library constructing device for the software defined satellite provided in fig. 6, reference may be made to the foregoing description, and in order to avoid repetition, redundant description is not repeated here.

In the embodiments provided in the present application, it should be understood that the disclosed apparatus and method can be implemented in other ways. The apparatus embodiments described above are merely illustrative, and for example, the flowchart and block diagrams in the figures 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 an independent part, or each module may exist separately, or two or more modules may be integrated to form an independent 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 such understanding, the technical solution of the present application or portions thereof that substantially contribute to the prior art may be embodied in the form of a software product stored in a storage medium and including instructions for causing a computer device (which may be a personal computer, a server, or a network device) to execute 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), a magnetic disk, or an optical disk, and 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 changes may be made by those skilled in the art. Any modification, equivalent replacement, improvement and the like made within the spirit and principle of the present application shall be included in the protection scope of the present application. It should be noted that: like reference numbers and letters refer to like items in the following figures, and thus, once an item is defined in one figure, it need not be further defined or explained in subsequent figures.

The above description is only for the specific embodiments of the present application, but the scope of the present application is not limited thereto, and any person skilled in the art can easily conceive of the changes or substitutions within the technical scope of the present application, and shall be covered by 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, herein, relational terms such as first and second, and the like may be 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. Also, 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 an … …" does not exclude the presence of other identical elements in a process, method, article, or apparatus that comprises the element.

Claims (11)

1. A reusable code base construction method for a software-defined satellite is characterized by comprising the following steps:

acquiring project information, element information and element relation information of an object to be stored, wherein the element comprises a variable, a function and a data type, the element information comprises at least one of variable information, function information, data type information, class definition information, macro definition information, function statement information and header file information, the element relation information comprises an element reference relation and a source code organization relation, and the object to be stored comprises a source code file or one or more lines of programming commands;

storing the object to be stored with the acquired fine-grained information, wherein the fine-grained information includes the project information, the element information and the element relationship information;

storing the fine-grained information by a plurality of types of data tables in a relational database, wherein the data tables comprise: the project table is used for storing the project information, the variable table is used for storing the variable information, the function table, the function parameter table and the function statement table are used for storing the function information, the data type table is used for storing the data type information, the class table is used for storing the class definition information, the macro definition table is used for storing the macro definition information, the function declaration table is used for storing the function declaration information, or the header file table is used for storing the header file information;

the acquiring of the item information, the element information and the element relationship information of the object to be stored includes:

performing semantic syntax analysis on the object to be stored to acquire the element information;

carrying out project engineering analysis on the object to be stored to acquire the project information;

the storing the object to be stored with the acquired fine-grained information includes:

storing the element information to the variable table, the function parameter table, the function statement table, the class table, the macro definition table, the function declaration table, the header table, and the data type table;

and storing the project information to the project table.

2. The method of claim 1, wherein the fine-grained information is stored in one of a relational database, a real-time database, and a NoSQL database.

3. The method for constructing the reusable code base oriented to the software-defined satellite according to claim 1, wherein the data tables further comprise a dependency relationship table, a file table and a file directory table;

the acquiring of the item information, the element information and the element relationship information of the object to be stored includes:

analyzing and splitting a code structure of a file organization of the object to be stored into code element units, and expressing the reference relation of the elements in the file structure based on the relation of the code element units in a database;

the storing the object to be stored with the acquired fine-grained information includes: storing the element reference relationship to the dependency relationship table, the file table and the file directory table;

the dependency relationship table comprises at least partial items of a reference element type, a reference element number, an item number to which the reference element belongs, a referenced element type, a referenced element number, an item number to which the referenced element belongs, a reference element creation time, a reference element modification time and a reference validity identification.

4. The method for constructing the reusable code base oriented to the software-defined satellite according to claim 1, wherein the data table further comprises a function declaration table and a header file table;

the variable table comprises: the method comprises the following steps of variable number, variable type, variable name, variable definition, initial value of variable, variable category, variable group, whether constant is present or not, variable description, item number to which the variable belongs, file number to which the variable belongs, type number to which the variable belongs, variable validity, variable record mark locking, starting line of the variable in a file, ending line of the variable in the file, total line of the variable, whether the variable is available to the outside, variable creation time, variable creation person, variable modification time and at least part of items of the variable modifier;

the data type table includes: the data type record locking method comprises the following steps of data type number, data type name, unique value of data type MD5, data type definition, member type, data type description, data type creating time, data type modifying time, data type item number, data type file number, data type class number, data type effective identifier, data type record identifier of a locking strip, a starting row of the data type in a file, and at least part of items of the data type in an ending row and a total row of the data type in the file;

the function table includes: the method comprises the following steps of function number, unique MD5 value corresponding to a function, function definition, function name, function category, function prototype, function description, function availability, function creation time, function modification time, function item number, function file number, function class number, function constraint type, function availability, locking at least partial items in function record identification, function position information and total line number, wherein the function position information is determined by a starting line and an ending line of the function in a file;

the function declaration table includes: the method comprises the following steps of a function statement number, a function number, a head file number to which the function statement belongs, a function name, a function statement definition body, a start line number of the function statement in a file, an end line number of the function statement in the file, an item number to which the function statement belongs, at least partial items in function statement record creation time and function statement record modification time, wherein the function statement start line and the function statement end line are at least part of start lines and end lines of the function statement in the file to which the function statement belongs;

the header file table includes: the number of the header file, the number of the header file in the file table, the content of the header file, the record creation time of the header file and the record modification time of the header file.

5. The software-defined satellite-oriented reusable code library building method of claim 1, wherein the macro definition table comprises: macro number, macro definition body, macro name, macro item number, macro file number, macro creation time, macro update time, macro validity, macro start line number, macro end line number, macro total line number, MD5 unique value corresponding to macro and at least part of items in the macro definition record identification are locked, wherein the macro start line and the macro end line are the start line and the end line of the macro in the file to which the macro belongs;

the class table includes: the method comprises the following steps of class number, class name, MD5 unique value corresponding to the class, class definition, file number to which the class belongs, item number to which the class belongs, class description, whether the class is valid, the starting position and the ending position of the class in a file, class creation time, class update time and at least part of locking item record identification.

6. The method for constructing the reusable code base oriented to the software-defined satellite according to claim 1, wherein the multiple types of data tables further comprise a code tree table and a project leaf function table; wherein the content of the first and second substances,

the code tree table includes: at least part of items in the upper-level function identification number, the lower-level function identification number, whether the upper-level function identification number is a head node or not, whether the upper-level function identification number is a leaf node or not, the item identification number, the code tree node creation time and the code tree node update time;

the item leaf function table includes: the leaf function number, the leaf function file number, the leaf function number, the leaf function name, the project leaf function record creation time, the project leaf function record update time and at least part of the project leaf function validity identification.

7. The method for constructing the reusable code library oriented to the software defined satellite according to claim 1, wherein the object to be stored is a source code file, and the acquiring of the item information, the element information, and the element relationship information of the object to be stored includes: acquiring project code package information, input/output interface information and the source code organization relation information;

the multi-class data table further includes: the system comprises an item code package information table used for storing the item code package information, an application input and output table used for storing the input and output interface information, and a file directory table and a file table used for storing the source code organization relation information.

8. The method for constructing the reusable code base oriented to the software defined satellite according to claim 7, wherein the item package information table comprises: the method comprises the following steps of selecting at least partial items from item identification numbers of items to which item packages belong, item package dependent dynamic library names, item package dependent static library names, item package dynamic library storage positions, item package static library storage positions, item package information table creation time, item package information table updating time and item package validity identifications.

9. The method for constructing the reusable code base oriented to the software-defined satellite according to claim 7, wherein the application input output table comprises: the interface record comprises at least part of interface type identification number, interface name, output position, resource number, function number to which the interface belongs, file number to which the interface belongs, project number to which the interface belongs, interface record creation time, interface record update time and interface validity.

10. The method of claim 7, wherein the code library for software-defined satellite is constructed from a code library database,

the file directory table comprises at least partial items in a file directory name, a previous-level directory number, a next-level directory number, a file directory affiliated item number, file directory validity, file directory record creation time, file directory record updating time and a file directory md5 unique value;

the file table includes: the method comprises the following steps of file name, directory number of the file to which the file belongs, item number of the file, directory number of the upper level of the file, file type, file validity characteristic, unique value of MD5 corresponding to the file, file path, file version, file table record creation time, update time and locking at least partial items in the file record identification.

11. A reusable code library construction device for a software-defined satellite is characterized by comprising:

the system comprises an acquisition module, a storage module and a processing module, wherein the acquisition module is configured to acquire item information, element information and element relation information of an object to be stored, the element comprises a variable, a function and a data type, the element information comprises at least one of variable information, function information, data type information, class definition information, macro definition information, function statement information and header information, the element relation information comprises an element reference relation and a source code organization relation, and the object to be stored comprises a source code file or one or more lines of programming commands;

a storage module configured to store the object to be stored with the acquired fine-grained information, wherein the fine-grained information includes element information and element relationship information,

the storage module is configured to: storing the fine-grained information by a plurality of types of data tables in a relational database, wherein the data tables comprise: the project table is used for storing the project information, the variable table is used for storing the variable information, the function table, the function parameter table and the function statement table are used for storing the function information, the data type table is used for storing the data type information, the class table is used for storing the class definition information, the macro definition table is used for storing the macro definition information, the function declaration table is used for storing the function declaration information, or the header file table is used for storing the header file information;

the acquiring of the item information, the element information and the element relationship information of the object to be stored includes:

performing semantic syntax analysis on the object to be stored to acquire the element information;

performing project engineering analysis on the object to be stored to acquire the project information;

the storing the object to be stored with the acquired fine-grained information includes:

storing the element information to the variable table, the function parameter table, the function statement table, the class table, the macro definition table, the function declaration table, the header table, and the data type table;

and storing the project information to the project table.

Images