JP2807162B2 - Program translator - Google Patents

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a program translating apparatus that divides a source program into a plurality of pieces, creates the program, and translates the created source program.

[0002]

2. Description of the Related Art Conventionally, when a computer program is created, a program to be created is often divided into a plurality of modules. This is because a plurality of program creators share the work and make it easy to modify and check the program. In recent years, in the C language, which is one of the widely used programming languages, variables used in one function are generally interpreted as local automatic variables in order to support the creation of divided programs. And
Even if there is a variable with the same name in another function, it is handled independently. These automatic variables are dynamically allocated, for example, in a so-called stack area, and the data that is the stored contents of the variables is determined only when the function that defines the variables is called. Regardless of the function call, a variable for always holding data is also called a static variable and is assigned to a specific memory address. Among these static variables, variables used from other files are treated as externally referable variables.

FIG. 6 shows a case where a source program is divided into a plurality of files 1, 2, 3, and the respective files 1, 2, 2, and 3.
Variables "ram1" and "ram1"
2 ”,“ ram3 ”, and“ ram4 ”are defined. It is assumed that the type of each variable is, for example, "int" representing an integer type. Each file 1
3 may include not only the definition of such externally referable variables, but also one or more function definitions. If each of the files 1 to 3 is compiled separately, the compilation itself will succeed if there are no other grammatical errors, etc.
Obtain the object program respectively. In order to create one program as a whole, it is necessary to link object programs obtained from the respective files 1 to 3. The object program also includes information such as variable names and relative addresses for referring to externally defined variables. In the case shown in FIG. 6, for example, "ram1"
And “ram2” are defined redundantly in file 1 and file 2. "Ram3" and "ram
"4" is also defined redundantly. For this reason, when linking object programs into one program, an overload error occurs.

FIG. 7 shows an example of using a preprocessor control line for including a header file, which is a function for supporting a divided program provided in the C language. The source program is, for example, “main.c”,
It is assumed that the file is divided into three files “sub1.c” and “sub2.c”. In order to avoid overloading variables that can be externally referenced, variables are declared and defined in a header file “ram.h”.
In “main.c”, this “ram.h” is replaced with “#inc
The instruction is fetched by the instruction of the preprocessor control line “lude”. Other files "sub1.c" and "s
ub2. Similarly, if "ram.h" is taken in with "c.c", it becomes overloaded, so the external definition file "ram_ex"
t. h ”is separately created and imported. That is,
As shown by, two RAM declarations are required. In some cases, the control program also requires a part for directly creating a program in a machine language. For this purpose, for example, "i
nit. An assembler program such as "asm" is also required. Assembler programs are translated into machine language by the assembler. A program written in C language,
In order to link a program written in the assembler language, it is necessary to make variables described in the C language program accessible from the assembler program. That is, redeclaration is necessary even in the assembler as shown by. As shown in the figure, for example, "init.as
It is necessary to declare the variable "a" used in "m" as "public".

[0005]

As described above, even when a variable that can be referred to externally is defined using the header file include function, as shown in FIG.
The included module differs depending on the file.
For this reason, as shown in FIG. 8, it is necessary to create two, a definition header file 5 and an external definition external header file 6. For example, if the type of “ram4” is “in
When changing from "t" to the character type "char", it is often the case that the modification of the external header file 6 is forgotten. Even if such a modification is forgotten, each source file is successfully compiled in the separate compilation. Links can also be apparently successful.
However, since the type of the variable “ram4” is different, the translated program is likely to malfunction, which is likely to cause a bug. In addition, even if a single variable is modified, a plurality of files must be surely modified, which imposes a heavy burden on a program creator.

[0006] An object of the present invention is to provide a program translating apparatus which can make necessary modifications to variable definitions only by modifying one file, and can create a highly reliable program with less burden on a program creator. To provide.

[0007]

According to the present invention, there is provided a definition file for defining a variable commonly used in a plurality of program files in which a source program is described, or a variable to be referred to is defined in another program file. In a program translator that reads an external definition file indicating that a definition is to be made at the time of translation of each program file, it reads a definition file and converts a description for defining variables into a description for referring to variables. And a file generating means for automatically generating an external definition file.

[0008]

According to the present invention, a source program is described by a plurality of program files. Variables commonly used in multiple program files are defined in the definition file. The fact that the referenced variable is defined in another program file is defined by the external definition file.
The external definition file is automatically generated by the file generation means reading the definition file and converting the description for defining the variable into the description for referring to the variable. The program translator reads the definition file or the external definition file at the time of translating each program file. Since the external definition file is automatically generated from the definition file, any change in the contents of the definition file is automatically corrected. Therefore, the burden on the program creator is small,
The generated program does not have a factor of causing a bug due to overloading or mismatch of types, so that a highly reliable program can be obtained.

[0009]

FIG. 1 shows a simplified configuration of an embodiment of the present invention. The header file 10 stores, for example, five variables “ram1” to “ram5” as an integer “int”.
This is a header file defined as By adding “extern” to the beginning of each line of the header file 10,
An external header file 11 is created. The header file 10 is taken into the file 20 according to the instruction “#include“ header file ”” by the preprocessor control line of one file 20. The external header file 11 is taken in according to the instruction “#include“ external header file ”” by the preprocessor control line in the plurality of files 21, 22 and 23. Translation device 30
File generating means 31 for automatically generating the external header file 11 from the header file 10;
23, and a compiler means 32 for taking in the header file 10 or the external header file 11 when executing a preprocessor instruction representing an include. The compiler means 32 compiles each of the files 20 to 23 individually to generate an object file 40. Each object file 40 is linked by a linker and put together as one whole program.

[0010] The object file 40 by the linker
When linking is used, an object file obtained by assembling an assembler source file described in assembly language can also be used. File generation means 3
1 is the header file 10 to the external header file 11
Can be automatically added to the source file of the assembler when the file is automatically generated.

FIG. 2 shows the operation of the file generating means 31 of the embodiment shown in FIG. In step c1, the operation starts, and in step c2, the header file 10 is opened to make it possible to read line by line. Next, in step c3, the program described in the header file 10 is read line by line. In step c4, it is determined whether or not the read line defines a variable. If a variable is defined, "extern" is added to the beginning of the line in step c5.
Is added to the file and written into another file as the external header file 11. After step c5 is completed, or when it is determined in step c4 that no variable is defined, the process proceeds to step c6. At step c6, it is determined whether or not the read program line is the last line. When it is determined that it is not the last line, the process returns to step c3. If it is determined that the line is the last line, the process ends in step c7. Such file generation means 31 and compiler means 32
It is realized as software operating on a computer device such as a workstation or a personal computer.

FIG. 3 illustrates the concept of translation achieved in another embodiment of the present invention. In this embodiment, a header file for defining a variable is handled in the same manner as a program file. From the definition file “ram.c”, the file generating means 31 automatically generates an external header file “ram_ext.h”, as shown in FIG. The compiler means 32 outputs “ram.c”, “main.c”,
Compile “sub1.c” and “sub2.c”. At this time, if there is an assembler language source file "init.asm" as shown in FIG.
m. Automatically add variable redeclaration when compiling "c". In addition, a public declaration indicating that the declaration is an external definition is added as shown by "."
t. It is not necessary to describe it in "asm" itself. The program file “mai” in which the source program is described
n. c, “sub1.c” and “sub2.c” have the same external header file “ram_ex”, respectively.
t. It suffices to describe a preprocessor instruction that takes in "h", and the included module is the same as shown by.

FIGS. 4 and 5 show "ram.
c "and" ram_ext.h ". "Ra
m. "c" includes, for example, a bit definition unit 50, a structure definition unit 60, a preprocessor definition unit 70, and a variable definition unit 80. In the bit definition section 50, the definition contents 51 of the bit field are described in the form of a structure. The structure definition unit 60 includes a structure declaration 61 for declaring “wordf” as one type of the structure “struct” and a union declaration 6 for declaring one type “byteef” of the union.
2 is included. The preprocessor definition unit 70 includes a reference comment 71 indicating the contents defined by another module for reference, and a constant “BY” actually defined by an instruction “#define” by a preprocessor control line for defining a constant.
Constant definition 7 representing the definition contents of "TE" and "WORD"
2 is included.

The variable definition section 80 includes a variable definition 81 for defining an unsigned character type variable, a structure definition 82 for defining a structure, and a structure definition for defining the structure declared in the structure declaration 61. 83 and constant definitions 84 for the preprocessor
And variable definitions 85 and 8 for defining unsigned character variables
6,87 and a constant definition 88 for the preprocessor.

[0015] The file generating means of this embodiment is "ra
m. c based on “ram_ext.c” shown in FIG.
h ”is automatically generated. In “ram_ext.h”, the bit definition unit 50, the structure definition unit 60, and the preprocessor definition unit 70 are copied as they are. The variable definition unit 80 in FIG. 4 is converted like the external variable definition unit 90 in FIG. In the external variable definition unit 90, a variable external definition 91, a structure variable external definition 92, 93, a constant definition 9
4. Variable external definitions 95, 96, 97 and constant definitions 98 are included. Among them, the constant definitions 94 and 98 are the same as the variable definitions 84 and 88 in FIG. At the beginning of the other part, "e
xtern "is added.

In this embodiment, the variable definition file is treated as "ram.c", and is handled in the same manner as a program file. In other program files, only the external definition file is included, and the same module is included. ing. However, it goes without saying that, for example, “ram.c” may be included in “main.c”. At this time, FIG.
This is substantially the same as the embodiment. To make it clear that the header file is included, use "ra
m. If the file name is changed to "h", the embodiment shown in FIG. 1 is obtained.

Also, the step of preparing such a definition file can be automated. After creating a plurality of program files, a common external variable is extracted from each program file, a definition file is created, and an external header file is automatically generated. A preprocessor instruction for including an external header file is added to each program file from which the external variables are extracted, for example, as in the embodiment of FIG. In this way, a series of files are automatically created, the burden on the program creator can be reduced, the possibility of bugs can be reduced, and the reliability of the created program can be increased.

Although the description has been given of the case where a program is created in C language, the same effect can be obtained with an assembler or another high-level language program translator that can use the include function. It is.

[0019]

As described above, according to the present invention, when changing the definition of a variable commonly used in a plurality of program files, only the related description in one definition file is changed. Then, the external definition file is also modified by the file generating means. Therefore, the burden on the program creator is reduced, and bugs and the like in the program due to overloading of variables and mismatch of types can be reduced, and the reliability of the program can be improved.

[Brief description of the drawings]

FIG. 1 is a block diagram showing a schematic electrical configuration of an embodiment of the present invention.

FIG. 2 is a flowchart showing the operation of the embodiment of FIG.

FIG. 3 is a block diagram showing a concept of processing realized by another embodiment of the present invention.

FIG. 4 is a program list showing an example of the contents of “ram.c” shown in FIG. 3;

FIG. 5 is a program list showing an example of the contents of “ram_ext.h” in FIG. 3;

FIG. 6 is a simplified program list showing the definition state of variables in a conventional split compilation.

FIG. 7 is a block diagram showing the concept of conventional program translation.

FIG. 8 is a simplified program list showing a problem of the conventional concept.

[Explanation of symbols]

 DESCRIPTION OF SYMBOLS 10 Header file 11 External header file 20-23 File 30 Translator 31 File generating means 32 Compiler means 80 Variable definition part 81,85-87 Variable definition 90 External variable definition part 91,95-97 Variable external definition

──────────────────────────────────────────────────続 き Continued on the front page (58) Fields surveyed (Int.Cl. ⁶ , DB name) G06F 9/45 G06F 9/06 JICST file (JOIS)

Claims (1)

(57) [Claims] 1. A definition file for defining variables commonly used in a plurality of program files in which a source program is described, or an external definition file indicating that variables to be referenced are defined in another program file Automatically reads the definition file, translates the description for defining variables into a description for referencing variables, and automatically generates an external definition file. A program translation device comprising file generation means.