JPH0744396A - Language processor with symbol backward reference designating function - Google Patents

Abstract

PURPOSE:To easily develop and maintain an application program by integrating multiplex definition which is performed without changing a name, and a backward reference machine for symbol so as to select any one of names to which the multiplex definition is performed. CONSTITUTION:A preprocessing part 11 inputs a source program 21, a control line is excluded from the program 21, and a source program 22 after preprocessing is outputted. A translation part 12 inputs the program 22 after preprocessing and outputs an object program 23. On the other hand, a linkage part 13 couples the program 23 prepared by the translation part 12, other object program 24 and library 25 being the set body of object programs, clarifies the reference and definition of the symbol, decides an address inside an executing module, performs relocation processing from the information of a relocation entry inside a relocation table based on them and prepares an executing module 26. Thus, the backward symbol is referred to backward.

Description

Detailed Description of the Invention

[0001]

BACKGROUND OF THE INVENTION 1. Field of the Invention The present invention relates to a language processor,
More specifically, the present invention relates to a language processing device with a symbol backward reference designating function when adding functions to a library provided by a vendor, debugging during program development, and application program maintenance in the field of application program development.

[0002]

2. Description of the Related Art In a conventional language processor, an example is given.
For example, as a conventional example [1], live provided by the vendor
Rari (Users who develop application programs
You can't change that library.)
The following methods are known to add functions to the tool.
It [Procedure for adding functions to the library module] Step 1-1: Inside the module of the library for adding functions
The function of lib func1 (). Step 1-2: Lib the function that defines the function addition part x
func1 (), and lib in xfunc1 ()
After adding the function, the lib in the library func1
() Is defined to be called. Step 1-3: Source program of application program
In g, the function lib in the library func1
Everywhere you call () lib xfunc
Rewrite to 1 (). Step 1-4: Source program of application and
Recompiles the source program that defines additional functions
After that, relink and execute module (application
Program).

Further, as a conventional example [2], when the contents of the parameters of the function in the library (provided by the vendor) referenced by the application program are displayed when the application program is debugged, The method is known. [Procedure for adding debug information output function to application program] Step 2-1: Add the logic for displaying the function parameter to the place where the function is called in the application program. Step 2-2: After recompiling the source program,
Relink and create an execution module.

[0004]

However, both the conventional examples [1] and [2] have a problem that the original source program must be changed. If the conditional compilation function provided depending on the language is used in the source program, the source program can be processed by one type, but the source program becomes difficult to see and is not preferable for maintenance. Moreover, if the conditional compilation function is not used, a plurality of source programs are required. Further, since the original source program is directly modified to add the function, recompilation and relinking are required to create the application program. The above-mentioned problem is caused in the language processor using the conventional technique by using the language specification that does not allow overloading, the rule for connecting the symbol reference and the overloaded symbol definition, and the reference rule for performing the forward reference, the backward reference, etc. This is because there is no function to select one symbol definition from the defined symbol definitions.

The present invention has been made in consideration of the above circumstances. When redefining the functions in the library described in the conventional examples [1] and [2], the multiple definition is performed without changing the name. And a symbol processing device with a symbol backward reference designating function that facilitates development and maintenance of an application program by incorporating a symbol backward reference function for selecting one from overloaded names in the language processing device. It is a thing.

[0006]

The technical means taken by the present invention to achieve the above object are as follows.
That is, the present invention is a language processing device having a split compiling function for creating an execution module from an input source program, and inputs a source program having a syntax including symbols such as reserved words and function names, Preprocessing of the source program Adds a symbol for backward reference to the beginning of the source program based on the preprocessing control line of the language processing program rule that can combine symbols, registers the symbol in the symbol table, and preprocesses the source program. Recognize the preprocessing part and the symbol of the syntax in the source program after preprocessing, analyze the function name or the registered backward reference symbol, and if it is a backward reference symbol, set the multiple permission flag in the symbol table. The function that generates the code for the function name and creates the object program, and the created object. The symbol reference and symbol definition in the target program based on the multiple permission flag of the symbol table, and the linkage part that creates the execution module by referring to the symbol defined in the source program in the rear. In addition, when a symbol reference and symbol definition are performed between files that include source programs, even if a symbol is defined in the file that includes the symbol reference and the source program that precedes that file, the reference to the symbol is A language processing apparatus with a symbol backward reference designating function, characterized in that an execution module is created by referring to a symbol defined by a source program in a backward file without performing it.

It is preferable that the language processing program is composed of ANSI standard C language.

The preprocessing control line added to the head of the source program for preprocessing by the preprocessing unit is preferably #pragma which describes a preprocessing specification depending on the processing system of C language.

The translation unit analyzes a vocabulary analysis unit that recognizes symbols such as reserved words and function names in the preprocessed source program, and analyzes whether the syntax composed of the symbols satisfies the C language specifications. It is preferably composed of a syntax analysis unit and a code generation unit for generating a code for the analyzed syntax, creating a symbol table, and creating an object program.

In the present invention, the backward reference of a symbol refers to a case where the direction from the left to the right of the files arranged from left to right is backward in the symbol reference rule between files including source programs. When a reference encounters a symbol reference in the source program, the reference to the symbol, even if it is already defined in the source program in the file containing the reference and in the file preceding it. No reference is made, but a reference to a symbol defined in the source program in a file specified after the file containing the reference is selected, and the backward-referenced symbol can be overloaded.

[0011]

According to the present invention, when the source program is input, the head of the source program is backreferenced based on the preprocessing control line of the language processing program rule capable of combining symbols in the preprocessing unit. The symbol added to the is registered in the symbol table, and the source program is preprocessed. Next, the translation unit recognizes the syntax symbol in the preprocessed source program, analyzes whether it is a registered backward reference symbol, and if it is a backward reference symbol, sets the multiple permission flag in the symbol table. Set and create an object program. Further, in the linkage section, it is clarified whether the symbol reference and symbol definition in the created object program are backward-referenced symbols based on the multiple permission flag of the symbol table, and the symbols defined in the backward source program are referred to. Create an execution module as follows. Therefore, the language processing device composed of the preprocessing unit, the translation unit, and the linkage unit performs the symbol reference and the symbol definition between the files including the source program, and the file including the symbol reference and the file before the file. Even if a symbol is defined in a certain source program, the symbol is not referred to, and the execution module can be created by referring to the symbol defined in the source program in the file at the back.

Since the language processing program is composed of ANSI standard C language, it is possible to perform language processing based on the C language program.

The preprocessing control line added to the head of the source program for preprocessing by the preprocessing unit is #pragma which describes the preprocessing specifications depending on the processing system of the C language, and a backward reference is made to this #pragma. Symbol can be added.

The translation unit analyzes a vocabulary analysis unit that recognizes symbols such as reserved words and function names in the preprocessed source program, and analyzes whether the syntax composed of symbols satisfies the C language specifications. It consists of a syntax analysis part, a code generation part for the parsed syntax, a symbol table creation, and a code generation part to create an object program. If the symbol is, the multiple permission flag can be set in the symbol table and the object program can be created.

[0015]

The present invention will be described in detail below based on the embodiments shown in the drawings. The present invention is not limited to this. Further, the present invention is mainly suitable for a language processing device that performs language processing in C language, and each component has a function of an ordinary language processing device in addition to enabling the backward reference designation of the symbol of the present invention. Will be explained.

FIG. 1 is a block diagram showing the basic configuration of the language processing apparatus of the present invention. In the figure, reference numeral 1 is a main body of a language processing apparatus, which is a CPU for executing language processing, and an RO.
A microcomputer including M, RAM and I / O ports is used. Reference numeral 2 denotes a hard disk device, which is a storage device for storing various programs for executing language processing and created programs and various data. Reference numeral 3 denotes a console, which is used as a personal computer, a terminal or the like having an input device and a display device for inputting various data and creating and maintaining various programs. Reference numeral 4 denotes a printer, and a dot matrix printer, an inkjet printer, a laser printer or the like is used as a printer for outputting the created program list and various data.

FIG. 2 is an explanatory diagram showing an embodiment of a source program applied to the language processing apparatus of the present invention. Figure 2-1
"C based on ANSI (American National Standards Institute)"
An example in which the function of the present invention is applied to a language processing system for processing a "language" is shown. In the ANSI "C language" program specification, a line starting with a control character "#" which gives a preprocessing (preprocessor) instruction. There is a “#pra
This is implemented by adding the function of the present invention to the part that describes the processing-system dependent preprocessing specification "gma".

Specifically, the description "#pr" shown in FIG.
The function of the present invention is applied to the language processing device by putting "agma backwords" at the beginning of the source program. That is, the sequence of function names described after the keyword "backwards" allows overloading, and FIG.
A reference of the same function name from within a source program having a description of -1 is combined with a function defined on the source program in a file arranged after the file containing the reference.

2-2, 2-3, and 2-4 are the actual software.
An example of the source program is shown below. This example is an application
Source program [a. c] (Fig. 2-
2) and the function lib in the [library] (Fig. 2-3)
func1 and lib It consists of func2 and these
The present invention is implemented when a function is added to the library function.
The case is shown. File containing functions that add functionality
[Filter. c] (FIGS. 2-4) is designated as a backward reference.
Function is lib func1, lib func2
After these functions are redefined and additional logic is written
The function is called again with, but the reference of this function is
Originally, in the ANSI "C" specification,
Although it is combined (recursive call) with the function of its own, in this embodiment
After this file because it is specified with a back reference
Defined within the program that is included in the ordered file
Combined with the function name defined here in the library
A lib func1 and lib tied to func2
Are combined.

[A. in main () in c]
b func1, lib calling func2
However, this is [filter. l defined in [c]
ib func1, lib bound to func2,
Lib calling from inside func1, lib f
unc2 is a lib defined in the library fun
c1 and lib respectively bound to func2. this
These series of calling functions were originally [a. c] and Libra
During the calling relationship between the files [filter. c] is a group
Changed to a calling function in the embedded state, and
[A. c] and source programs in [library],
Or without changing the object program at all
It also shows that it is okay.

FIG. 3 is an explanatory view showing the structure of the language processor main body of the present invention and the relationship between the programs. In FIG. 3, reference numeral 11 denotes a preprocessing unit that processes a control line (line starting with #) in the source program. The preprocessor 11 receives the source program 21 as input, and the preprocessed source program 2 in which the control line is deleted from the source program 21.
2 is output. Reference numeral 12 is a translation unit, which receives the preprocessed source program 22 as an input and
3 is output.

The translation unit 12 is a vocabulary analysis unit 12A that recognizes symbols such as reserved words and function names in the source program.
And a syntax analysis unit 12B that recognizes whether the syntax composed of symbols satisfies the language usage, code generation for the received syntax, creation of a symbol table, creation of a relocation section, etc., and output the object program 23. It is composed of a code generator 12C.

Reference numeral 13 is a linkage unit, which links the object program 23 created by the translation unit 12, the other object programs 24, and the library 25, which is an aggregate of the object programs, to clarify the reference and definition of symbols. , An address in the execution module is determined, and based on them, the relocation processing is performed from the information of the relocation entry in the relocation table to create the execution module 26.

FIG. 4 is an explanatory diagram showing the structure of the object program format. As shown in FIG. 4, the object program 23 has an object program format, and the execution module 26 has an execution module format. The object program format includes a header portion 41 having offset and size information from the beginning of the file such as each section, a text section 42 including an instruction portion of a generated code,
Data section 4 consisting of the data part of the generated code
3, a relocation section 44 having relocation information of each section, a symbol table 45 having symbol information of each section, and a character string table 46 having character strings of actual symbols.

The relocation section 44 is composed of relocation entries. The relocation offset 44a indicates where the relocation section is located from the beginning of each section, and the number of symbol entry in the symbol table where the information for the symbol is. A symbol table index 44b shown, a relocation size 44c representing the size of the portion to be relocated, and a relocation type 44d representing the type of relocation (absolute address or relative address, etc.). In the present invention, a backwards type is added to this relocation type 44d.

The symbol table 45 is composed of symbol table entries, and a pointer 45a to a character string table indicating a pointer to a character string table containing a character string representing a symbol name and an actual address of the symbol are set. Address 45b, size 45c indicating the data size if the symbol represents data,
It is composed of a flag 45d indicating whether it is a local symbol or a global symbol, and a section 45e indicating a section in which the symbol is defined. In the present invention, a new overload permission flag is newly added to this flag 45d.

FIG. 5 is an explanatory diagram showing the structure of the execution module format. As shown in FIG. 5, the execution module format is a text segment 5 consisting of a header portion 51 having an offset from the beginning in the file of each segment and the like and size information, and an instruction code
2, a data segment 53 including a data code, a symbol table 54 including a symbol entry, and a character string table 55 including a character string of a symbol for a symbol.

With the above configuration, the present invention is realized by adding functions to the preprocessing unit 11, the translation unit 12, and the linkage unit 13 in the language processing apparatus main body 1, respectively. These embodiments will be described with reference to the flowcharts shown in FIGS. 6, 7, and 8. [Adding functions to the preprocessing unit] #pragma in the preprocessing unit
A logic for recognizing the process for the keyword "backwards" is added. Description: #pragma backwards b1, b
2, ..., Bn b1, ..., Bn represent backward reference symbols (hereinafter referred to as backward symbols). Here, bacward
After recognizing the keyword s, b1, ..., Bn are registered in the backward symbol table for registering backward symbols.

FIG. 6 is a flow chart showing the processing contents of the preprocessing section. In FIG. 6, Step 601: “Pragm” in the source program
The process of reading the symbol next to “a” is performed. Step 602: The read symbol is “backwa”.
Check if "rds". If NO, then "backwa"
Performs a pragma process other than "rds", and if YES, recognizes that it is a "backwards" process. Step 603: Reads the next symbol. Step 604: Checks whether the symbol string is the end. If it is not the end, the process proceeds to step 605. Step 605: The read symbol is registered in the backward symbol table, and the processes of steps 603 to 605 are repeated until the end of the line is recognized.

[Addition of Function to Translation Unit] The translation unit 12 includes a vocabulary analysis unit 12A, a syntax analysis unit 12B, and a code generation unit 12C.
It consists of In the present invention, the code generator 12C is modified, but the part of the instruction code generation process for the function call is targeted.

FIG. 7 is a flowchart showing the processing contents of the translation unit. In FIG. 7, step 701: Check whether the function call name is a symbol registered in the backward symbol table created by the preprocessing unit 11. Step 702: If it is a registered symbol, the overload definition flag is set in the flag 45d in the symbol table entry. Step 703: The relocation type 44d in the relocation entry is set to the backwards type (b
ackwords attribute). Step 704: The symbol entry set together with other information is output to the symbol table 45 in the object file. Step 705: Output the relocation entry set with other information to the relocation section 44 in the object file. Step 706: Output the generated code for the function call to the text section 42 in the object file.

[Addition of Function to Linkage Processing] The processing of the linkage processing 13 clarifies the reference between symbols of the object files 23 and 24 to be input and the object files in the library 25, the definition function, and the text section. The actual address is determined based on the information of the relocation entry in the relocation section 44 in the relocation section in 42 and the data section 43, the relocation process is performed, and the process of creating the execution module 26 is performed. Relocation processing is the processing that determines the actual address in the part that specifies the address in the generated code and the actual execution address has not yet been determined (called the relocation part), and sets that address in the relocation part. I mean.

FIG. 8 is a schematic flowchart showing the processing content 1 of the linkage unit. In FIG. 8, step 801: object files 23, 24, 2
Check if there is 5. Step 802: Object files 23, 24, 2
While there is 5, process each object file. The addition of functions to the linkage unit processing of the present invention is performed within the processing of each object file of the linkage unit 13 (see the flowchart of FIG. 9). When there is no object file to be processed, the process proceeds to step 803.

Step 803: Relocation processing is performed based on the relocation entry information in the relocation list created in step 802. End all relocation processing. Step 804: When all the relocation processing is completed, the text section of each relocated object is sequentially output to the text segment 52 in the execution module. Step 805: Similarly, the data sections are sequentially output to the data segment 53 in the execution module. Step 806: The symbol table and the character string table of each object are output to the symbol table 54 and the character string table 55 in the execution module. Step 807: Create and output the header 51 of the execution module.

FIG. 9 is a detailed flowchart showing the processing content 2 of the linkage unit. In FIG. 9, Step 901: Read the relocation entry from the relocation section 44 of each object file. Step 902: Step 903 if reading is OK
If the reading is not OK (there is no relocation entry), the process proceeds to step 909, which is processing for the symbol table. Step 903: Check whether the relocation type 44d in the relocation entry is a "backwards" type, and if it is a "backwards" type, move to step 904, otherwise move to step 906. Step 904: Recognize the character string of the symbol from the pointer 45a to the table indicating the beginning of the character string of the symbol defined in the entry in the symbol table indicated by the symbol table index 44b in the relocation entry, and recognize this symbol name. Is registered in the backward symbol table in the linkage processing section.

Step 905: This relocation entry is registered in the backward relocation list in the linkage processing section, and the process returns to step 901 of the next relocation entry process. Step 906: Check whether the symbol indicated by the relocation symbol index is registered in the global symbol table in the linkage processing section. Step 907: If registered, relocation processing is performed, and the processing returns to step 901 for the next relocation entry processing. Step 908: If not registered, the relocation entry is registered in the relocation list, and the process returns to step 901 of the next relocation entry process.

Next, the flow after step 909 will be described. Step 909: Read the symbol table entry from the symbol table 45. Step 910: If the reading is OK, the process proceeds to step 911. If the reading is not OK (there is no symbol table entry), the processing of each object file of the linkage unit 13 is ended. Step 911: It is checked from the pointer 45a to the character string table indicating the symbol whether the symbol is overloaded (if it is already registered in the global symbol table, it is overloaded). If it is not multiple definition, the process proceeds to step 915, the symbol is registered in the global symbol table, and the process returns to step 909 to process the next symbol table entry.

Step 912: If it is an overload, then it is checked whether it is that symbol or a backward symbol (it is a backward symbol if it is already registered in the backward symbol table), and if it is not a backward symbol, an overload error occurs. Processing (step 916) is performed.
If it is a backward symbol, the process proceeds to step 913. Step 913: Perform relocation processing of the relocation in the backward relocation list (created at step 905) for the backward symbol.
In this step, the backward reference of backward symbols, which is the object of the present invention, is realized.

Step 914: The backward symbol is deleted from the backward symbol table (registered at step 904), and the process proceeds to the next symbol table entry. Therefore, the backward reference of the backward symbol, which is the object of the present invention, is realized.

[0040]

According to the present invention, since it has the above-mentioned structure, the following effects can be obtained. 1) The function can be added to the function in the library provided by the system without changing the original program that refers to the function in the library, and the maintenance becomes easy. 2) It is easy to redefine the library created by the user, no error of multiple definition is output, a program including redefinition can be created, and functions can be easily added, so that a prototype can be created easily. 3) Addition of debug information output function such as displaying the contents of parameters passed to the functions in the library provided by the system without changing the original source program that references the functions in the library or the functions in the library. Can be added.

[Brief description of drawings]

FIG. 1 is a block diagram showing a basic configuration of a language processing device of the present invention.

FIG. 2 is an explanatory diagram showing an example of a source program applied to the language processing device of the present invention.

FIG. 3 is an explanatory diagram showing the relationship between the configuration of the language processing apparatus body of the present invention and each program.

FIG. 4 is an explanatory diagram showing the structure of an object program format.

FIG. 5 is an explanatory diagram showing a configuration of an execution module format.

FIG. 6 is a flowchart showing the processing contents of a preprocessing unit.

FIG. 7 is a flowchart showing the processing contents of the translation unit.

FIG. 8 is a schematic flowchart showing a processing content 1 of a linkage unit.

FIG. 9 is a detailed flowchart showing a processing content 2 of a linkage unit.

[Explanation of symbols]

 1 language processing device main body 2 hard disk device 3 console 4 printer 11 preprocessing unit 12 translation unit 12A vocabulary analysis unit 12B syntax analysis unit 12C code generation unit 13 linkage unit

Claims (4)

[Claims] 1. A language processing device having a split compilation function for creating an execution module from an input source program, wherein a source program having a syntax including symbols such as reserved words and function names is input, Before preprocessing the source program, add a symbol for backward reference to the beginning of the source program based on the preprocessing control line of the language processing program rule that can combine the Recognize the processing unit and the symbol of the syntax in the preprocessed source program, analyze whether it is a function name or a registered backward reference symbol, and if it is a backward reference symbol, set the multiple permission flag in the symbol table. , A translation unit that generates code for function names and creates an object program, and the created object The symbol reference and symbol definition in the target program based on the multiple permission flag of the symbol table, and the linkage part that creates the execution module by referring to the symbol defined in the source program in the rear. In addition, when performing symbol reference and symbol definition between files containing source programs, even if a symbol is defined in the file containing the symbol reference and the source program before that file, the reference to the symbol is A language processing device with a symbol backward reference designating function, characterized in that an execution module is created by referencing a symbol defined by a source program in a backward file without performing. 2. The language processing apparatus with a symbol backward reference designating function according to claim 1, wherein the language processing program is an ANSI standard C language. 3. The pre-processing control line added to the head of the source program for pre-processing by the pre-processing unit is #pragma which describes a pre-processing specification dependent on the processing language of C language. The language processing device with a symbol back reference designating function according to claim 1. 4. The lexical analysis unit that recognizes symbols such as reserved words and function names in the preprocessed source program and whether the syntax composed of the symbols satisfies the C language specifications. The symbol back reference designating function according to claim 1, comprising a syntax analysis unit for analyzing, a code generation unit for the analyzed syntax, a symbol table generation unit, and a code generation unit for generating an object program. Language processor.