Abstract:
When a source program written in Java or the like and using methods of BigDecimal class, a priority conforming to a predetermined arithmetic rule is identified for an arithmetic operational method included in an arithmetic operation statement, and the arithmetic operational method and the identified priority are registered into a storage device. Then, in a case where it is judged based on data stored in the storage device that a plurality of arithmetic operational methods are included in an arithmetic operational statement, and an arithmetic operational method with low priority is defined as an instance of an arithmetic operational method with high priority, following processing is carried out to generate specification data, that is, the arithmetic operational method with low priority and an instance and argument of the arithmetic operational method with low priority are converted into a first subexpression using an arithmetic operational sign in accordance with a predetermined rule. Then, parentheses representing that the arithmetic operation are carried out with priority is added to the first subexpression. In addition, the arithmetic operational method with high priority and an argument of the arithmetic operational method with high priority are converted into a second subexpression using an arithmetic operational sign in accordance with the predetermined rule. Finally, the second subexpression is linked with the first subexpression.

Description:
TECHNICAL FIELD OF THE INVENTION  
       [0001]     The present invention relates to a technique for automatically generating a specification for a computer program.  
       BACKGROUND OF THE INVENTION  
       [0002]     It is often more difficult to review programs written, for example, in Java (trademark of Sun Microsystems Inc.) than programs written in COBOL and etc. This might be because the reviewer&#39;s skill for Java is poor. However, this is mainly because mathematical expressions and syntaxes in COBOL are represented by method invocations, accordingly the programs in Java are difficult to read. For example, “WK_OUTOUBI&gt;XHIAWYEIDT” in COBOL is expressed by “wk — ×16.getWK_OUT OUBI( ).isGreaterThan(xhiarxhi.getXHIAWYEIDT( ))” in Java. Therefore, the readability is spoiled. Moreover, because many statements not related to reviews such as creation of objects and EJB (Enterprise Java Beans) initialization are set forth, these also impede improving the efficiency of reviewing.  
         [0003]     Incidentally, automatic generation of specifications is disclosed, for example, in U.S. Pat. No. 5,742,827. That is, the syntax of the input program is analyzed, and the syntactic structure and data attributes are obtained. At the same time, the data flow is analyzed to obtain data flow information. In addition, the names of temporal variables within the program are detected, and data that has inclusion with those temporal variables is detected. Then, the data flows from reference locations to the temporal variables to setting locations of associated variables are traced by the inclusion of data, applications of the temporal variables such as holding of intermediate results of calculations, type conversion, division, composition, and so on are discerned, and those temporal variables which can be erased are deleted. Intermediate representations in which temporal variables have been erased are replaced by natural language descriptions to obtain a specification. However, problems in object-oriented languages as described above are not taken into consideration.  
         [0004]     In the aforementioned art, any solution to a problem in which it is difficult to make a review of a program written in a program language such as Java is not described.  
       SUMMARY OF THE INVENTION  
       [0005]     Accordingly, it is an object of the invention to provide a technique for automatically generating a specification for facilitating the review of a program written in a program language such as Java.  
         [0006]     A method according to the present invention is a method for generating specification data from a source program (e.g., a source program described using a method of the Java&#39;s BigDecimal class) in which arithmetic operations are described in a method format, which comprises: identifying a priority conforming to a predetermined arithmetic rule for an arithmetic operational method included in an arithmetic operation statement that is included in a source program and defines an arithmetic operation, and registering the arithmetic operational method and the priority into a storage device; in a case where it is judged based on data stored in the storage device that a plurality of arithmetic operational methods are included in an arithmetic operational statement and an arithmetic operational method with low priority is defined as an instance of an arithmetic operational method with high priority, generating specification data and storing the specification data into a specification data storage by converting the arithmetic operational method with low priority and an instance and argument of the arithmetic operational method with low priority into a first subexpression using an arithmetic operational sign in accordance with a predetermined rule, adding parentheses representing that the arithmetic operation are carried out with priority, to the first subexpression, converting the arithmetic operational method with high priority and an argument of the arithmetic operational method with high priority into a second subexpression using an arithmetic operational sign in accordance with the predetermined rule, and linking the second subexpression with the first subexpression.  
         [0007]     For example, in the Java&#39;s BigDecimal class used in mathematical expressions employed, for example, in the financial area, every arithmetic operation is represented by a method invocation. If this description is left intact, it is very difficult to make a review. Furthermore, if arithmetic operational statements described using methods of the BigDecimal class are simply converted, the order of priorities of operators (such as + and ×) does not hold. Therefore, it is difficult to make a review as to whether correct processing is done. Accordingly, by carrying out the aforementioned processing, it becomes possible to present the correct contents of the arithmetic operational statements in a format that is easily understandable to the reviewer.  
         [0008]     Furthermore, in the aforementioned registering, a data block holding the priority for the arithmetic operational method, data concerning an instance of the arithmetic operational method, and data concerning an argument of the arithmetic operational method may be generated and stored in the storage device. In some cases, the instance and argument may be described using arithmetic operational methods. In such cases, a data block may also be constructed for this instance and argument, and a reference may be made from a data block for the original arithmetic operational method. Moreover, a data block may be generated for later processing even if the argument and instance are not described using the arithmetic operational method.  
         [0009]     Furthermore, the aforementioned generating may comprise: referring to a first dictionary storing a variable name so as to correspond to a word or phrase indicating the meaning of the variable name, and replacing variables contained in the first and second subexpressions with corresponding words or phrases. Consequently, the reviewer can read the specification with greater ease.  
         [0010]     In addition, the present invention may further comprise: analyzing the source program to identify a processing statement and a condition associated with the processing statement, and storing them in the specification data storage in a corresponding manner. In this case, the aforementioned registering may be carried out for the processing statement and the condition that are arithmetic operational statements.  
         [0011]     The aforementioned generating may comprise checking whether there are parentheses surrounding only one term in an arithmetic operational expression or there are parentheses surrounding only parenthesized characters; and removing the parentheses if there are parentheses surrounding only one term in a mathematical expression or there are parentheses surrounding only parenthesized characters. By carrying out such a processing, the arithmetic operational expression can be expressed more accurately.  
         [0012]     Additionally, the aforementioned generating may comprise referring to a second dictionary storing words or phrases indicating the meanings of values of variables, extracting a word or phrase corresponding to a certain value of a certain variable, and storing the extracted word or phrase into the specification data storage (e.g. so as to correspond to the certain value of the certain variable). This is because, for example, in a case where a condition concerning a case in which a variable ABC becomes equal to 1 is stipulated, if one cannot understand the meaning of “1”, there is a case where it is difficult to make a review.  
         [0013]     Further, the aforementioned data concerning the argument may contain data indicating whether or not the argument is an expression. At that time, the aforementioned generating may comprise: referring to the data block to judge whether the argument of the arithmetic operational method is an expression or not; converting the expression into a third subexpression using arithmetic operational signs in accordance with the predetermined rule if it is judged that the argument is an expression, and adding parentheses to the third subexpression. This is because it may be necessary to take account of the priorities of the operators when the argument is also an expression.  
         [0014]     It is possible to create a program for causing a computer to carry out the method for generating the specification data of the invention and a program to realize the wireless communication portable terminal, and the programs are stored in a storage medium or a storage device such as, for example, a flexible disk, a CD-ROM, a magneto-optical disk, a semiconductor memory, or a hard disk. Besides, the program may be distributed in digital signals through a network. Incidentally, the intermediate data in the processing is temporarily stored in a storage device such as a memory of a computer. 
     
    
     BRIEF DESCRIPTION OF THE DRAWINGS  
       [0015]      FIG. 1  is a functional block diagram of an embodiment of the present invention;  
         [0016]      FIG. 2  is a diagram showing a processing flow of the main processing relating to the embodiment of the invention;  
         [0017]      FIG. 3  is a diagram showing a processing flow of a table conversion processing;  
         [0018]      FIGS. 4A-4C  are diagrams of examples of the conversion;  
         [0019]      FIG. 5  is a diagram showing one example of data stored in a word/word/phrase dictionary;  
         [0020]      FIG. 6  is a diagram showing one example of data stored in a code dictionary;  
         [0021]      FIG. 7  is a diagram showing a processing flow of an expression conversion processing;  
         [0022]      FIG. 8  is a diagram showing a processing flow of an arithmetic operation analyzing processing;  
         [0023]      FIG. 9  is a diagram illustrating the structure of a data block;  
         [0024]      FIG. 10  is a diagram illustrating the priority order of arithmetic operational methods;  
         [0025]      FIG. 11  is a diagram showing a processing flow of an instance analyzing processing;  
         [0026]      FIG. 12  is a diagram showing a processing flow of an argument analyzing processing;  
         [0027]      FIG. 13  is a diagram showing a specific example of the data block chain;  
         [0028]      FIG. 14  is a diagram showing a processing flow of a conversion processing;  
         [0029]      FIG. 15  is a diagram showing a processing flow of subexpression conversion processing;  
         [0030]      FIG. 16  is a diagram showing a processing flow of a second instance conversion processing;  
         [0031]      FIG. 17  is a diagram showing a processing flow of the second instance converting processing;  
         [0032]      FIG. 18  is a diagram showing one example of specification data;  
         [0033]      FIG. 19  is a diagram showing a table stipulating a fundamental conversion rule; and  
         [0034]      FIG. 20  is a functional diagram of a computer. 
     
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS  
       [0035]      FIG. 1  is a functional block diagram of a specification data generation apparatus according to one embodiment of the present invention. The specification data generation apparatus  10  has a source program storage  1  for storing a source program for which a specification is generated, a syntax analyzer  2  for carrying out a processing such as parsing of the source program, a syntax analysis result storage  3  for storing the results of the processing performed by the syntax analyzer  2 , a table generator  4  for converting the data stored in the syntax analysis result storage  3  into data in tabular form, a word/phrase dictionary  8  in which the relation between each variable and a word or phrase indicating the meaning of the variable is registered, a code dictionary  9  in which the relation among each variable, its value, and a word or phrase indicating the meaning is registered, a table data storage  5  for storing the results of the processing performed by the table generator  4  and the like, an expression converter  6  for carrying out a processing for converting arithmetic operational expressions (described in detail later) using the data stored in the table data storage  5 , and a data block storage  7  for storing data blocks that are intermediate data in the expression converter  6 . The word/phrase dictionary  8  and code dictionary  9  are used by the table generator  4  and expression converter  6 .  
         [0036]     Next, the flow of the processing performed by the specification data generation apparatus  10  shown in  FIG. 1  is described by referring to  FIGS. 2-19 . First, the syntax analyzer  2  reads out the source program to be processed from the source program storage  1 , performs well-known syntactic analysis including parsing, and stores the results of the analysis in the syntax analysis result storage  3  (step S 1 ). Then, the table generator  4  uses the data stored in the syntax analysis results storage  3  and refers to the word/phrase dictionary  8  and code dictionary  9  to carry out a table generation processing (step S 3 ). This table generation processing will be described in detail later. The results of the table generation processing are stored in the table data storage  5 . The expression converter  6  uses the data stored in the table data storage  5  and refers to the word/phrase dictionary  8  and code dictionary  9  to carry out an expression conversion processing (step S 5 ). This expression conversion processing will also be described in detail. The results of the expression conversion processing are stored in the table data storage  5 .  
         [0037]     Next, the table generation processing is described by referring to  FIGS. 3-6 . First, the table generator  4  reads one unprocessed line from the syntax analysis result storage  3  (step S 11 ). Then, it judges whether or not the read line is a conditional statement or not (step S 13 ). Here, it is checked whether there is an “if” statement or the like. If it is judged that there is a conditional statement, it carries out a processing for extracting the conditional statement (step S 15 ). Data concerning the extracted conditional statement is temporarily stored in a storage device such as a main memory. On the other hand, if it is judged that there is no conditional statement, the read line contains a certain processing statement. In addition, if the read line is a conditional statement, a processing statement associated with the conditional statement exists. Therefore, it carries out a processing for extracting the processing statement (step S 17 ). Data concerning the extracted processed statement is temporarily stored in the storage device such as the main memory. If there is a comment statement associated with the conditional statement and processing statement extracted in steps S 15  and S 17 , it carries out a processing for extracting the comment statement (step S 19 ). Data concerning the extracted comment statement is temporarily stored in the storage device such as the main memory. Furthermore, it carries out a processing for extracting the line numbers of the extracted conditional statement, processing statement, and comment statement (step S 21 ). The extracted line numbers are temporarily stored in the storage device such as the main memory.  
         [0038]     Then, the table generator  4  generates a table from the extracted data stored, for example, in the main memory, and stores the table in the table data storage  5  (step S 23 ). After that, it judges whether all lines have been processed (step S 25 ). When there is any unprocessed line, the processing returns to the step S 11 . On the other hand, when all the lines have been processed, the processing returns to the original processing.  
         [0039]     As an example, a case where the following Java source program (only a part of which is shown) is processed is described.  
                                                   3 if (in_param.getRETURNCODE( ) == 0){           4        out_param.setNISSU(in_param.getNISSU( ));           5    }                      
 
         [0040]     In this case, the conditional statement is “in_param.getRETURN CODE( )=0”. The processing statement is “out_param.setNISSU(in_param.getNISSU( ))”. Although the numeral at the left end is a line number, it is not contained in the actual program but is shown here for reference. In such a case, data as shown in  FIG. 4A  is held, for example, at the stage of the step S 23 . In the example of  FIG. 4A , the table includes a column of item numbers, a column of line numbers (line number of the processing statement and line number of the conditional statement associated with the processing statement), a column processing contents, a column of condition  1  (when plural conditions are associated, subsequent conditions will follow), and a column of remarks (comment statement). The processing statements, associated conditional statements and their line numbers are registered.  
         [0041]     Incidentally, in the step S 23 , data shown in  FIG. 4A  may be further converted according to a conversion rule described in the end of the description of the present embodiment to store data as shown in  FIG. 4B . That is, “out_param.setNISSU(in_param.get NISSU( ))” is converted into “out_param.NISSU=in_param.NISSU”. “in_param.getRETURN CODE( )==0” is converted into “in_param.RETURNCODE=0”. Furthermore, a conversion from the variable to the word or phrase may be carried out by referring to the word/phrase dictionary  8  and code dictionary  9 . The processing for converting expressions as described below is mainly a processing for methods of the BigDecimal class. Therefore, simple conversions are performed for the processing statements and conditional statements, which have been clearly found to have no relationship to any method of the BigDecimal class in the step S 23 . For example, as shown in  FIG. 4C , the variable is converted into a word or phrase indicating the meaning of the variable using the word/phrase dictionary  8  storing the data as shown in  FIG. 5 . That is, the word/phrase dictionary  8  stores a variable name, and a word or phrase data indicating its meaning. Accordingly, “in_param” is converted into “input area”, “RETURNCODE” is converted into “return value”, “out_param” is converted into “output area”, and “NISSU” is converted into “No. of days”. The code dictionary  9  may also be used. The code dictionary  9  holds data as shown in  FIG. 6 . That is, the code dictionary  9  includes a variable name, its value, and data indicating its meaning. Therefore, if a combination of the corresponding variable name and its value is identified, data indicating the meaning is also registered in the table.  
         [0042]     The expression conversion processing is next described by referring to  FIG. 7 . First, the expression converter  6  identifies one of unprocessed cells in the column of the processing contents and the column of the condition in the table (step S 31 ). Then, it judges whether a method of the BigDecimal class is stipulated for the statement contained in this cell (step S 33 ). If it is judged that a method of the BigDecimal class is stipulated, it carries out an arithmetic operation analysis processing for the statement in the cell (step S 35 ). Although this processing will be described later, it generates a group of data blocks for the statement contained in the cell and stores the group of data blocks in the data block storage  7 . Then, it carries out a conversion processing using the data stored in the data block storage  7  (step S 37 ). Although this processing will be described later, it stores an arithmetic operational expression using normal operators into the cell. Incidentally, at this time, it also carries out a replacement processing using the word/phrase dictionary  8  and code dictionary  9 . On the other hand, if it is judged that any method of the BigDecimal class is not stipulated, it carries out a normal character string conversion processing according to a conversion rule described in the end of the description of the present embodiment, and stores the generated data in the cell (step S 45 ).  
         [0043]     After the step S 37  or S 45 , it carries out a processing for checking whether there are unnecessary parentheses in the arithmetic operational expression in the cell (step S 39 ). If it is judged that there are unnecessary parentheses in the arithmetic operational expression in the cell, it carries out a processing for removing the unnecessary parentheses (step S 41 ). For example, in a case where only a variable or constant is present within the parentheses, the parentheses are unnecessary. Therefore, it removes them. For instance, in a case where an expression or subexpression “c.multiply(a).add (b)” is contained in the cell, a conversion resulting in “c*(a)+(b)” may be done by the conversion processing. In such a case, ( ) of (a) and ( ) of (b) are unnecessary. Therefore, they are deleted. Furthermore, where a subexpression “((a+b))*c” is obtained, ( ) on the outside of ((a+b)) are unnecessary and so they are removed. Data obtained after the removal is saved in the cells of the table. In this way, (1) parentheses surrounding only a variable or constant and (2) parentheses not surrounding a character string other than parentheses are unnecessary and so they are deleted. In a case where it is judged that there are no unnecessary parentheses, or after the step S 41 , it judges whether the processing has been carried out for all the cells of the table (step S 43 ). If there exists any unprocessed cell, the processing returns to the step S 31 . On the other hand, if there exists no unprocessed cell, the processing returns to the original processing.  
         [0044]     Next, the arithmetic operation analysis processing (step S 35  in  FIG. 7 ) is described by referring to FIGS.  8  to  13 . First, the expression converter  6  generates a data block for methods of the BigDecimal class in the subexpression to be processed (step S 50 ). In a case where this processing is called at the step S 35  in  FIG. 7 , the entire expression is processed. However, because this processing is called recursively, the subexpression, which is a portion of the expression, is processed. It secures an area in the data block storage  7 . The data block is a data area as shown, for example, in  FIG. 9 . That is, the data block contains an area for a method name (or expression), an area for instance data, an area for argument data, an area for priority order, and an area for a flag indicating whether the argument is an expression. The name of a called method or the like is stored in the area for the method name. In a case where the instance is not a method, the data name of the instance is stored in the area for the instance data. In a case where the instance is a method, a pointer (or the data block itself) to the data block for the method of the instance is stored. The data name is stored in the area for the argument data in a case where the argument is not an expression. In a case where the argument is an expression, the pointer to the data block for the argument (or the data block itself) is stored. The priority order of the operator corresponding to the method of the BigDecimal class is stored in the area for the priority order. With respect to a flag indicating whether the argument is an expression or not, if the argument of the method is an expression, “1”, for example, is stored. If not, “0” is stored. In the present embodiment, in a case where the present arithmetic operation analysis processing is called in steps other than the step S 35  of  FIG. 7 , it is assumed that the forefront address of the data block is registered in the area for the instance data or in the area for the argument data in accordance with the processing performed in the calling source.  
         [0045]     In addition, a method invocation is composed of three parts: instance portion, method name, and argument. For example, in the case of a method invocation “data 1 .add(data 2 )”, the instance portion is “data 1 ”. The method name is “add”. The argument is “data 2 ”. In a case where method invocations take place consecutively (e.g., in the case of a method invocation “data 1 .add(data 2 ).multiply(data 4 )”), the instance of the method “multiply” is “data 1 .add(data 2 )”. The argument of the method “multiply” is “data 4 ”. The instance of the method “add” is “data 1 ”. The argument of the method “add” is “data 2 ”.  
         [0046]     Then, it judges whether the subexpression to be processed is a method invocation of the BigDecimal class (step S 51 ). Because it has been checked in the step S 33  of  FIG. 7  whether it is a method invocation of the BigDecimal class, a duplication occurs, if this processing is called at the step S 35  of  FIG. 7 . However, because the present arithmetic operation analysis processing is called recursively, the present step is necessitated.  
         [0047]     If it is judged that it is a method invocation of the BigDecimal class, it carries out an instance analysis processing (step S 53 ). This processing is described later. The present arithmetic operation analysis processing is also called in the instance analysis processing. Then, it obtains the method name of the subexpression to be processed, and sets the method name in the area for the method name in the data block for this method (step S 55 ). Moreover, it obtains the priority of the method, and sets the priority in the area for the priority order (step S 57 ). The priority orders of methods are shown in  FIG. 10 . That is, the priority order has been determined in advance such that “pow&gt;multiply” or “divide&gt;add or subtract”. This represents the priority orders in normal calculations. In addition, it carries out an argument analysis processing (step S 59 ). This processing will be described later. In the argument analysis processing, the present arithmetic operation analysis processing is also called. Then, control returns to the original processing.  
         [0048]     On the other hand, if it is judged at the step S 51  that any method of the BigDecimal class is not called in the subexpression to be processed, it checks whether any class other than the BigDecimal class is called (step S 61 ). If there is a method invocation of a class other than the BigDecimal class, it carried out the instance analysis processing (step S 63 ), and obtains the method name, and sets the method name in the area for the method name in the data block for the method (step S 65 ). Furthermore, it carries out the argument analysis processing for the method (step S 67 ). The step S 63  is the same processing as the step S 53 . The step S 67  is the same processing as the step S 59 . Then, control returns to the original processing.  
         [0049]     Moreover, if it is judged at the step S 61  that it is not a method invocation, it carries out a normal character string conversion processing as described in the last part of the present embodiment, and registers the character string in the area for the method name in the data block of the subexpression to be processed (step S 69 ). Then, control returns to the original processing.  
         [0050]     Next, the instance analysis processing is described by referring to  FIG. 11 . The expression converter  6  makes a decision as to whether a method invocation is contained in the instance to be processed (step S 71 ). If it is judged that no method invocation is contained in the instance to be processed, it obtains the instance name, and sets the instance name in the area for the instance data in the data block for the subexpression to be processed (step S 73 ). Then, control returns to the original processing. On the other hand, if it is judged that a method invocation is contained, it carries out the arithmetic operation analysis processing shown in  FIG. 8  for this method (step S 75 ). Then, control returns to the original processing. As described above, in a case where a method invocation is present in the instance, a chain of data blocks is formed.  
         [0051]     Next, the argument analysis processing is described by referring to  FIG. 12 . The expression converter  6  makes a decision as to whether the argument to be processed is an expression or not (step S 81 ). The result of the decision is set in the data block as a flag indicating whether the argument is an expression or not. If it is judged that the argument to be processed is not an expression, it obtains the argument name, and sets the argument name in the area for the argument data in the data block for the subexpression to be processed (step S 83 ). Then, control returns to the original processing. On the other hand, if it is judged that the argument is an expression, it carries out the arithmetic operation analysis processing of  FIG. 8  (step S 85 ). Then, control returns to the original processing. As described above, in a case where the argument is an expression, a chain of the data blocks is formed.  
         [0052]     A specific example of the arithmetic operation analysis processing is now described. It is assumed that an arithmetic operational expression “data 1 .add(data 2 .method 1 ( )).subtract(data 3 .data 4 ).multiply(data 5 )” is to be processed.  
         [0053]     First, a data block for the method “multiply” is generated in the step S 50 . For example, a data block  1301  as shown in  FIG. 13  is generated. Because it is confirmed that the method “multiply” is a method invocation of the BigDecimal class in the step S 51 , the instance analysis processing is carried out in the step S 53 . In the instance analysis processing, it is checked that the instance is a method invocation in the step S 71 . Because a method “subtract” exists, the arithmetic operation analysis processing for the method “subtract” is carried out in the step S 75 .  
         [0054]     Then, a data block  1302  for the method “subtract” is generated in the step S 50  ( FIG. 13 ). A pointer to the data block  1302  is set in the area for the instance data in the data block  1301 . Because it is checked that the method “subtract” is a method invocation of the BigDecimal class, the instance analysis processing is carried out in the step S 53 . In the instance analysis processing, it is checked that the instance is a method invocation in the step S 71 . Because there is a method “add”, the arithmetic operation analysis processing is carried out for the method “add” in the step S 75 .  
         [0055]     A data block  1303  ( FIG. 13 ) for the method “add” is generated in the step S 50 . A pointer to the data block  1303  is set in the area for the instance data in the data block  1302 . Because it is checked that the method “add” is a method invocation of the BigDecimal class, the instance analysis processing is carried out in the step S 53 . In the instance analysis processing, it is judged that the instance is not a method invocation in the step S 71  and therefore, the instance name “data 1 ” is obtained in the step S 73  and stored in the area for the instance data in the data block  1303 . Then, the method name “add” is obtained in the step S 55  and stored in the area for the method name in the data block  1303 . A method priority corresponding to the method “add” is obtained at the step S 57  and priority “ 3 ” is set in the area for the priority order in the data block  1303  (see  FIG. 10 ). Then, the argument analysis processing is carried out in the step S 59 . In the argument analysis processing, it is judged whether the argument of the method “add” is an expression or not in the step S 81 . Here, it is judged that it is an expression using a method “data 2 .method 1 ( )”, and the arithmetic operation analysis processing is carried out for the argument in the step S 85 . A flag indicating whether the argument of the data block  1303  is an expression or not is set to “1”.  
         [0056]     Then, a data block  1304  ( FIG. 13 ) for the method “method 1 ” is generated in the step S 50 . A pointer to the data block  1304  is set in the area for the argument data in the data block  1303 . Because it is judged at the step S 51  that the method “method 1 ” is not a method invocation of the BigDecimal class and therefore, control goes to the step S 61 . A decision is made as to whether it is a method invocation. Because the method “method 1 ” is a method invocation, the instance analysis processing is carried out at the step S 63 . In the instance analysis processing, a decision is made as to whether the instance is a method invocation in the step S 71 . Because it is “data 2 ”, it is determined that it is not a method invocation. In the step S 73 , instance name “data 2 ” is obtained and set in the area for the instance data in the data block  1304 . Then, method name “method 1 ” is obtained in the step S 65  and set in the area for the method name in the data block  1304 . The argument analysis processing is carried out in the step S 67 . In the argument analysis processing, a decision is made as to whether the argument of the method “method 1 ” is an expression in the step S 81 . Because the argument is empty in this example, no setting is made in the step S 83 . The argument analysis processing for the method “method 1 ” is completed. A flag indicating whether the argument of the data block  1304  is an expression or not is set to “0”.  
         [0057]     Here, the argument analysis processing for the method “add” is completed. Also, the instance analysis processing for the method “subtract” is completed. That is, processings up to the step S 53  for the method “subtract” are completed. The name of the method “subtract” is obtained in the step S 55  and set in the area for the method name in the data block of the data block  1302 . Furthermore, a method priority corresponding to the method “subtract” is obtained in the step S 57 , and priority “ 3 ” (see  FIG. 10 ) is set in the area for the priority order in the data block  1302 . Thereafter, the argument analysis processing for the method “subtract” is carried out in the step S 59 . In the argument analysis processing, a decision is made as to whether the argument of the method “subtract” is an expression or not in the step S 81 . Because the argument is “data 3 +data 4 ” in this example, it is determined that the argument is an expression. The arithmetic operation analysis processing for this argument is carried out in the step S 85 . A flag indicating whether the argument of the data block  1302  is an expression or not is set to “1”.  
         [0058]     Then, a data block  1305  for the argument “data 3 +data 4 ” is generated in the step S 50 . A pointer to the data block  1305  is set in the area for the argument data in the data block  1302 . A decision made in the step S 51  is that the argument “data 3 +data 4 ” is not a method invocation of the BigDecimal class. It is determined in the step S 61  that it is not a method. Accordingly, the processing for converting a character string is carried out for the argument in the step S 69 . The “data 3 +data 4 ” is set in the area for the method name in the data block  1305 .  
         [0059]     In this way, the argument analysis processing for the method “subtract” is completed. Also, the instance analysis processing for the method “multiply” is completed. That is, the processing up to the step S 53  for the method “multiply” is completed. The name of the method “multiply” is obtained in the step S 55  and set in the area for the method name in the data block  1301 . In the step S 57 , a method priority corresponding to the method “multiply” is obtained, and priority “ 2 ” (see  FIG. 10 ) is set in the area for the priority order in the data block  1301 . Then, the argument analysis processing is carried out for the method “multiply” in the step S 59 . In the argument analysis processing, a decision is made as to whether the argument of the method “multiply” is an expression or not in the step S 81 . Because the argument is “data 5 ” in this example, it is determined that the argument is not an expression. In step S 83 , the argument is set in the area for the argument data in the data block  1301 . A flag indicating whether the argument of the data block  1301  is an expression or not is set to “0”.  
         [0060]     By carrying out the processing described so far, a data structure including a chain of data blocks as shown in  FIG. 13  is generated. The chain of the data blocks is made to correspond to a cell in the table in the table data storage  5 .  
         [0061]     Incidentally, the processing described in connection with  FIGS. 8-13  is a processing only for one method in the cell of the table or for one term in a case where plural terms are present in one cell. In some cases, the aforementioned processing must be carried out plural times for each one cell.  
         [0062]     Next, the conversion processing (the step S 37  in  FIG. 7 ) is described by referring to  FIGS. 14-17 . First, the expression converter  6  identifies an unprocessed forefront data block in the data block storage  7  (step S 91 ). Then, it carries out a subexpression conversion processing for a group of data blocks chained from the forefront data block (step S 93 ). This processing will be described later. After that, it judges whether all the data blocks have been processed (step S 95 ). If there is any unprocessed data block, control returns to the step S 91 . If the processing for all the data blocks is completed, control goes back to the original processing.  
         [0063]     The subexpression conversion processing is described by referring to  FIG. 15 . First, the expression converter  6  reads out data (data in the area for the method name or in the area for the argument data) in the area of the data block that is to be processed (step S 101 ). Then, it judges whether the read method name is a method of the BigDecimal class (step S 103 ). If it is judged that the read method name is a method of the BigDecimal class, it judges whether the method priority for the instance of the method is lower than the priority of the method itself (step S 105 ). For example, in the arithmetic operational expression that is a basis of the data blocks shown in  FIG. 13 , the method “multiply” is shown next to the method “subtract” when viewed from the left. However, the actual calculation is the multiplication of the argument of the method “multiply” and the whole instance of the method “multiply”, which includes the arithmetic operation by the method “subtract”. Accordingly, if the expression is converted to a normal arithmetic operational expression, the whole instance must be parenthesized according to the priorities of operators. However, in the case of a subtraction or summation that is not higher in priority than a multiplication (i.e., “subtract” or “add” is used instead of “multiply”), no parentheses are necessary. Accordingly, the value of the area for the priority order for the forefront data block  1301  and the value of the area for the priority order for the data block  1302 , which is referenced from the area for the instance data are compared.  
         [0064]     In a case where the priority of the method in the instance of this method is lower than that of the method itself, it generates an opening parenthesis to the left side and registers the open parenthesis (step S 107 ). For example, “(” is stored into the cell to be processed in the table data storage  5 . Then, control proceeds to step S 109 . On the other hand, in a case where the priority of the method in the instance of this method is higher than that of the method itself, it carries out a second instance conversion processing (step S 109 ). The second instance conversion processing will be described later. Then, it judges whether the opening parenthesis has been generated (step S 111 ). In a case where control has passed through the step S 107 , the opening parenthesis has been generated. Therefore, it generates a closing parenthesis to the right side and registers the closing parenthesis (step S 113 ). For example, “)” is stored into the cell to be processed in the table data storage  5 . In a case where it is judged that the opening parenthesis has not been generated or after the steps S 113 , it converts the method name of the method to be processed into an operator, and registers the operator (step S 115 ). If the method is “multiply”, it is converted into “*”. If the method name is “add”, it is converted into “+”. If the method name is “subtract”, it is converted into “−”. If the method name is “divide”, it is converted into “/”. If the method name is “pow”, it is converted into “**”. The operator is registered in the cell to be processed in the table data storage  5 . Then, it carries out a second argument conversion processing (step S 117 ). This second argument conversion processing will be described later. Then, control returns to the original processing.  
         [0065]     On the other hand, if it is judges at the step S 103  that the read method name or the like does not indicate a method of the BigDecimal class, it is considered that a normal method or expression is stored in the data block being processed. Therefore, it expands the data block (step S 119 ). For example, if it is a normal expression, it is left intact. If it is a normal method, it reads out data from the area for the instance data and expands the read data into a form such as “instance.method”. Then, it carries out a word/phrase conversion processing using the word/phrase dictionary  8  and code dictionary  9 , for instance, and registers the result (step S 121 ). If there is no registration in the word/phrase dictionary  8  or code dictionary  9 , the data is registered intact into the cell to be processing in the table data storage  5 . If the instance is “in_param”, the method name is “NISSU”, and there is a registration in the word/phrase dictionary  8  as shown in  FIG. 5 , a conversion to “input area. No. of days” is made, and the result is registered into the cell to be processed in the table data storage  5 . Then, control returns to the original processing.  
         [0066]     Next, the second instance conversion processing at the step S 109  is described by referring to  FIG. 16 . First, the expression converter  6  judges whether the instance of the method to be processed is a method invocation (step S 125 ). That is, it checks whether or not a pointer to the data block to be referenced is registered in the area for the instance data in the data block relating to the present processing. If the instance of the method to be processed is a method invocation, it identifies the data block at the invocation destination from the pointer (step S 129 ), and carries out the subexpression conversion processing in  FIG. 15  (step S 131 ). Then, control returns to the original processing. On the other hand, in a case where the instance of the method to be processed is not a method invocation, it expands the instance name stored in the area for the instance data in the data block relating to this processing, and registers the expanded instance name in the cell to be processed in the table data storage  5  (step S 127 ). Here, it converts a character string indicating the instance name into a word or phrase indicating the meaning by referring to the word/phrase dictionary  8 , for example, converts the value of the variable into a word or phrase indicating the meaning by referring to the code dictionary  9 , and registers the results into the cell to be processed in the table data storage  5 . In a case where there is no registration in the word/phrase dictionary  8  and code dictionary  9 , it registers the instance name or the value of the variable intact. Then, control returns to the original processing. As described above, in a case where a method is stipulated in the instance, data blocks are chained. Therefore, the processing is carried out along the chain.  
         [0067]     Next, the second argument conversion processing (step S 117 ) is described by referring to  FIG. 17 . First, the expression converter  6  checks whether the argument to be processed is an expression (step S 135 ). This can be easily judged according to the state of the flag indicating whether the argument of the data block is an expression or not. If the block is an expression, it generates an opening parenthesis to the left side, and registers the opening parenthesis in the cell to be processed in the table data storage  5  (step S 137 ). Then, it identifies the data block relating to the argument by referring to the area for the argument data in the data block of the method (step S 139 ).  
         [0068]     If it is judged at the step S 135  that the argument is not an expression, or after the step S 139 , it carries out the subexpression conversion processing for the argument (step S 141 ). In particular, if the decision made in step S 135  is affirmative (YES), the processing is performed for the data block identified at the step S 139 . If the decision made in the step S 135  is negative (NO), the processing is performed for the data block of the original method. Then, it judges whether the opening parenthesis has been generated (step S 143 ). That is, a decision is made as to whether control has passed through the step S 137 . In a case where the opening parenthesis has been generated, it generates the corresponding closing parenthesis, and registers the closing parenthesis in the cell to be processed in the table data storage  5  (step S 145 ). Then, control returns to the original processing. On the other hand, in a case where the opening parenthesis has not been generated, control returns to the original processing.  
         [0069]     The data block as shown in  FIG. 13  is processed by performing the aforementioned processing to obtain a normal arithmetic operational expression that is easily readable for the reviewer, and by further converting the expression into words or phrases indicating the meaning of the variable to present them to the reviewer in tabular form.  
         [0070]     With respect to the processing in  FIGS. 14-17 , a case where a data block as shown in  FIG. 13  is processed is described in detail. First, the expression converter  6  reads out the method name “multiply” registered in the area for the method name in the data block  1301  in the step S 101 . In the step S 103 , it checks whether the method is a method of the BigDecimal class. Because the method “multiply” is a method of the BigDecimal class, it compares the priority registered in the area for the priority order in the data block  1301  for the method “multiply” with the priority registered in the area for the priority order in the data block  1302 , the latter priority being obtained by tracing from the pointer set in the area for the instance data in the data block  1301 . Then, it judges whether the priority of the method of the instance of the method “multiply” is lower than that of the method “multiply” itself. In this example, the priority of the method “subtract” of the instance of the method “multiply” is “ 3 ”. The priority of the method “multiply” itself is “ 2 ”. Therefore, the condition is satisfied. Accordingly, it generates the opening parenthesis in the step S 107 , resulting in “(” at this stage. Then, it carries out the second instance conversion processing in the step S 109 . In the second instance conversion processing, it judges whether the instance of the method “multiply” is a method invocation in the step S 125 . Because the method name “subtract” is registered in the area for the instance data in the data block  1302 , the method name being obtained by tracing from the pointer set in the area for the instance data in the data block  1301 , it is determined that the instance is a method invocation. Then, it identifies the data block  1302  of the invocation destination in the step S 129 . After that, it carries out the subexpression conversion processing in the step S 131 .  
         [0071]     In the step S 101  of the subexpression conversion processing, the expression converter  6  reads out the method name “subtract” registered in the area for the method name in the data block  1302 . In the step S 103 , it checks whether the method name indicates a method of the BigDecimal class. Because the method “subtract” is a method of the BigDecimal class, it compares the priority registered in the area for the priority order in the data block  1302  for the method “subtract” with the priority registered in the area for the priority order in the data block  1303 , the latter priority being obtained by tracing from the pointer set in the area for the instance data in the data block  1302 . Then, it judges whether the priority of the method of the instance of the method “subtract” is lower than that of the method “subtract” itself. In this example, the priority of the method “add” of the instance of the method “subtract” is “ 3 ”. The priority of the method “subtract” itself is “ 3 ”. Therefore, the condition is not satisfied. Accordingly, it carries out the second instance conversion processing in the step S 109 . In the second instance conversion processing, it judges whether the instance of the method “subtract” is a method invocation in the step S 125 . Because the method name “add” is registered in the area for the method name in the data block  1303 , which is obtained by tracing from the pointer set in the area for the instance data in the data block  1302 , it is determined that the instance is a method invocation. Then, it identifies the data block  1303  of the invocation destination in the step S 129 . After that, it carries out the subexpression conversion processing in the step S 131 .  
         [0072]     In the step S 101  of the subexpression conversion processing, the expression converter  6  reads out the method name “add” registered in the area for the method name in the data block  1303 . Then, it checks whether the method is a method of the BigDecimal class in the step S 103 . Because the method “add” is a method of the BigDecimal class, it compares the priority registered in the area for the priority order in the data block  1303  for the method “add” with the priority of the instance set in the area for the instance data in the data block  1303  in the step S 105 . Because the instance “data 1 ” is registered in the area for the instance data in the data block  1303 , no priority is set. Accordingly, the condition is not satisfied. Consequently, it carries out the second instance conversion processing in the step S 109 . In the second instance conversion processing, it judges whether the instance of the method “add” is a method invocation in the step S 125 . As described previously, “data 1 ” is registered in the area for the instance data in the data block  1303 . Therefore, it is determined that there is no method invocation. Then, the instance name “data 1 ” from the area for the instance data in the data block  1303  is read out and expanded, resulting in “(data 1 ”. Because the second instance conversion processing for the method “add” is completed, it judges whether the opening parenthesis has been generated in the processing for the method “add” at the step S 111 . Because the opening parenthesis is not generated here, it expands an operator corresponding to the method name “add”, resulting in “(data 1 +”. Then, it carries out the second argument conversion processing in the step S 117 .  
         [0073]     In the second argument conversion processing, the expression converter  6  judges whether the argument of the data block  1303  is an expression, according to the state of the flag indicating whether the argument is an expression or not. Because “1” indicating that it is an expression is registered in this example, it generates the opening parenthesis in the step S 137 , resulting in “(data 1 +(”. Next, it identifies the data block  1304  for the argument from the pointer in the area for the argument data in the data block  1303  (step S 139 ). Then, it carries out the subexpression conversion processing at the step S 141 .  
         [0074]     In the subexpression conversion processing, the expression converter  6  reads out a method name “method 1 ” from the area for the method name in the data block  1304  in the step S 101 . It is determined in the step S 103  that “method 1 ” is not a method of the BigDecimal class. Then, in the step S 119 , it expands the data block  1304 , resulting in “(data 1 +(data 2 .method 1 ”. As a result, the subexpression conversion processing for the data block  1304  is completed. Then, control returns to the second argument conversion processing for the argument of the data block  1303 . In the step S 143 , it judges whether the opening parenthesis has been generated. Because the opening parenthesis was generated in the step S 137 , it generates a closing parenthesis in the step S 145 , resulting in “(data 1 +(data 2 .method 1 )”. Thus, the second argument conversion processing for the argument of the data block  1303  is completed, and the subexpression conversion processing for the data block  1303  is also completed. Then, the second instance conversion processing for the instance of the data block  1302  is completed, and control returns to the subexpression conversion processing for the data block  1302 .  
         [0075]     As a result, the expression converter  6  judges whether the opening parenthesis was generated in the step S 111 . However, because the opening parenthesis has not been generated for the data block  1302 , control goes to the step S 115 . In the step S 115 , it expands an operator corresponding to the method name “subtract”, resulting “(data 1 +(data 2 .method 1 )−” at this stage. Then, it carries out the second argument conversion processing in the step S 117 .  
         [0076]     In the second argument conversion processing, the expression converter  6  judges whether the argument is an expression, according to the state of the flag indicating whether the argument of the data block  1302  is an expression or not in step S 135 . Because the flag is “1” in the data block  1302 , the argument is an expression. Therefore, it generates an opening parenthesis, resulting in “(data 1 +(data 2 .method 1 )−(”. Also, it identifies the data block relating to the argument from the pointer registered in the area for the argument data in the data block  1302  (step S 139 ). In this example, the data block  1305  is identified. In the step S 141 , it carries out the subexpression conversion processing for the argument “data 3 +data 4 ”.  
         [0077]     In the subexpression conversion processing, the expression converter  6  reads out the method name “data 3 +data 4 ” from the area for the method name in the data block  1305  in the step S 101 . In the step S 103 , it judges whether “data 3 +data 4 ” is a method of the BigDecimal class. Because the “data 3 +data 4 ” is not a method of the BigDecimal class, it expands the data block in the step S 119 , resulting in “(data 1 +(data 2 .method 1 )−(data 3 +data 4 ”. In this way, the subexpression conversion processing for the data block  1305  is completed, and control returns to the second argument conversion processing for the data block  1302 . Then, it judges whether the opening parenthesis has been expanded in the step S 143 . Because control has passed through the step S 137 , the opening parenthesis has been generated, it generates the closing parenthesis in the step S 145 , resulting in “(data 1 +(data 2 .method 1 )−(data 3 +data 4 )”. With this step, the second argument conversion processing for the data block  1302  is completed. At the same time, the subexpression conversion processing for the data block  1302  is also completed. In addition, the second instance conversion processing for the data block  1301  is completed.  
         [0078]     Accordingly, control returns to the subexpression conversion processing for the data block  1301 , and the expression converter  6  judges whether the opening parenthesis has been generated in the step S 111 . Because control has passed through the step S 107 , the opening parenthesis has been generated. Therefore, it generates the closing parenthesis in the step S 113 . Furthermore, it converts the method name into a corresponding operator. At this stage, “(data 1 +(data 2 .method 1 )−(data 3 +data 4 )*” is obtained. Then, it carries out the second argument conversion processing for the data block  1301  in the step S 117 .  
         [0079]     In the second argument conversion processing, the expression converter  6  judges whether the argument of the data block  1301  is an expression, according to the state of the flag indicating whether the argument is an expression or not in the step S 135 . Because the flag is set to “0” in the data block  1301 , the argument is not an expression. Therefore, it carries out the subexpression conversion processing for “data 5 ” registered in the area for the argument data in the data block  1301  in the step S 141 .  
         [0080]     In the subexpression conversion processing, the expression converter  6  reads out the data “data 5 ” registered in the area for the argument data in the data block  1301  in the step S 101 , and judges whether the data is a method of the BigDecimal class in the step S 103 . Because the “data 5 ” is not a method, it expands the argument data in the data block  1301  intact in the step S 119 , resulting in “(data 1 +(data 2 .method 1 )−(data 3 +data 4 )*data 5 ”.  
         [0081]     In this way, the methods are converted into data in a form that can be easily reviewed by the reviewer. Incidentally, in the above embodiment, conversions using the word/phrase dictionary  8  are not performed for data 1 , data 2 , method 1 , data 3 , data 4 , and data 5 . However, if they are registered in the word/phrase dictionary  8 , the conversions for them are carried out. With respect to “data 2 .method 1 ”, because extra parentheses are attached, they are removed in unnecessary parenthesis removing processing.  
         [0082]     In a case where the following source program exists, for example, data stored in the table data storage  5  takes a form as shown in  FIG. 18 .  
         [0083]     [Example of Source Program] 
                                   class sample {        void calc(denpyo in_param){         if (in_param.getRETURNCODE( ) == 0) {          out_param.setNISSU(in_param.getNISSU( ));         } else {          if (in_param.getRETURNCODE( ) == 1) {          out_param.setGANKIN(BigDecimal.valueOf(out_param.       getGANKIN( ).get( )+(1+200)).divide(BigDecimal.valueOf(out_param.       getRITANI( ).get( )),0,BigDecimal.ROUND_DOWN).       multiply(BigDecimal.valueOf(out_param.getRITANI( ).get( ))));           if (out_param.getHASUKUBUN( ).equals(“2”)) {            out_param.setRISOKU(BigDecimal.valueOf(out_param.get       WK_GANKIN( ).get( )).multiply(BigDecimal.valueOf(out_param.       getNISSU( ).get( ))).multiply(BigDecimal.valueOf(out_param.       getRATE( ).get( ))).divide(BigDecimal.valueOf(365).multiply(BizMath.       pow(BigDecimal.value Of(10),7,10)),10,BigDecimal.ROUND_DOWN).       add(new BigDecimal(“0.999”)));           } else {            out_param.setWK_RISOKUA(BigDecimal.       valueOf(out_param.getWK_GANKIN( ).get( )).multiply(BigDecimal.       valueOf(out_param.getNISSU( ).get( ))).multiply(BigDecimal.       valueOf(out_param.getRATE( ).get( ))).divide(BigDecimal.valueOf(365).       multiply(BizMath.pow(BigDecimal.valueOf(10),7,1)),1,BigDecimal.       ROUND_DOWN));           }          } else {           out_param.setERRORNO(2);           return;          }         }         out_param.setERRORNO(0);        }       }                  
 
         [0084]     Project name, work space, and file name listed in a higher position within  FIG. 18  are data items extracted from the environment within the specification data generation apparatus  10 . Because they are not main portions of the present embodiment, their description is omitted herein. The method name corresponds to the data in the second line of the source program. The third and following lines are summarized in the table of  FIG. 18 . The first line is the same as in  FIG. 4C . The fundamental data stored are identical. However, because conditions are set at plural stages, they are classified into each column such as condition  1 , condition  2 , or condition  3 . In a case where more conditions are set, the number of columns is increased. In the column of condition  3 , which has the item number 3, “fraction treatment category. round-up” is registered. The data is provided by the code dictionary  9 , and indicates the variable value “2” of “output area. fraction treatment category”.  
         [0085]     Next, the conversion rule in the character string conversion whose detail explanation was omitted in the above description is described.  
         [0000]     (1) Basic Conversion Pattern  
         [0086]     The basic conversion pattern is indicated in  FIG. 19 .  
         [0000]     (2) Expansion of a Conversion Method to the BigDecimal Type  
         [0087]     In order to carry out the arithmetic operation of BigDecimal, it is necessary to convert a data class variable and work variable into a variable of BigDecimal type. However, because it is unnecessary in the specification data, following conversion is carried out.  
         [0000]     BigDecimal.valueOf(getter of data item)=&gt;data item  
         [0000]     A specific example is as follows:  
         [0000]     BigDecimal.valueOf(wk — ×16.getWK_ZOUHENGK( ).get( ))  
         [0000]    
       
         
           
              =&gt;wk — ×16. WK_ZOUHENGK 
 
 (3) Method “Divide of BigDecimal Class 
 
           
         
       
     
         [0089]     In the above description, the methods “subtract”, “add” and “multiply” are indicated as examples. The method “divide” is converted as follows:  
         [0000]     BigDecimal.valueOf(data_item — 1).divide(BigDecimal.valueOf(data_item — 2), length under the decimal point, ROUNDED destination)=&gt;data_item — 1/data_item — 2  
         [0000]     A specific example is as follows:  
         [0000]     BigDecimal.valueOf(wk — ×16.getWK_ZOUHENGK( ).get( )).divide(BigDecimal.valueOf(kwlarkgv.getKGVKWCYUJBZK( ).get( ), 10, BigDecimal.ROUND_DOWN)  
         [0000]    
       
         
           
              =&gt;wk — ×16.WK_ZOUHENGK/KWLARKGV.KGVKWCYUJBZK 
 
 (4) Method pow of BizMath Class 
 
           
         
       
     
         [0091]     The following conversion is carries out.  
         [0000]     BizMath.pow(multiplicand, exponent)  
         [0000]    
       
         
           
              =&gt;multiplicand**exponent 
 
 BizMath.pow(BigDecimal.valueOf(multiplicand), exponent, reference length under the decimal point) 
 
              =&gt;multiplicand**exponent 
 
 A specific example is as follows: 
 
 BizMath.pow(BigDecimal.valueOf(wk — ×16.getWK_ZOUHENGK( ).get( ), 3, 5) 
 
              =&gt;wk — ×16.WK_ZOUHENGK**3 
 
 (5) Method pow of Math Class 
 
           
         
       
     
         [0095]     The following conversion is carried out.  
         [0000]     Math.pow(double type multiplicand, double type exponent)  
         [0000]    
       
         
           
              =&gt;multiplicand**exponent 
 
 A specific example is as follows: 
 
 Math.pow((double) (wk — ×16.getWK_ZOUHENGK( ).get( ), 3.5) 
 
              =&gt;wk — ×16.WK_ZOUHENGK**3.5 
 
 (6) Method for Special Processing 
 
           
         
       
     
         [0098]     The following conversion is carried out.  
         [0000]     setscale (length under the decimal point, BigDecimal.ROUND_DOWN) (never set at the end of the setter method)=&gt;“” (delete)  
         [0000]     A specific example is as follows:  
         [0000]     x.setCC(BigDecimal.valueOf(x.getCC( ).get( )).multiply(BigDecimal.valueOf(x.getBB( ).get( )).setScale(10, BigDecimal.ROUND_DOWN).divide(BigDecimal.valueOf(x.getAA( ).get( )), 8, BigDecimal.ROUND_DOWN))  
         [0000]    
       
         
           
              =&gt;CC=CC*BB/AA  
           
         
       
     
         [0100]     In addition, the following conversion is also carried out.  
         [0000]     setter method(calculation result. setscale (length under the decimal point, BigDecimal.ROUND_HALF_UP))  
         [0000]    
       
         
           
              =&gt;add “ROUNDED” to the end of the execution statement after the conversion 
 
 A specific example is as follows: 
 
 x.setCC(BigDecimal.valueOf(x.getCC( ).get( )).divide(BigDecimal.valueOf(x.getAA( ).get( )), 8, BigDecimal.ROUND_DOWN).setScale(8, BigDecimal.ROUND_HALF_UP)) 
 
              =&gt;CC=CC/AA ROUNDED 
 
 (7) Others 
 
           
         
       
     
         [0103]     For example, “set” is replaced with “=” as described below.  
         [0104]     wk — ×16.setWK_RISOKUG(wk — ×16.getWK_RISOKUG( ).checkDigit(BigDecimal.valueOf(wk — ×16.getWK_KEKKA1( ).get( )).multiply(BigDecimal.valueOf(wk — ×16.getWK_KEKKA2( ).get( ))).multiply(BigDecimal.valueOf(wk — ×16.getWK_TSUKISU( ).get( )).divide(BizMath.pow(BigDecimal.valueOf( 10),7,0 ), 0,BigDecimal.ROUND_DOWN)))=&gt;  
         [0000]     wk — ×16.WK_RISOKUG=wk — ×16.WK_RISOKUG.checkDigit(wk — ×16.WK_KEKKA1*wk — ×16.WK_KEKKA2*wk — ×16.WK_TSUKISU/(10**7))  
         [0105]     As described above, although one embodiment of the invention is described, this invention is not limited to this. That is, in an actual program, the functional blocks in  FIG. 1  does not always correspond to program modules. In addition, because it is possible to obtain the same result, there are some steps, which can be executed in parallel or whose execution orders can be exchanged.  
         [0106]     The specification data generation apparatus  10  is a computer, and the computer has a configuration as shown in  FIG. 20 . That is, a memory  2501  (storage device), a CPU  2503  (processor), a hard disk drive (HDD)  2505 , a display controller  2507  connected to a display device  2509 , a drive device  2513  for a removal disk  2511 , an input device  2515 , and a communication controller  2517  for connection with a network are connected through a bus  2519 . An operating system (OS) and an application program for carrying out the foregoing processing in respective embodiments, are stored in the HDD  2505 , and when executed by the CPU  2503 , they are read out from the HDD  2505  to the memory  2501 . As the need arises, the CPU  2503  controls the display controller  2507 , the communication controller  2517 , and the drive device  2513 , and causes them to perform necessary operation. Besides, intermediate processing data is stored in the memory  2501 , and if necessary, it is stored in the HDD  2505 . In this embodiment of this invention, the application program to realize the aforementioned functions is stored in the removal disk  2511  and distributed, and then it is installed into the HDD  2505  from the drive device  2513 . It may be installed into the HDD  2505  via the network such as the Internet and the communication controller  2517 . In the computer as stated above, the hardware such as the CPU  2503  and the memory  2501 , the OS and the necessary application program are systematically cooperated with each other, so that various functions as described above in details are realized.  
         [0107]     Although the present invention has been described with respect to a specific preferred embodiment thereof, various change and modifications may be suggested to one skilled in the art, and it is intended that the present invention encompass such changes and modifications as fall within the scope of the appended claims.