CN115509532A - Method for automatically generating C language structure body to protobuf file and interconversion code - Google Patents

Abstract

The invention relates to a method for converting a C language structure to a protobuf file and an automatic code generation method for mutual conversion, belonging to the field of automatic driving. First, scan the folder storing the C language source code to read all relevant text content; secondly, based on the read text content , combined with the grammatical structure defined by the C language, the keyword information of the interface structure is extracted from the text; then the proto file is generated according to the corresponding relationship between the protobuf grammar and the C language grammar, and the conversion code and proto from the structure to proto are generated respectively Conversion code to structure. The present invention can automatically realize the conversion between the two interface structures in batches, eliminate interface errors caused by manual links, and greatly improve the integration efficiency of automatic driving software development.

Description

C language structure to protobuf file and mutual conversion code automatic generation method

technical field

The invention belongs to the field of automatic driving, and relates to a method for automatically generating a C language structure into a protobuf file and mutual conversion codes.

Background technique

In the field of autonomous driving, traditional control-related software is written in C language or regenerated into C language code using a model-based development method. With the development of autonomous driving and intelligent networked vehicles, the concepts of software-defined vehicles and software-as-a-service have received more and more attention. In this context, protobuf is increasingly being used in the field of autonomous driving to solve the interface communication between many distributed modules of autonomous driving. protobuf (protocol buffer) is Google's internal mixed-language data standard. By serializing structured data (serialization), it is a language-independent, platform-independent, and extensible serialized structured data format for communication protocols, data storage, and other fields.

In order to be compatible with the existing code or the C language code automatically generated based on the model, it is often necessary to define the corresponding proto file based on the existing C language structure, and use an additional software adaptation layer to convert the software interface structure generated by protobuf Convert to a C language structure or convert a C language structure to a software interface generated by protobuf. This conversion process needs to be carried out manually. When the number of data interfaces is large, the work is cumbersome, time-consuming and very prone to software errors.

Chinese patent CN200810173686.9 discloses a method for converting XML messages and C language program structures, and CN201811104489.1 discloses a method and device for converting data formats. The conversion problem and conversion between protobuf data format and json data format. It cannot be used to automatically generate the conversion code between the c language structure and the protobuf generated structure.

Contents of the invention

In view of this, the object of the present invention is to provide a method for automatically generating the corresponding proto file of the c language structure and the mutual conversion code between the protobuf generated structure.

To achieve the above object, the present invention provides the following technical solutions:

A method for automatically generating C language structures into protobuf files and mutual conversion codes. First, scan the folder where the C language source code is stored to read all relevant text content; secondly, based on the read text content, combined with the grammar defined by the C language Structure, extract the keyword information of the interface structure from the text; then generate the proto file according to the corresponding relationship between protobuf grammar and C language grammar, and generate the conversion code from the structure to proto and the conversion code from proto to the structure respectively.

Further, it specifically includes the following steps:

S1: Establish a comparison table of basic variable types between C language structure and protobuf language;

S2: Scan the folder where the C language source code is saved, obtain the text content of all files in the folder and store it in the variable content;

S3: delete the comment code in content;

S4: Based on the syntax, obtain the relevant definitions of all structures in the content and extract keyword information;

S5: traverse each matched field, extract the structure name, the variable type of each variable, and the variable name;

S6: Convert the extracted keyword information into proto text information based on the comparison table in step S1 and save it in a new text;

S7: Create a file to save the conversion code from the c structure to the proto structure and the conversion code from the proto structure to the c language structure;

S8: traverse all the extracted structure interface information;

S9: Generate a declaration of the structure mutual conversion function based on the structure name;

S10: traverse all variables of the structure;

S11: Write the text content in the variable content to the file, and return to step S8 to continue traversing.

Further, in step S5, if the variable name is followed by a pair of square brackets, the variable is an array, marked as repeated_num equal to the value in the square brackets, if there is no square brackets, marked as repeated_num=0.

Further, step S9 specifically includes: defining the name of the C language structure as name, and the name of the proto structure as proto_<name>, adding proto underscores before the variable name for distinction; respectively generating `<name>to_<name>(const proto_ <name>&temp)` and `proto_<name>to_proto_<name>(const<name>&temp)` convert the function declaration statement and save it to the variable content.

Further, in step S10, traverse all the variables of the structure, if the variable type val_type can be found in the basic type table, it indicates that the variable is a basic type, and it is enough to assign a value with the proto type through an equal sign; then judge whether the variable repeated_num is 0, if not, create a loop based on the array size repeated_num, and generate the basic type assignment conversion code; if so, generate the basic type assignment statement.

Further, in step S10, traverse all the variables of the structure, if the variable type val_type is not found in the basic type table, it indicates that the variable is a self-defined type, which is converted by the conversion function; then judge whether the variable repeated_num is 0, if No, create a loop based on the size of the array to generate a custom structure conversion code; if so, generate a structure conversion code and add it to the variable content.

The beneficial effect of the present invention is that: the present invention can automatically realize the conversion between two interface structures in batches, eliminate interface errors caused by manual links, and greatly improve the integration efficiency of automatic driving software development.

Other advantages, objects and features of the present invention will be set forth in the following description to some extent, and to some extent, will be obvious to those skilled in the art based on the investigation and research below, or can be obtained from It is taught in the practice of the present invention. The objects and other advantages of the invention may be realized and attained by the following specification.

Description of drawings

In order to make the purpose of the present invention, technical solutions and advantages clearer, the present invention will be described in detail below in conjunction with the accompanying drawings, wherein:

Figure 1 is a schematic diagram of keyword extraction;

Figure 2 is a schematic diagram of converting keywords to proto;

Fig. 3 is an overall flow chart of the automatic generation method of C language structure to protobuf file and mutual conversion code.

detailed description

Embodiments of the present invention are described below through specific examples, and those skilled in the art can easily understand other advantages and effects of the present invention from the content disclosed in this specification. The present invention can also be implemented or applied through other different specific implementation modes, and various modifications or changes can be made to the details in this specification based on different viewpoints and applications without departing from the spirit of the present invention. It should be noted that the diagrams provided in the following embodiments are only schematically illustrating the basic concept of the present invention, and the following embodiments and the features in the embodiments can be combined with each other in the case of no conflict.

Wherein, the accompanying drawings are for illustrative purposes only, and represent only schematic diagrams, rather than physical drawings, and should not be construed as limiting the present invention; in order to better illustrate the embodiments of the present invention, some parts of the accompanying drawings may be omitted, Enlargement or reduction does not represent the size of the actual product; for those skilled in the art, it is understandable that certain known structures and their descriptions in the drawings may be omitted.

In the drawings of the embodiments of the present invention, the same or similar symbols correspond to the same or similar components; , "front", "rear" and other indicated orientations or positional relationships are based on the orientations or positional relationships shown in the drawings, which are only for the convenience of describing the present invention and simplifying the description, rather than indicating or implying that the referred devices or elements must It has a specific orientation, is constructed and operated in a specific orientation, so the terms describing the positional relationship in the drawings are for illustrative purposes only, and should not be construed as limiting the present invention. For those of ordinary skill in the art, the understanding of the specific meaning of the above terms.

The present invention proposes a method for automatically generating the corresponding proto file of the c language structure and the mutual code conversion between the protobuf generated structure, which can automatically realize the conversion between the two interface structures in batches, and eliminate the interface errors caused by manual links. It greatly improves the integration efficiency of autonomous driving software development.

The invention firstly scans the folder storing the source code of c language to read all relevant text content, and secondly extracts the keyword information of the interface structure from the text based on the read text content combined with the grammatical structure defined by the c language. Then generate the proto file according to the corresponding relationship between protobuf grammar and c language grammar, and generate the conversion code from structure to proto and the conversion code from proto to structure respectively.

1. Establish a keyword comparison table between c language and protobuf language, as shown in Table 1.

Table 1

c language protobuf double double float float int int32 long int64 short int32 unsigned short uint32 unsigned int uint32 unsigned long uint64 bool bool [] repeated structure message

2. Load all the files in the folder where the c language source code is stored, obtain the text content of all files and store them in the variable content.

3. Delete the comment codes contained or started with "/*...*/" or "//" in the content to improve post-processing efficiency.

4. In content, check all file fields that meet the following conditions. Conditions: start with struct, contain a pair of braces, and end with 0 or several characters and a semicolon.

5. Traverse each matched field, as shown in Figure 1, further extract the structure name struct_name, the variable type val_type of each variable, and the variable name val_name. If the variable name is followed by a pair of square brackets, the variable is an array, marked as repeated_num is equal to the value in the square brackets, if there is no square brackets, it is marked as repeated_num=0.

6. As shown in Figure 2, based on the comparison table built in step 1, generate and convert the extracted c language interface structure information into a proto file and write it into a new text, such as interface.proto.

7. Create a file to save the conversion code from the c structure to the proto structure and the conversion code from the proto structure to the c language structure,

8. Traverse all the extracted structure interface information and perform the following steps.

9. Define the name of the c language structure as name, and the name of the proto structure as proto_<name>, and add proto underscores before the variable name for distinction. Generate `<name>to_<name>(const proto_<name>&temp)` and `proto_<name>to_proto_<name>(const<name>&temp)` transformation function declaration statements respectively, and save them in the variable content.

10. Traverse all the variables of the structure. If the variable type val_type can be found in the basic type table, it indicates that the variable is a basic type, and it can be assigned with the proto type by an equal sign. Then judge whether the variable repeated_num is 0, if not, establish a loop based on the array size repeated_num, and generate the basic type assignment conversion code. If so, generate the underlying type assignment statement. If not found, it indicates that the variable is a custom type, and the conversion function is still required for conversion. Then judge whether the variable repeated_num is 0, if not, create a loop based on the size of the array, and generate a custom structure conversion code. If so, generate the structure conversion code and add it to the variable content

11. Write the text content in the variable content to the file.

12. Step 8 is traversed.

Finally, it is noted that the above embodiments are only used to illustrate the technical solutions of the present invention without limitation. Although the present invention has been described in detail with reference to the preferred embodiments, those of ordinary skill in the art should understand that the technical solutions of the present invention can be carried out Modifications or equivalent replacements, without departing from the spirit and scope of the technical solution, should be included in the scope of the claims of the present invention.

Claims (6)

1. A kind of C language structure body turns protobuf file and mutual conversion code automatic generation method, it is characterized in that: first scan the folder that deposits C language source code to read all relevant text content; Secondly based on the text content read, combine The grammatical structure defined by the C language extracts the keyword information of the interface structure from the text; then generates the proto file according to the corresponding relationship between the protobuf grammar and the C language grammar, and generates the conversion code from the structure to proto and the proto to structure respectively body conversion code. 2. the C language structure body according to claim 1 turns protobuf file and mutual conversion code automatic generation method, it is characterized in that: specifically comprise the following steps: S1: Establish a comparison table of basic variable types between C language structure and protobuf language; S2: Scan the folder where the C language source code is saved, obtain the text content of all files in the folder and store it in the variable content; S3: delete the comment code in content; S4: Based on the syntax, obtain the relevant definitions of all structures in the content and extract keyword information; S5: traverse each matched field, extract the structure name, the variable type of each variable, and the variable name; S6: Convert the extracted keyword information into proto text information based on the comparison table in step S1 and save it in a new text; S7: Create a file to save the conversion code from the c structure to the proto structure and the conversion code from the proto structure to the c language structure; S8: traverse all the extracted structure interface information; S9: Generate a declaration of the structure mutual conversion function based on the structure name; S10: traverse all variables of the structure; S11: Write the text content in the variable content to the file, and return to step S8 to continue traversing. 3. the C language structure according to claim 2 turns protobuf file and mutual conversion code automatic generation method, it is characterized in that: in step S5, if variable name is followed by a pair of square brackets then this variable is an array, marked as repeated_num is equal to The value in the square brackets, if there is no square brackets, it is marked as repeated_num=0. 4. the C language structure body according to claim 2 turns protobuf file and mutual conversion code automatic generation method, it is characterized in that: step S9 specifically comprises: definition C language structure body name is name, proto structure body name is proto_<name >, add proto underscore before the variable name to distinguish; respectively generate `<name>to_<name>(constproto_<name>&temp)` and `proto_<name>to_proto_<name>(const<name>&temp)` conversion Function declaration statement, and save to the variable content. 5. the C language structure body according to claim 2 turns protobuf file and mutual conversion code automatic generation method, it is characterized in that: in step S10, traverse all variables of structure body, if variable type val_type can find in basic type table , it indicates that the variable is a basic type, and it is enough to assign a value with the proto type through an equal sign; then judge whether the variable repeated_num is 0, if not, create a loop based on the array size repeated_num, and generate a basic type assignment conversion code; if so, generate a basic type assignment statement. 6. the C language structure body according to claim 2 turns protobuf file and mutual conversion code automatic generation method, it is characterized in that: in step S10, traverse all variables of structure body, if variable type val_type does not find in basic type table , it indicates that the variable is a custom type, which is converted by the conversion function; then judge whether the variable repeated_num is 0, if not, create a loop based on the size of the array, and generate a custom structure conversion code; if so, generate a structure conversion code, And add to the variable content.

Images