程序变换方法、程序及存储媒体.pdf

一种程序变换方法，以及为将此程序在计算机上实行的程序及存储这个程序的存储媒体。然而，在以前的技术中，具有由于实际不调出(函数)的分析不充分而无法消除虚拟函数的情况。本发明的变换步骤(S100)，目标分析步骤(S104)，检出包含在程序的类(Class)中的生成了目标的类(Class)，将该结果存储到分析信息存储部分(12)，不要函数分析步骤(S105)，分析接受了信息存储部分(12)上存储的信息而不生成类(Class)的函数(不要函数)，将该结果存储到分析信息存储部分(12)，不要函数消除步骤(S106)，接受存储在分析信息存储部分(12)上的信息，消除不要函数的定义。

1.  一种程序变换方法，是包括变换由目标指向语言记述的，至少有一种类(Class)的输入程序的变换步骤的程序变换方法，其特征为：
上述变换步骤，包括：
输入上述输入程序的输入步骤；
分析上述输入程序中的上述类(Class)有无目标的生成，将分析结果存储到目标分析信息存储部分的目标分析步骤；
对应于上述目标分析信息存储部分的上述分析结果，抽出不要的处理，将分析结果存储到不要处理信息存储部分的不要函数分析步骤；
对应于上述不要处理信息存储部分的上述分析结果，消除上述不要处理的不要处理消除步骤；
输出目的程序的输出步骤。

2.  根据权利要求1所述的程序变换方法，其特征为：
上述目标分析步骤中，当分析出上述类(Class)为不生成目标的目标未生成类(Class)时，
上述不要处理分析步骤中，上述不要处理，抽出与上述目标未生成类(Class)相关的函数。

3.  根据权利要求1所述的程序变换方法，其特征为：
上述目标分析步骤中，当分析出上述类(Class)为不生成目标的目标未生成类(Class)时，
上述不要处理分析步骤中，上述不要处理，抽出上述目标未生成类(Class)的函数。

4.  根据权利要求1所述的程序变换方法，其特征为：
上述变换步骤，还包括在上述输入步骤之后且上述不要处理分析步骤之前，分析上述类(Class)的承接关系的类(Class)分析步骤，
上述不要处理分析步骤中，分析包含在上述类(Class)中类(Class)树状图中的叶的类(Class)是否生成目标，当上述叶的类(Class)不生成目标时，上述不要处理，是抽出上述叶的类(Class)的处理。

5.  根据权利要求4所述的程序变换方法，其特征为：
上述叶的类(Class)，是第1叶的类(Class)，
上述不要处理分析步骤中，在由于第1叶的类(Class)的消除又有形成为叶的第2叶的类(Class)的情况下，且，上述第2叶的类(Class)不生成目标时，上述不要处理，是还抽出上述第2叶的类(Class)的处理。

6.  根据权利要求1所述程序变换方法，其特征为：
上述变换步骤，还包括：
在上述输入步骤之后且上述不要处理分析步骤之前，分析上述类(Class)的承接关系的类(Class)分析步骤，以及
分析上述类(Class)的虚拟函数的虚拟函数分析步骤；
上述不要处理分析步骤，包括：抽出承接上述类(Class)，且不重写上述类(Class)的虚拟函数的非重写虚拟函数保有类(Class)的步骤；以及上述类(Class)和上述非重写虚拟函数保有类(Class)中目标不生成时，上述不要处理包括抽出上述类(Class)的上述虚拟函数的步骤。

7.  根据权利要求6所述的程序变换方法，其特征为：
上述不要处理分析步骤，还包括特定不要处理分析步骤，
上述特定不要处理分析步骤中，判定上述类(Class)的虚拟函数是否全部不要，当判定为上述类(Class)的虚拟函数全部不要时，上述不要处理，抽出Constructor内自动生成的处理。

8.  根据权利要求6所述程序变换方法，其特征为：
上述不要处理分析步骤，还包括特定不要数据分析步骤，
上述特定不要数据分析步骤中，判定上述类(Class)的虚拟函数是否所有都不要，当判定为上述类(Class)的虚拟函数全部都不要时，上述不要处理，抽出有关上述类(Class)的虚拟函数的数据。

9.  根据权利要求1所述的程序变换方法，其特征为：
上述变换步骤，还包括基于来自用户的消除处理指定，分析由上述消除处理指定所指定的处理的消除指定处理分析步骤。

10.  根据权利要求9所述的程序变换方法，其特征为：
上述消除处理指定，是记述上述输入程序中的消除处理指定记述。

11.  根据权利要求9所述的程序变换方法，其特征为：
上述消除处理指定是指令线选择(Command Line Option)。

12.  根据权利要求1所述的程序变换方法，其特征为：
上述变换步骤，重复数次。

13.  一种程序变换方法，是包括变换由目标指向语言记述的，至少有一种类(Class)的输入程序的变换步骤的程序变换方法，其特征为：
包括：译码步骤和结合步骤，且
译码步骤包含：输入上述输入程序的输入步骤；抽出上述类(Class)的与目标相关的处理的目标关联处理抽出步骤；分析有关上述类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析步骤；输出包括上述目标分析信息存储部分的上述分析结果及上述输入程序的变换结果的输出步骤；
结合步骤包含：基于上述译码步骤中的上述输出步骤的输出，抽出不要处理的不要处理分析步骤；对应于上述不要处理分析步骤的分析结果，连接连接对象的连接步骤。

14.  根据权利要求13所述程序变换方法，其特征为：
上述目标分析步骤中，当分析出上述类(Class)是不生成目标的目标未生成类(Class)时，
上述不要处理分析步骤中，上述不要处理，抽出上述目标未生成类(Class)的函数。

15.  根据权利要求13所述程序变换方法，其特征为：
上述译码步骤，还包括分析上述类(Class)的承接关系的类(Class)分析步骤；
上述输出步骤中，还输出上述类(Class)分析步骤的分析结果；
上述不要处理分析步骤中，分析包含在上述类(Class)的类(Class)树状图中的叶的类(Class)是否生成目标，
当上述叶的类(Class)不生成目标时，上述不要处理，是抽出上述叶的类(Class)的处理。

16.  根据权利要求15所述程序变换方法，其特征为：
上述叶的类(Class)，是第1叶的类(Class)，
上述不要处理分析步骤中，在第1叶的类(Class)的消除又有重新形成叶的第2叶的类(Class)的情况下，且，上述第2叶的类(Class)不生成目标时，上述不要处理，是抽出上述第2叶的类(Class)的处理。

17.  根据权利要求13所述程序变换方法，其特征为：
上述译码步骤，还包括：
分析上述类(Class)的承接关系的类(Class)分析步骤，以及
分析上述类(Class)的虚拟函数的虚拟函数分析步骤；
上述输出步骤中，还输出上述类(Class)分析步骤及上述虚拟函数分析步骤的分析结果；
上述不要处理分析步骤，还包括：承接上述类(Class)，且抽出不重写上述类(Class)的虚拟函数的非重写式虚拟函数保有类(Class)的步骤；上述类(Class)和上述非重写虚拟函数保有类(Class)中目标不生成时，上述不要处理包括抽出上述类(Class)的上述虚拟函数的步骤。

18.  根据权利要求17所述程序变换方法，其特征为：
上述不要处理分析步骤，还包括特定不要处理分析步骤；
上述特定不要处理分析步骤中，
判定上述类(Class)的虚拟函数是否全部不要，当判定为上述类(Class)的虚拟函数全部不要时，上述不要处理，抽出与上述类(Class)的上述虚拟函数相关的数据。

19.  一种序变换方法，是包括变换由目标指向语言记述的，至少有一种类(Class)的输入程序的变换步骤的程序变换方法，其特征为：
包括：前置编译步骤和变换步骤，且
前置编译步骤包含：输入上述输入程序的第1输入步骤；上述输入程序中分析上述类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析步骤；对应于上述目标分析信息存储部分的上述分析结果，抽出不要处理的不要处理分析步骤；
变换步骤包含：输入上述输入程序及上述不要处理分析步骤的分析结果的第2输入步骤；对应于上述不要处理分析步骤的分析结果消除不要处理的不要处理消除步骤。

20.  根据权利要求19所述程序变换方法，其特征为：
上述目标分析步骤中，当分析出上述类(Class)是不生成目标的目标未生成类(Class)时，
上述不要处理分析步骤中，上述不要处理，抽出上述目标未生成类(Class)的函数。

21.  根据权利要求19所述程序变换方法，其特征为：
上述前置编译步骤，还包括：在上述第1输入步骤之后且上述不要处理分析步骤之前，分析上述类(Class)的承接关系的类(Class)分析步骤；
上述不要处理分析步骤中，分析包含在上述类(Class)的类(Class)树状中的叶的类(Class)是否生成目标，当上述叶的类(Class)不生成目标时，上述不要处理，是抽出上述叶的类(Class)的处理。

22.  根据权利要求21所述程序变换方法，其特征为：
上述叶的类(Class)，是第1叶的类(Class)，
上述不要处理分析步骤中，在第1叶的类(Class)的消除又有重新形成叶的第2叶的类(Class)的情况下，且，上述第2叶的类(Class)不生成目标时，上述不要处理，是抽出上述第2叶的类(Class)的处理。

23.  根据权利要求19所述程序变换方法，其特征为：
包括：
上述前置编译步骤，还包含：
在上述输入步骤之后且上述不要处理分析步骤之前，分析上述类(Class)的承接关系的类(Class)分析步骤，以及
分析上述类(Class)的虚拟函数的虚拟函数分析步骤；
上述不要处理分析步骤包含：承接上述类(Class)，且抽出不重写上述类(Class)的虚拟函数的非重写虚拟函数保有类(Class)的步骤；上述类(Class)和上述非重写虚拟函数保有类(Class)中不生成目标时，上述不要处理包括抽出上述类(Class)的上述虚拟函数的步骤。

24.  根据权利要求23所述程序变换方法，其特征为：
上述不要处理分析步骤，还包括特定不要处理分析步骤；
上述特定不要处理分析步骤中，判定上述类(Class)的虚拟函数是否全部不要，当判定为上述类(Class)的虚拟函数全部不要时，上述不要处理，抽出constructer内自动生成的处理。

25.  根据权利要求23所述程序变换方法，其特征为：
上述不要处理分析步骤，还包括特定不要处理分析步骤，
上述特定不要处理分析步骤中，判定上述类(Class)的虚拟函数是否全部不要，当判定出上述类(Class)的虚拟函数全部不要时，上述不要处理，抽出上述类(Class)的上述虚拟函数关联的数据。

26.  一种程序，是将由目标指向语言记述的输入程序通过计算机进行变化的程序，其特征为：
包括：
输入上述输入程序的方法；
对包含在上述程序中的类(Class)，分析其目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析方法；
对应于上述目标分析信息存储部分的上述分析结果，抽出不要的处理，将分析结果存储到不要处理信息存储部分的不要处理分析方法；以及
对应于上述不要处理信息存储部分的上述分析结果，消除上述不要处理的不要处理消除方法。

27.  一种程序，是由目标指向语言记述的输入程序通过计算机进行变换的程序，其特征为：
包括：译码方法和结合方法，且
上述译码方法包含：输入上述输入程序的输入方法；上述输入程序中分析上述类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析方法；输出上述目标分析信息存储部分的上述分析结果及输出上述输入程序的变换结果的输出方法；
上述结合方法，包含：基于上述译码方法中的上述输出方法的输出，抽出不要处理的不要处理分析方法；对应于上述不要处理分析方法的分析结果，连接连接对象的连接方法。

28.  一种程序，是由目标指向语言记述的输入程序通过计算机进行变化的程序，其特征为：
包括：前置编译方法和变换方法，且
上述前置编译方法包含：输入输入程序的第1输入方法；分析上述输入程序的上述类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析方法；对应于上述目标分析信息存储部分的上述分析结果，抽出不要处理的不要处理分析方法；
上述变换方法包含：输入上述输入程序及上述不要处理分析方法的分析结果的第2输入方法；对应于上述不要处理分析方法的分析结果消除不要处理的不要处理消除方法。

29.  一种存储媒体，是计算机读取可能的，将由目标指向语言记述的输入程序通过计算机进行变换的存储程序的存储媒体，其特征为：
上述程序，包括：
输入上述输入程序的方法；
包含在上述程序中分析有关类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析方法；
对应于上述目标分析信息存储部分的上述分析结果，抽出不要的处理，将分析结果存储到不要处理信息存储部分的不要处理分析方法；以及
对应于上述不要处理信息存储部分的上述分析结果，消除上述不要处理的不要处理消除方法。

30.  一种存储媒体，是计算机读取可能的，存储由目标指向语言记述的输入程序且由计算机进行变换的程序的存储媒体，其特征为：
上述程序，包括：译码方法和结合方法，且
上述译码方法包含：输入上述输入程序的输入方法；上述程序中分析有关上述类(Class)的目的生成的有无，将分析结果存储到目标分析信息存储部分的目标分析方法；输出包括上述目标分析信息存储部分的上述分析结果及上述输入程序的变换结果的输出方法；
上述结合方法包含：基于上述译码方法中的上述输出方法的输出，抽出不要处理的不要处理分析方法；对应于上述不要处理分析方法的分析结果，连接连接对象的连接方法。

31.  一种存储媒体，是计算机读取可能的，存储由目标指向语言记述的输入程序且由计算机进行变换的程序的存储媒体，
上述程序，包括：前置编译方法和变换方法，且
上述前置编译方法包含：输入输入程序的第1输入方法；分析上述输入程序中的上述类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析方法；对应于上述目标分析信息存储部分的上述分析结果，抽出不要处理的不要处理分析方法；
变换方法包含：输入上述输入程序及上述不要处理分析方法的分析结果的第2输入方法；对应于上述不要处理分析方法的分析结果消除不要处理的不要处理消除方法。

程序变换方法、程序及存储媒体
技术领域
本发明，是涉及将由目标指向语言记述了的程序转变为目标程序的程序变换方法、为使该程序能在计算机上实行的程序以及存储这个程序的存储媒体。
背景技术
近年，伴随着程序的大规模化，为了提高程序开发的效率，也为谋求(程序)再利用，或者是为了提高程序的维修性，C++或者是Java(V)等的目标指向语言的程序开发被引起重视。
以前的程序型语言，注重程序，通过调出程序组合实行所希望的处理。对此，目标指向语言，是注重了汇总数据和对这个数据的操作的类(Class)，通过类(Class)目的和这个操作的组合实行所希望的处理。且这个操作，在C++中称为成员函数，在Java(R)中称为方法(method)。
一般情况下，因为一个程序中使用的类(Class)的数量增长为多数，成员函数(方法)的数量也变得庞大。为此，程序要成为大规模的话，实际使用怎样的成员函数(方法)对程序设计员来讲是很难掌握的，实际不被调出的成员函数(方法)的编译(code)被包含到目的程序中的情况增多。为此，在将目标指向语言做成的程序变换为目的程序的自动编译器(compiler)中，尽可能减少成员函数(方法)的数量的技术就变得重要了。
作为消除成员函数(方法)的以前的技术，是在全程序中调查成员函数(方法)实际上是否被使用，消除经过调查而得知没有被使用的成员函数(方法)的技术(参照专利文件1)。
然而，在目标指向语言中，对应于程序实行时的目的实体的变动具有变换多样性的概念，在C++中，具有多样性的成员函数称为虚拟函数。在Java(R)中，全部的方法都具有多样性。
使用虚拟函数，在程序实行时，对应于目标的实型调出的成员函数会发生变换，为此，编程时由静态分析要调出任何一个成员函数都是困难的。但是，使用虚拟函数的情况下，某种条件下分析不被调出的成员函数则是可能的。
作为消除不被调出的虚拟函数的方法，是注目于虚拟函数的调出，由这个调出在有可能调出的成员函数上标注记号的方法(参照专利文件2)。在这个方法中，对于所有的虚拟函数的调出由于有可能调出的函数都标注了记号，没有标注记号的函数则作为不调出函数分析。
(专利文件1)
特开2001-14171号公报
(专利文件2)
特开平9-269898号公报
(发明所要解决的课题)
然而，在以前的技术中，具有由于实际不调出(函数)的分析不充分而无法消除虚拟函数的情况。
专利文件1所揭载的技术，参照了成员函数的地址，但是，不被调出的成员函数被分析为有必要(保留)时，就形成了冗长的编码。为了解成员函数实际上到底是否被调出，就必须通过对全部的程序的成员函数地址是如何使用的做出分析，这就需要庞大的分析时间。
还有，专利文件2所揭示的技术中，误将没有可能调出的虚拟函数分析成为有可能调出，出现了无法消除的冗长编码的情况。
发明内容
本发明，是以通过构筑更多的消除不要成员函数(方法)地方法，提供更有效的程序变换方法为目的。为此，注意到只要目标不生成，对应它的成员函数就为不要(函数)这一点。
(解决课题的方法)
本发明的第1程序变换方法，是包括变换由目标指向语言记述的，至少有一种类(Class)的输入程序的变换步骤的程序变换方法。上述变换步骤，包括：输入上述输入程序的输入步骤；分析上述程序中上述类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析步骤；对应于上述目标分析信息存储部分的上述分析结果，抽出不要的处理，将分析结果存储到不要处理信息存储部分的不要函数分析步骤；对应于上述不要处理信息存储部分的上述分析结果，消除上述不要处理的不要处理消除步骤；输出目标程序的输出步骤。
这样，通过判定类(Class)中生成目标处理的有无确实可以消除不要的处理。因此，比以前更容易削减更多的编码尺寸。
且，作为类(Class)的一种，构造体或者是共用体等也成为分析对象，就是通用性高的程序也能够做成有效的编码。
上述目标分析步骤中，当分析出上述类(Class)是不生成目标的目标未生成类(Class)时，上述不要处理分析步骤中，上述不要处理，通过抽出与上述目标未生成类(Class)相关的函数组，可能将函数组作为处理对象。
且，所谓的“目标未生成类(Class)相关的函数组”，并不只是目标未生成类(Class)的相关函数组，可以说是目标未生成类(Class)和具有承接关系的类(Class)的函数，在这些函数中也包含虚拟函数。
上述目标分析步骤中，当分析出上述类(Class)是不生成目标的目标未生成类(Class)时，上述不要处理分析步骤中，上述不要处理，通过抽出与上述目标未生成类(Class)相关的函数组，就可能将不被调出的函数消除。
上述变换步骤，还包括在上述输入步骤之后且上述不要处理分析步骤之前，分析上述类(Class)的承接关系的类(Class)分析步骤，上述不要处理分析步骤中，分析包含在上述类(Class)的类(Class)树状图中的叶的类(Class)是否生成目标，当上述叶的类(Class)不生成目标时，上述不要处理，通过抽出上述叶的类(Class)的处理，考虑了类(Class)的承接关系的分析成就为可能。具体地讲，包含在类(Class)树状图中的类(Class)中的任何目标生成时，可以单独消除叶的类(Class)的不要处理。
上述叶的类(Class)，是第1叶的类(Class)，上述不要处理分析步骤中，在第1叶的类(Class)的消除又有重新形成叶的第2叶的类(Class)的情况下，且，上述第2叶的类(Class)不生成目标时，上述不要处理，通过再抽出上述第2叶的类(Class)的处理，也可能消除分析中途的由叶形成的类(Class)。
上述变换步骤，在上述输入步骤之后且上述不要处理分析步骤之前，还包括：分析上述类(Class)的承接关系的类(Class)分析步骤；分析上述类(Class)的虚拟函数的虚拟函数分析步骤；上述不要处理分析步骤，承接上述类(Class)，且，抽出不重写上述类(Class)的虚拟函数的非重写式虚拟函数保有类(Class)的步骤；上述类(Class)和上述非重写式虚拟函数保有类(Class)中不生成目标的情况下，由于上述不要处理抽出上述类(Class)的上述虚拟函数的步骤，就可能消除不被调出的虚拟函数。
上述不要处理分析步骤，还包括特定不要处理分析步骤，上述特定不要处理分析步骤中，当判定为上述类(Class)的虚拟函数全部不要的情况下，上述不要处理，通过抽出自动编译器内自动生成的处理，由消除某类(Class)所有的虚拟函数可以消除重新的不要处理，这样就可以进一步削减编码尺寸。
上述不要处理分析步骤，还包括特定不要数据分析步骤，上述特定不要数据分析步骤中，判定上述类(Class)的虚拟函数是否所有都不要，当判定为上述类(Class)的虚拟函数全部都不要的时候，上述不要处理，通过抽出上述类(Class)的虚拟函数的数据，由消除某类(Class)的所有的虚拟函数可以消除重新生成的不要数据，这样就可以进一步削减编码尺寸。
上述变换步骤，由于还包括基于用户的消除处理指定，分析由上述消除处理指定所指定的处理的消除指定处理分析步骤，由消除指定可消除变换步骤无法自动检出的处理，这样就可以进一步削减编码尺寸。
上述消除处理指定，由于它是上述输入程序中记述的消除处理指定记述，这样就可以保持程序的记述容易性。
由于上述消除处理指定是指令线选择(Command Line Option)，不需要输入程序的变更，在变换步骤实行时可以指定消除。
上述变换步骤，最好的是重复数次。
本发明的第2程序变换方法，是包括变换由目标指向语言记述的，至少有一种类(Class)的输入程序的变换步骤的程序变换方法，包括：输入上述输入程序的输入步骤；抽出上述类(Class)的与目标相关的处理的目标关联函数抽出步骤；上述程序中分析上述类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析步骤；输出包括上述目标分析信息存储部分的上述分析结果及上述输入程序的变换结果的输出步骤的译码步骤；在上述译码步骤中基于上述输出步骤的输出，抽出不要处理的不要处理分析步骤；对应于上述不要处理分析步骤的分析结果，连接连接对象的连接步骤的结合步骤。
这样，通过判定有关类(Class)中生成目标的处理的有无确实可以消除不要的处理。因此，比以前更容易削减更多的编码尺寸。
上述目标分析步骤中，当分析为上述类(Class)是不生成目标的目标未生成类(Class)时，上述不要处理分析步骤中，上述不要处理，通过抽出与上述目标未生成类(Class)相关的函数，就可能消除不调出的函数。
上述译码步骤，还包括分析上述类(Class)的承接关系的类(Class)分析步骤；上述输出步骤中，还输出上述类(Class)分析步骤的分析结果，上述不要处理分析步骤中，分析包含在上述类(Class)中类(Class)树状图中的叶的类(Class)是否生成目标，当上述叶的类(Class)不生成目标时，上述不要处理，通过抽出上述叶的类(Class)的处理，考虑了类(Class)的承接关系的分析就成为可能。具体地讲，包含在类(Class)树状图中的类(Class)中的任何目标生成时，可以单独消除叶的类(Class)的不要处理。
上述叶的类(Class)，是第1叶的类(Class)，上述不要处理分析步骤中，在第1叶的类(Class)的消除又有重新形成叶的第2叶的类(Class)的情况下，且，上述第2叶的类(Class)不生成目标时，上述不要处理，通过再抽出上述第2叶的类(Class)的处理，也可能消除分析中途的由叶形成的类(Class)。
上述译码步骤，还包括：分析上述类(Class)承接关系的类(Class)分析步骤；分析上述类(Class)的虚拟函数的虚拟函数分析步骤；上述输出步骤中，还输出上述类(Class)分析步骤及上述虚拟函数分析步骤的分析结果；上述不要处理分析步骤，抽出承接上述类(Class)，且不重写上述类(Class)的虚拟函数的非重写虚拟函数保有类(Class)的步骤；上述类(Class)和上述非重写虚拟函数保有类(Class)中不生成目标的情况下，由于上述不要处理抽出上述类(Class)的上述虚拟函数的步骤，就可能消除不被调出的虚拟函数。
上述不要处理分析步骤，还包括特定不要处理分析步骤，上述特定不要处理分析步骤中，判定上述类(Class)的虚拟函数是否全部不要，当判定为上述类(Class)的虚拟函数全部不要的情况下，上述不要处理，通过抽出上述类(Class)的上述虚拟函数相关的数据，由消除某类(Class)所有的虚拟函数可以消除重新生成的不要数据，这样就可进一步削减编码尺寸。
本发明的第3程序变换方法，是包括变换由目标指向语言记述的，至少有一种类(Class)的输入程序的变换方法的程序变换方法，包括：输入上述输入程序的第1输入方法；上述输入程序中分析上述类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析方法；对应于上述目标分析信息存储部分的上述分析结果，抽出不要处理的不要处理分析方法的前置编译方法；输入上述输入程序及上述不要处理分析方法的分析结果的第2输入方法；对应于上述不要处理分析方法的分析结果消除不要处理的不要处理消除方法的变换方法。
这样，通过判定有关类(Class)中生成目标的处理的有无确实可以消除不要的处理。因此，比以前更容易削减更多的编码尺寸。
上述目标分析方法中，当分析为上述类(Class)不生成目标的目标未生成类(Class)时，上述不要处理分析方法中，上述不要处理，通过抽出与上述目标未生成类(Class)的函数，就可能消除不调出的函数。
上述前置编译方法，在上述第1输入方法之后且上述不要处理分析方法之前，还包括分析上述类(Class)的承接关系的类(Class)分析方法，上述不要处理分析方法中，分析包含在上述类(Class)中类(Class)树状中的叶的类(Class)是否生成目标，当上述叶的类(Class)不生成目标时，上述不要处理，通过抽出上述叶的类(Class)的处理，考虑了类(Class)的承接关系的分析就成为可能。具体地讲，包含在类(Class)树状图中的类(Class)中的任何目标生成时，可以单独消除叶的类(Class)的不要处理。
上述叶的类(Class)，是第1叶的类(Class)，上述不要处理分析方法中，在第1叶的类(Class)的消除又有重新形成叶的第2叶的类(Class)的情况下，且，上述第2叶的类(Class)不生成目标时，上述不要处理，通过再抽出上述第2叶的类(Class)的处理，也可能消除分析中途的由叶形成的类(Class)。
上述前置编译方法，在上述输入方法之后且上述不要处理分析方法之前，还包括：分析上述类(Class)的承接关系的类(Class)分析方法；分析上述类(Class)的虚拟函数的虚拟函数分析方法；上述不要处理分析方法，承接上述类(Class)，且，抽出不重写上述类(Class)的虚拟函数的非重写虚拟函数保有类(Class)的方法；上述类(Class)和上述非重写虚拟函数保有类(C lass)中不生成目标的情况下，由于上述不要处理包括抽出上述类(Class)的上述虚拟函数的方法，就可能消除不被调出的虚拟函数。
上述不要处理分析方法，还包括特定不要处理分析方法，上述特定不要处理分析方法中，判定上述类(Class)的虚拟函数是否全部不要，当判定为上述类(Class)的虚拟函数全部不要的情况下，上述不要处理，通过抽出上述类(Class)的上述虚拟函数相关的数据，由消除某类(Class)所有的虚拟函数可以消除重新生成的不要数据，可进一步削减编码尺寸。
上述不要处理分析方法，还包括特定不要处理分析方法，上述特定不要处理分析方法中，判定上述类(Class)的虚拟函数是否全部不要，当判定为上述类(Class)的虚拟函数全部不要的情况下，上述不要处理，通过抽出上述类(Class)的上述虚拟函数相关的数据，由消除某类(Class)所有的虚拟函数可以消除重新生成的不要数据，可进一步削减编码尺寸。
本发明的第1程序，是将由目标指向语言记述的输入程序通过计算机进行变换的程序，包括：输入上述输入程序的方法；分析包含在上述程序中的类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析方法；对应于上述目标分析信息存储部分的上述分析结果，抽出不要的处理，将分析结果存储到不要处理信息存储部分的不要函数分析方法；对应于上述不要处理信息存储部分的上述分析结果，消除上述不要处理的不要处理消除方法。
这个程序由计算机实行后，通过判定类(Class)中生成目标的处理的有无确实可以消除不要的处理。因此，比以前更容易削减更多的编码尺寸。
本发明的第2程序，是由目标指向语言记述的输入程序通过计算机进行变换的程序，包括：输入上述输入程序的输入方法；上述程序中分析有关上述类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析方法；输出上述目标分析信息存储部分的上述分析结果及上述输入程序的变换结果的输出方法的译码方法；基于上述译码方法中上述输出方法的输出，抽出不要处理的不要处理分析方法；对应于上述不要处理分析方法的分析结果，连接连接对象的连接方法的结合方法。
这个程序由计算机实行后，通过判定类(Class)中生成目标的处理的有无确实可以消除不要的处理。因此，比以前更容易削减更多的编码尺寸。
本发明的第3程序，是将由目标指向语言记述的输入程序通过计算机进行变换的程序，包括：输入输入程序的第1输入方法；上述输入程序中分析上述类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析方法；对应于上述目标分析信息存储部分的上述分析结果，抽出不要处理的不要处理分析方法的前置编译方法；输入上述输入程序及上述不要处理分析方法的分析结果的第2输入方法；包括对应于上述不要处理分析方法的分析结果消除不要处理的不要处理消除方法的变换方法。
这个程序由计算机实行后，通过判定类(Class)中生成目标的处理的有无确实可以消除不要的处理。因此，比以前更容易削减更多的编码尺寸。
本发明的第1存储媒体，是将由目标指向语言记述的输入程序通过计算机进行变换的程序存储的存储媒体，上述程序包括：输入上述输入程序的方法；分析上述程序中类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析方法；对应于上述目标分析信息存储部分的上述分析结果，抽出不要的处理，将分析结果存储到不要处理信息存储部分的不要函数分析方法；对应于上述不要处理信息存储部分的上述分析结果，消除上述不要处理的不要处理消除方法；的计算机读取可能的存储媒体。
这个存储媒体上存储的程序由计算机实行后，通过判定类(Class)中生成目标的处理的有无确实可以消除不要的处理。因此，比以前更容易削减更多的编码尺寸。
本发明的第2存储媒体，是存储由目标指向语言记述的输入程序通过计算机进行变换的程序的存储媒体，上述程序包括：输入上述输入程序的输入方法；分析上述程序中上述类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析方法；输出上述目标分析信息存储部分的上述分析结果及上述输入程序的变换结果的输出方法的译码方法；在上述译码方法中基于上述输出方法的输出，抽出不要处理的不要处理分析方法；对应于上述不要处理分析方法的分析结果，连接连接对象的连接方法的结合方法；为特征的计算机读取可能的存储媒体。
这个存储媒体上存储的程序由计算机实行后，通过判定类(Class)中生成目标的处理的有无确实可以消除不要的处理。因此，比以前更容易削减更多的编码尺寸。
本发明的第3存储媒体，是存储由目标指向语言记述的输入程序通过计算机变换的程序的存储媒体，上述程序包括：输入输入程序的第1输入方法；分析上述输入程序中上述类(Class)的目标生成的有无，将分析结果存储到目标分析信息存储部分的目标分析方法；包括对应于上述目标分析信息存储部分的上述分析结果，抽出不要处理的不要处理分析方法的前置编译方法；输入上述输入程序及上述不要处理分析方法的分析结果的第2输入方法；包括对应于上述不要处理分析方法的分析结果消除不要处理的不要处理消除方法的变换方法；为特征的计算机读取可能的存储媒体。
这个存储媒体上存储的程序由计算机实行后，通过判定类(Class)中生成目标的处理的有无确实可以消除不要的处理。因此，比以前更容易削减更多的编码尺寸。
附图说明
图1，是表示第1实施方式中程序变换步骤S100的构成的程序框图。
图2(a)、图2(b)、图2(c)及图2(d)，分别表示类(Class)抽出步骤S103、目标分析步骤S104、不要函数分析步骤S105及不要函数消除步骤S106的构成的程序框图。
图3，是表示程序的例的图。
图4(a)，是表示类(Class)抽出步骤S103中所抽出的类(Class)信息表的图。
图4(b)，是表示目标分析步骤S104中所分析的类(Class)信息表的图。
图4(c)，是表示不要函数分析步骤S105中所分析的消除函数集合S1的表的图。
图5，是表示第2实施方式中程序变换步骤S200的构成的程序框图。
图6，是表示类(Class)分析步骤S201的构成的程序框图。
图7，是表示不要函数分析步骤S202的构成的程序图。
图8，是表示程序的例的图。
图9(a)，是表示类(Class)分析步骤S201中所抽出的类(Class)信息表的图。
图9(b)，是表示类(Class)分析步骤S201中所分析的类(Class)树状图。
图9(c)，是表示目标分析步骤S104中所分析的类(Class)信息表的图。
图10(a)～图10(e)，是表示消除函数集合S1的状态变换的图。
图11，是表示第3实施方式中程序变换步骤S300的构成的程序框图。
图12，是表示虚拟函数分析步骤S301的构成的程序框图。
图13，是表示不要函数分析步骤S302的构成的程序框图。
图14，是表示不要函数分析步骤S302的步骤h6的构成的程序框图。
图15，是表示程序的例的图。
图16(a)，是表示类(Class)分析步骤S201中所抽出的类(Class)信息表的图。
图16(b)，是表示类(Class)分析步骤S201中所分析的类(Class)树状图。
图16(c)，是表示目标分析步骤S104中所分析的类(Class)信息表的图。
图17(a)～图17(d)，是表示虚拟函数集合S2的状态变换的表的图。
图17(e)～图17(h)，是表示类(Class)集合S3及消除函数集合S1的状态变换的表的图。
图18，是表示第4实施方式中程序变换步骤S400的构成的程序框图。
图19，是表示不要处理·不要数据分析步骤S401的构成的程序框图。
图20，是表示不要处理·不要数据消除步骤S402的构成的程序框图。
图21(a)，是表示消除类(Class)集合S4的状态的表的图。
图21(b)，是表示类(Class)F的虚拟函数表的表图。
图21(c)，是表示与类(Class)F相关的虚拟函数表的地址设定处理的图。
图22，是表示第5实施方式中程序变换步骤S500的构成的程序框图。
图23，是表示消除指定函数分析步骤S501的构成的程序框图。
图24(a)和图24(b)，是表示消除函数集合的状态变换的表的图。
图25，是表示第6实施方式中译码步骤S610及结合步骤S620，各步骤S10、S620中保存生成的信息的存储部分的构成的程序框图。
图26(a)，是表示类(Class)抽出步骤S613的构成的程序框图。
图26(b)，是表示目标分析步骤S614的构成的程序框图。
图27，是表示结合步骤S620中不要函数分析步骤S621及连接步骤S622的构成的程序框图。
图28(a)～图28(c)，是表示有关文件夹「a.cc」、「b；cc」及「main.cc」的分析信息存储部分22中收存的分析数据的表的图。
图28(d)，是表示不要函数分析步骤S621中分析结果的表的图。
图29，是表示第7实施方式中译码步骤S710及结合步骤S720和存储各个步骤S710、S720中生成的信息的存储部分的构成的程序框图。
图30，是表示类(Class)分析步骤S711的构成的程序框图。
图31(a)，是表示不要函数分析步骤S721的构成的程序框图。
图31(b)，是表示不要函数分析步骤S721中步骤s1(类(Class)树状集合S1’计算步骤)的构成的程序框图。
图32(a)～图32(f)，是表示有关文件夹「a.cc」～「main.cc」收存在分析信息存储部分22的分析数据的表的图。
图33(a)，是表示不要函数分析步骤S721的步骤s1中计算的类(Class)树状集合S1’表的图。
图33(b)和图33(c)，是表示不要函数分析步骤S721的步骤S2’中计算的非静止成员函数定义集合S2’及目标生成类(Class)集合S3’的表的图。
图34(a)～图34(e)，是表示不要函数分析步骤S721中叶的类(Class)集合S6及消除函数集合S5的状态的变换的表的图。
图35，是表示第8实施方式中存储译码步骤S810及结合步骤S820和各步骤S810、S820中生成的信息的存储部分的结构的程序框图。
图36，是表示不要函数分析步骤S821的构成的程序框图。
图37(a)～图37(e)，是表示有关文件夹「f.cc」、「g.cc」、「h.cc」、「main.cc」及「sub.cc」的收存在分析信息存储部分22的类(Class)集合S1、非静止成员函数集合S2及目标生成集合S3的表的图。
图38(a)，是表示不要函数分析步骤S821的步骤u1中计算的类(Class)树状集合S1’的表的图。
图38(b)和图38(c)，是表示不要函数分析步骤S821的步骤u2中计算的虚拟函数集合S2’及目的生成类(Class)集合S3’的表的图。
图39(a)～图39(c)，是表示虚拟函数集合S2’、消除函数集合S5及类(Class)集合S6的状态的变换的表的图。
图40，是表示第9实施方式中存储译码步骤S910及结合步骤S920和各步骤S910、S920中生成的信息的存储部分的构造的程序框图。
图41，是表示虚拟函数分析步骤S911的构成的程序框图。
图42，是表示不要函数·不要数据分析步骤S921的构造的程序框图。
图43，是表示连接步骤S922的构成的程序框图。
图44(a)～图44(e)，是表示有关文件夹「f.cc」、「g.cc」、「h.cc」、「main.cc」及「sub.cc」的收存在分析信息存储部分22的类(Class)集合S1、非静止成员函数集合S2及目标生成集合S3的表的图。
图45(a)～图45(c)，是表示第9实施方式中，类(Class)树状集合S1’、虚拟函数集合s2’及目标生成类(Class)集合S3’的状态的表的图。
图46(a)～图46(c)，是表示虚拟函数集合S2’、类(Class)集合S6、消除函数集合S6及消除虚拟函数表集合S7的状态变换表的图。
图47，是表示第10实施方式中存储编译步骤S1010及程序变换步骤S1020和各步骤S1010、S1020中生成的信息的存储部分的构成的程序框图。
(符号说明)
S100    程序变换步骤        S107    输出步骤
S101    输入步骤            S200    程序变换步骤
S102    句法分析步骤        S201    类(Class)分析步骤
S103    类(Class)抽出步骤   S202    不要函数分析步骤
S104    目标分析步骤        S300    程序变换步骤
S105    不要函数分析步骤    S301    虚拟函数分析步骤
S106    不要函数消除步骤    S302    不要函数分析步骤
S400    程序变换步骤         S811     虚拟函数分析步骤
S401    不要处理·不要数     S820     结合步骤
        据分析步骤           S821     不要函数分析步骤
S402    不要处理·不要数     S910     译码步骤
        据消除步骤           S911     虚拟函数分析步骤
S500    程序变换步骤         S920     结合步骤
S501    消除指定函数分析     S921     不要函数·不要数
        步骤                          据解析步骤
S610    译码步骤             S922     连接步骤
S611    输入步骤             S1010    编译步骤
S612    句法分析步骤         S1011    输入步骤
S613    类(Class)抽出步骤    S1012    句法分析步骤
S614    目标分析步骤         S1013    类(Class)抽出步
S615    输出步骤         骤
S620    结合步骤             S1014    目标分析步骤
S621    不要函数分析步骤     S1015    不要函数分析步骤
S622    连接步骤             S1020    程序变换步骤
S710    译码步骤             S1021    输入步骤
S711    类(Class)分析步骤    S1022    句法分析步骤
S720    结合步骤             S1023    不要函数消除步骤
S721    不要函数分析步骤     S1024     输出步骤
S810    译码步骤
具体实施方式
目标指向语言中，数据与这个数据对应的成员函数是成对的。本发明，着眼于在没有存储数据的类(Class)目标的情况下，对应该数据的成员函数，因为没有操作对象而成为不要(函数)这一点。
且，本说明书及附图中，使用了类(Class)C1、C2这样的用语。这是将接受处理的各类(Class)一般化表示。函数F1、类(Class)树状图T1、通过P1及连接对象L1也一样。
(第1实施方式)
以下，参照附图说明本发明第1实施方式中编程器(图中未示)进行的程序变换方法。且，这个程序变换方法，是将记述处理的程序输入到编程器实行的。图1，是表示第1实施方式中程序变换步骤S100的构成的程序框图。
如图1所示，本实施方式的变换步骤S100，包括：输入成为变换对象的程序的输入步骤S101；分析程序的句法，进行象征桌面(SymbolTable)、句法主干(Syntax Tree)等的生成的句法分析步骤S102；将包含在程序中的类(Class)信息存储到分析信息存储部分12上的类(Class)抽出步骤S103；检出包含在程序类(Class)中的生成了目标的类(Class)，将该结果存储到分析信息存储部分12的目标分析步骤S104；分析接受了信息存储部分12上存储着的信息而不生成类(Class)的函数(不要函数)，将该结果存储到分析信息存储部分12的不要函数分析步骤S105；接受存储在分析信息存储部分12上的信息，消除不要函数的定义的不要函数消除步骤S106；将消除了不要函数的程序(以下成为目的程序)输出给生成编译存储部分13的输出步骤S107。重复类(Class)抽出步骤S103～不要函数消除步骤S106直至输出的各编译不再发生变换。
且，不要函数分析步骤S105中，基于从分析信息存储部分12得到的由类(Class)抽出步骤S103抽出的信息和由目标分析步骤S104分析了的类(Class)信息，分析不要函数。
接下来，参照程序例说明程序变换步骤S100中自输入步骤S101～输出步骤S107的更详细的操作。图3，是表示程序的例的图。
首先，程序变换步骤S100开始后，输入步骤S101、句法分析步骤S102的处理也就跟着进行了，但是因为这些步骤都不是本发明的主要之点，在此省略它们的详细说明。
接下来，参照图2(a)、图3及图4(a)说明类(Class)抽出步骤S103的处理。图2(a)，是表示类(Class)抽出步骤S103的构成的程序框图。
如图2(a)所示，类(Class)抽出步骤S103中，包含在句法分析步骤S102内分析了的程序中的所有类(Class)C1，重复步骤a1～步骤a4所表示的循环。
在图3所示的程序中，成为类(Class)C1的是类(Class)A和类(Class)B。图3所示的程序组合到类(Class)抽出步骤S103，由步骤a1抽出如类(Class)A，在步骤a2中判定类(Class)A是否已经登录到分析信息存储部分12中。在开始判定类(Class)A时，判定结果为No，处理转至步骤a3。在此，类(Class)A的判定进行到第2次以后时，类(Class)A已经登录到分析信息存储部分12中，所以判定结果成为Yes，处理转至步骤a4。
步骤a3中，将类(Class)A登录到分析信息存储部分12中，初期化对应类(Class)A的生成标志使其成为OFF，处理转至步骤a4。
处理转至步骤a4后，类(Class)A换成其他的类(Class)，这种情况下，类(Class)B，重复步骤a1～步骤a4的循环。以上处理结束后，分析信息存储部分12中的生成标志的状态便成为图4(a)所示的状态。且，图4(a)，是表示由类(Class)抽出步骤S103抽出的类(Class)信息的表的图。
接下来，参照图2(b)及图3说明目标分析步骤S104的处理。图2(b)是表示目标分析步骤S104的构成的程序框图。
如图2(b)所示，目标分析步骤S104中，包含在程序内的所有处理(函数自身)，重复步骤b1～步骤b4所表示的循环。
图3所示的程序中成为分析对象的处理，是如文件夹「a.cc」中的文句「a＝1；」或者是文件夹「main.cc」中的文句「B obj_b；」等。图3所示的程序组合到目标分析步骤S104后，由步骤b1抽出如文句「a＝1；」，由步骤b2判定文句「a＝1；」是否生成类(Class)目标处理。因为文句「a＝1；」不生成类(Class)目标，所以判定结果成为No，处理转至步骤b4。在此，所谓的生成类(Class)目标处理，意味着由类(Class)型变数生成、成员函数生成、还有向类(Class)型的型变换生成而生成目标的情况的处理。本实施方式中，如派生类(Class)内的基础类(Class)那样的辅助目标是(发明)对象外。
处理转至步骤b4后，程序中包含的其他处理，重复步骤b1～步骤b4的循环。图3所示的程序中，因为生成类(Class)目标的处理只是文件夹「main.cc」的文句「B obj_b；」，所以，这由步骤b2判定的话，结果成为Yes，处理转至步骤b3。
步骤b3中，从分析信息存储部分12取得文句「B obj_b；」的生成有关成为目标对象的类(Class)B的类(Class)信息，设定类(Class)B的生成标志为ON。以上处理结束后，分析信息存储部分12中生成标志的状态成为如图4(b)所示的状态。在此，图4(b)，是表示目标分析步骤S104中分析了的类(Class)信息的表的图。
接下来，参照图2(c)、图3及图4(c)说明不要函数分析步骤S105的处理。图2(c)，是表示不要函数分析步骤S105的构成的程序框图。
如图2(c)所示，不要函数分析步骤S105中，首先在步骤c1中初期化消除函数集合S1使其成为空集合。并且，分析信息存储部分12中存储的所有的类(Class)C2，重复步骤c2～步骤c5所示的循环。
图3所示程序中，成为类(Class)C2的是类(Class)A及类(Class)B。图3所示的程序组合到不要函数分析步骤S105后，由步骤c2抽出类(Class)A，由步骤c3判定类(Class)A的生成标志是否为OFF。如图4(b)所示的那样，因为类(Class)A的生成标志为OFF，处理转至步骤c4。
步骤c4中，类(Class)A的所有非静止成员函数都被追加到消除函数集合S1中。其结果，如图4(c)所示那样，在消除函数集合S1上，追组合到了作为类(Class)A的非静止成员函数的「A∷A() 」、「A∷(void)」及「A∷g(int)」。在此，图4(c)，是表示不要函数分析步骤S105中分析了的消除函数集合S1的表的图。其后，处理转至步骤c5。
处理转至步骤c5后，类(Class)A换成其他的类(Class)，这种情况下的类(Class)B，重复步骤c2～步骤c5的循环。这时，如图4(b)所示的那样，因为类(Class)B的生成标志为ON，步骤c3的判定结果为No，处理转至步骤c5。
接下来，参照图2(d)和图3说明不要函数消除步骤S106的处理。图2(d)，是表示不要函数消除步骤S106的构成的程序框图。
如图2(d)所示那样，不要函数消除步骤S106中，包含在消除函数集合S1的所有的函数F1，重复步骤d1～步骤d3的循环。
图3所示的程序中，成为函数F1的是「A∷A()」、「A∷f(void)」及「A∷g(int)」。图3所示的程序组合到不要函数消除步骤S106后，由步骤d1抽出函数自身(函数定义)「A∷A()」，在步骤d2消除「A∷A()」。其后，处理转至步骤d4，通过重复步骤d1～步骤d3的处理，按顺序消除「A∷f(void)」及「A∷g(int)」。
本实施方式中，注意到在目标没有生成的情况下，与其对应的函数也不会被调出这一点。通过判定程序中是否生成各类(Class)的目标的处理，确实可以消除不要函数。因此，比以前容易削减更多的编码尺寸。
且，本实施方式中，至输出编译不再发生变化为止重复类(Class)抽出步骤S103～不要函数消除步骤S106。由此，由消除函数定义确实可以消除重新形成的函数，可以更有效地变换程序。然而，本发明中，为了缩短编程时间，将类(Class)抽出步骤S103至不要函数消除步骤S106的一连串处理既可以事先定为只进行一定次数，也可以定为只进行一次。
(第2实施方式)
以下，参照图面说明本发明第2实施方式中编程器(图中未示)进行的程序变换方法。且，这个程序变换方法，是将记述处理的程序输入到编程器实行的。图5，是表示第2实施方式中程序变换步骤S200的构成的程序框图。
如图5所示，本实施方式的变换步骤S200，包括：输入成为变换对象的程序的输入步骤S101；分析程序的句法，进行象征桌面(SymbolTable)、句法主干(syntax tree)等的生成的句法分析步骤S102；将包含在程序中的类(Class)信息抽出，再分析类(Class)定义将类(Class)之间的承接关系存储在分析信息存储部分12上的类(Class)抽出步骤S201；检出包含在程序的类(Class)中的生成了目标的类(Class)，将该结果存储到分析信息存储部分12的目标分析步骤S104；分析接受了信息存储部分12上存储的信息而不生成类(Class)的函数(不要函数)，将该结果存储到分析信息存储部分12的不要函数分析步骤S202；接受存储在分析信息存储部分12上的信息，消除不要函数的定义的不要函数消除步骤S106；将消除了不要函数的程序(以下成为目的程序)输出给生成编译存储部分13的输出步骤S107。类(Class)抽出步骤S201～不要函数消除步骤S106，直至输出的各编译不再发生变换进行重复。
本实施方式中，类(Class)分析步骤S201，不只是抽出包含在程序中的类(Class)信息，还分析类(Class)定义并将类(Class)之间的承接关系存储到分析信息存储部分12中。并且，在不要函数分析步骤S202中，基于从分析信息存储部分12由类(Class)分析步骤S201抽出的类(Class)及类(Class)之间的承接关系的信息，和由目标分析步骤S104分析了的类(Class)信息，分析不要函数，存储到分析信息存储部分12中。
在此，参照程序例说明输入步骤S101～不要函数消除步骤S106的详细的操作。且，这些步骤中与第1实施方式相同之处，省略其详细的说明。图8，是表示程序的例的图。
首先，输入步骤S101及句法分析步骤S102中，由与第1实施方式同样的方法进行处理。
接下来，参照图6说明类(Class)分析步骤S201的处理。图6，是表示类(Class)分析步骤S201的构成的程序框图。如图6所示，类(Class)分析步骤S201中，包含在程序内所有的类(Class)C1，重复步骤e1～步骤e7所示的循环。
在图8所示的程序中，成为步骤C1的是类(Class)A、类(Class)B、类(Class)C、类(Class)D及类(Class)E。图8所示的程序组合到类(Class)分析步骤S201上，由步骤e1抽出如类(Class)A，在步骤e2中判定类(Class)A是否已经登录到分析信息存储部分12上。类(Class)A的判定开始时，判定结果成为No，处理转至步骤e3。在此，类(Class)A的判定进行到第2次以后时，类(Class)A已经登录到分析信息存储部分12上，所以判定结果成为Yes，处理转至步骤e7。
步骤e3中，将类(Class)A登录到分析信息存储部分12上，初期化对应类(Class)A的生成标志使其判定结果成为OFF，处理转至步骤e4。
处理转至步骤e4后，判定类(Class)A是否有基础类(Class)C2，如图8所示，因为类(Class)A不具有基础类(Class)C2，步骤e4的判定成为No，处理转至步骤e6。
在步骤e6中，重新生成类(Class)A的类(Class)树状图Tr，并将其存储到分析信息存储部分12，处理转至步骤步骤e7。在此，类(Class)树状图是表示类(Class)之间的承接关系的树状图。这时的类(Class)的类(Class)树状图中只包含类(Class)A。
处理转至步骤e7后，类(Class)A换成不同类(Class)，如类(Class)B，重复步骤e1～步骤e7的循环。如图8所示，类(Class)B是由类(Class)A派生的。也就是，类(Class)B的基础类(Class)是类(Class)A，所以，步骤e4的判定结果成为Yes，处理转至步骤e5。在步骤e5中，存储在分析信息存储部分12中的类(Class)A的类(Class)树状图Tr上追加作为派生类(Class)的类(Class)B，处理转至步骤e7。
其后，就类(Class)C、类(Class)D及类(Class)E，重复步骤e1～e7的循环。这时，如图8所示，因为类(Class)C的基础类(Class)是类(Class)A，类(Class)D及类(Class)E的基础类(Class)是类(Class)C，所以，类(Class)C、类(Class)D及类(Class)E，由步骤e5追加以类(Class)A为基础类(Class)的类(Class)树状图。以上的处理结束后，分析信息存储部分12中的生成标志成为图9(a)所示的状态，以类(Class)A为基础类(Class)的类(Class)树状图Tr，成为图9(b)所示状态。且，图9(a)，是表示类(Class)分析步骤S201中所抽出的类(Class)信息表的图。图9(b)，是表示类(Class)分析步骤S201中所分析的类(Class)的树状图Tr。
接下来，在目标分析步骤S104中，与由第1实施方式同样的方法(图2(b)所示)分析生成目标的类(Class)。其结果，在类(Class)A～类(Class)E内生成目标的是类(Class)A及类(Class)B，所以，分析信息存储部分12中的生成标志的状态成为如图9(c)所示的状态。图9(c)，是表示目标分析步骤S104中所分析的类(Class)信息表的图。
接下来，参照图7、图8说明不要函数分析步骤S202的处理。图7，是表示不要函数分析步骤S202的构成的程序图。
如图7所示，不要函数分析步骤S202中，首先，在步骤f1中初期化消除函数集合S1使其成为空集合。并且，在步骤f2中，向叶的类(Class)集合S2追加类(Class)树状图Tr内的叶的类(Class)。所谓的叶的类(Class)，是在类(Class)树状图中不再有子类(Class)(派生类(Class))的类(Class)，在图9(b)所示的类(Class)树状图Tr内，类(Class)B、类(Class)D及类(Class)E就是这样的子类(Class)。这时，消除函数集合S1及叶的类(Class)集合S2变成图10(a)所示状态。图10(a)～图10(e)，是表示消除函数集合S1的状态变换的图。并且，叶的类(Class)集合S2所包含的各类(Class)，重复步骤f3～f10的循环。
首先，由步骤f4抽出类(Class)B，从叶的类(Class)集合S2消除类(Class)B。接下来，步骤f5中，判定类(Class)B的生成标志是否为OFF。如图9(c)所示，因为类(Class)B的生成标志是ON，判定结果成为No，处理转至步骤f10。这时的消除函数集合S1及叶的类(Class)集合S2成为图10(b)所示状态。
接下来，叶的类(Class)集合S2所包含的其他类(Class)，如类(Class)D，重复步骤f3～步骤f10的循环。首先，由步骤f4抽出类(Class)D，从叶的类(Class)集合S2消除类(Class)D。接下来，步骤f5中，因为类(Class)D的生成标志为OFF(如图9(c)所示)，处理转至步骤f6。步骤f6中，向消除函数集合S1追加类(Class)D的所有的非静止成员函数。这时的消除函数集合S1及叶的类(Class)集合S2成为图10(c)所示状态。步骤f7中，从图9(b)所示的类(Class)树状图Tr消除类(Class)D。
步骤f8中，判定类(Class)树状图Tr中是否有重新形成叶的类(Class)。如图9(b)所示，因为即便是消除类(Class)D也没有成为叶的类(Class)，判定结果成为No，处理转至步骤f10。
接下来，叶的类(Class)集合S2所包含的其他类(Class)，如类(Class)E，重复步骤f3～步骤10的循环。首先，由步骤f4抽出类(Class)E，从叶的类(Class)集合S2消除类(Class)E。接下来，步骤f5中，因为类(Class)E的生成标志为OFF(如图9(c)所示)，处理转至步骤f6。步骤f6中，向消除函数集合S1追加类(Class)E的所有的非静止成员函数。步骤f7中，从图9(b)所示的类(Class)树状图Tr消除类(Class)E。
步骤f8中，判定类(Class)树状图Tr中是否有重新形成叶的类(Class)。如图9(b)所示，因为消除了类(Class)E类(Class)C成为重新形成叶的类(Class)，判定结果成为Yes，处理转至步骤f9。步骤f9中，向叶的类(Class)集合S2追加重新形成了叶的类(Class)C，处理转至步骤f10。这时的消除函数集合S1及叶的类(Class)集合S2成为图10(d)所示状态。
接下来，新追加到叶的类(Class)集合S2的类(Class)C，重复步骤f3～步骤f10的循环。
首先，由步骤f4抽出类(Class)C，从叶的类(Class)集合S2消除类(Class)C。接下来，步骤f5中，因为类(Class)C的生成标志为OFF(如图9(c)所示)，处理转至步骤f6。步骤f6中，向消除函数集合S1追加类(Class)C的所有的非静止成员函数。步骤f7中，从图9(b)所示的类(Class)树状图Tr消除类(Class)C。
步骤f8中，判定类(Class)树状图Tr中是否有重新形成叶的类(Class)。如图9(b)所示，因为即便是消除类(Class)C也没有重新形成叶的类(Class)，判定结果成为No，处理转至步骤f10。这时的消除函数集合S1及叶的类(Class)集合S2成为图10(e)所示状态，叶的类(Class)集合S2成为了空集合，所以，不要函数分析步骤S202的处理就结束了。
经过以上的步骤以后，在不要函数消除步骤S106中，由与第1实施方式同样的方法(图2(d)所示)，消除包含在消除函数集合S1中的函数定义(图8所示函数(B))。
本实施方式中，在程序中的类(Class)具有承接关系的情况下，分析该承接关系做成类(Class)树状图。并且，判定类(Class)树状图中叶的类(Class)是否生成目标。由此，可以消除有关该叶的类(Class)的函数。还有，由于该叶的类(Class)的消除，判定是否具有重新形成叶的类(Class)，再通过判定形成叶的类(Class)是否生成目标，也可以消除重新形成叶的类(Class)的函数。也就是，在分析的中途也可以消除重新形成叶的类(Class)。
本实施方式中，考虑了承接关系的分析成为了可能，在类(Class)树状图中，可以确实判定消除可能的函数和消除不可能的函数，就可以更有效地进行消除函数。因此，可以比以前更容易削减更多的编码尺寸。
且，本实施方式中，至输出编译中的变化消失为止重复类(Class)分析步骤S201～不要函数消除步骤S106。因此，由消除函数定义可以确实消除重新生成的不要函数，就可以更有效地变换程序。然而，本发明中，为了缩短编译时间，对类(Class)分析步骤S201至不要函数消除步骤S106的一连串处理，既可以事先决定进行一定的次数，也可以决定只实行一次。
(第3实施方式)
以下，参照图面说明本发明第3实施方式中编程器(图中未示)进行的程序变换方法。且，这个程序变换方法，是将记述处理的程序输入到编程器实行的。图11，是表示第3实施方式中程序变换步骤S300的构成的程序框图。
如图11所示，本实施方式的变换步骤S300，包括：输入成为变换对象的程序的输入步骤S101；分析程序的句法，进行象征桌面(SymbolTable)、句法主干(syntax tree)等的生成的句法分析步骤S102；将包含在程序中的类(Class)信息抽出，再分析类(Class)定义将类(Class)之间的承接关系存储在分析信息存储部分12上的类(Class)抽出步骤S201；进行虚拟函数分析的虚拟函数分析步骤S301；检出包含在程序的类(Class)中的生成了目标的类(Class)，将该结果存储到分析信息存储部分12的目标分析步骤S104；分析接受了信息存储部分12上存储的信息而不生成目标的类(Class)的函数(不要函数)，将该结果存储到分析信息存储部分12的不要函数分析步骤S302；接受存储在分析信息存储部分12上的信息，消除不要函数的定义的不要函数消除步骤S106；将消除了不要函数的程序(以下成为目的程序)输出给生成编译存储部分13的输出步骤S107。类(Class)抽出步骤S201～不要函数消除步骤S106，直至输出的各编译不再发生变换进行重复。
本实施方式中，虚拟函数分析步骤S301中，进行包含在程序中的类(Class)的虚拟函数的分析。当该类(Class)为承接其他类(Class)而派生的类(Class)的情况下，将派生类(Class)的虚拟函数分为重写保存和不重写保存的情况。为此，虚拟函数分析步骤S301中，分析派生类(Class)的虚拟函数是否重写基础类(Class)的虚拟函数。
并且，不要函数分析步骤S302中，从分析信息存储部分12，基于类(Class)分析步骤S201、虚拟函数分析步骤S301及目标分析步骤S104的信息，分析不要函数，并将分析结果存储到分析信息存储部分12中。
接下来，参照程序例说明输入步骤S101～不要函数消除步骤S106的详细的操作。且，这些步骤中与第1或者是第2实施方式相同之处，省略其详细的说明。图15，是表示程序的例的图。
首先，输入步骤S101及句法分析步骤S102，由与第1实施方式同样的方法进行处理。
接下来，类(Class)分析步骤S201中，由与第2实施方式相同的方法(图6所示)，进行程序中包含的类(Class)C1的信息和它的承接关系，并将其分析结果存储到分析信息存储部分12中。其结果，如图16(a)所示，在分析信息存储部分12中的类(Class)F、类(Class)G及类(Class)H的生成标志被初期化成为OFF。还有，图15所示的程序中，因为类(Class)G及类(Class)H是从类(Class)F派生的，所以，以类(Class)F为基础类(Class)的类(Class)树状图Tr就成为如图16(b)所示的状态。且，图16(a)，是表示类(Class)分析步骤S201中所抽出的类(Class)信息表的图。图16(b)，是表示类(Class)分析步骤S201中所分析的类(Class)树状图。
接下来，参照图12及图15说明虚拟函数分析步骤S301的处理。图12，是表示虚拟函数分析步骤S301的构成的程序框图。
如图12所示，虚拟函数分析步骤S301中，包含在程序中的所有类(Class)C1，重复步骤g1～g10所示的循环。
图15所示的程序中，成为类(Class)C1的是类(Class)F、类(Class)G及类(Class)H。图15所示的程序组合到虚拟函数分析步骤S301上，就由步骤g1抽出如类(Class)F，由步骤g2判定类(Class)F是否登录到了分析信息存储部分12中。在类(Class)F的判定开始时，判定结果成为No，处理转至步骤g3。在此，类(Class)F的判定在进行到第2次以后时，类(Class)F已经登录到了分析信息存储部分12中，所以判定结果成为Yes，处理转至步骤g10。
步骤g3中，将类(Class)F的信息登录到虚拟函数集合S2中。还有，初期化虚拟函数集合S2内的类(Class)F的虚拟函数定义集合及重写虚拟函数定义集合使其成为空集合。在此，虚拟函数集合S2被存储在分析信息存储部分12内。接下来，步骤g4中，判定类(Class)F有无虚拟函数定义。如图15所示，因为类(Class)F具有虚拟函数定义，所以判定结果成为Yes，处理转至步骤g5。
接下来，类(Class)F所有虚拟函数定义F1，重复步骤g5～步骤g9的循环。
步骤g6中，将类(Class)F所有的虚拟函数定义「F:m1」追加到虚拟函数集合S2内类(Class)F的虚拟函数定义集合中，步骤g7中，判定虚拟函数定义「F:m1」是否重写基础类(Class)的虚拟函数定义。这时，因为类(Class)F没有基础类(Class)，这个判定结果成为No，处理转至步骤g9。又因为类(Class)F没有其他的虚拟函数定义，类(Class)F的步骤g5～步骤g9的处理结束，处理转至步骤g10。
其后，类(Class)F换成其他的类(Class)，如类(Class)G，重复步骤g1～步骤g9的处理。如图15所示，因为类(Class)G具有虚拟函数定义，步骤g4的判定结果成为Yes，步骤g6中，将类(Class)G的虚拟函数定义「G:m1」登录到虚拟函数集合S2中的虚拟函数定义集合中。还有，如图16(b)所示，类(Class)G的基础类(Class)是类(Class)F，所以，类(Class)G的虚拟函数定义重写类(Class)F的虚拟函数定义。因此，步骤g7的判定结果成为Yes，处理转至步骤g8。步骤g8中，将由虚拟函数定义「G:m1」重写了的虚拟函数定义「F:m1」存储到虚拟函数集合S2中的重写虚拟函数定义集合。
其后，类(Class)H，也重复步骤g1～步骤g9的处理。如图15所示，因为类(Class)H具有虚拟函数定义，所以，步骤g4的判定结果成为Yes，步骤g6中，将类(Class)H的虚拟函数定义「H:m1」登录到虚拟函数集合S2中的虚拟函数定义集合中。还有，如图16(b)所示，类(Class)H的基础类(Class)是类(Class)F，所以，类(Class)H的虚拟函数定义重写类(Class)F的虚拟函数定义。因此，步骤g7的判定结果成为Yes，处理转至步骤g8。步骤g8中，将由虚拟函数定义「H:m1」重写了的虚拟函数定义「F:m1」存储到虚拟函数集合S2中的重写虚拟函数定义集合。通过以上的步骤，类(Class)F、类(Class)G及类(Class)H中的虚拟函数定义集合和重写虚拟函数定义集合，变成图17(a)所示状态。图17(a)～图17(d)，是表示虚拟函数集合S2的状态的表的图。
接下来，目标分析步骤S104中，由与第1实施方式同样的方法(图2(b)所示)分析生成目标的类(Class)。类(Class)F、类(Class)G及类(Class)H内生成目标的是类(Class)G及类(Class)H，所以，分析信息存储部分12中的生成标志的状态成为如图16(c)所示的状态。图16(c)，是表示目标分析步骤S104中所分析的类(Class)信息表的图。
接下来，参照图13、图14及图17(a)～图17(d)说明不要函数分析步骤S302的处理。图13，是表示不要函数分析步骤S302的构成的程序框图。图14，是表示不要函数分析步骤S302的步骤h6的构成的程序框图。
如图13所示，不要函数分析步骤S302中，收存在分析信息存储部分12中的所有类(Class)树状图T1，重复步骤h1～步骤h12的循环。
图15所示的程序中，成为类(Class)树状图T1的只是图16(b)所示的类(Class)树状图Tr中的一个。由步骤h1抽出类(Class)树状图Tr后，在步骤h2中，包含在类(Class)树状图Tr中的类(Class)，从根的类(Class)到叶的类(Class)的顺序，重复步骤h2～步骤h11的循环。也就是，首先进行了作为根的类(Class)的类(Class)F的处理之后，进行作为叶的类(Class)的类(Class)G及类(Class)H的处理。
类(Class)F组合到步骤h3的处理之后，判定类(Class)F是否具有不重写其他虚拟函数定义的虚拟函数定义。如图17(a)所示，类(Class)F具有作为虚拟函数定义的「F:m1」，因为类(Class)F的重写虚拟函数定义集合为空集合，判定为「F:m1」不重写其他虚拟函数定义。因此，判定结果成为Yes，处理转至步骤h4。
接下来，类(Class)F所有的虚拟函数定义，重复步骤h4～步骤h10的循环。类(Class)F的虚拟函数定义只有「F:m1」，所以进行「F:m1」的处理。
步骤h5中，由类(Class)F初期化分析信息存储部分12内的类(Class)集合S3。这时，如图17(e)所示，在类(Class)集合S3内只包含类(Class)F。图17(e)～图17(h)，是表示类(Class)集合S3及消除函数集合S1的状态变换的表的图。步骤h6中，进行非重写类(Class)的分析。有关这个处理在后面叙述。
步骤h7中，调查类(Class)集合S3所包含的所有类(Class)的生成标志是否为OFF。在类(Class)集合S3中只包含类(Class)F，如图16(c)所示，因为类(Class)F的生成标志为OFF，判定结果成为Yes，处理转至步骤h8。
在步骤h8中，将类(Class)F的虚拟函数定义「F:m1」追加到消除函数集合S1上。这时的类(Class)集合S3及消除函数集合S1，变成图17(f)所示状态。
步骤h9中，如图17(b)所示，从虚拟函数集合S2中消除虚拟函数定义「F:m1」的相关信息。这时，作为虚拟函数定义「F:m1」的相关信息，消除存储在虚拟函数定义集合的「F:m1」和存储在重写虚拟函数定义集合上的「F:m1」。其后，处理转至步骤h10。类(Class)F，因为没有「F:m1」以外的虚拟函数定义，有关类(Class)F的步骤h4～步骤h10的循环结束。
其后，从步骤h11返回到步骤h2，类(Class)树状图Tr内的叶的类(Class)G及类(Class)H，重复步骤h2～步骤h11的循环。
类(Class)G组合到处理之后，步骤h3中，判定类(Class)G是否具有不重写其他虚拟函数定义的虚拟函数定义。如图17(a)所示，这时，类(Class)G的重写虚拟函数定义集合为空集合，所以判定结果成为Yes，处理转至步骤h4。步骤h5中，由类(Class)G初期化类(Class)集合S3。还有，步骤h7中，如图16(c)所示，因为类(Class)G的生成标志为ON，所以判定结果成为No，处理转至步骤h10。这时，如图17(c)所示，虚拟函数集合S2成为以前的状态，另一方面，类(Class)集合S3及消除函数集合S1成为图17(g)所示状态。类(Class)G的步骤h2～步骤h11的处理结束后，类(Class)H也进行同样的处理。其结果，如图17(d)所示，虚拟函数集合S2处于以前的状态，另一方面，类(Class)集合S3及消除函数集合S1成为图17(h)所示状态。
接下来，参照图14说明不要函数分析步骤S302中的步骤h6(非重写类(Class)分析步骤)的处理。图14，是表示不要函数分析步骤S302的步骤h6的构成的程序框图。
尽管类(Class)F、类(Class)G及类(Class)H都组合到这个处理，但是，在此只以类(Class)F为例说明组合到处理的情况。
如图14所示，首先由步骤i1取得存储在类(Class)集合S3中的类(Class)。在类(Class)F组合到处理的时刻，如图17(e)所示，在类(Class)集合S3中只包含类(Class)F，所以取得类(Class)F。在步骤i2中，将从类(Class)F到叶的类(Class)的所有的通过P1包含到通过集合PS(图中未示)中。类(Class)F包含在类(Class)树状图Tr(图16(b)所示)，因为叶的类(Class)为类(Class)G及类(Class)H，所以，将类(Class)F至类(Class)G的通过「FG」和类(Class)F至类(Class)H的通过「FH」包含到通过集合PS中。
接下来，通过集合PS内的所有通过P1，重复步骤i3～步骤i8的循环。通过「FG」组合到处理后，按照类(Class)F、类(Class)G的顺序重复步骤i4～步骤i7所示的处理。
类(Class)F组合到步骤i5后，判定结果成为No，处理转至步骤i6。步骤i6中，当类(Class)集合S3内没有包含类(Class)F时，追加类(Class)F，如图17(e)所示，但在此因为类(Class)集合S3内已经包含了类(Class)F，就保持其原状态。
接下来，类(Class)G组合到步骤i5后，这个时刻类(Class)G的重写虚拟函数定义集合中包含了「F:m1」(图17(b)所示)，步骤i5的判定结果成为Yes，步骤i5～步骤i7的处理结束。其后，移至步骤i8的处理。
处理从步骤i8返回到步骤i3后，在通过集合PS内，通过「FG」以外的通过「FH」也进行同样的处理。由此，类(Class)F的非重写类(Class)分析步骤h6的处理结束。
接下来，图11所示的不要函数分析步骤S106中，由与第1实施方式(图2(d)所示)同样的方法，消除登录到消除函数集合S1上的函数自身。图15所示的程序中，可以消除由函数(C)所示的函数定义。
本实施方式中，在程序中的类(Class)具有承接关系的情况下，分析该承接关系做成类(Class)树状图。并且，类(Class)树状图中派生类(Class)的虚拟函数中的至少一个，不重写其基础类(Class)上时，该派生类(Class)和基础类(Class)又不生成目标时，消除该基础类(Class)的虚拟函数。
另一方面，类(Class)树状图上派生类(Class)的虚拟函数中的全部，上述到该基础类(Class)的虚拟函数上时，没有生成基础类(Class)的目标时，消除该基础类(Class)的虚拟函数。这个消除的判定中，与派生类(Class)的目标是否生成无关。
又以上这些，即便是具有虚拟函数的程序，确实可以判定可能消除的函数和不可能消除的函数，这样就可以更有效地消除函数。因此，比以前更容易削减更多的编码尺寸。
且，本实施方式中，将类(Class)分析步骤S201～不要函数消除步骤S106重复至输出编译的变化消失为止。由此，通过消除函数定义确实可以消除重新生成的不要函数，所以就可以更有效地变换程序。然而，本发明中，为了缩短编译时间，将类(Class)分析步骤S201至不要函数消除步骤S106的一连串处理，既可以事先决定为进行一定次数，也可以决定为只进行一次。
(第4实施方式)
以下，参照图面说明本发明第4实施方式中编程器(图中未示)进行的程序变换方法。且，这个程序变换方法，是将记述处理的程序输入到编程器实行的。图18，是表示第4实施方式中程序变换步骤S400的构成的程序框图。
如图18所示，本实施方式的变换步骤S400，包括：输入成为变换对象的程序的输入步骤S101；分析程序的句法，进行象征桌面(SymbolTable)、句法主干(syntax tree)等的生成的句法分析步骤S102；将包含在程序中的类(Class)信息抽出，再分析类(Class)定义将类(Class)之间的承接关系存储在分析信息存储部分12上的类(Class)抽出步骤S201；进行虚拟函数分析的虚拟函数分析步骤S301；检出包含在程序的类(Class)中的生成了目标的类(Class)，将该结果存储到分析信息存储部分12的目标分析步骤S104；分析接受了信息存储部分12上存储的信息的不要函数，抽出具有该不要函数的类(Class)，将该结果存储到分析信息存储部分12的不要处理·不要数据分析步骤S401；接受存储在分析信息存储部分12上的信息，消除不要函数的定义的不要函数消除步骤S106；从分析信息存储部分12存储的分析信息中，消除不要处理数据的不要处理·不要数据消除步骤S402；将消除了不要处理及不要数据后的程序(以下成为目的程序)输出给生成编译存储部分13的输出步骤S107。类(Class)抽出步骤S201～不要处理·不要数据消除步骤S402，直至输出的各编译不再发生变换进行重复。
本实施方式中，不要处理·不要数据分析步骤S401中，在第3实施方式同样方法的基础上增加分析不要函数，再抽出判定了所有虚拟函数定义可能消除的类(Class)。
并且，不要处理·不要数据消除步骤S402中，消除判定了所有虚拟函数定义可能消除的类(Class)的虚拟函数表和地址设定处理。
接下来，参照程序例说明输入步骤S101～不要处理·不要数据消除步骤S402的详细的操作。且，这些步骤中与第1～第3实施方式相同之处，省略详细的说明。再，作为程序例，再次参照第3实施方式所使用的图15。还有，关于分析信息存储部分12收存的信息，同样再次参照第3实施方式所使用的图16及图17。
首先，输入步骤S101及句法分析步骤S102，由与第1实施方式同样的方法进行处理。
接下来，类(Class)分析步骤S201，由与第2实施方式相同的方法(图6所示)，进行程序中包含的类(Class)C1的信息和它们的承接关系的分析，并将其结果存储到分析信息存储部分12中。其结果，如图16(a)所示，在分析信息存储部分12中类(Class)F、类(Class)G及类(Class)H的生成标志被初期化成为OFF。还有，图15所示的程序中，因为类(Class)G及类(Class)H是从类(Class)F派生的，所以，以类(Class)F为基础类(Class)的类(Class)树状图Tr就成为如图16(b)所示的状态。
接下来，虚拟函数分析步骤S301中，由与第3实施方式相同的方法(如图12所示)，进行虚拟函数定义及重写虚拟函数定义的分析，将其结果存储到分析信息存储部分12中。其结果，虚拟函数定义集合和重写虚拟函数定义集合成为图17(a)所示状态。
接下来，目标分析步骤S104中，由与第1实施方式同样的方法(图2(b)所示)分析生成目标的类(Class)。因为类(Class)F、类(Class)G及类(Class)H内生成目标的是类(Class)G及类(Class)H，所以，分析信息存储部分12中的生成标志成为如图16(c)所示的状态。
接下来，参照图19说明不要处理·不要数据分析步骤S401的处理。图19，是表示不要处理·不要数据分析步骤S401的构成的程序框图。
如图19所示，不要处理·不要数据分析步骤S401中，进行步骤h1～步骤h12、步骤j1～步骤j2的处理。这些处理中，省略与第3实施方式相同的步骤h1～步骤h12，只说明步骤j1～j2。图15所示的程序中，处理按照成为根类(Class)的类(Class)F、成为叶的类(Class)的类(Class)G及类(Class)H的顺序进行。
首先，类(Class)F组合到步骤j1的时刻，如图17(f)所示，类(Class)F的虚拟函数定义「F:m1」已经追加到消除函数集合S1。因此，步骤j1的判定结果成为Yes，处理转至步骤j2。步骤j2中，如图21(a)所示，在消除类(Class)集合S4中追加类(Class)F，处理转至步骤h11。且，消除类(Class)集合S4存储在分析信息存储部分12中。图21(a)，是表示消除类(Class)集合S4的状态的表的图。
接下来，类(Class)G组合到步骤j1的时刻，如图17(g)所示，类(Class)G的虚拟函数定义不追加到消除函数集合S1。因此，步骤j1的判定结果成为No，处理转至步骤h11。类(Class)H也进行同样的分析。
接下来，参照图20说明不要处理·不要数据消除步骤S402中的处理。图20，是表示不要处理·不要数据消除步骤S402的构成的程序框图。
如图20所示，不要处理·不要数据消除步骤S402中，重复步骤k1～步骤k4的循环。
步骤k1中，抽出包含在消除类(Class)集合S4中的类(Class)F后，由步骤k2消除如图21(b)所示的类(Class)F的虚拟函数表的数据(D)。图21(b)，是表示类(Class)F的虚拟函数表的图。接下来，步骤k3中，在图21(c)所示的Constructor(制造者or建造者)内的虚拟函数表的地址处理设定中，消除有关类(Class)F的处理(E)。图21(c)，是表示有关类(Class)F的虚拟函数表的地址设定处理的图。其后，处理转至步骤k4。再后，转至如图18所示的输出步骤S107。
本实施方式，可以获得与第3实施方式相同的效果。还有，编程器能够自动消除生成数据(D)及处理(E)。因为能够消除设定地址的处理，所以能够生成编码尺寸小及实行步骤数少的编译。
且，本实施方式中，将类(Class)分析步骤S201～不要处理·不要数据消除步骤S402重复至输出编译的变换消失为止。由此，通过消除函数定义确实可以消除重新生成的不要函数，所以就可以更有效地变换程序。然而，本发明中，为了缩短编译时间，将类(Class)分析步骤S201至不要函数消除步骤S106的一连串处理，既可以事先决定为进行一定次数，也可以决定只进行一次。
(第5实施方式)
以下，参照图面说明本发明第5实施方式中编程器(图中未示)进行的程序变换方法。且，这个程序变换方法，是将记述处理的程序输入到编程器实行的。图22，是表示第5实施方式中程序变换步骤S500的构成的程序框图。
如图22所示，本实施方式的变换步骤S500，包括：输入成为变换对象的程序的输入步骤S101；分析程序的句法，进行象征桌面(SymbolTable)、句法主干(syntax tree)等的生成的句法分析步骤S102；将包含在程序中的类(Class)信息抽出，再分析类(Class)定义将类(Class)之间的承接关系存储在分析信息存储部分12上的类(Class)抽出步骤S201；检出包含在程序的类(Class)中的生成了目标的类(Class)，将该结果存储到分析信息存储部分12的目标分析步骤S104；分析接受了信息存储部分12上存储的信息而不生成类(Class)的函数(不要函数)，将该结果存储到分析信息存储部分12的不要函数分析步骤S202；分析消除指定的类(Class)的函数的消除指定函数分析步骤S501；接受存储在分析信息存储部分12上的信息，消除不要函数的定义的不要函数消除步骤S106；将消除了不要函数后的程序(以下成为目的程序)输出给生成编译存储部分13的输出步骤S107。类(Class)抽出步骤S201～不要函数消除步骤S106，直至输出的各编译不再发生变换进行重复。
接下来，参照程序例说明输入步骤S101～不要函数消除步骤S106的详细的操作。且，这些步骤中与第1或者是第2实施方式相同之处，省略详细的说明。再，作为程序例，再次参照第2实施方式所使用的图8。
首先，在输入步骤S101中，按次序输入存储在程序存储部分11的所有程序。这时，由指令线应用指定消除函数时，认识应用，存储指定了的函数。例如，用户由指定线应用指定了类(Class)B的消除时，应用记述「-delete_memfunc＝B」。认识这个应用，存储有关类(Class)B的函数。
接下来，句法分析步骤S102中，分析从输入步骤S101接受的程序的句法，进行象征桌面(Symbol Table)的生成或者是句法主干(syntax tree)的生成等，并将结果转给类(Class)分析步骤S201。这时，用户通过程序中的消除指定记述指定消除函数时，认识认识消除记述，存储指定了的函数。图8所示的程序中，用户由消除指定记述(G)指定了类(Class)B的非静止的成员函数，存储这个函数。
类(Class)分析步骤S201，由与第2实施方式相同的方法(图6所示)，进行程序中包含的类(Class)的信息和它们的承接关系的分析，并将其结果存储到分析信息存储部分12中。其结果，类(Class)A～类(Class)E的生成标志及类(Class)树状图Tr，就成为如第2实施方式的图9(a)、图9(b)所示的状态。
接下来，目标分析步骤S104中，由与第1实施方式同样的方法(图2(b)所示)分析生成目标的类(Class)。其结果，类(Class)A～类(Class)E的生成标志，就成为如第2实施方式的图9(c)所示的状态。
接下来，不要函数分析步骤S202中，由与第2实施方式同样的方法(图7所示)分析不要函数。其结果，如图24(a)所示，在消除函数集合S1中，存储了有关类(Class)C、类(Class)D及类(Class)E的函数。且，图24(a)所示的消除函数集合S1中，存储了与图10(e)相同的函数。图24(a)、图24(b)，是表示消除函数集合的变换的表的图。
接下来，参照图23说明消除指定函数分析步骤S501的处理。图23，是表示消除指定函数分析步骤S501的构成的程序框图。
如图23所示，消除指定函数分析步骤S501中，分析信息存储部分12所存储的所有类(Class)C1，重复步骤m1～步骤m6的循环。
图8所示的程序中，成为类(Class)C1的是类(Class)A～类(Class)E。图8所示的程序组合到消除指定函数分析步骤S501后，由步骤m1抽出如类(Class)A，由步骤m2判定类(Class)A是否被消除指定了。如图8文件夹「main.cc」所示，由消除指定记述(G)消除指定了类(Class)B，类(Class)A没有被消除指定，所以，判定结果成为No，处理转至步骤m6。
当处理从步骤m6转至步骤m1后，接下来抽出类(Class)B，判定类(Class)B是否被消除指定。如图8的文件夹「main.cc」所示，类(Class)B被消除指定，判定结果成为Yes，处理转至步骤m3。
步骤m3中，判定类(Class)B的生成标志是否为OFF。因为类(Class)B的生成标志为ON(第2实施方式的图9(c)所示)，判定结果成为No，处理转至步骤m5。
步骤m5中，在类(Class)B的函数中Constructor(制造者)或者是代入演算子等的特别函数以外的非静止成员函数追加到消除函数集合S1。这时，特殊函数没有追加到消除函数集合S1的原因，是因为类(Class)B是目标生成类(Class)，为生成目标Constructor(制造者)是必要的。具体地讲，如图24(b)所示，将类(Class)B的特殊函数以外的非静止成员函数的「B∷g1」追加到消除函数集合S1中。其后，处理转至步骤m6。
步骤m3，如果类(Class)B的生成标志为OFF，判定结果就成为Yes，处理转至步骤m4。步骤m4中，类(Class)B的所有的非静止成员函数追加到消除函数集合S1上。其后，处理转至步骤m6。
当处理从步骤m6转至步骤m1后，类(Class)C～类(Class)E也进行同样的重复。且，因为类(Class)C～类(Class)E不被消除指定，步骤m2的判定结果为No，类(Class)C～类(Class)E的函数不追加到消除函数集合S1。
接下来，不要函数消除步骤S106，由与第1实施方式同样的方法(图2(d)所示)，消除包含在消除函数集合S1的函数定义。由以上的处理，不只是图8所示的函数(B)，由第2实施方式可以自动消除无法判定为消除可能的函数(F)。
本实施方式，可以获得与第2实施方式相同的效果。还有，可以消除由用户消除指定的类(Class)的函数。这时，消除指定了的类(Class)的目标生成时，不消除特殊函数而残留。这样，就可以更有效地削减编码尺寸。
且，本实施方式中，消除指定类(Class)的目标生成时，步骤m5，有关该类(Class)的特殊函数不追加到消除函数集合S1上而残留。但是，本发明中，特殊函数中只残留目标生成必要的Constructor(制造者)，消除代入演算子亦可。
且，本实施方式中，将类(Class)分析步骤S201～不要处理·不要数据消除步骤S402重复至输出编译的变换消失为止。由此，通过消除函数定义确实可以消除重新生成的不要函数，所以就可以更有效地变换程序。然而，本发明中，为了缩短编译时间，将类(Class)分析步骤S201至不要函数消除步骤S106的一连串处理，既可以事先决定为进行一定次数，也可以决定只进行一次。
(第6实施方式)
以下，参照图面说明本发明第6实施方式中编程器(图中未示)进行的程序变换方法。且，这个程序变换方法，是将记述处理的程序输入到编程器实行的。图25，是表示第6实施方式中译码步骤S610及结合步骤S620和存储各步骤S610、S620中生成的信息的存储部分的构成的程序框图。
如图25所示，本实施方式中，通过译码步骤S610译码存储在程序存储部分21的程序，生成目的编码，再将该目的编码存储到目的编码存储部分23中。并且，结合步骤S620进行连接处理后存储到实行编码存储部分24中。
程序存储部分21中，成为变换对象的程序，分别存储在源极文件夹21a、21b、21c中。
译码步骤S610，包括：输入成为变换对象的程序的输入步骤S611；分析程序的句法，进行象征桌面(Symbol Table)、句法主干(syntax tree)等的生成的句法分析步骤S612；将包含在程序中的类(Class)信息存储在分析信息存储部分22上的类(Class)抽出步骤S613；检出包含在程序的类(Class)中的生成了目标的类(Class)，将该结果存储到分析信息存储部分22的目标分析步骤S614；将由各步骤变换的程序及存储在分析信息存储部分22中的分析信息作为编译输出给目的编码存储部分23的输出步骤S615。
目的编码存储部分23中，目的编码分别存储在目的文件夹23a、23b、23c中。
结合步骤S620包括：读入存储在目的编码存储部分23中的目的文件夹23a～23c，抽出该目的文件夹23a～23c分析不要函数的不要函数分析步骤S621，利用不要函数分析步骤S621的分析结果连接必要的编译或者是数据，输出给实行编码存储部分24的连接步骤S622。
实行编码存储部分24中，由结合步骤S620结合的实行编译，作为实行形式文件夹24a被保存。
接下来，参照程序例说明译码步骤S610及结合步骤S620及各步骤的更详细的操作。且，作为程序例，再次参照第1实施方式所使用的图3。
首先，译码步骤S610一开始，输入步骤S611、句法分析步骤S612中的处理也就进行了，但是因为这些步骤都不是本发明的主要之点，省略它们的详细说明。
接下来，就类(Class)抽出步骤S613的处理，参照图26(a)说明。图26(a)，是表示类(Class)抽出步骤S613的构成的程序框图。
如图26(a)所示，类(Class)抽出步骤S613中，包含在句法分析步骤S612内分析了的程序的所有类(Class)C1，重复步骤n1～步骤n5所表示的循环。
在图3所示的程序中，如处理文件夹「a.cc」时，由步骤n1抽出包含在文件夹「a.cc」中的类(Class)A，在步骤n2中判定类(Class)A是否已经登录到分析信息存储部分22。类(Class)A开始判定时，判定结果为No，将处理转至步骤n3。在此，类(Class)A的判定进行到第2次以后时，类(Class)A已经登录到分析信息存储部分22中，所以判定结果成为Yes，处理转至步骤n5。
步骤n3中，将类(Class)A登录到分析信息存储部分22，处理转至步骤n4。
步骤n4中，检出类(Class)A的所有的非静止成员函数定义，登录到分析信息存储部分22中的成员函数定义集合S2中。也就是，将文件夹「a.cc」中的类(Class)A的非静止成员函数「A∷A()」、「A∷f(void)」及「A∷g(int)」登录到成员函数定义集合S2中。其后，处理从步骤n5转至步骤n1。
接下来，文件夹「b.cc」组合到类(Class)抽出步骤S613后，类(Class)B进行同样的处理。再接下来，文件夹「main.cc」组合到类(Class)抽出步骤S613后，类(Class)A及类(Class)B进行同样的处理。
接下来，参照图26(b)说明目标分析步骤S614的处理。图26(b)，是表示目标分析步骤S614的构成的程序框图。
如图26(b)所示，目标分析步骤S614中，包含在程序中的所有处理，重复步骤p1～步骤p5所表示的循环。
图3所示的程序中成为分析对象的处理，是如文件夹「a.cc」中的文句「a＝1；」等。文件夹「a.cc」组合到目标分析步骤S104，由步骤b1抽出如文句「a＝1；」，由步骤b2判定文句「a＝1；」是否生成类(Class)目标处理。因为文句「a＝1；」不生成类(Class)目标，所以判定结果成为No，处理转至步骤p5。
处理转至步骤p5后，程序中包含的其他处理，重复步骤p1～步骤p5的循环。图3所示的程序的文件夹「b.cc」中，不包含生成目标处理。因为文件夹「main.cc」内包含生成类(Class)目标的文句「Bobj_b；」，所以，这由步骤p2判定的话，结果成为Yes，处理转至步骤p3。
步骤p3中，文句「B obj_b；」中成为生成的目标的对象的类(Class)B，判定是否已经登录到分析信息存储部分22的目的生成类(Class)集合S3。类(Class)B的判定开始时，判定结果成为No，处理转至步骤p4。在此，类(Class)B的判定进行到第2次以后时，类(Class)B已经登录到分析信息存储部分22，所以，判定结果成为Yes，处理转至步骤p5。
步骤p4中，将类(Class)B登录到分析信息存储部分12中的目标生成类(Class)集合S3中，处理转至步骤p5。
这些分析结果，有关分析信息存储部分12中的文件夹「a.cc」、「b.cc」及「main.cc」的分析信息，成为如图28(a)～图28(c)所示的状态。图28(a)～图28(c)，是表示有关文件夹「a.cc」、「b:cc」及「main.cc」的分析信息存储部分22中收存的分析数据的表的图。
接下来，输出步骤S615中，将变换程序的结果及存储在分析信息存储部分22的分析编译输出给目的编码存储部分23。目的编码存储部分23中，将文件夹「a.cc」、「b:cc」及「main.cc」的变换结果及分析信息作为文件夹「a.obj」、「b:obj」及「main.obj」保存。
接下来，参照图27说明结合步骤S620。图27，是表示结合步骤S620中不要函数分析步骤S621及连接步骤S622的构成的程序框图。
如图27所示，不要函数分析步骤S621中，由步骤q1，基于存储在目的编码存储部分23的分析信息，计算类(Class)集合S1’、非静止成员函数定义集合S2’及目标生成类(Class)集合S3’。由此，以每个文件夹存储的类(Class)集合S1’、非静止成员函数定义集合S2’及目标生成类(Class)集合S3’，如图28(d)所示总合成一个(文件夹)。图28(d)，是表示不要函数分析步骤S621中分析结果的表的图。
步骤q2中，如图28(d)所示，从类(Class)集合S1’包含的类(Class)A、B，除去目标生成类(Class)集合S3’包含的类(Class)B的类(Class)的类(Class)A，登录到目标未生成类(Class)集合S4中。其后，处理转至步骤q3，初期化不要函数集合S5使其成为空集合。
目标未生成类(Class)集合S4所包含的所有类(Class)，重复步骤q4～步骤q6的循环。
类(Class)A组合到处理后，在步骤q5中，将有关类(Class)A的所有非静止成员函数从如图28(d)所示的非静止成员函数定义集合S2’取出，追加到不要函数集合S5中。其后，处理转至步骤q6。因为目标未生成类(Class)函数S4中只包含了类(Class)A，步骤q4～步骤q6的处理结束。
其后，处理转至连接步骤S622，程序中所有的连接对象L1，重复步骤q7～步骤q10。
图3所示的程序组合到步骤q7后，由步骤q8，如果「A∷A()」是连接对象时，判定「A∷A()」是否为包含在不要函数集合S5的函数。因为「A∷A()」包含在不要函数集合S5中，处理转至步骤q10。且「A∷f(void)」及「A∷g(int)」也包含在不要函数集合S5中，进行同样的处理。
这时，如果不包含在不要函数集合S5中的「B∷B()」等的非静止成员函数是连接对象时，步骤q8的判定结果成为No，处理转至步骤q9。在这种情况下，步骤q9中，对「B∷B()」进行通常的连接处理。处理转至步骤q10。这个处理的结果，输出给实行编码存储部分24。
本实施方式中，通过判定程序中各类(Class)是否有生成目标的处理，确实可以消除不要函数。因此，比以前容易削减更多的编码尺寸。
(第7实施方式)
以下，参照图面说明本发明第7实施方式中编程器(图中未示)进行的程序变换方法。且，这个程序变换方法，是将记述处理的程序输入到编程器实行的。图29，是表示第7实施方式中译码步骤S710及结合步骤S720和存储各步骤S710、S720中生成的信息的存储部分的构成的程序框图。
如图29所示，本实施方式中，通过译码步骤S710译码存储在程序存储部分21的程序，生成目的编码，再将该目的编码存储到目的编码存储部分23中。并且，结合步骤S720进行连接处理后存储到实行编码存储部分24中。
程序存储部分21中，成为变换对象的程序，分别存储在源极文件夹21a、21b、21c中。
译码步骤S710，包括：输入成为变换对象的程序的输入步骤S611；分析程序的句法，进行象征桌面(Symbol Table)、句法主干(syntax tree)等的生成的句法分析步骤S612；抽出程序中包含的类(Class)信息，再将分析了类(Class)定义的类(Class)之间的承接关系存储到分析信息存储部分22上的类(Class)分析步骤S711；检出包含在程序的类(Class)中的生成了目标的类(Class)，将该结果存储到分析信息存储部分22的目标分析步骤S614；将由各步骤变换的程序及存储在分析信息存储部分22中的分析信息作为编译输出给目的编码存储部分23的输出步骤S615。
目的编码存储部分23中，目的编码分别存储在目的文件夹23a、23b、23c中。
结合步骤S720，包括：读入存储在目的编码存储部分23中的目的文件夹23a～23c，抽出该目的文件夹23a～23c分析不要函数的不要函数分析步骤S721，利用不要函数分析步骤S721的分析结果连接必要的编译或者是数据，输出给实行编码存储部分24的连接步骤S622。
实行编码存储部分24中，由结合步骤S720结合的实行编译，作为实行形式文件夹24a被保存。
本实施方式中，类(Class)分析步骤S711，不只抽出程序中包含的类(Class)信息，还将分析了类(Class)定义的类(Class)之间的承接关系存储到分析信息存储部分22。并且，不要函数分析步骤S721，基于类(Class)之间的承接关系的信息和目标生成有无的信息分析不要函数。
接下来，参照程序例说明译码步骤S710及结合步骤S720中各步骤的更详细的操作。且，这些步骤中与第6实施方式相同之处省略其详细说明。且，作为程序例，再次参照第2实施方式所使用的图8。
首先，输入步骤S611及句法分析步骤S612，由与第6实施方式同样的方法进行处理。
接下来，参照图30说明类(Class)分析步骤S711的处理。图30，是表示类(Class)分析步骤S711的构成的程序框图。如图30所示，类(Class)分析步骤S711中，包含在由句法分析步骤S612分析了的程序内所有的类(Class)C1，重复步骤r1～步骤r7所示的循环。
在图8所示的程序中，如处理文件夹「a.cc」组合到处理时，由步骤r1抽出包含在文件夹「a.cc」中的类(Class)A，在步骤r2中判定类(Class)A是否已经登录到分析信息存储部分22。类(Class)A开始判定时，判定结果为No，将处理转至步骤r3。在此，类(Class)A的判定进行到第2次以后时，类(Class)A已经登录到分析信息存储部分22中，所以判定结果成为Yes，处理转至步骤r6。
步骤r3中，将类(Class)A登录到分析信息存储部分22中，处理转至步骤r4。
步骤r4中，判定类(Class)A是否有基础类(Class)，当具有基础类(Class)时，将有关类(Class)A的所有的基础类(Class)登录到类(Class)集合S1中的基础类(Class)栏。因为类(Class)A没有基础类(Class)，在类(Class)集合S1中的基础类(Class)栏上不作任何登录。也就是，类(Class)集合S1中的基础分集合是空集合。
步骤r5中，检出类(Class)A的所有的非静止成员函数定义，登录到分析信息存储部分22中的成员函数定义集合S2中。文件夹「a.cc」中的类(Class)A的非静止成员函数是「A∷A()」、「A∷f(void)」及「A∷g(int)」，将它们登录到成员函数定义集合S2中。
其后，处理从步骤r6转至步骤r1后，文件夹「a.cc」的其他文件夹，重复步骤r1～步骤r6的循环。因为文件夹「b.cc」包含的类(Class)A是从类(Class)B派生来的，所以在步骤r4中，类(Class)集合S1中的类(Class)B的基础类(Class)栏上登录类(Class)A。其后，文件夹「a.cc」、「b.cc」、「c.cc」及「main.cc」进行同样的处理。
接下来，目标分析步骤S614的处理中，由与第6实施方式同样的方法(如图26(b)所示)，分析生成目标的类(Class)，并将生成目标的类(Class)登录到目标生成类(Class)集合S3中。各文件夹中，生成目标的只是文件夹「main.cc」中的类(Class)A及类(Class)B，所以，文件夹「a.cc」、「b.cc」、「c.cc」「d.cc」及「e.cc」的目标生成类(Class)集合S3成为空集合，文件夹「main.cc」的目标生成类(Class)集合S3中登录了类(Class)A及类(Class)B。
以上的类(Class)分析步骤S711及目标分析步骤S614的分析结果，分析信息存储部分22中的类(Class)集合S1、非静止成员函数集合S2及目标生成类(Class)集合S3，成为图32(a)～图32(f)所示状态。图32(a)～图32(f)，是表示文件夹「a.cc」～「main.cc」的收存在分析信息存储部分22中的分析数据的表的图。
接下来，输出步骤S615中，由与第6实施方式同样的方法，将变换程序的结果及存储在分析信息存储部分22的分析数据输出给目的编码存储部分23。
目的编码存储部分23中，将文件夹「a.cc」、「b:cc」、「c.cc」、「d.cc」、「e.cc」及「main.cc」的变换结果及分析信息作为文件夹「a.obj」、「b:obj」、「c.obj」、「d:obj」、「e.obj」及「main.obj」保存。
接下来，参照图31(a)说明不要函数分析步骤S721。图31(a)，是表示不要函数分析步骤S721的构成的程序框图。
如图31所示，不要函数分析步骤S721中，首先由步骤s1，进行计算类(Class)树状图集合S1’。关于步骤s1在后面叙述。由这个处理，可以得到如图33(a)所示的类(Class)树状图集合S1’。图33(a)，是表示不要函数分析步骤S721的步骤s1计算的类(Class)树状图集合S1’的表的图。
步骤s2中，基于目的编码存储部分23中存储的分析信息，如图33(b)、图33(c)所示，计算非静止成员函数定义集合S2’及目标生成类(Class)集合S3’。图33(b)和图33(c)，是表示不要函数分析步骤S721的步骤S2’中计算的非静止成员函数定义集合S2’及目标生成类(Class)集合S3’的表的图。
步骤s3中，初期化消除函数集合S5使其成为空集合。步骤s4中，从类(Class)树状图集合S1’，将类(Class)B、类(Class)D及类(Class)E登录到叶的类(Class)集合S6中。这时，叶的类(Class)集合S6及消除函数集合S5，成为如图34(a)所示状态。图34(a)～图34(e)，是表示不要函数分析步骤S721中叶的类(Class)集合S6及消除函数集合S5的状态的变换的表的图。
接下来，叶的类(Class)集合S6所包含的各类(Class)，重复步骤s5～步骤s12的循环。这个循环，直至叶的类(Class)集合S6所包含的类(Class)消失为止重复进行。
这时，类(Class)B、类(Class)C、类(Class)D及类(Class)E包含在叶的类(Class)集合S6中。首先，类(Class)B组合到处理后，由步骤s6，如图34(b)所示，从叶的类(Class)集合S6消除类(Class)B。并且，由步骤s7，判定类(Class)B是否包含在目标未生成类(Class)集合S4(图中未示)。因为生成了类(Class)B的目标，所以判定结果成为No，处理转至步骤s12。
处理从步骤s12转至步骤s5后，重复包含在叶的类(Class)集合S6中的类(Class)D的步骤s5～步骤s12的循环。类(Class)D不生成目标，步骤s7的判定结果成为Yes，处理转至步骤s8。步骤s8中，如图34(c)所示，将类(Class)D的非静止成员函数追加到消除函数集合S5上。其后，由步骤s9，将类(Class)D从类(Class)树状图集合S1消除。步骤s10中，判定是否具有成为叶的类(Class)。因为没有生成叶的类(Class)，所以判定成为No，处理转至步骤s12。
接下来，类(Class)E也重复步骤s5～步骤s12的循环。类(Class)E的目标不生成，步骤s7的判定结果成为Yes，步骤s8中，将类(Class)E的非静止成员函数追加到消除函数集合S5上。其后，步骤s10中，将类(Class)E从类(Class)树状图集合S1’消除。由此，类(Class)C成为了叶的类(Class)，步骤s10的判定结果成为Yes，处理转至步骤s11。步骤s11中，如图34(d)所示，将成为叶的类(Class)C追加到叶的类(Class)集合S6中。
其后，处理从步骤s12转至步骤s5，类(Class)C，重复步骤步骤s5～步骤s12的循环。类(Class)C的目标不生成，所以，步骤s7的判定成为Yes。其后，由步骤s8，将类(Class)C的非静止成员函数追加到消除函数集合S5上，由步骤s9中，将类(Class)C从类(Class)树状图集合S1’消除。因为就是消除了类(Class)C也没有成为叶的类(Class)，所以，步骤s10的判定结果成为No。由以上的处理，如图34(e)所示，叶的类(Class)集合S6成为空集合状态，消除函数集合S5成为包含类(Class)D、类(Class)E及类(Class)C的非静止成员函数的状态。
接下来，参照图31(b)说明不要函数分析步骤S721中的步骤s1(类(Class)树状图集合S1’计算步骤)的处理。图31(b)，是表示不要函数分析步骤S721中的步骤s1(类(Class)树状图集合S1’计算步骤)的构成的程序框图。步骤s1中，目的编码存储部分23所包含的所有类(Class)，重复步骤t1～t6的循环。
类(Class)A组合到处理后，由步骤t2，判定类(Class)A是否已经登录到类(Class)树状图集合S1’。类(Class)A已经登录了的话处理转至步骤t6，若还没有登录的话处理转至步骤t3。
步骤t3中，判定类(Class)A是否具有基础类(Class)。由于类(Class)A不具有基础类(Class)，判定结果成为No，处理转至步骤t5。步骤t5中，做成类(Class)A的类(Class)树状图，登录到类(Class)树状图集合S1’中。且，这时类(Class)A的类(Class)树状图中所包含的只是类(Class)A。
处理从t6转至步骤t1后，类(Class)B也进行步骤t1～步骤t6的循环。因为类(Class)B的基础类(Class)是类(Class)A，步骤t3的判定结果成为Yes，处理转至步骤t4。步骤t4中，从类(Class)树状图集合S1’中检索属于类(Class)A的类(Class)树状图，将类(Class)B作为类(Class)A的派生类(Class)追加到类(Class)树状图中。
类(Class)C、类(Class)D及类(Class)E，与类(Class)B一样，追加到类(Class)A的类(Class)树状图中。通过以上的处理，就能够得到图33(a)所示的类(Class)树状图集合S1’。
接下来，连接步骤S622中，由与第6实施方式相同的方法，进行程序中所有的连接对象的连接处理。
本实施方式中，当程序中的类(Class)具有承接关系时，分析该承接关系做成类(Class)树状图。并且，判定类(Class)树状图中叶的类(Class)是否生成目标。由此，可以消除有关这个叶的类(Class)的函数。还有，由于该叶的类(Class)的消除，判定是否具有成为叶的类(Class)，再通过判定成为叶的类(Class)是否生成目标，可能消除有关成为叶的类(Class)的函数。也就是，就是在分析的中途也能够消除成为叶的类(Class)。
本实施方式中，考虑了承接关系的分析成为了可能，在类(Class)树状图中，确实可以判定消除可能的函数和消除不可能的函数，可以更有效地消除函数。因此，比以前能够削减更多的编码尺寸。
(第8实施方式)
以下，参照图面说明本发明第8实施方式中编程器(图中未示)进行的程序变换方法。且，这个程序变换方法，是将记述处理的程序输入到编程器实行的。图35，是表示第8实施方式中译码步骤S810及结合步骤S820和存储各步骤S810、S820中生成的信息的存储部分的构成的程序框图。
如图35所示，本实施方式中，通过译码步骤S810译码存储在程序存储部分21的程序，生成目的编码，再将该目的编码存储到目的编码存储部分23中。并且，结合步骤S820进行连接处理后存储到实行编码存储部分24中。
程序存储部分21中，成为变换对象的程序，分别存储在源极文件夹21a、21b、21c中。
译码步骤S810，包括：输入成为变换对象的程序的输入步骤S611；分析程序的句法，进行象征桌面(Symbol Table)、句法主干(syntax tree)等的生成的句法分析步骤S612；将包含在程序中的类(Class)信息抽出，再将分析类(Class)定义的类(Class)之间的承接关系存储在分析信息存储部分22上的类(Class)分析步骤S711；进行虚拟函数分析的虚拟函数分析步骤S811；检出包含在程序的类(Class)中的生成了目标的类(Class)，将该结果存储到分析信息存储部分22的目标分析步骤S614；将由各步骤变换的程序及存储在分析信息存储部分22中的分析信息作为编译输出给目的编码存储部分23的输出步骤S615。
目的编码存储部分23中，目的编码分别存储在目的文件夹23a、23b、23c中。
结合步骤S820，包括：读入存储在目的编码存储部分23中的目的文件夹23a～23c，抽出该目的文件夹23a～23c中的分析不要函数的不要函数分析步骤S821；利用不要函数分析步骤S821的分析结果只连接必要的编译或者是数据，输出给实行编码存储部分24的连接步骤S622。
实行编码存储部分24中，由结合步骤S820结合的实行编译，作为实行形式文件夹24a被保存。
本实施方式中，虚拟函数分析步骤S811，进行关于程序中所包含的类(Class)的虚拟函数。当该类(Class)是承接其他类(Class)派生的时候，派生类(Class)的虚拟函数，又分为重写基础类(Class)的虚拟函数的情况和不重写基础类(Class)的虚拟函数的情况。为此，虚拟函数分析步骤S811中，分析派生类(Class)的虚拟函数是否重写基础类(Class)的虚拟函数。
并且，在不要函数分析步骤S821中，基于类(Class)分析步骤S711、虚拟函数分析步骤S811及目标分析步骤S614的信息分析不要函数。
接下来，参照程序例说明译码步骤S810及结合步骤S820及各步骤的更详细的操作。且，这些步骤中与第3、第6还有第7的实施方式相同之处，省略其详细说明。且，作为程序，再次参照第3实施方式所使用的图15。
首先，输入步骤S611及句法分析步骤S612，进行与第6实施方式相同的方法处理。
接下来，类(Class)分析步骤S711中，由与第7实施方式同样的方法(图3所示)，进行程序中所包含的类(Class)信息和它的承接关系的分析，并将其结果存储到分析信息存储部分22内的类(Class)集合S1中。
接下来，虚拟函数分析步骤S811中，由与第3实施方式相同的方法(图12所示)，进行程序中所包含的所有类(Class)的虚拟函数定义及重写虚拟函数的分析，并将其结果存储到分析信息存储部分22内的虚拟函数集合S2中。
接下来，目标分析步骤S614中，由与第6实施方式相同的方法(图26(b)所示)，分析生成目标的类(Class)，并将生成目标的类(Class)登录到分析信息存储部分22内的目标生成类(Class)集合S3中。
以上的类(Class)分析步骤S711、虚拟函数分析步骤S811及目标分析步骤S614的分析结果，分析信息存储部分22中图37(a)～图37(e)所示的信息被保存。图37(a)～图37(e)，是表示有关文件夹「f.cc」、「g.cc」、「h.cc」、「main.cc」及「sub.cc」的收存在分析信息存储部分22的类(Class)集合S1、非静止成员函数集合S2及目标生成集合S3的表的图。
接下来，输出步骤S615中，由与第6实施方式相同的方法，将变换了程序的结果及存储在分析信息存储部分22中的分析数据输出给目的编码存储部分23。目的编码存储部分23中，文件夹「f.cc」、「g.cc」、「h.cc」、「main.cc」及「sub.cc」的变换结果及分析信息，作为文件夹「f.obj」、「g.obj」、「h.obj」、「main.obj」及「sub.obj」存储。
接下来，参照图36说明不要函数分析步骤S821的处理。图36，是表示不要函数分析步骤S821的构成的程序框图。
如图36所示，首先由步骤u1，用与第7实施方式相同的方法(图31(b)所示)进行类(Class)树状图集合S1’的计算处理。由这个处理，如图38(a)所示，在类(Class)树状图集合S1’内，形成了包含类(Class)F、类(Class)G、类(Class)H的类(Class)树状图Tr。图38(a)，是表示不要函数分析步骤S821的步骤u1中计算的类(Class)树状集合S1’的表的图。
步骤u2中，基于存储在目的编码存储部分23中的分析信息，如图38(b)、图38(c)所示，计算虚拟函数集合S2’及目标生成类(Class)集合S3’。图38(b)和图38(c)，是表示不要函数分析步骤S821的步骤u2中计算的虚拟函数集合S2’及目的生成类(Class)集合S3’的表的图。
步骤u4中，初期化消除函数集合S5使其成为空集合。其后，类(Class)树状图集合S1’内所有的类(Class)树状图T1，重复步骤u4～步骤u15的循环。图15所示的程序中，类(Class)树状图集合包含的只是类(Class)树状图Tr的一个。
处理转至步骤u5后，类(Class)树状图Tr内的各类(Class)，按照从根类(Class)到叶的类(Class)的方向，重复步骤u5～步骤u14的循环。也就是，首先在进行了根类(Class)的类(Class)F的处理后，进行叶的类(Class)的类(Class)G及类(Class)H的处理。
类(Class)F组合到处理后，由步骤u6，查询类(Class)F的虚拟函数集合S2，判定类(Class)F是否具有不重写其他函数定义的虚拟函数定义。如图38(b)所示，类(Class)F具有作为虚拟函数定义的「F:m1」，因为类(Class)F的重写虚拟函数定义集合为空集合，就判定类(Class)F不重写其他虚拟函数定义。因此，判定结果为Yes，处理转至步骤u7。
接下来，类(Class)F的所有虚拟函数定义，重复步骤u7～步骤u13。
步骤u8中，由类(Class)F初期化类(Class)集合S6。步骤u9中，由与第3实施方式相同的方法(图14所示)，进行非重写类(Class)的分析。步骤10中，判定类(Class)集合S6中所包含的所有类(Class)是否没有包含在目标生成类(Class)集合S3’中。这时，类(Class)集合S6包含的类(Class)只有类(Class)F，又因为类(Class)F没有包含在目标生成类(Class)集合S3’，所以判定结果成为Yes，处理转至步骤u11。
步骤u11中，将类(Class)F的虚拟函数定义「F:m1」追加到消除函数集合S5中。步骤u12中，从包含在类(Class)树状图Tr中的类(Class)F、类(Class)G及类(Class)H的虚拟函数集合S2’消除有关类(Class)F的虚拟函数定义「F:m1」的信息，由此进行虚拟函数集合S2’的更新。这时，作为有关虚拟函数定义「F:m1」的信息，消除存储在虚拟函数定义集合中的「F:m1」和存储在重写虚拟函数定义集合中的「F:m1」。以上的处理结果，虚拟函数集合S2’、消除函数集合S5及类(Class)集合S6，成为图39(a)所示状态。图39(a)～图39(c)，是表示虚拟函数集合S2’、消除函数集合S5及类(Class)集合S6的状态的变换的表的图。
其后，处理转至步骤u13后，类(Class)F，因为没有「F:m1」的其他虚拟函数定义，有关类(Class)F的步骤u7～步骤u13的循环结束。
接下来，处理从步骤u14返回到步骤u5，类(Class)树状图Tr内的叶的类(Class)G及类(Class)H，重复步骤u5～步骤14的循环。
类(Class)G组合到处理后，步骤u6中，判定类(Class)G是否具有不重写其他虚拟函数定义的虚拟函数定义。这时，如图39(a)所示，因为类(Class)G的重写虚拟函数定义集合为空集合，判定结果成为Yes，处理转至步骤u7。其后，由步骤u8，类(Class)G初期化类(Class)集合S6。由此，类(Class)集合S6包含的只有类(Class)G，类(Class)G又包含在目标生成类(Class)集合S3’中，所以步骤u10的判定结果成为No，处理返回到步骤u5。这时，如图39(b)所示，虚拟函数集合S2’及消除函数集合S5成为以前的状态。
接下来，类(Class)H也进行同样的处理。其结果，如图39(c)所示，虚拟函数集合S2’及消除函数集合S5成为以前的状态。
其后，处理转至步骤u15。由以上步骤，结束不要函数分析步骤S821。
接下来，连接步骤S622中，由与第6实施方式相同的方法，对程序中所有的连接对象进行连接处理。
本实施方式中，程序中的类(Class)具有承接关系时，分析该承接关系做成类(Class)树状图。并且，类(Class)树状图中派生类(Class)的虚拟函数中的至少一个不重写该基础类(Class)的虚拟函数时，这个派生类(Class)和基础类(Class)二者都不生成目标时，消除该基础类(Class)的虚拟函数。
另一方面，类(Class)树状图中派生类(Class)的虚拟函数中的全部，重写该基础类(Class)的虚拟函数时，不生成基础类(Class)的目标时，消除该基础类(Class)的虚拟函数。这个消除判定中，派生类(Class)的目标是否生成并没有关系。从以上步骤，即便是在具有虚拟函数的程序中，确实可以判定消除可能的函数和消除不可能的函数，就能更有效地消除函数。因此，比以前更容易消除更多的编码尺寸。
(第9实施方式)
以下，参照图面说明本发明第9实施方式中编程器(图中未示)进行的程序变换方法。且，这个程序变换方法，是将记述处理的程序输入到编程器实行的。图40，是表示第9实施方式中译码步骤S910及结合步骤S920和存储各步骤S910、S920中生成的信息的存储部分的构成的程序框图。
如图40所示，本实施方式中，通过译码步骤S910译码存储在程序存储部分21的程序，生成目的编码，再将该目的编码存储到目的编码存储部分23中。并且，结合步骤S920进行连接处理后存储到实行编码存储部分24中。
程序存储部分21中，成为变换对象的程序，分别存储在源极文件夹21a、21b、21c中。
译码步骤S910，包括：输入成为变换对象的程序的输入步骤S611；分析程序的句法，进行象征桌面(Symbol Table)、句法主干(syntax tree)等的生成的句法分析步骤S612；将包含在程序中的类(Class)信息抽出，再将分析类(Class)定义的类(Class)之间的承接关系存储在分析信息存储部分22上的类(Class)分析步骤S711；进行虚拟函数分析的虚拟函数分析步骤S911；检出包含在程序的类(Class)中的生成了目标的类(Class)，将该结果存储到分析信息存储部分22的目标分析步骤S614；将由各步骤变换的程序及存储在分析信息存储部分22中的分析信息作为编译输出给目的编码存储部分23的输出步骤S615。
目的编码存储部分23中，目的编码分别存储在目的文件夹23a、23b、23c中。
结合步骤S920，包括：读入存储在目的编码存储部分23中的目的文件夹23a～23c，抽出该目的文件夹23a～23c中的分析不要函数的虚拟函数分析步骤S911；利用不要函数·不要数据分析步骤S921的分析结果只连接必要的编译或者是数据，输出给实行编码存储部分24的连接步骤S922。
实行编码存储部分24中，由结合步骤S920结合的实行编译，作为实行形式文件夹24a被保存。
本实施方式中，虚拟函数分析步骤S911中，在第8实施方式同样的方法上组合到分析虚拟函数，再抽出虚拟函数表。
并且，不要函数·不要数据分析步骤S921中，将判定为所有虚拟函数定义都消除可能的类(Class)的虚拟函数表追加到消除虚拟函数表集合上。其后，连接步骤S922中，消除追加到消除虚拟函数表集合的虚拟函数表，将地址变换为无效值。
接下来，参照程序例说明译码步骤S910及结合步骤S920及各步骤的更详细的操作。且，这些步骤中与第3、第4、第6、第7还有第8的实施方式相同之处，省略其详细说明。且，作为程序，再次参照第3实施方式所使用的图15。
首先，输入步骤S611及句法分析步骤S612，进行与第6实施方式相同的方法处理。
接下来，类(Class)分析步骤S711中，由与第7实施方式同样的方法(图3所示)，进行程序中所包含的类(Class)信息和它的承接关系的分析，并将其结果存储到分析信息存储部分22内的类(Class)集合S1中。
接下来，参照图41说明虚拟函数分析步骤S911。图41，是表示虚拟函数分析步骤S911的构成的程序框图。
如图41所示，虚拟函数分析步骤S911中，进行步骤g1～步骤g10的处理。这些处理中，省略与第3实施方式相同的步骤g1～步骤g10(图12所示)的说明。
步骤w1中，登录类(Class)集合S1中类(Class)C1的所有的虚拟函数表。这时，成为类(Class)C的是类(Class)F、类(Class)G及类(Class)H。例如，类(Class)F组合到处理，将类(Class)F的虚拟函数表「vbtl_F」登录到分析信息存储部分22中的类(Class)集合S1上。类(Class)G及类(Class)H也同样。
接下来，目标分析步骤S614中，由与第6实施方式相同的方法(图26(b)所示)，分析生成目标的类(Class)，并将生成目标的类(Class)登录到目标生成类(Class)集合S3中。
以上的类(Class)分析步骤S711、虚拟函数分析步骤S911及目标分析步骤S614的分析结果，分析信息存储部分22中图44(a)～图44(e)所示的信息被保存。图44(a)～图44(e)，是表示有关文件夹「f.cc」、「g.cc」、「h.cc」、「main.cc」及「sub.cc」的收存在分析信息存储部分22的类(Class)集合S1、非静止成员函数集合S2及目标生成集合S3的表的图。本实施方式中，如图44(a)～图44(e)所示，在各文件夹的虚拟函数集合S2上登录了虚拟函数表。
接下来，输出步骤S615中，由与第6实施方式相同的方法，将变换了程序的结果及存储在分析信息存储部分22中的分析数据输出给目的编码存储部分23。目的编码存储部分23中，文件夹「f.cc」、「g.cc」、「h.cc」、「main.cc」及「sub.cc」的变换结果及分析信息，作为文件夹「f.obj」、「g.obj」、「h.obj」、「main.obj」及「sub.obj」存储。
接下来，参照图42说明不要函数·不要数据分析步骤S921的处理。图42，是表示不要函数·不要数据分析步骤S921的构成的程序框图。
如图42所示，不要函数·不要数据分析步骤S921中，进行步骤u1～步骤u15，步骤x1～步骤x2的处理。这些处理中省略与第8实施方式相同的步骤u1～步骤u15(图36所示)的说明。
且，由步骤u1的处理，生成图45(a)所示的类(Class)树状图集合S1’，由步骤u2的处理生成图45(b)、图45(c)所示的虚拟函数集合s2’及目标生成类(Class)集合S3’。图45(a)～图45(c)，在第9实施方式中，是表示类(Class)树状图集合S1’、虚拟函数集合s2’及目标生成类(Class)集合S3’的状态的表的图。
步骤x1中，判定类(Class)C1的所有的虚拟函数定义是否追加到了消除函数集合S5上。这时，成为类(Class)C1的是类(Class)F、类(Class)G及类(Class)H。例如，在类(Class)F组合到步骤x1的处理的时刻，类(Class)F的虚拟函数定义「F:m1」已经追加到了消除函数集合S5上(步骤u11)。为此，判定结果成为Yes，处理转至步骤x2。
步骤x2中，在消除虚拟函数表集合S7中，追加类(Class)F的所有虚拟函数表。也就是，将类(Class)F的虚拟函数表「Vtbl_F」追加到消除虚拟函数表集合S7中。以上处理的结果，虚拟函数集合S2’、类(Class)集合S6、消除函数集合S5及消除虚拟函数表集合S7，成为图46(a)的状态。图46(a)～图46(c)，是表示虚拟函数集合S2’、类(Class)集合S6、消除函数集合S5及消除虚拟函数表集合S7的状态变换的表的图。
接下来，类(Class)G组合到步骤x1的时刻，如图46(a)所示，类(Class)G的虚拟函数定义不追加到消除函数集合S5。为此，判定结果为No，处理转至步骤u14。由此，可以得到图46(b)所示的分析结果。
接下来，类(Class)H组合到步骤x1的时刻，如图46(b)所示，类(Class)H的虚拟函数定义不追加到消除函数集合S5。为此，判定结果为No，处理转至步骤u14。由此，可以得到图46(c)所示的分析结果。
接下来，参照图43说明连接步骤S922的处理。图43，是表示连接步骤S922的构成的程序框图。
连接步骤S922中，如图43所示，进行步骤q7～步骤q10和步骤y1～步骤y2的处理。这些处理中省略与第6实施方式的连接步骤S622(图27所示)同样的步骤q7～步骤q10的说明。
步骤y1中，判定连接对象L1是否为消除虚拟函数表集合S7所包含的数据。例如，说明「vtbl_F」是连接对象时，「Vtbl_F」包含在图46(c)所示的消除虚拟函数表集合S7，所以判定结果成为Yes，处理转至步骤y2。
步骤y2中，将「vtbi_F」的地址变更为例如零指示(Null Pointer)等的无效值，在必须要有「vtbl_F」的地址的地方，使地址成为无效值。
另一方面，步骤y1中，说明例如「vtbl_F」是连接对象的情况，「vtbl_F」不包含在如图46(c)所示的消除虚拟函数表集合S7中，判定结果成为No，处理转至步骤q8。
本实施方式中，可以得到与第8实施方式同样的效果。还有，可以消除消除虚拟函数表集合S7所示的数据。因此，可以生成编码尺寸更小效果更好的编译。
(第10实施方式)
以下，参照图面说明本发明第10实施方式中编程器(图中未示)进行的程序变换方法。且，这个程序变换方法，是将记述处理的程序输入到编程器实行的。图47，是表示第10实施方式中前置编译步骤S1010及程序变换步骤S1020和存储各步骤S1010、S1020中生成的信息的存储部分的构成的程序框图。
程序存储部分31中，成为变换对象的程序，分别存储在源极文件夹31a、31b、31c中。
前置编译步骤S1010，包括：输入成为变换对象的程序的输入步骤S1011；分析程序的句法，进行象征桌面(Symbol Table)、句法主干(syntaxtree)等的生成的句法分析步骤S1012；将包含在程序中的类(Class)信息存储在分析信息存储部分32上的类(Class)抽出步骤S1013；检出包含在程序的类(Class)中的生成了目标的类(Class)，将该结果存储到分析信息存储部分32的目标分析步骤S1014；基于由各步骤变换的程序及存储在分析信息存储部分32中的分析信息分析不要函数，并存储到分析信息存储部分32的不要函数分析步骤S1015。
分析信息存储部分32，存入由类(Class)抽出步骤S1013、目标分析步骤S1014及不要函数分析步骤S1015分析了的信息。
程序变换步骤S1020，包括：存储在分析信息存储部分32中的分析信息，及存储在程序存储部分31的程序按照一个一个的顺序输入的输入步骤S1021；进行象征桌面(Symbol Table)、句法主干(syntax tree)等的生成的句法分析步骤S1022；从输入步骤S1021输入的信息中取得不要函数的信息，消除不要函数定义的不要函数消除步骤S1023；将由各步骤变换的程序作为目的程序输出给生成编译存储部分33的输出步骤S1024。
生成编译存储部分33中，存储了目的程序。
接下来，说明前置编译步骤S1010及程序变换步骤S1020中各步骤更详细的操作。且，作为程序例，再一次参照第1实施方式所使用的图3。
首先，前置编译步骤S1010开始后，进行输入步骤S1011及句法分析步骤S1012的处理，但是因为这些都不是本发明的主要之处，省略详细说明。
接下来，类(Class)抽出步骤S1013中，由与第1实施方式同样的方法(图2(a)所示)，抽出程序中所包含的所有类(Class)信息。其结果，可以得到与第1实施方式同样的图4(a)所示的类(Class)信息。
接下来，目标分析步骤S1014中，由与第1实施方式同样的方法(图2(b)所示)，分析生成目标的类(Class)，并将生成目标的类(Class)存入分析信息存储部分32中。其结果，可以得到与第1实施方式同样的图4(b)所示的类(Class)信息。
接下来，不要函数分析步骤S1015中，由与第1实施方式同样的方法(图2(c)所示)，基于分析信息存储部分32所存储的分析数据，分析不要函数，存入分析信息存储部分32。其结果，可以得到与第1实施方式同样的图4(c)所示的消除函数集合S1。
接下来，程序变换步骤S1020开始后，进行输入步骤S1021及句法分析步骤S1022中的处理，但是因为这些都不是本发明的主要之处，省略详细说明。
接下来，不要函数消除步骤S1023中，由与第1实施方式同样的方法(图2(d)所示)，基于消除函数集合S1消除不要函数定义(图3所示函数(A))。
本实施方式中，即便是前置编译步骤，也能够比以前消除更多的编码尺寸。
且，本实施方式中，包含了前置编译步骤S1010、类(Class)抽出步骤S1013、目标分析步骤S1014及不要函数分析步骤S1015。因此，本发明中，取代它们用第2实施方式所示的类(Class)分析步骤S201、目标分析步骤S104、不要函数分析步骤S202包含在前置编译步骤S1010中亦可。这种情况下，可以得到与第2实施方式相同的效果。
同样，本发明中，在前置编译步骤S1010中包含第3实施方式所示的类(Class)分析步骤S201、虚拟函数分析步骤S301、目标分析步骤S104、不要函数分析步骤S302亦可。这种情况下，可以得到与第3实施方式相同的结果。
同样，本发明中，在前置编译步骤S1010中包含第4实施方式所示的类(Class)分析步骤S201、虚拟函数分析步骤S301、目标分析步骤S104及不要函数·不要数据分析步骤S401，还有取代不要函数消除步骤S1023，包含不要处理·不要函数消除步骤S402亦可。这种情况下，可以得到与第4实施方式相同的结果。
同样，本发明中，在前置编译步骤S1010中包含第5实施方式所示的类(Class)分析步骤S201、目标分析步骤S104、不要函数分析步骤S202及消除指定函数分析步骤S501亦可。这种情况下，可以得到与第5实施方式相同的结果。
(发明效果)
根据本发明，通过判定是否有类(Class)的生成处理，确实可以消除不要处理。因此，比以前更容易削减更多的编码尺寸。