Abstract:
A log acquisition method is provided that allows a processing log of software to readily be acquired and reduces the man-hours needed for analyzing a bug. The log acquisition method is a method for acquiring a runtime log of a program  91  including a function (FuncAA), comprising the step of changing the address of the function (FuncAA) loaded to the address of a function ( 92 ) for log acquisition and selecting the function (Func AA), wherein the function ( 92 ) for log acquisition comprises the steps of: calling the function (Func AA) ( 96 ) the log of which is to be acquired to cause a predetermined process to be executed ( 97 ), receiving the result of the execution ( 98 ), and passing said result to said program  91  ( 101 ), recording given information when calling the address of the selected function (Func AA) ( 95, 100 ), and recording given information when receiving the result of the execution of the selected function (Func AA) ( 99, 100 ).

Description:
FIELD OF THE INVENTION  
         [0001]    The present invention relates to a technology for acquiring processing logs for software consisting of a plurality of modules.  
         BACKGROUND OF THE INVENTION  
         [0002]    Software failure that does not repeatedly occur has been solved by acquiring and analyzing the processing log of the software to identify the cause of the failures.  
           [0003]    Processing log acquisition according to such prior-art methods has the following problems:  
           [0004]    (1) Software modules must be modified to add a routine for acquiring a process log. Accordingly, the workload for acquiring the process log is heavy.  
           [0005]    (2) Processing log acquisition is performed for each module and therefore logs are generated on a module-by-module basis. It is difficult to obtain a chronological log of entire software processing. Consequently, a large number of man-hours are required for analyzing a log to identify the cause of a failure because it does not provide a broad view of the entire processing.  
         SUMMARY OF THE INVENTION  
         [0006]    The present invention has been made to solve the problems described above. An object of the present invention is to provide a method that allows a log of a software program separated into modules to be readily obtained and reduces the number of man-hours needed to analyze the cause of software failure, a program for causing a computer to perform the method, and a storage medium containing the program.  
           [0007]    To achieve the object, the present invention provides a log acquisition method for acquiring a runtime log of a program including a function for performing a predetermined process, comprising the step of: changing the address of the function loaded for performing the predetermined process to the address of a function for log acquisition, wherein the function for log acquisition comprises the steps of: calling the function for performing the predetermined process to cause the predetermined process to be executed, receiving the result of the execution, and passing the result to the program; determining whether or not a pointer parameter is defined in a predetermined manner in a function definition in the program; and if the pointer parameter is defined in the predetermined manner, recording a memory content pointed to by the pointer parameter as a log according to the definition.  
           [0008]    To achieve the object described above, the present invention provides a log acquisition method for obtaining a runtime log of a program including a function for performing a predetermined process, comprising the steps of:  
           [0009]    changing the address of the function loaded for performing the predetermined process to the address of a function for log acquisition; and  
           [0010]    selecting the function for log acquisition; wherein the function for log acquisition comprises the steps of: calling the function for performing the predetermined process to cause the process to be executed, receiving the result of the execution, and passing the result to the program; recording given information as a log when calling the function selected in the selecting step; and recording given information as a log when receiving the result of execution of the function selected in the selecting step.  
           [0011]    Other features and advantages of the present invention will be apparent from the following description taken in conjunction with the accompanying drawings, in which like reference characters designate the same or similar parts throughout the figures thereof. 
       
    
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0012]    The accompanying drawings, which are incorporated in and constitute a part of the specification, illustrate embodiments of the invention and, together with the description, serve to explain the principles of the invention.  
         [0013]    [0013]FIG. 1 shows a configuration of a computer (software evaluation system) for implementing a method for acquiring logs according to a first embodiment;  
         [0014]    [0014]FIG. 2 shows an ordinary organization of memory in which functions are loaded according to the first embodiment;  
         [0015]    [0015]FIG. 3 shows an organization of the memory while using IAT Patch according to the first embodiment;  
         [0016]    [0016]FIG. 4A shows the process while using the IAT Patch according to the first embodiment;  
         [0017]    [0017]FIG. 4B shows a flowchart of a process for acquiring a log according to the first embodiment;  
         [0018]    [0018]FIG. 5 shows an internal configuration while using the IAT Patch according to the first embodiment;  
         [0019]    [0019]FIG. 6 shows an ordinary memory organization while an instance of COM server interface is generating according to the first embodiment;  
         [0020]    [0020]FIG. 7 shows a memory organization according to the first embodiment while using VTable Patch;  
         [0021]    [0021]FIG. 8A shows the process while using the VTable Patch according to the first embodiment;  
         [0022]    [0022]FIG. 8B shows a flowchart of a process for acquiring log according to the first embodiment;  
         [0023]    [0023]FIG. 9 shows an internal configuration of the software evaluation system according to the first embodiment;  
         [0024]    [0024]FIG. 10 shows an example of a function definition according to a second embodiment;  
         [0025]    [0025]FIG. 11 shows a description written in IDL for acquiring pointer parameter data entities as a log according to the second embodiment;  
         [0026]    [0026]FIG. 12 shows a flowchart of a process for acquiring a log according to the second embodiment;  
         [0027]    [0027]FIG. 13 shows log data obtained according to the second embodiment;  
         [0028]    [0028]FIG. 14 shows a description in function definition written in IDL for obtaining a function such as a callback function that are not exported according to a third embodiment;  
         [0029]    [0029]FIG. 15 shows a memory organization according to the third embodiment;  
         [0030]    [0030]FIG. 16 shows a flowchart of a process for acquiring a log according to the third embodiment;  
         [0031]    [0031]FIG. 17 shows log data obtained according to the third embodiment without the definition shown in FIG. 14;  
         [0032]    [0032]FIG. 18 shows log data obtained according to the third embodiment through the use of the definition shown in FIG. 14;  
         [0033]    [0033]FIG. 19 shows a description written in IDL for obtaining a variable length array parameter as a log in a function definition according to a fourth embodiment;  
         [0034]    [0034]FIG. 20 shows a flowchart of a process for acquiring a log according to the fourth embodiment with the function defined as shown in FIG. 19;  
         [0035]    [0035]FIG. 21 shows log data ( 250 ) obtained according to the fourth embodiment;  
         [0036]    [0036]FIG. 22 shows an example of the functions the parameters of which cannot be obtained with an ordinary function definition;  
         [0037]    [0037]FIG. 23 shows how structures use memory;  
         [0038]    [0038]FIG. 24 shows a description in IDL for acquiring a log of function parameters shown in FIG. 22 according to a fifth embodiment;  
         [0039]    [0039]FIG. 25 shows a flowchart of a process for acquiring a log according to the fifth embodiment;  
         [0040]    [0040]FIG. 26 shows details of structure parameter analysis which are depicted according to memory location;  
         [0041]    [0041]FIG. 27 shows log data obtained according to the fifth embodiment;  
         [0042]    [0042]FIG. 28 shows an example of the functions the parameters of which cannot be obtained with an ordinary function definition according to a sixth embodiment;  
         [0043]    [0043]FIG. 29 shows how structures are located in memory;  
         [0044]    [0044]FIG. 30 shows a description in IDL for acquiring a log of the function parameters shown in FIG. 28 according to the sixth embodiment;  
         [0045]    [0045]FIG. 31 shows a flowchart of a process for acquiring a log according to the sixth embodiment;  
         [0046]    [0046]FIG. 32 shows log data obtained with the definition shown in FIG. 30 according to the sixth embodiment;  
         [0047]    [0047]FIG. 33 shows a user interface for setting a function/method initiating a log acquisition process according to a seventh embodiment;  
         [0048]    [0048]FIG. 34 shows a flowchart of a process for acquiring a log according to the seventh embodiment;  
         [0049]    [0049]FIG. 35 shows a user interface for setting a function/method stopping log acquisition according to an eighth embodiment;  
         [0050]    [0050]FIG. 36 shows a flowchart of a process for obtaining a log according to the eighth embodiment;  
         [0051]    [0051]FIG. 37 shows a user interface to which a setting is added for using a trigger function in the event of abnormal end according to a ninth embodiment;  
         [0052]    [0052]FIG. 38 shows error definitions for functions/methods according to the ninth embodiment;  
         [0053]    [0053]FIG. 39 shows a flowchart of a process for obtaining a log according to the ninth embodiment;  
         [0054]    [0054]FIG. 40 is a flowchart showing details of the ordinary log acquisition process according to the ninth embodiment;  
         [0055]    [0055]FIG. 41 shows a flowchart of a process for obtaining a log according to the ninth embodiment;  
         [0056]    [0056]FIG. 42 shows a user interface displaying a tree view of interfaces and methods according to a tenth embodiment;  
         [0057]    [0057]FIG. 43 shows a flowchart of a process for acquiring a log according to the tenth embodiment;  
         [0058]    [0058]FIG. 44 shows a user interface displaying a tree view of interfaces and methods according to an eleventh embodiment;  
         [0059]    [0059]FIG. 45 shows a flowchart of a process for acquiring a log according to the eleventh embodiment;  
         [0060]    [0060]FIG. 46 shows a flowchart of a process for dividing and storing a log on a date-by-date basis according to a twelfth embodiment;  
         [0061]    [0061]FIG. 47 shows a flowchart of a process for dividing and storing a log according to the size or number of log files according to a thirteenth embodiment;  
         [0062]    [0062]FIG. 48 schematically shows memory storing a predetermined number of logs from among the logs obtained in according to a fourteenth embodiment; and  
         [0063]    [0063]FIG. 49 shows a flowchart of a process for acquiring the predetermined number of logs from among the logs obtained according to the fourteenth embodiment. 
     
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS  
       [0064]    Preferred embodiments of the present invention will now be described in detail in accordance with the accompanying drawings.  
         [0065]    [First Embodiment] 
         [0066]    In a first embodiment, an import function or virtual address table contained in memory, which is an arrangement for calling a function in a module from another module, is used to hook and log function calls between modules, thereby enabling a chronological log of an entire software program to be acquired without any modifications to the software modules. The first embodiment will be described below in detail.  
         [0067]    System Configuration  
         [0068]    [0068]FIG. 1 shows a configuration of a computer (software evaluation system) performing a log acquisition method according to embodiments of the present invention. For simplicity, it is assumed herein that the software evaluation system is built within a single personal computer. However, the features of the log acquisition method of the present invention is effective whether the system is built in a single PC or a plurality of PCs as a network system.  
         [0069]    The computer in which the software evaluation system is provided comprises a CPU  1 , a chip set  2 , a RAM  3 , a hard disk controller  4 , a display controller  5 , a hard disk drive  6 , a CD-ROM drive  7 , and a display  8 . It also comprises a signal line  11  connecting the CPU  1  with the chip set  2 , a signal line  12  connecting the chip set  2  with the RAM  3 , a peripheral bus  13  connecting the chip set  2  with peripheral devices, a signal line  14  connecting the hard disk controller  4  with the hard disk drive  6 , a signal line  15  connecting the hard disk controller  4  with the CD-ROM drive  7 , and a signal line  16  connecting the display controller  5  with the display  8 .  
         [0070]    Acquisition of Log Concerning Function Process  
         [0071]    In order to facilitate the understanding of the software evaluation system that implements the log acquisition method according to the first embodiment of the present invention, how a software program separated into a plurality of modules is ordinarily loaded in a memory will first be described with reference to FIG. 2.  
         [0072]    A software program consisting of modules in general is separated into a set of executable files EXE ( 23 ) and a set of dynamic link libraries DLL ( 27 ) existing as modules and serving as a complement to the EXE. The EXE consists of a code segment ( 28 ), a data segment ( 29 ), and an import function address table ( 22 ). The import function table is further divided into DLLs ( 21 ,  24 ) to which functions belong. Each DLL contains addresses ( 30  to  35 ) at which each function is loaded. The contents of the functions of each DLL are separately loaded ( 25 ,  26 ) and each function ( 36  to  41 ) is loaded as part of the associated DLL. FIG. 2 shows an example in which one EXE uses the functions in two dynamic link libraries, A.DLL and B.DLL. Six functions, Func AA, Func AB, Func AC, Func BA, Func BB, and Func BC are used.  
         [0073]    When a code in a code segment of the EXE calls function Func AA, the address ( 30 ) of Func AA written in the import function address table is first read. In effect, the address of AA code ( 36 ) read as part of A.DLL is written here. The code of the EXE can call Func AA of A.DLL by calling the address of the AA code ( 36 ).  
         [0074]    [0074]FIG. 3 shows an organization of the memory according to the first embodiment. This organization differs from the one shown in FIG. 2 in that a technology called IAT Patch (Import Address Table Patch) is used with log acquisition codes to redirect function calls.  
         [0075]    When log acquisition is initiated, C.DLL ( 58 ), which is a DLL for the IAT Patch is loaded in the memory. C.DLL changes the addresses of functions written in the import function address table ( 52 ) to the addresses ( 61  to  66 ) of log acquisition codes, Func CAA, Func CAB, Func CAC, Func CBA, Func CBB, and Func CBC, in C.DLL. The codes Func CAA, Func CAB, Func CAC, Func CBA, Func CBB, and Func CBC in C.DLL ( 73  to  78 ) perform logging and calls the corresponding functions, Func AA, Func AB, Func AC, Func BA, Func BB, and Func BC ( 67  to  72 ) loaded in the memory for responding to the function calls.  
         [0076]    [0076]FIG. 4A shows an IAT Patch process performed in the example shown in FIG. 3. FIG. 4B is a flowchart of a log acquisition process. For simplicity, the figures show how the log acquisition code works with IAT Patch when the EXE calls Func AA in A.DLL.  
         [0077]    When the EXE ( 91 ) calls Func AA ( 94 ), the log acquisition code in C.DLL stores the DLL name/function name (step S 402 ), the call time, and parameter used in the call in the memory and stores the memory content pointed to by a pointer parameter used in the call in another memory ( 95  and step S 403 ). C.DLL then calls Func AA in A.DLL ( 93 ), which is intended to be called ( 96  and step S 404 ). When the Func AA process ( 96 ) in A.DLL ends and control is returned to C.DLL ( 98 ), C.DLL stores the return time and return value in memory and stores the memory content pointed to by the pointer parameter in the return in another memory. Then C.DLL writes the log information it has stored into a file ( 100  and step S 405 ). The control then returns to the EXE as if Func AA in A.DLL was completed in a conventional way ( 101 ).  
         [0078]    [0078]FIG. 5 shows an internal configuration of the software evaluation system that implements the log acquisition method according to the first embodiment. Conventionally, an executable EXE ( 113 ) calls a function in DLL-1 ( 116 ) or DLL-2 ( 117 ). In this method, in contrast, a log acquisition code called an API tracer ( 114 ) is embedded to generate a processing log ( 115 ). The API tracer ( 114 ) operates according to a file ( 111 ) that describes definitions of functions in DLL-1 or DLL-2 and a setting scenario (trace scenario) that specifies which function in which DLL in an import function table should be rewritten to obtain a log.  
         [0079]    Acquisition of Log Concerning Method Process  
         [0080]    Described below is how an executable file EXE ( 113 ) is loaded in a memory in the software evaluation system implementing the log acquisition method according to the first embodiment when an instance of an interface exported in a COM (Component Object Model) server. In order to explain this, how it is ordinarily loaded will first be described in FIG. 6.  
         [0081]    When an instance of an interface is generated, the requested interface ( 121 ,  122 ) and its methods ( 130  to  135 , programs describing procedures to be performed by objects in object-oriented programming) are ordinarily generated in the COM server. Both of them are loaded in a memory. A virtual address table ( 118 ,  120 ) is generated for each interface generated and provided to the EXE that has issued the request for generation of the instance. The generated addresses ( 124  to  129 ) of methods are contained in the virtual address table. The EXE uses this information to issues a call to each interface. Shown in FIG. 6 is an example in which the EXE ( 119 ) generates instances of two interfaces, Interface A ( 121 ) and Interface B ( 122 ), and uses methods in these interface. Specifically, Method AA, Method AB, Method AC, Method BA, Method BB, and Method BC ( 130  to  135 ) are used.  
         [0082]    When a code of the EXE calls Method AA, the address ( 124 ) of Method AA is first read from the virtual address table. Actually written in the virtual address table is the address of the Method AA code ( 130 ) generated as part Interface A in the COM server. The EXE code can call Method AA of Interface A by calling that address.  
         [0083]    [0083]FIG. 7 shows an organization of the memory of the software evaluation system according to the first embodiment. This organization differs from the one shown in FIG. 6 in that a technique called VTable Patch (virtual address table patch) is used with a log acquisition code to redirect a method call.  
         [0084]    When log acquisition is initiated, a DLL ( 143 ) for VTable Patch is loaded in the memory. The DLL changes the addresses of the methods contained in the virtual address table ( 136 ,  138 ) to the addresses ( 145  to  150 ) of Method A′A, Method A′B, Method A′C, Method B′A, Method B′B, and Method B′C that are log acquisition codes in DLL. The codes Method A′A, Method A′B, Method A′C, Method B′A, Method B′B, and Method B′C ( 157  to  162 ) in the DLL ( 143 ) perform logging and call the corresponding methods, Method AA, Method AB, Method AC, Method BA, Method BB, and Method BC ( 157  to  162 ).  
         [0085]    [0085]FIG. 8A shows a flowchart of a process of VTable Patch in FIG. 7. FIG. 8B shows a flowchart of a log acquisition process. For simplicity, the figures show how the log acquisition code works with VTable Patch when the EXE calls Method AA in Interface A in the COM server.  
         [0086]    When the EXE ( 163 ) calls Method AA ( 166 ), a log acquisition code in the DLL ( 164 ) stores the module name/interface name/method name in the DLL (step S 1802 ), the call time, parameters used in the call in memory and stores the memory content pointed to by a pointer parameter in another memory ( 167  and step S 803 ). The DLL ( 164 ) then calls Method AA in the COM server ( 165 ) which is intended to be called ( 168  and step S 804 ). When Method process AA ( 169 ) in COM server ( 165 ) comes to an end and control returns to the DLL ( 170 ), the DLL ( 164 ) stores the return time and return value in the memory and the memory content pointed to by the pointer parameter at the return time in another memory ( 171 ). The DLL then write the log information it stored in a file ( 172  and step S 805 ) and returns the control to the EXE ( 163 ) as if Method AA in the COM server ( 165 ) ended in a conventional way ( 171 ).  
         [0087]    [0087]FIG. 9 shows an internal configuration of the software evaluation system according to the first embodiment. Conventionally, an executable EXE ( 176 ) calls a method in the COM server 1 ( 179 ) or COM server 2 ( 180 ). In this method, in contrast, a log acquisition code called an API tracer ( 177 ) is embedded to generate a processing log ( 178 ). The API tracer ( 177 ) operates according to a file ( 174 ) that describes definitions of functions in the COM server 1 ( 179 ) or COM server 2 ( 180 ) and a setting scenario ( 175 ) that specifies which method in which interface in which COM server in a virtual address table should be rewritten to obtain a log.  
         [0088]    As can be seen from the foregoing description, the log acquisition method according to the present embodiment for acquiring processing logs of software separated into a plurality of modules enables a function/method call provided in a module to be logged without modifying the module itself, thereby reducing workload for obtaining the processing logs. Furthermore, logs generated can be acquired as chronological logs, facilitating analysis of the logs and consequently reducing the number of man-hours needed for identifying the cause of software failure.  
         [0089]    [Second Embodiment] 
         [0090]    A second embodiment of the present invention will be described below in which pointer parameter data in binary that cannot be acquired with conventional method.  
         [0091]    [0091]FIG. 10 shows an example of function definitions in a software evaluation system according to the second embodiment. The definitions are written in widely used IDL. A type library file that is tokenized IDL is used as a function definition file in the software evaluation system implementing the log acquisition method according to the second embodiment.  
         [0092]    [0092]FIG. 11 shows description written in IDL for acquiring pointer parameter data in a log form by specifying binary acquisition in pointer parameters in function definitions according to the present embodiment.  
         [0093]    In the definition of the function FuncBinidIs, custom (PAT_PARAM_ATTR_ID, “binid_is( )”) is declared for long*lplparam ( 201 ), where PAT_PARAM_ATTR_ID ( 200 ) is an identifier used in IDL by the software evaluation system. The definition of “binid_is( )” stores data of a size equal to the size of a data type (long type in this example) of this parameter on the basis of a pointer pointed to by this parameter in a log as binary data.  
         [0094]    In the definition of the function FuncSizeIs, custom (PAT_PARAM_ATTR_ID, “size_is(dwCount)”) is declared for int*lplparam ( 202 ). The definition “size_is(dwCount)” specifies that the data size of this parameter is dwcount, which is its first parameter. “dwCount×the size of parameter data type (int type in this example)” of data are stored in the log as binary data from the pointer pointed to by this parameter.  
         [0095]    In the definition of the function FuncLengthIs, custom (PAT_PARAM_ATTR_ID, “length_is(dwLength)”) is declared for char*lpszparam ( 203 ). The definition “length_is(dwLength)” specifies that this parameter should have data of size dwLength, which is its first parameter. “dwLength×the size of parameter data type (char in this example)” of data is stored as binary data in the log from the pointer pointed to by this parameter.  
         [0096]    In the definition of the function FuncBytesIs, custom (PAT_PARAM_ATTR_ID, “bytes_is(dwSize)”) is declared for void*lpparam ( 204 ). The definition “bytes_is(dwSize)” specifies that the data size of this parameter is dwSize, which is the first parameter, in bytes. The dwSize bytes of data are stored as binary data in the log from pointer pointed to by this parameter.  
         [0097]    In the definition of the function FuncBytesIs2, custom (PAT_PARAM_ATTR_ID, “bytes_is(12)”) is declared for void*lpparam ( 205 ). The definition “bytes_is(12)” specifies that this parameter should have data of 12 bytes specified. Twelve bytes of data are stored in the log as binary data from the pointer pointed to by this parameter.  
         [0098]    [0098]FIG. 12 shows a flowchart of a process for acquiring a log in the software evaluation system according to the second embodiment when the functions are defined as shown in FIG. 11.  
         [0099]    When the process starts (step S 1201 ), log acquisition is initiated and the module name, interface name, function/method name are stored in the HDD (step S 1202 ). Then the call time, a parameter, and, memory content pointed to by a pointer parameter are stored in the HDD (step S 1203 ). It is determined whether or not binary acquisition is specified in the function definitions (step S 1204 ) and, if so, the memory size required for storing the data is calculated for each of the definitions (binid_is, size_is, length_is, and bytes_is) (step S 1205 ) and the calculated size of the data in the memory pointed to by the pointer parameter is stored in the HDD (step S 1206 ). Then the original function is called (step S 1207 ). After returning from the function, the log acquisition code stores the return time, return value, and the content in memory pointed to by the pointer parameter in the HDD (step S 1208 ). Then it determines whether binary acquisition is specified in the function (step S 1209 ) and, if so, calculates the memory size required for storing the data for each of the definitions (binid_is, size_is, length_is, and bytes_is) (step S 1210 ) and stores the calculated size of the data in the memory pointed to by the pointer parameter in the HDD. Then the original function is called (step S 1211 ). This process will end when an end command is provided by the user (step S 1212 ).  
         [0100]    [0100]FIG. 13 shows log data acquired in accordance with the definitions in FIG. 11 in the software evaluation system according to the second embodiment.  
         [0101]    A log ( 210 ) excluding Data ID can be acquired when no binary acquisition is specified in function definitions. If binary acquisition is specified, DataId and binary data log ( 211 ) can be obtained. Compared with the log of FuncSizeIs acquired with specification of binary acquisition, the log of FuncSizeIs acquired without specification of binary acquisition provides only one piece of int-type data pointed to by the pointer parameter IpParam. However, the data actually points to 10 pieces of int-type data. Thus, 4 bytes (int-type data size)×10=40 bytes in total can be acquired when binary acquisition is set.  
         [0102]    As can be seen from the forgoing description, the pointer parameter data that cannot otherwise be acquired can be acquired in binary in a logged manner by associating sizes with the pointer parameters according to the second embodiment.  
         [0103]    [Third Embodiment] 
         [0104]    A third embodiment will be described in which an unexported function such as a callback function is obtained as a log.  
         [0105]    [0105]FIG. 14 shows a description in IDL for acquiring functions such as a callback function that are not exported in function definitions according to the third embodiment.  
         [0106]    In the definition of the function SetCallBack, custom (PAT_PARAM_ATTR_ID, “funcname_is(FuncCallBack)”) is declared for DWORD pfnFuncCallBack ( 221 ). The function SetCallBack sets a callback function for a module. DWORD pfnFuncCallBAck is a parameter for setting the address of that callback function. The definition “funcname_is(FuncCallBack)” causes the log acquisition process to recognize a value provided to this parameter as the address of the FuncCallBack function ( 222 ) and replace it with an address for acquiring the log. The original value is stored for the purpose of calling the original callback function during the acquisition of the log. This allows the log of the unexported callback function to be acquired.  
         [0107]    In the definition of the function GetFuncPointer, custom (PAT_PARAM_ATTR_ID, “funcname_is(FuncInternal”) is declared for DWORD pfnFuncInternal ( 223 ). The function GetFuncPointer is a function for acquiring the pointer of a function in a module that has not been exported. DWORD pfnFuncInternal is a parameter for acquiring the pointer of an unexported function. The definition “funcname_is(FuncInternal)” causes the log acquisition process to recognize a value provided to this parameter as the address of the function FuncInternal ( 224 ) and replace it with an address for acquiring the log. The original value is stored for the purpose of calling the original callback function during the acquisition of the log. This allows the log of the function in the module that has not been exported to be acquired.  
         [0108]    The function GetFuncPointeArray ( 225 ) is a function for acquiring the address of an array of functions in the module that have not been exported and placing them in the structure FUNCPOINTERARRAY ( 220 ). Here, custom(PAT_PARAM_ATTR_ID, “funcInternal_is(FuncInternal 1-4)”) is declared for the definition of each member of the FUNCPOINTERARRAY. The definition “funcname_is(FuncInternal 1-4)”) causes the log acquisition process to recognize a value provided to the members of the structure as the address of the functions FuncInternal 1-4 ( 226 ) and replace it with an address for acquiring the log. The original value is stored for the purpose of calling the original, unexported function during the acquisition of the log. This allows the log of the unexported function in the module to be acquired.  
         [0109]    [0109]FIG. 15 shows a memory organization in the software evaluation system according to the third embodiment. This organization differs from the one shown in FIG. 3 in that codes for acquiring the log of hidden functions are added. FuncAD ( 231 ) in A.DLL is a function that has not been exported and therefore is not contained in the Import Address Table ( 230 ). If funcname_is is defined for FuncAD, FuncCAD ( 232 ) is generated in C.DLL for acquiring the log and the address of FuncCAD is used for replacing a parameter value defined in funcname_is, which returns the address of FuncAD.  
         [0110]    [0110]FIG. 16 shows a flowchart of a process for acquiring a log in the software evaluation system according to the third embodiment when the functions are defined as shown in FIG. 14.  
         [0111]    When the process starts (step S 1601 ), the log acquisition is initiated and the module name, interface name, function/method name are stored in the HDD (step S 1602 ). Then the call time, a parameter, and contents pointed to by the pointer parameter are stored in the HDD (step S 1603 ). It is determined whether or not funcname_is is specified in the function definitions (step S 1604 ) and, if so, the function definition defined in funcname_is is obtained form a function definition file and a code for log acquisition is generated according to that definition (step S 1605 ). Then the value defined in funcname_is is stored and replaced with the address of the log acquisition code generated (step S 1606 ).  
         [0112]    The original function is then called (step S 1607 ). After returning from the function, the log acquisition code stores the return time, return value, and the content in memory pointed to by the pointer parameter in the HDD (step S 1608 ). Then it determines whether binary acquisition is specified in the function (step S 1609 ) and, if so, obtains the definition of the function defined in funcname_is from a function definition file and generates a code for log acquisition according to the definition (step S 1610 ). Then it stores the value defined in funcname_is and replaces it with the address of the log acquisition code generated (step S 1611 ). This process will end when an end command is issued by the user (step S 1612 ).  
         [0113]    Once the parameter set in funcname_is has been replaced with the address of the log acquisition code generated, the original function called by using that address is treated in a similar manner in which an ordinary log is treated (that is, the generated log acquisition code calls an unexported function, causes it to be executed, receives the result of execution, passes the result to the original function, and logs information concerning the call to the unexported function and information concerning the reception of the results of the execution).  
         [0114]    [0114]FIG. 17 shows log data acquired in the software evaluation system according to the third embodiment when the definitions shown in FIG. 14 are not provided. No log of unexported internal functions can be acquired if log acquisition for them is not set in a function definition file.  
         [0115]    [0115]FIG. 18 shows log data acquired from the definitions shown in FIG. 14 in the software evaluation system according to the third embodiment. The logs of unexported functions, such as SetCallBack, FuncInternal, and FuncInternal4 can be acquired because settings for acquiring the callback functions and unexported internal functions are provided in a function definition file.  
         [0116]    Thus, the third embodiment has the advantage that the logs of unexported functions which cannot otherwise be acquired can be acquired.  
         [0117]    [Fourth Embodiment] 
         [0118]    A fourth embodiment will be described in which a log of a variable-length array parameter, which cannot be acquired with conventional methods, is obtained.  
         [0119]    [0119]FIG. 19 shows a description in IDL for acquiring a log of a variable-length array parameter according to the fourth embodiment.  
         [0120]    In the definition of the function FuncArrayIs, custom(PAT_PARAM_ATTR_ID, “array_is(dwCount)”) is declared for int*lpnparam ( 240 ). The definition “array_is(dwCount)” specifies that this pointer parameter is an int-type array and the number of elements of the array is equal to dwCount, which is the first parameter. The pointer pointed to by this pointer parameter is treated as an array of dwCount number of int-type data elements and the data is stored in the log.  
         [0121]    [0121]FIG. 20 shows a flowchart of a process for acquiring a log in the software evaluation system when a function is defined as shown in FIG. 19.  
         [0122]    When the process starts (step S 2001 ), the log acquisition is initiated and the module name, interface name, function/method name are stored in the HDD (step S 2002 ). Then it is determined whether or not variable-length array acquisition (array_is) is set in the function definitions (step S 2003 ). If so, the parameter defined by the pointer parameter is treated as definition of an array (step S 2004 ) and the call time, parameter, and the content pointed to by the pointer parameter are stored in the HDD (step S 2005 ). Then the original function is called (step S 2006 ). After returning from the function, the log acquisition code determines whether or not variable-length array acquisition (array_is) is set in the function definitions (step S 2007 ) and if so, the parameter defined by the pointer parameter is treated as definition of an array (step S 2008 ) and the return time, the return value, and the memory content pointed to by the pointer parameter in the HDD (step S 2009 ). The process will end when an end command is provided by the user (step S 2010 ).  
         [0123]    [0123]FIG. 21 shows log data ( 250 ) acquired without the definition shown in FIG. 19 and log data ( 251 ) acquired with the definitions shown in FIG. 19 in the software evaluation system according to the fourth embodiment. When the definitions are not made in the function definition file, only the first data for each parameter is acquired in log data ( 250 ) because pointer parameters cannot be treated as an array. In contrast, when the definitions are not made in the function definition file, the pointer parameters are treated as arrays and therefore all data in the arrays are obtained in log data ( 251 ).  
         [0124]    In this way, the fourth embodiment provides the advantage that a log of variable-length parameters, which is a function log that cannot be obtained with conventional methods.  
         [0125]    [Fifth Embodiment] 
         [0126]    A fifth embodiment will be described in which a log of a function that cannot be acquired with conventional methods, is acquired.  
         [0127]    [0127]FIG. 22 shows an example of a function which is used in the software evaluation system according to the fifth embodiment and for which parameters cannot be obtained with conventional function definitions.  
         [0128]    Three structures, STRUCTSIZE1, STRUCTSIZE2, and STRUCTSIZE3, are defined. The DWORD dwSize member of each structure should contain the size of that structure. The first parameter dwKind of the FuncGetData function should indicate the pointer of one of the three structures that is passed to the second parameter lpBuf. The FuncGetData function treats lpBuf as the pointer to STRUCTSIZE1 if the first parameter is 1, or as the pointer to STRUCTSIZE2 if the first parameter is 2, or as the pointer to STRUICTSIZE3 if the first parameter is 3. If the FuncGetData were defined with a conventional function definition, lpBuf would be a void-type pointer and consequently no data can be obtained.  
         [0129]    [0129]FIG. 23 shows how memory is used by each of the structures STRUCTSIZE1, STRUCTSIZE2, and STRUCTSIZE3 in FIG. 22. The STRUCTSIZE 1 ( 260 ) has a member DWORD dwSize ( 261 ) at offset 0×000, DWORD dwParam1 ( 262 ) at 0×0004, DWORD dwParam2 ( 263 ) at 0×0008, and DWORD dwParam3 ( 264 ) at 0×000C. The structure STRUCTSIZE 2 ( 265 ) has DWORD dwSize and DWORD dwParam1-DWORD dwParam3 ( 266 - 269 ) at the same offsets as those for the members of STRUCTSIZE1 and, in addition, DWORD dwParam4 ( 270 ) at 0×0010. STRUCTSIZE3 ( 271 ) has DWORD dwSize and DWORD dwParam1-DWORD dwParam4 ( 272 - 276 ) at the same offsets as the members of STRUCSIZE2 and, in addition, DWORD dwParam5 ( 277 ) at 0×0014. As just described, the memory locations of the dwSize-dwParam4 of STRUCTSIZE3 are the same as those of STRUCTSIZE2 and the memory locations of the dwSize-dwParam3 are the same as those of STRUCTSIZE1.  
         [0130]    [0130]FIG. 24 shows a description in IDL for acquiring a log of parameters of the function as shown in FIG. 22 in the software evaluation system according to the fifth embodiment.  
         [0131]    The separate structures STRUCTSIZE1, STRUCTSIZE2, and STRUCTSIZE 3 in the original function are defined as a single structure ( 291 ). The definition is the same as that of STRUCSIZE3 because STRUCTSIZE3 has the memory locations that overlap the memory locations of STRUCTSIZE1 and STRUCTSIZE2. [custom (PAT_PARAM_ID, “structsize_is( )”) is set for the DWORD dwSize member of the this structure, which indicates the size of the structure ( 290 ). This allows the log acquisition process to obtain the size of the structure during data analysis of the structure. The second parameter lpBuf in the FuncGetData function is defined as the STRUCTSIZE type ( 292 ). This causes the parameter is treated as the STRUCTSIZE type when it is stored as a log. If this technique were not used and a description were provided in a function definition file in such a manner as to obtain data on STRUCTSIZE3, a call to GetFuncData with dwKind=1 or 2 would cause an memory exception because data on STRUCTURESIZE1 or STRUCTSIZE2 exists and a log acquisition process would attempt to acquire the log of dwParam3 or dwParam4 data.  
         [0132]    [0132]FIG. 25 shows a flowchart of a process for acquiring a log in the software evaluation system according to the fifth embodiment when the function are defined as shown in FIG. 24.  
         [0133]    When the process starts (step S 2501 ), log acquisition is initiated and the module name, interface name, function/method names are stored in the HDD (step S 2502 ). Then it is determined whether or not the size of the structure (structsize_is) of the structure is specified in the function definitions (step S 2503 ). If so, set structure parameter data of the size defined in the size specification (structsize_is) is analyzed (step S 2504 ). Then, the call time, parameter, and memory content pointed to by a pointer parameter are stored in the HDD (step S 2505 ). Then the original function is called (step S 2506 ). After returning from the function, the process determines whether or not the size of the structure (structsize_is) of the structure is specified in the function definitions (step S 2507 ) and if so, the set structure parameter data of the size defined in the size specification (structsize_is) is analyzed (step S 2508 ). Then the return time, return value, and the memory content pointed by the pointer parameter are stored in the HDD (step S 2509 ). The process will end when an end command is provided by the user (step S 2510 ).  
         [0134]    [0134]FIG. 26 shows details of the structure parameter analysis performed in FIG. 25, on the basis of the memory locations.  
         [0135]    When GetFuncData is used in an actual program with dwKind=1, the STRUCTSIZE1 structure ( 300 ) is used and the members ( 301 - 304 ) use memory as shown in FIG. 25. If the function definition shown in FIG. 24 has been provided, it is recognized as the STRUCTSIZE structure ( 305 ) in the software evaluation system and the members ( 306 - 311 ) may use memory as shown. If size specification (structsize_is) is set, the value of dwSize can be checked to know that the size of the structure is dwSize bytes and the dwsize bytes of data ( 302 ) is obtained as a log from STRUCTSIZE structure.  
         [0136]    [0136]FIG. 27 shows log data obtained through the user of the definitions shown in FIG. 24 in the software evaluation system according to the fifth embodiment. Data on the structures that would be void* and only pointers would be able to be acquired with an ordinary function definition can be acquired as logs according to the types of the structures used.  
         [0137]    Thus, the fifth embodiment has the advantage that a log of parameters that cannot be acquired with conventional methods can be acquired.  
         [0138]    [Sixth Embodiment] 
         [0139]    [0139]FIG. 28 shows an example of the functions that are used in the software evaluation system according to a sixth embodiment and of which parameters cannot be obtained with a conventional function definition.  
         [0140]    Three structures STRUCTKIND1, STRUCTKIND2, and STRUCTKIND3 are defined. The first parameter dwKind of the FuncGetData function should indicates the pointer of one of the three structures that is passed to the second parameter lpBuf. The FuncGetData function treats lpBuf as the pointer to STRUCTKIND1 if the first parameter is 1, or as the pointer to STRUCTKIND2 if the first parameter is 2, or as the pointer to STRUICTKIND3 if the first parameter is 3. If the FuncGetData were defined with a conventional function definition, lpBuf would be a void-type pointer and consequently no data can be obtained.  
         [0141]    [0141]FIG. 29 shows how memory is used by each of the structures STRUCTKIND1, STRUCTKIND2, and STRUCTKIND3. The STRUCTKIND1 ( 330 ) has a member char chParam ( 331 ) at offset 0×0000, DWORD dwParam ( 332 ) at 0×0001, and short shParam ( 333 ) at 0×0005. The structure STRUCTKIND2 ( 334 ) has a member short shParam ( 335 ) at offset 0×000, DWORD dwParam ( 336 ) at 0×0002, and char chParam ( 337 ) at 0×0006. The structure STRUCTKIND3 ( 338 ) has a member char chParam ( 339 ) at 0×0000, short shParam ( 340 ) at 0×0001, DWORD dwParam ( 341 ) at 0×0003, long lParam ( 342 ) at 0×0007, and int nParam at 0×000B. The structures include no size information and memory organizations for structure data differs from one structure to another. Therefore, the method described with respect to the fifth embodiment cannot be used.  
         [0142]    [0142]FIG. 30 shows a description in IDL for acquiring a log of the parameters of the function shown in FIG. 28 in the software evaluation system according to the sixth embodiment.  
         [0143]    The structures are defined with a conventional method. [custum(PAT_PARAM_ID, “structkind_is(dwKind:1:STRUCTKIND1*, 2:STRUCTKIND2*, 3:STRUCTKIND3*)”)] is set for the second parameter void*lpBuf of the FuncGetData function. This causes the lpBuf to be treated as the STRUCTKIND1* data type if the value of the first parameter dwKind is 1, or as STRUCTKIND2* if the value is 2, or as STRUCTKIND3* if the value is 3 and stored as a log.  
         [0144]    [0144]FIG. 31 shows a flowchart of a process for acquiring a log in the software evaluation system according to the sixth embodiment when the function is defined as shown in FIG. 30.  
         [0145]    When the process starts (step S 3101 ), log acquisition is initiated and the module name, interface name, function/method names are stored in memory (step S 3102 ). Then it is determined whether or not structure type specification (structkind_is) is set in the function definition (step S 3103 ). If it is set, the set structure parameter data is analyzed as the data type defined in the type specification (structkind_is) (step S 3104 ). Then the call time, parameter, and memory content pointed to by a pointer parameter are stored in the memory (step S 3105 ). Then the original function is called (step S 3106 ). After returning from the function, the process determines whether or not structure type specification (structkind_is) is set in the function definition (step S 3107 ). If it is set, the set structure parameter data is analyzed as the data type defined in the type specification (structkind_is) (step S 3108 ). Then the return time, return value, and the memory content pointed to by the pointer parameter is stored in the memory (step S 3109 ). The process will end when an end command is provided by the user (step S 3110 ).  
         [0146]    [0146]FIG. 32 shows log data acquired with the definitions shown in FIG. 30 according to the sixth embodiment. Data on the structures that would be void* and only pointers would be able to be acquired with an ordinary function definition can be acquired as logs according to the types of the structures used.  
         [0147]    Thus, the sixth embodiment provides the advantage that a log of parameters that cannot be acquired with conventional method can be acquired.  
         [0148]    [Seventh Embodiment] 
         [0149]    A user interface for making settings for log acquisition and a process performed according to information set through the user interface in a seventh embodiment. FIG. 33 shows a user interface setting functions/methods for initiating log acquisition according to the seventh embodiment.  
         [0150]    The user interface includes a dropdown list ( 352 ,  353 ) of modules/interfaces ( 350 ) from which a user can select a module/interface the log of which is to be acquired and a dropdown list ( 354 ,  355 ) of functions/methods ( 351 ) exported in the selected module/interface, from which the user can select a function/method to be set as a log acquisition trigger.  
         [0151]    [0151]FIG. 34 shows a flowchart of a process for acquiring a log according to settings in the interface shown in FIG. 33 in the software evaluation system according to the seventh embodiment.  
         [0152]    When the process is started (step S 3401 ), the log acquisition code determines whether or not a called function/method is set as a log acquisition trigger (step S 3402 ). If it matches the log acquisition trigger, the code starts log acquisition and stores the module name, interface name, function/method name in the HDD (step S 3403 ). Then the log acquisition code stores the call time, parameter, and the memory content pointed by a pointer parameter in the HDD (step S 3404 ) and calls the original function/method (step S 3405 ). When returning from the function/method, the log acquisition code stores the return time, the return value, and the memory content pointed to by the pointer parameter in the HDD (step S 3406 ). The process continues until an end command is provided by the user (step S 3407 ) without making determination as to the log acquisition initiation trigger.  
         [0153]    As can be seen from the forgoing description, the seventh embodiment provides the advantage that it allows the user to select any of functions/methods the log of which is to be acquired, thereby facilitating log analysis.  
         [0154]    (Eighth Embodiment] 
         [0155]    While it allows a user to select any function/method the log of which is to be acquired according to the seventh embodiment, it allows the user to select any function/method the log of which is to be stopped will be described in an eighth embodiment.  
         [0156]    [0156]FIG. 35 shows a user interface for setting a function/method the log of which is to be stopped according to the eighth embodiment.  
         [0157]    The user interface includes a dropdown list ( 358 ,  359 ) of modules/interfaces ( 356 ) from which a user can select a module/interface the log of which is to be acquired. It also includes a dropdown list ( 360 ,  361 ) of functions/methods ( 357 ) exported in the selected module/interface, from which the user can select a function/method to be set as a log acquisition stop trigger.  
         [0158]    [0158]FIG. 36 shows a flowchart of a process for acquiring a log in accordance with settings in the interface shown in FIG. 35 in the software evaluation system according to the eighth embodiment.  
         [0159]    When the process is started (step S 3601 ), log acquisition is started and the module name, interface name, function/method name is stored in the HDD (step S 3602 ). The log acquisition code then stores the call time, a parameter, and the memory content pointed to by a pointer parameter in the HDD (step S 3603 ) and calls the original function/method (step S 3604 ). When returning from the function/method, the log acquisition code stores the return time, the return value, and the memory content pointed to by the pointer parameter in the HDD (step S 3605 ). Then it determines whether or not the called function/method is set as a log acquisition stop trigger (step S 3606 ). If it matches the log acquisition stop trigger, the log acquisition process end (step S 3607 ). If it does not match the log acquisition stop trigger, the process will end in response to an end command from the user (step S 3606 ).  
         [0160]    Thus, the eighth embodiment provides the advantage that the user can stop acquisition of the log of any set function/method and acquire only the log that the user wants to, thereby facilitating log analysis.  
         [0161]    [Ninth Embodiment] 
         [0162]    While the user interfaces described with respect to the seventh and eighth embodiments allow the user to select a function/method to start/stop acquisition of its log, log acquisition may be started/stopped only if any function/method selected by the user is terminated by an error.  
         [0163]    [0163]FIG. 37 shows a log acquisition start/stop user interface having an option added for using the trigger function (log acquisition start/stop function) only if the function/method is terminated by an error according to a ninth embodiment. This user interface can be applied to both interfaces shown in FIGS. 33 and 35.  
         [0164]    The user interface includes a dropdown list ( 364 ,  365 ) of modules/interfaces ( 362 ) whose log can be acquired and from which a user can select a module/interface to set, a dropdown list ( 366 ,  367 ) of functions/methods ( 363 ) exported in the selected module/interface from which the user can select a function/method to set, and a check box ( 368 ) for activating a trigger function only if the function/method is terminated by an error.  
         [0165]    [0165]FIG. 38 shows error definitions for functions/methods according to the ninth embodiment. The error definitions in the present embodiment take the form of files. Each file contains a parameter and return value of each function/method and its defined error condition.  
         [0166]    [0166]FIG. 39 shows a flowchart of a process for acquiring a log in the software evaluation system according to the present embodiment. In this process, the function of using a trigger only when a log acquisition starts and an error occurs is specified in accordance with settings made in the interface shown in FIG. 37.  
         [0167]    When the process is started (step S 3901 ), the log acquisition code determines whether or not a function/method is set as a log acquisition trigger (step S 3902 ). If it is set as the log acquisition initiation trigger, the log acquisition code temporarily stores the module name, interface name, function/method name in memory (step S 3903 ).  
         [0168]    The log acquisition code then temporarily stores the call time, a parameter, and the memory content pointed to by a pointer parameter in memory (step S 3904 ) and calls the original function/method (step S 3905 ). After returning from the method, the log acquisition code temporarily stores the return time, a return value, and a content pointed to by the pointer parameter in memory (step S 3906 ).  
         [0169]    Then the log acquisition code determines whether or not the log acquisition initiation trigger should be used only if an error occurs (step S 3907 ) and, if so, determines whether or not the function/method has resulted in an error (step S 3908 ). If no error has occurred, the log acquisition code discards the log it has temporarily stored in the memory (step S 3909 ) and returns to the top of the process. On the other hand, if the function/method has resulted in an error, the code stores the log it has temporarily stored in the memory into the HDD (step S 3910 ) and continues the ordinary log acquisition process (step S 3911 ). The process continues until an end command is provided from the user (step S 3912 ).  
         [0170]    [0170]FIG. 40 shows details of the ordinary log acquisition process shown at step S 3911  in FIG. 39.  
         [0171]    When the process is started (step S 4001 ), log acquisition starts and the module name, interface name, function/method name is stored in the HDD (step S 4002 ). Then the log acquisition code stores the call time, a parameter, and the memory content pointed to by a pointer parameter in the HDD (step S 4003 ) and calls the original function/method (step S 4004 ). After returning from the function/method, the log acquisition code stores the return time, return value, and memory content pointed to by the pointer parameter in the HDD (step S 4005 ).  
         [0172]    [0172]FIG. 41 shows a flowchart of a process for obtaining a log in the software evaluation system according to the present embodiment. In this process, the function of using a trigger only when a log acquisition stops and an error occurs is specified in accordance with settings in the interface shown in FIG. 37.  
         [0173]    When the process is started (step S 4101 ), log acquisition is started and the module name, interface name, function/method name are stored in the HDD (step S 4102 ). The log acquisition code stores the call time, a parameter, and the memory content pointed to by a pointer parameter in the HDD (step S 4103 ) and calls the original function/method (step S 4104 ). After returning from the function/method, the log acquisition code stores the return time, return value, and memory content pointed to by the pointer parameter in the HDD (step S 4105 ). It then determines whether or not the called function/method is set as a log acquisition stop trigger (step S 4106 ). If it matches the log acquisition stop trigger, it determines whether or not the log acquisition stop trigger should be used only if an error occurs (step S 4107 ) and, if so, it determines whether or not the function/method has resulted in an error (step S 4108 ). If it has resulted in an error, the log acquisition process ends (step S 4109 ). The process also ends when an end command is provided by the user (step S 4110 ).  
         [0174]    Thus, the ninth embodiment provides the advantage that log acquisition can be started or stopped when an error occurs in a given function/method and the user can acquired the log that the user wants to obtain, thereby facilitating log analysis.  
         [0175]    [Tenth Embodiment] 
         [0176]    While selectable functions/methods are arranged in a predetermined order in the user interfaces in the seventh to ninth embodiments, they may be displayed in a tree view that allows a user to readily determine the relationships among interfaces and methods.  
         [0177]    [0177]FIG. 42 shows a user interface that provides a tree view of interfaces and methods according to a tenth embodiment.  
         [0178]    The user interface has a view ( 380 ) for displaying interfaces and methods in tree form. When a user checks an interface, InterfaceA ( 381 ), all methods MethodAA, MethodAB, and MethodAC ( 382 - 384 ) in the interface are selected as targets for log acquisition. When the user unchecks an interface InterfaceB ( 385 ), all method MethodBA, MethodBB, and Method BC ( 385 - 388 ) in the interface are deselected and excluded from the target for log acquisition.  
         [0179]    [0179]FIG. 43 shows a flowchart of a process for acquiring a log in the software evaluation system according to the tenth embodiment when targets for log acquisition are selected as shown in FIG. 42.  
         [0180]    Once the process has been started (step S 4301 ), the log acquisition code determines, each time a call to a method in an interface is made, whether or not the interface associated with the method is a target for log acquisition (step  4302 ). If it is a target for log acquisition, then the log acquisition code stores the module name, interface name, and method name in the HDD (step S 4303 ).  
         [0181]    Then the log acquisition code stores the call time, parameter, memory content pointed to by a pointer parameter in the HDD (step S 4304 ) and calls the original method (step S 4305 ). After returning from the method, the log acquisition code stores the return time, return value, and memory content pointed to by the pointer parameter in the HDD (step S 4306 ). The process continues until an end command is provided by the user (step S 4307 ).  
         [0182]    Thus, the user can more readily know the relationship between interfaces and methods and readily selects an interface to obtain its log, thereby facilitating acquisition of the desired log.  
         [0183]    [Eleventh Embodiment] 
         [0184]    While all the method in an interface are selected in the seventh to tenth embodiments, individual method(s) may be independently selected.  
         [0185]    [0185]FIG. 44 shows a user interface that provides a tree view of interfaces and methods according to an eleventh embodiment. This user interface is the same as the one shown in FIG. 42 but the method for selecting from among them is different.  
         [0186]    The user interface includes a view ( 389 ) for displaying interfaces and methods in tree form. A user can check any of the methods MethodAA ( 391 ), MethodAC ( 393 ), MethodBA ( 395 ), and uncheck any of the methods MethodAB ( 392 ), MethodBB ( 396 ), Method BC ( 397 ) to select only one or more methods that are left checked in interfaces InterfaceA ( 210 ), InterfaceB ( 394 ) as targets of log acquisition, rather than all the methods in each interfaces.  
         [0187]    [0187]FIG. 45 shows a flowchart of a process for acquiring a log in the software evaluation system according to the eleventh embodiment when targets of log acquisition are selected as shown in FIG. 44.  
         [0188]    Once the process has been started (step S 4501 ), the log acquisition code determines, each time a call to a method in an interface is made, whether or not any of the methods associated with the interface are targets for log acquisition (step S 4502 ). If it any of them are targets for log acquisition, then the log acquisition code stores the module name, interface name, and method name(s) in the HDD (step S 4503 ). The process (step S 4504  to S 4507 ) is the same as the one shown in FIG. 43 according to the tenth embodiment.  
         [0189]    Thus, this embodiment provides the advantage that the user can readily select an individual method or methods to acquire the log of them, rather than an interface, which is a larger unit. Consequently, the user can readily acquire his/her desired log.  
         [0190]    [Twelfth Embodiment] 
         [0191]    While an acquired log is stored in a given location in the HDD in the embodiments described above, a log may be stored on a date-by-date basis in order to facilitate log analysis.  
         [0192]    [0192]FIG. 46 shows a flowchart of a process for storing logs separated on a date-by-date basis.  
         [0193]    When the process is started (step S 4601 ), log acquisition is initiated and the module name, interface name, function/method name are stored in memory (step S 4602 ).  
         [0194]    The log acquisition code then stores the call date and time, parameter, and a memory content pointed to by a pointer in memory (step S 4603 ) and calls the original function/method (step S 4604 ). After returning from the function/method, the log acquisition code return date and time, return value, memory content pointed to by the pointer parameter in memory (step S 4605 ). Then it determines whether or not the date of the return of the called function/method differs from the return date previously stored (step S 4606 ). If the date differs from the previous return date, the log acquisition code generates a new log file and stores the log in that file (step S 4607 ). On the other hand, if they are the same, the log acquisition code stores the log in the existing log file (step S 4608 ). This process end (S 4610 ) when an end command is provided by the user (step S 4609 ).  
         [0195]    Thus, this embodiment provides the advantage that it allows the user to acquire logs on a date-by-date basis, thereby facilitating log analysis.  
         [0196]    [Thirteenth Embodiment] 
         [0197]    While logs are stored on a date-by-date basis in the twelfth embodiment described above, logs can be stored separately according to the size or number of the logs.  
         [0198]    [0198]FIG. 47 shows a flowchart of a process for separately storing logs according to the size or the number of the logs.  
         [0199]    When the process is started (step S 4701 ), log acquisition starts and the module name, interface name, and function/method name are stored in memory (step S 4702 ). The log acquisition code then stores the call time, parameter, and the memory content pointed to by a pointer parameter in memory (step S 4703 ) and calls the original function/method (step S 4704 ). After returning from the function/method, the log acquisition code stores the return time, the return value, and the memory content pointed to by the pointer parameter in memory (step S 4705 ). Then it determines whether storing the new log data in an existing log file causes the size of the file or the number of logs in the file to exceed to a predetermined value (step S 4706 ).  
         [0200]    If the size or the number of the logs exceeds the predetermined value, the log acquisition code generates a new log file and stores the log in that file (step S 4707 ). Otherwise, if not exceed it stores the log in the existing log file (step S 4708 ). If the log acquisition code generates a new log file, it determines whether or not a ring buffer is used and the number of log files generated is more than two (step S 4709 ). If so, it deletes the oldest log file (step  4710 ). This process ends (step S 4712 ) when an end command is provided from the user (step S 4711 ).  
         [0201]    Thus, the user can acquire size-controlled, generated files and a predetermined number of generated logs. The present embodiment therefore has the advantage that it provides more manageable logs. Furthermore, using a ring buffer can limit the load placed by the software evaluation system on the resources of the PC, enabling stable log acquisition.  
         [0202]    [Fourteenth Embodiment] 
         [0203]    [0203]FIG. 48 schematically shows memory in which a predetermined number of acquired logs are stored.  
         [0204]    N log storage areas ( 398 ) are provided for storing a predetermined number of logs. Each log storage area stores a log of functions/methods. The information is stored includes the module name, interface name, function/method name, call time, parameter data at the call time, the end time, parameter data at the end time, and return value data ( 399 ). The information has a variable size. Log data is stored in the memory areas in order, from log storage memory area 1 to log storage memory area n. When the areas are exhausted, the logs are overwritten, starting from log storage memory are 1.  
         [0205]    [0205]FIG. 49 shows a flowchart of a process for acquiring logs and storing a predetermined number of acquired logs in the memory.  
         [0206]    When the process is started (step S 4901 ), a variable x indicating the location of a log storage area is initialized to 1 (step S 4902 ). Then log acquisition is started and the module name, interface name, function/method name are stored in the log storage memory area x (step S 4903 ).  
         [0207]    The log acquisition code then stores the call time, a parameter, and the memory content pointed to by a pointer parameter in log storage memory area x (step S 4904 ) and calls the original method/function (step S 4905 ). After returning from the function/method, the log acquisition code stores the return time, the return value, and the memory content pointed to by the pointer parameter in log storage memory area x (step S 4906 ). Then it adds 1 to the variable x that indicates the location of a log storage memory area (step S 4907 ) and determines whether x exceeds the number n of the log storage memory areas (step S 4908 ).  
         [0208]    If x is larger than n, it assigns 1 to x so that the log storage memory areas are reused from the top log storage memory area (step S 4909 ). Then it determines whether or not a ring buffer is to be used (step S 4910 ). If not, the log acquisition code stores all log data in the memory into a log file (step S 4911 ) and deletes all the log data from the memory (step S 4912 ). This process ends (step S 4914 ) when an end command is provided from the user (step S 4913 ).  
         [0209]    Thus, memory usage can be limited ad load placed by the software evaluation system on the resources of the PC can be minimized, enabling stable log acquisition.  
         [0210]    [Other Embodiments] 
         [0211]    The present invention may be applied to a system consisting of a plurality of devices (for example, a host computer, interface devices, a reader, and a printer) or a standalone apparatus (for example a copying machine or facsimile machine.  
         [0212]    The object of the present invention can also be achieved by providing a storage medium containing a program code of software that implements the functions of the embodiments described above to a system or an apparatus and causes to a computer (or CPU or MPU) of the system or the apparatus to read and execute the program code stored on the storage medium.  
         [0213]    In that case, the program code read from the storage medium implements the functions of the embodiments described above and the storage medium on which the program code is stored constitutes the present invention.  
         [0214]    The storage medium for providing the program code may be a floppy® disk, disk, hard disk, optical disk, magneto-optical disk, CD-ROM, CD-R, magnetic tape, nonvolatile memory card, or ROM.  
         [0215]    The present invention includes not only implementations in which the features of the embodiments described above are implemented by a computer reading and executing the program code but also implementations in which an OS (operating system) or the like running on a computer executes all or part of the actual processing to implement the features of the embodiments described above according to instructions in the program code.  
         [0216]    Furthermore, the present invention includes cases where the program code read from the storage medium is written into an expansion board inserted into a computer or memory provided in a expansion unit connected to a computer and a CPU or other processor provided in the expansion board or expansion unit executes all or part of the actual processing and the processing implements the features of the embodiments described above.  
         [0217]    As described above, the present invention allows processing logs of software divided into a plurality of modules to be readily acquired and reduces the man-hours need to analyze the cause of software failure.  
         [0218]    As many apparently widely different embodiments of the present invention can be made without departing from the spirit and scope thereof, it is to be understood that the invention is not limited to the specific embodiments thereof except as defined in the claims.