JP2005346406A - Method for solving reference of other program in language translation program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To solve a problem that translation performance and memory consumption may be influenced because all executable files (DLL) to be referred to should be loaded and other corresponding programs should be retrieved and detected in the case of referring to the interface information of other programs from other executable files in the translation of a program language. <P>SOLUTION: At the initial reference of the interface information of another program, a repository analysis part 206 stores the interface information of the other program acquired from an executable file (DLL) 207 to be referred to in a local repository 208, and at the second reference of the interface information of the other program and after, the interface information of the other program is acquired from the local repository 208 to solve reference between programs. <P>COPYRIGHT: (C)2006,JPO&NCIPI

Description

  The present invention relates to a reference method for referring to another program in a software program of a computer.

  As a recent software, create a common software environment without being aware of the difference of operating systems, and also run in any language in the same execution environment under the Common Language Specification (Common Language Runtime) ) Technology has been introduced. With the common language runtime, it is possible to build software that is not language-aware. For example, in object-oriented programming, an instance object of a class generated in the COBOL language is inherited by an instance object of a class generated in the C # language, or a method of a C # language class is called from a COBOL language program. Is possible.

  When a source program is translated into an executable program that is an application for running on the common language runtime, each language translator is referenced if the source program references a class in another executable program. You must get information about classes in other executable programs.

  For example, in the .NET Framework, in order to obtain class information in another assembly (unit of an executable program included in a DLL file or EXE file in a Windows (registered trademark) system), from the binary format of the assembly, As information on a class to be externally referenced, metadata information including interface information such as a method name and an argument included in the class is acquired using an access function of the assembly (see, for example, Patent Document 1).

JP 2002-024032 A

  In the above prior art, when referring to a class included in a DLL that is another assembly on the source program, the class to be referred to is specified in the reference source class on the source program. The language compiler must find the specified class from the file names of multiple referenced DLLs specified on the command line. Procedure for loading all referenced DLLs specified on the command line and obtaining information using access functions for referring to manifests and metadata included in the DLL which is a kind of assembly from among them Search for each class one by one and find out.

  In the above case, while compiling the source program, as a problem when referring to a DLL that is another assembly, loading all the referenced DLLs and compressing the memory, and searching the DLL one by one It may take a search time to find a class to be referenced. The object of the present invention is to search for a class that has been referenced once in the second and subsequent searches with less memory and less search time, thereby shortening the compilation time during program development and improving the efficiency of program development. There is to make it.

  In order to achieve the above object, a local repository is introduced as a local external storage file managed locally. Here, the repository stores the interface information of a class, and provides the interface information of the class when the class information is referenced from another assembly. The local repository stores definition information of a class that has been referenced once, and performs name reference resolution using the local repository at the second and subsequent references.

  As described above, the interface information of the class referenced from the source program is acquired using the local repository, and all the DLLs that are considered to contain the referenced class are searched to find the referenced class, and the language translation. It is possible to reduce the processing time for developing the program on the memory so that the program can use the interface information of the class. In particular, the more assemblies (DLLs) that contain classes that are referenced from the source program, the referenced assemblies will not be changed, and the source program under development will be translated many times. The more effective it is. Improve language translation performance and improve program development efficiency.

  In addition, in the method of directly obtaining the interface information of the referenced class from another assembly (DLL), it is necessary to load all the assemblies considered to contain the referenced class into the memory, which consumes a lot of memory. Therefore, using a local repository is also effective from the viewpoint of reducing computer resources.

  An embodiment of the present invention will be described with reference to the drawings.

  FIG. 1 shows the basic configuration of the present invention. The computer 101 includes a CPU 102, a display 103, a keyboard 104, a secondary storage device 105, and a main storage device 106, and each component is connected by a bus 110. The secondary storage device 105 includes a source program 111 created by the user. The main storage device 106 translates an operating system 107, which is a basic program for operating a computer, an application program 109 operated by a user, and a source program 111, and an executable program (for execution on the operating system 107) ( It is composed of a language translation program 108 that creates an application program 109). Here, the operating system 107 also includes a common language-based program for operating an application program created from various language translation programs such as .NET Framework.

  FIG. 2 shows the configuration of the language translation program 108 using a local repository as an external storage. The language translation program 108 receives the source program 111 created by the user and outputs an assembly 109 that operates on the operating system 107. The assembly 109 is an execution unit that operates on the common language infrastructure, and indicates an executable program included in a DLL file or EXE file in the Windows (registered trademark) system.

  When the source program 111 is input, the language translation program 108 decomposes the lexical analyzer 201 into lexical phrases. The decomposed lexical phrase is converted into an intermediate language 203 expressed internally according to the syntax by the syntax analysis unit 202. The semantic analysis unit 204 expresses the intermediate language 203 in more detail, and the code generation unit 205 converts it into an assembly 109 that is an executable program.

  When the source program 111 refers to another assembly (DLL file) 207 such as calling a class library of the operating system 107, the language translation program 108 obtains interface information such as the called class and refers to the class. It is necessary to resolve the relationship. Therefore, in the syntax analysis unit 202, if the source program 111 refers to another assembly 207, interface information of another class referred to by the repository analysis unit 206 is acquired and analyzed, and passed to the syntax analysis unit 202. To resolve the class reference relationship. Here, in the common language infrastructure system such as .NET Framework, the assembly is used as a repository as it is.

  In the present invention, when a class included in the referenced assembly 207 is referred to, the interface information of the class is acquired as it is from the referenced assembly 207 for the first time. At that time, the repository analysis unit 206 stores the interface information in the local repository 208. If the same class is referenced in another part of the source program, or if the source program is translated again, the interface information of the class is not acquired from the referenced assembly 207 but stored locally. Obtain from the repository 208.

  FIG. 3 shows a configuration diagram of the local repository 208. The local repository 208 includes a local repository header 301 and a local repository main body 302. The header section 301 of the local repository includes a class name 303 to be referred to from the source program 111, a DLL name 304 including the referenced class, a DLL update date and time 305, and a local repository main body 302. Is composed of an index 306 to the interface information stored in. The local repository main unit 302 includes class interface information 307 for each class to be referenced. The class interface information 307 includes information on the method name of the method included in the class and the argument of the method. The class interface information 307 is associated with an index 306 to the interface information included in the header section 301 of the local repository.

  FIG. 4 shows an example of information stored in the local repository when referring to a class included in another assembly from the source program. In FIG. 4, it is assumed that one assembly 109 is generated from three source programs of the source program A (401), source program B (402), and source program C (403). In class A1 in source program A (401), assembly X. Reference is made to class X1 and class X2 included in dll (404). In class B1 in source program B (402), assembly X. class X1 and assembly Y. included in dll (404). Reference is made to class Y1 included in dll (405). In class C1 in the source program C (403), assembly X. Reference is made to class X3 included in dll (404). In that case, the interface information of class X1, class X2, class X3, and class Y1 is stored in the local repository 208. As the information of the class X1 in the header section 301 of the local repository, the class name “class X1”, the DLL name “X.dll” including the class X1 and the update date and time of the DLL “X.dll” “2004040110 08:04: 15 ”, since the interface information is stored at the head of the main body 302 of the local repository, the index“ 0 ”to the interface information is stored. Similarly, information on class X2, class X3, and class Y1 is stored in the header section 301 of the local repository. On the other hand, the interface information of class X1 is stored at the head (that is, index 0) as the information of class X1 in the main body 302 of the local repository. Similarly, interface information of class X2, class X3, and class Y1 is stored in order.

  In FIG. 5, a processing flow in which the repository analysis unit 206 refers to a class included in another assembly 207 using the local repository 208 will be described. First, the repository analysis unit 206 determines whether a class of another assembly (DLL) is referenced (501). If it is not referenced, exit without doing anything. If so, it is determined whether the referenced class is in the local repository (502). If it is in the local repository, it is determined whether the updated date / time 305 of the referenced class stored in the header section 301 of the local repository is newer than the current updated date / time of the DLL including the class (503). Here, the update date and time is for consistency with the interface information included in the current DLL, and may be version information or the like. If the determination in 503 is new, the interface information 307 of the referenced class is acquired from the index 306 to the interface information stored in the header section 301 of the local repository (504), and the information is passed to the syntax analysis unit 202. To finish. If there is no reference class in the local repository (502) that does not exist, the referenced assemblies (DLLs) are searched one by one (505) to find the class to be referenced. If the update date 305 of the referenced class is newer than the current update date of the DLL containing the class (503), if it is older, the DLL name stored in the header section 301 of the local repository. 304 is searched (506). At 505 and 506, it is determined whether an assembly (DLL) containing the referenced class has been found (507). If found, the information of the class to be referenced is registered in the local repository (508), and the process proceeds to the processing (504) for acquiring the interface information 307 of the referenced class. When the assembly (DLL) including the referenced class is not found in the determination (507), a search error is output (509), and the process is terminated.

It is a figure which shows the basic composition of this invention. It is a figure which shows the structure of the language translation program using a local repository. It is a figure which shows the structure of the local repository which stores the class once referred. It is a figure which shows the example of the information stored in a local repository, when referring to the class contained in another assembly (DLL) from a source program. It is a flowchart which shows the process which refers to the class contained in another assembly (DLL) using a local repository.

Explanation of symbols

  DESCRIPTION OF SYMBOLS 101 ... Computer, 102 ... CPU, 103 ... Display, 104 ... Keyboard, 105 ... Secondary storage device, 106 ... Main storage device, 107 ... Operating system, 108 ... Language translation program, 109 ... Application program (Assembly (executable program) )), 110 ... bus, 111 ... primitive program, 203 ... assembly (executable program), 201 ... lexical analysis unit, 202 ... syntax analysis unit, 203 ... intermediate language, 204 ... semantic analysis unit, 205 ... code generation unit, 206 ... Repository analysis unit, 207 ... Referenced assembly (DLL), 208 ... Local repository, 301 ... Local repository header, 302 ... Local repository body, 303 ... Referenced class name, 304 ... DLL name, 305 ... Update DLL Date, 306 ... index to interface information, 307 ... interface information classes (method name, method arguments information), 401 ... source program A, 402 ... source program B, 403 ... source program C, 404 ... assembly X. dll, 405, assembly Y. dll, 501... Judgment process of whether a class of another assembly (DLL) is referenced, 502... Judgment process of whether or not the referenced class exists in the local repository, 503. 504... Processing for acquiring interface information of a referenced class, 505... Searching for each referenced assembly (DLL), 506... Processing for searching for the DLL name stored in the header part of the local repository, 507... Processing for determining whether an assembly (DLL) including the referenced class is found, 508... Information on the class referenced by the local repository 509, processing for outputting a search error.

Claims (3)

  In the translation of a language that refers to the interface information of another program from the executable file, the step of holding the interface information of the other program referenced at the first reference in the external memory and the input from the external memory at the second or subsequent reference Another program reference solution comprising the step of resolving program interface information.   2. The method according to claim 1, wherein by comparing the update date / time of the interface information of the other program in the external storage with the update date / time of the executable file, the interface information of the other program in the external storage and the other program in the executable file To ensure consistency with other interface information. A recording medium device storing a program for realizing the functions according to claim 1, claim 2 and claim 3.

Images