CN1788254A - 关于Lyee指向软件的静态分析方法 - Google Patents

关于Lyee指向软件的静态分析方法 Download PDF

Info

Publication number
CN1788254A
CN1788254A CN03826435.8A CN03826435A CN1788254A CN 1788254 A CN1788254 A CN 1788254A CN 03826435 A CN03826435 A CN 03826435A CN 1788254 A CN1788254 A CN 1788254A
Authority
CN
China
Prior art keywords
statement
definition
speech
type
lyee
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Pending
Application number
CN03826435.8A
Other languages
English (en)
Inventor
M·梅里
B·克塔里
H·藤田
M·埃希奥伊
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Catena Corp
Original Assignee
Catena Corp
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Catena Corp filed Critical Catena Corp
Publication of CN1788254A publication Critical patent/CN1788254A/zh
Pending legal-status Critical Current

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F11/00—Error detection; Error correction; Monitoring
    • G06F11/36—Preventing errors by testing or debugging software
    • G06F11/3604—Software analysis for verifying properties of programs

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Software Systems (AREA)
  • Computer Hardware Design (AREA)
  • Quality & Reliability (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Stored Programmes (AREA)

Abstract

Lyee必要条件中，应用在以往方法中使用的静态分析方法。具体地，将Lyee必要条件作为对象进行优化(古典式优化、根据谓语向量的排列的优化)、分断、必要条件调试、键入(错误检测、类型发现、使用类型的安全)。此外，将这些作为实施了适于Lyee All工具生成的优化代码的预处理的形式输出必要条件。由此，使Lyee方法论中用于生成具有更高质量(更少的保存和执行时间的耗费)的代码的必要条件定义的优化成为可能。

Description

关于Lyee指向软件的静态分析方法
技术领域
本发明涉及对于例如无论业务用·个人用等的用途、商业应用·游戏等的种类·内容、软件单体·电气化产品ROM插入等的形态、所有用途、种类·内容、形态中的软件都能使用的软件分析方法，特别涉及关于Lyee(注册商标。以下相同)指向软件的静态分析方法。
背景技术
软件开发与维护成为我们经济中具有主要的重要性的活动。在计算机被广泛应用的情况下，这种活动在生产事业中涉及很广的范围。
每年为开发·维护软件都耗费数千亿美元的巨额资金。今天，软件开发领域的参与者彼此的竞争比以前更加激烈。为了在该竞争生存，这些参与者(公司)必须最大限度地保持生产经营的效率，使费用保持在最小限度。他们还必须按时交出具有高质量的产品(软件)。但是，为软件开发，目前可利用的工具和方法论存在不能断言有正好适合公司需要的部分。
基本上，软件研究·开发的目标是寻找能够简单、快捷地构筑更高质量的软件的方法。这10年间，推敲、提出各种方法论与技术，相应地改良了软件开发周期的步幅。
虽然承认这些改良有相当的贡献，但将其更广泛的使用还存在困难。事实上，这其中创造出能够明确理解和修正的系统几乎是不可能的，因此仍然只有具有广泛能力、技能以及知识的专家才能很好的使用这些。相反地，这意味着软件的执行需要录用高薪的人才、高价的维护以及大规模的检查。由此理由，企业目前对于新的有希望的软件开发周期的改良方法论非常欢迎，同时做好了支付相应报酬的准备。
Lyee(含意为“用于软件开发的统一的方法论”的末端字符)是一种新的非常有希望的方法论。谋求有效处理与不同领域相关的大范围的软件问题的Lyee，能够只定义为所希望的软件开发的必要条件来开发软件。更准确的说，用户可以只给出词、关于词的运算表达式、该运算的条件(前提条件)以及画面与打印的预览图(例如，参考专利文献1及2、4到6)。
然后，将其后所有的麻烦的程序设计过程(控制逻辑侧面)交给计算机做。即，SE(系统工程师)等人不需要进行逻辑设计。虽然Lyee刚发明不久，但是该使用结果显示了超出想象的可能性。事实上，与现有的方法论相比，可以很大程度减少开发时间、维护时间以及文件容量(70～80％)。到目前，由必要条件进行代码自动生成的开发者能够利用被称为LyeeALL的原始的支援工具(例如，参考专利文献3及4)。
尽管如此，为使在任何新的方法论中都如此，即使对于Lyee，也必须进行证实其效率、应该改良其质量的研究。而且，为进一步实现用户友好界面，LyeeALL工具改良的余地不能说为零。
一方面，作为软件的静态分析方法，存在(1)优化技术、(2)程序分断技术、(3)必要条件调试、(4)键入等(参考非专利文献1及4)方法。
(1)优化技术(参照非专利文献3及8)是通过引入一系列的改变，以缩减代码列的容量、其执行时间、耗费保存等为目的来进行的，但在与Lyee方法论的组合中，以前优化对象是通过Lyee完成的代码列，将Lyee必要条件作为其对象没有在技术上明确实现(参考专利文献4)。
(2)程序分断技术在传统的程序设计语言中，长时间被用于将程序阅读理解与调试作为“进行分离管理”的方法。另外，也成功地用在很多应用的分析中，但是，这些应用的目标是检测结合、算法的调试、反向管理、组件再利用、自动并行化、程序合并以及验证辅助，在此之前没有与Lyee方法论相结合的构想(参考非专利文献12)。
(3)必要条件调试能在代码生成前检出必要条件的错误，以得到更有益的结果，在此之前没有与Lyee方法论相结合的构想。
(4)键入系统(参考非专利文献2及11)主要用于将程序的几个动态的好的行为特性保证为静态，由此，编译时能够检测出程序执行时频繁出现的错误。另外，键入技术确实成功地用于所开发的软件对于某些安全性问题的处理，在此之前没有与Lyee方法论相结合的构想。
(专利文献1)
国际公开WO97/16784 A1册
(专利文献2)
国际公开WO98/19232 A1册
(专利文献3)
国际公开WO99/49387 A1册
(专利文献4)
国际公开WO00/79385 A1册
(专利文献5)
国际公开WO02/42904 A1册
(专利文献6)
日本国专利申请公开特开2002-202883号公报
(非专利文献1)
M.Bozga、J.C.Fernandez、L.Ghirvu等著《用于自动测试生成改良的静态分析的使用》2000年，p.235-250
(非专利文献2)
L.Cardelli著《类型系统》、计算机科学与工程学手册、第103章、CRC Press公司、1997年
(非专利文献3)
T.Henning著《优化方法》、spring verlag出版、1975年
(非专利文献4)
S.Muchnick著《程序编译器设计的移植》、Morgan Kaufman出版、加利福尼亚、1999年
(非专利文献5)
根来文生著《Lyee软件原理》、关于21世纪信息化社会的国际会议2000(IS2000)、p.121-189、2000年11月
(非专利文献6)
根来文生著《Lyee入门》、软件生产技术研究所、东京、日本、2001年
(非专利文献7)
根来文生、I.Hamid著、《意图工程学的建议》、关于数据基础与信息系统的第五次东欧会议研究(ADBIS’)、2000年9月
(非专利文献8)
S.Pande、D.P.Agrawal著《用于可升级的并行系统的编译器优化：语言、编译技术及执行时间系统》、Springer-Verlag公司、2001年
(非专利文献9)
D.E.Rutherford著、《格论(Lattice Theory)序论》、Hafner出版、纽约、1965年
(非专利文献10)
F.Tip著《关于程序分断技术的调查》、程序设计语言杂志、3(3)：p.121-189、1995年9月
(非专利文献11)
D.Volpano、G.Smith及C.Irvine著《用于准确的流程分析的静态类型系统》、计算机安全杂志、4(3)：p.167-187、1996年
(非专利文献12)
W.Weiser著《程序分断》、IEEE Trans Software Engineering、p.352-357、1984年7月
像这样，作为能简单快捷地构筑更高质量的软件方法，一直以来提出各种方法论和技术，相应地改良了软件开发周期的步骤，但是这些不能实现明确的理解和修正，所以只有具有广泛能力、技能、以及知识的专家才能很好地使用，因此，在软件执行中存在着必须大规模支出劳务费、软件维护费以及检查费的问题。
为解决该问题，提出了被称为Lyee的有前途的方法论，存在着改良的余地用于其效率、质量的研究、用户更容易使用的实现。
发明内容
本发明是为解决上述现有技术问题而进行的。具体地，本发明目的在于提供一种协助Lyee方法论中具有更高质量(更少的保存与执行时间的耗费)的代码生成的关于Lyee指向软件的静态分析方法。
为此，进一步本发明的目的在于，展示为分析Lyee必要条件(它们的定义、它们的计算状态以及它们的属性中的1组词)，通过使用古典的静态分析方法的技术，能进一步增进Lyee方法论的方法，并提供可实际利用该方法的关于Lyee指向软件的静态分析方法。
并且本发明另一个目的在于，展示键入和其它静态分析技术到底能否改良Lyee方法论的某些局面，提供可实际利用的该方法的关于Lyee指向软件的静态分析方法。
另外本发明的目的在于，提出了Lyee必要条件分析器即用于给予几个静态分析的技术开发的原型，并提供可实际利用该原型的关于Lyee指向软件的静态分析方法。
并且，本发明的目的在于，示意性地提出关于本工作以及今后研究的几个结论性意见，并提供可实际利用其关于Lyee指向软件的静态分析方法。
在此，“Lyee(注册商标)”是指由作为涉及本申请发明的发明者一员的根来文生发明的涉及软件制作方法等的发明及技术，更详细的内容公开在例如由上述专利文献1至专利文献6等规定的各国际公开公报等中。
本发明为达到上述目的，具备：为按照Lyee方法论制作软件，得到的包含每个词的定义式的要求定义的步骤；将该得出的要求定义作为关键词检出常数的步骤；按照使用检出的常数的定义式传送该常数的步骤。
所谓“传送常数”是要求定义(Lyee必要条件)的词中存在常数的情况下，将该常数代入到该词中，代入到具有使用该词的定义式的词中，通过不断的代入来整理每个词的定义式。
在本发明中，对作为根据Lyee的软件制作的前阶段的Lyee必要条件实施优化，所以能够完成在根据Lyee方法论制作的软件中编码列容量的减小、耗费储存的减少、程序执行时间的进一步减少。
并且，本发明具备：为按照Lyee方法论制作软件，得到包含每个词的要求定义的步骤；由该得到的要求定义中的定义式检出模式的步骤；以该检出的模型作为置换式的表现来置换该要求定义的步骤。
所谓的“将模式作为置换式”是当必要条件中的模式多次出现时，将其置换为暂时变量。
在本发明中，Lyee必要条件的多次出现的模式只计算一次，不需要多次计算，所以能减少代码的执行时间。
另外，本发明具备：为按Lyee方法论制作软件，得到包含每个词的定义式以及前提条件的要求定义的步骤；基于上述要求定义，得到遵守BNF语法记述至少涉及上述词的识别符、定义式以及前提条件的声明的步骤；对获得的每个声明定义Def/Use函数的步骤；由定义的Def/Use函数间的顺序关系得到上述声明间的顺序关系的步骤。
所谓“声明”是将必要条件中的词和与其相对的定义式、前提条件、输入输出属性等作为一个函数化的表达。另外，所谓“Def/Use函数”是表示每个这种声明被定义词的函数、表示用于定义该被定义的词的其它词的函数。
在本发明中，可以知道将Lyee必要条件的词与该定义式等对声明的形态进行变换、分析的结果Lyee基础理论中的谓语向量的最佳(即减少执行时间)组合，因此，例如通过与必要条件生成的代码工具(LyeeALL)结合，能进一步推动根据Lyee的软件制作中的效率化。
另外，本发明具备：为按照Lyee方法论制作软件，得到每个词的定义式以及包含输入输出属性的要求定义的步骤；基于该要求定义，得到记述至少与该词相关的标识符、上述定义式以及输入输出属性的声明的步骤；由该得到的声明(第1声明)引入对与该声明相关的词的定义有贡献的声明(第2声明)，对相关的总的声明执行该第1以及第2声明作为同一声明群的分断函数的步骤；由该分断函数得到相互独立的分断的步骤。
所谓“分断函数”是使程序收敛于与特定计算相关的声明，具有区分每个相互独立的声明群的功能的函数。
在本发明中，由于能并行执行相互独立的分断群，所以能完成执行时间的缩短，特别是即使在声明数多的情况下，也能减少必要条件的理解错误。
另外，本发明具备：为按照Lyee方法论制作软件，得到包含每个词的定义式以及输入输出属性的要求定义的步骤；基于该要求定义，得到记述至少与上述词相关的标识符、该定义式以及上述输入输出属性的声明的步骤；基于关于该得到的声明的规定的分析，检出上述要求定义的错误的步骤。
在“检出要求定义中的错误”中，例如使用关于声明的规定，发现非活性声明、循环声明、不完全声明、多余声明等。当然，错误检出并不限定在这些声明中，也可以将其它的声明作为对象。
本发明，在Lyee方法论中的方案函数执行中，因为能够防止控制移动实际上不能执行的辅助程序，所以能够达到处理时间的减少、提高耗费保存的效率。
并且，本发明具备：为按照Lyee方法论制作软件，得到包含每个词的定义式以及输入输出属性的要求定义的步骤；基于该要求定义，得到记述至少与上述词相关的标识符、该定义式以及输入输出的声明的步骤；对该得到的声明、该声明中的运算符以及对数据定义各种类型代数的步骤；对于该定义的类型代数，使用相关连的环境以及预定的类型规则发现上述要求定义中的类型错误的步骤。
“类型代数”是将类型的概念引入涉及由必要条件生成的声明词、定义式等，将同等处理类型的不同作为错误，为以数学公式的方式进行在必要条件阶段中排除操作引入的概念。
在本发明中，将Lyee必要条件作为队形进行类型的分析，使用类型规则发现必要条件中的错误，所以能够进一步促进程序错误的减少。
此外，本发明具备：为按照Lyee方法论制作软件，得到包含每个词的定义式以及输入输出属性的要求定义的步骤；基于该要求定义，得到记述至少涉及上述词的识别符、该定义式以及输入输出属性的声明的步骤；对上述得到的声明、该声明中的运算符以及数据，定义类型代数的步骤；基于该定义的类型代数，使用规定的环境和类型规则，由该要求定义中的输入词生成媒介以及输出词的类型的步骤。
在本发明中，由输入词唯一地预先导出输出词和媒介地类型，所以，能够达到用户操作地简单化、错误的减少。
并且，本发明具备：为按照Lyee方法论制作软件，得到包含每个词的定义式以及输入输出属性的要求定义的步骤；基于该要求定义，得到记述至少涉及该词的识别符、该定义式、输入输出属性以及安全标号的声明的步骤；使用表示该得到的声明中的安全标号间的关系网络，定义使安全标号与该词的值相关连的函数的步骤；基于该定义的标号函数，使用规定的安全方针，算出不遵守规定的安全方针的程序的步骤。
所谓“安全标号”是表示关于某信息的安全必要条件(例如“公开的”、“秘密的”)的标号。“标号函数”是用于对必要条件中的词给予这种安全标号、以数学公式的方式处理的函数。此外，所谓“安全方针”是能够由用户方自由规定的、决定具有某种安全标号的信息如何处理的指针。
在本发明中，通过将上述键入技术扩大到信息安全，能完成对明确存在发生违反安全余地的设计上的缺陷起作用的自动程序验证。
本发明也可以为以下构成，具备：为按照Lyee必要条件制作软件，接受包含每个词的定义式以及前提条件的要求定义的要求定义接受部；由该接受要求定义分析包含于这的词汇以及语法、输出中间表达的分析部；由该输出的中间表达开始对该要求定义进行关于数据流程以及控制流程的分析、输出数据流程图以及控制流程图的分析部；对于经过该流程分析的要求定义实施优化、输出改善后的规约的优化部。
此时的“要求定义接受部”是具有输入实施本申请的例如加工前的Lyee必要条件(要求定义)的功能的单位，例如，作为登载的存储介质或ROM等，实现将该功能程序化并作为可执行的形式。
所谓“分析部”是具有由被接受的该要求定义抽取词汇以及句法进行分析后，该要求定义作为句法情况的中间表达进行输出的功能的单位，例如作为登载的存储介质或ROM等，能够实现将该功能程序化并作为可执行的形式。
所谓“流程分析部”是具有由中间表达开始，由1必要条件点到另1必要条件点的数据流程控制的循环中有关系的所有的信息作为例如控制流程图(Control Flow Graph：CFG)以及数据流程图(Data-FlowGraph：DFG)进行输出的功能的单位，例如作为登载的存储介质或ROM等，能够实现将该功能程序化并作为可执行的形式。
所谓“优化部”是，例如执行常数传送技术、适于LyeeAll工具生成能够更快执行且耗费保存更少的程序、具有生成规则简单化的声明的系列的功能的单位，例如作为登载的存储介质或ROM等，能够实现将该功能程序化并作为可执行的形式。
所谓“限制器”是具有以下功能的单位，接受与由流程基础分析要素以及分断评价标准标准生成的流程相关(与各词相关连的Def/Use等)的信息，作为输出，给出与这些给出的评价标准对应的分断。例如作为登载的存储介质或ROM等，能够实现将该功能程序化并作为可执行的形式。
因此，按照本发明，将上述各自的功能作为可以实现单位的例如介质，作为输入接受Lyee的必要条件，作为输出给出调整适于LyeeAll生成的优化代码的分断和顺序，并且，可以执行常数传送等其它的必要条件的优化。
此外，本发明不只作为软件分析方法，也可以作为软件分析装置、或大范围的软件开发方法、软件开发装置、以及用于在计算机中执行这些的软件、保存该软件的存储介质、搭载该软件的装置、在例如ROM等中保存该软件的额定专用机器、或作为业务方式执行这些的业务模型等实现，本发明包含这些实施方式。
附图说明
第1图是以代码列表示涉及本发明的Lyee方法论中的必要条件执行的示意图。
第2图是用于说明涉及本发明的Lyee方法论中的模块概念的示意图。
第3图是用于说明涉及本发明的Lyee方法论中的方案函数概念的示意图。
第4图是表示涉及本发明的Lyee方法论中的谓语向量的动态结构的流程图。
第5图是表示涉及本发明的Lyee方法论L4，a、以及L4，b的谓语向量的动态结构的流程图。
第6图是表示涉及本发明的Lyee方法论L3，a、以及L3，b的谓语向量的动态结构的流程图。
第7图是用于示意性地说明涉及本发明的Lyee方法论中的画面相互作用的示意图。
第8图是用于说明涉及本发明的Lyee方法论中的处理路径图的概念的示意图。
第9图是用于说明涉及本发明一实施方式的UseDirectAndIndirect(s，S)算法的流程图。
第10图是用于说明检出涉及本发明一实施方式的循环声明语句的算法的流程图。
第11图是用于说明检出涉及本发明一实施方式的不完全声明语句的算法的流程图。
第12图是用于说明检出涉及本发明一实施方式的无用声明语句的算法的流程图。
第13图是用于说明检出涉及本发明一实施方式的无用声明语句的算法的流程图。
第14图是用于说明检出涉及本发明一实施方式的2个之中应该先执行的声明语句的算法的流程图。
第15图是用于说明排列涉及本发明一实施方式的声明语句顺序的算法的流程图。
第16图是用于说明排列涉及本发明一实施方式的声明语句顺序的算法的流程图。
第17图是用于说明抽取涉及本发明一实施方式的词a的分断算法的流程图。
第18图是用于说明抽取涉及本发明一实施方式的词a的分断算法的流程图。
第19图是用于说明检出涉及本发明一实施方式的独立的分断算法的流程图。
第20图是用于说明涉及本发明一实施方式的键入的算法的流程图。
第21图是用于说明涉及本发明一实施方式的键入的算法的流程图。
第22图是用于说明涉及本发明一实施方式的键入的算法的流程图。
第23图是用于说明涉及本发明一实施方式的键入的算法的流程图。
第24图是用于说明涉及本发明一实施方式的键入的算法的流程图。
第25图是用于说明涉及本发明一实施方式的键入的算法的流程图。
第26图是用于说明涉及本发明的一实施方式的Lyee必要条件分析器的动态结构的功能程序块以及流程图。
具体实施方式
作为本发明的基本考虑方法是称为Lyee的开发方法论，关于此，公开在上述的专利文献1至专利文献6等中。
在软件系统的研究于开发的过程中，问题最多的工作之一是充分理解必要条件并将它们正确地变为代码。为解决这个问题，在Lyee方法论中，提出由必要条件产生程序的简单的方法。
关于Lyee方法论背景中的哲学的原则，根据上述的文献，下面参考附图·表，为理解如何查看通过使用该方法论写软件的方法与根据该方法由必要条件自动生成的代码，只集中几个实用的构思进行说明。
(1)Lyee必要条件
在Lyee方法论中，必要条件作为多个声明(语句)(statements)的集合以声明的方法给出。声明包含词、与其相伴的词的定义、运算条件及属性(输入/输出、类型、安全性属性等)。
为简单化，在本说明书中看作各声明的包含下面的1)到5)的信息。
1)词(Word)
词的标识符
2)定义(Definition)：定义词的表达式。为简单化，作为表达式可以考虑为是以下中任意的一个。
Exp：＝val|id||(Exp)|op Exp|Exp op Exp
val：＝num|num.num|bool
num：＝0|1…|9|num num
bool：＝：true|false
id：＝a|…|z|A|…|Z|id num|id id
Op：＝+|-|*|or|and|＜|＜＝|＝|＜＞|＞|＞＝|not
上述所示的表达式Exp的定义如下。
·Exp：
式中″Exp″(表达式)、值″val ″、标识符″id″、各个给出的表达式″Exp″、后面表述式是接续的单项运算符″op Exp″(例如-2、-(a+b))、或者伴随其它表达式的二项运算符中的″Exp opExp″。
·Val：
值″val″是数值″num″、浮点数值″num.num″(数值.数值)、或者逻辑值(真假值)″bool″。
·num
数值″num″是数字(degit)或一个数值后续的数值″num.num″。
·bool：
逻辑值是真(true)或假(flase).
·id
标识符″id″是字符、字符后的数值接续的″id num″或者标识符后的标识符接续″id id″。
·op
运算符是+、-、*、or、and、＜、＜＝、＜＞、＞、＞＝、或not。
2)条件(Condition)
所谓条件是词的运算条件，是被作为逻辑运算符的表达式Exp。如果没有条件(即，条件常为真)，该项目作为空白栏。
3)IO
为明确显示，该项目将被定义的词分为输入词、输出词或中间词(intermediate Word)。如果词为输入，并且是由文件输入，该项目的为值IF，如果词是由画面输入，则为IS。同样，如果词为输出，则该栏为值OF(输出给文件的情况)或OS(输出给画面的情况)。可是，如果是中间词，该栏作为空白栏。所谓中间词，并不输入，并且，不输出根据定义的表达式生成的值，生成的值只对其它的输出词的生成起作用。
4)类型(Type)
该项目为指定词的类型而分配，是整数″int″、浮点数″float″或逻辑值″bool″中的任意一个值。
5)安全性(Security)
该项目为确定所定义的词的安全级别而被分配，取公开(public)或非公开(secret)中的任意一个值。如果被定义的词不是输入，项目″类型″与″安全性″可以为空栏。同样，其它种类的类型和其它种类的安全级别也能容易地扩大，正确地满足真正的Lyee必要条件。
表1是表示Lyee必要条件的例子。
(表1)
  词   定义   条件   IO   类型   安全
  ...
  a   b+c   b*e＞2   OF   int   secret
  c   IS   float   public
  b   2*c+5   c＞0   OS   float   public
  e   IS   float   public
  ...
在本说明书中，以下声明(statement)是指必要条件表的1行的内容。
例如，在表1中定义词a的声明(把这记为sa)在表2中记述。
(表2)
词a的声明
  词   定义   条件   IO   类型   安全
  a   b+c   b*e＞2   OF   int   secret
在本说明书中，以下如果s是声明，其后的定义使用如下的意思。
1)Word(s)是声明的项目为″词″的意思。
2)Definition(s)是声明的项目为″定义″的意思。
3)Condition(s)是声明的项目为″条件″的意思。
4)IO(s)是声明的项目为″IO″的意思。
5)Type(s)是声明的项目为″类型″的意思。
6)Security(s)是声明的项目为″安全性″的意思。
(2)Lyee程序的代码生成
把Sw作为定义词w的声明。传统的程序设计语言中，表1中给出的必要条件与表3中给出的代码相对应。Lyee方法论中，用户不需要指定这些定义的执行顺序(控制逻辑)。在表1中，尽管词a使用词b来定义，声明Sb被分配在Sa的后面。在Lyee方法论中，作为软件理论部分的控制逻辑自动生成的结果，能够大量减少程序涉及错误和程序时间。
(表3)
  声明   代码
sa   if b*e＞2then a：＝b+c；output(a)；endif
  sc   input(c)；
Sb   if c＞2then b：＝2*c+5；output(b)；endif
  se   input(e)；
由表1的必要条件，我们能够自动生成计算a与b的值的程序，并将其输出。在此，图1是将必要条件反应在执行中的情况作为代码列来表达的示意图。如该图所示，程序到达某一定点前，简单地重复这些指示，即，无论怎样的重复，图1所示的哪个词的值都不变化。
然后，即使改变关于与图3中给出的声明相关连的代码的顺序，也不能改变程序的意思，即总是将正确的值赋予词。
然后，更详细地声明根据Lyee由必要条件自动地生成程序的结构和内容。在Lyee方法论中，一组声明的执行(表1中给出的)是以独特的方法来执行的。Lyee在图2中表示与声明相关连的代码，分配在以Lyee术语称呼的3个模块上(W02、W03、W04)。
如该图所示，W02模块处理输出词，然后W03模块算出词的计算条件，该结果保存在几个变量中(作为值取逻辑值)。例如，词a的定义中使用的″b*e＞2″的条件在W03模块中计算，真/假的该结果保存在″a_cond″的另外一个变量中。最后，W04模块按照在必要条件中给出的定义进行词的计算。另外，其输出计算出来的词的值。
在Lyee中，从W04开始，达到一定点之前对所有定义的词进行该值的计算。在W04中，对于词的值不能再有进展时，控制转到W02模块。自己的号到来时，第2个模块在未达到一定点前(没有得到重新取入输入的状态)，重复进行不足的词的输入，然后将控制转到W03。最后，与W04模块的情况一样，根据必要条件，达到一定的点之前，W03模块算出词的计算条件。
如图3所示，在达到整体稳定状态前，该整体的过程(W04→W02→W03)重复进行，该单位被称为基本结构(Scenario Function方案函数)。可以容易地得到图1所示的程序的执行结果与图2所示的程序的执行结果相同。
并且，Lyee确立具有使应该生成的代码的结构与必要条件内容一定没有关系的固定结构的简洁的标准程序(按Lyee术语称为″基础理论″)。包括整体的全程程序(global program)简单地称为谓语向量(predicate vector)。图4为展示上述谓语向量结构的图。
如该图所示，作为谓语向量的目的根据模块而改变。例如，在W04模块，最初的目的是根据该计算的定义对词赋值。例如对于图2中所示的例子，与词a与词b的计算相关的谓语向量按图5所示。另外，对图4及图5的各步骤的详细说明符合上述专利文献1至6，所以在此省略。
对于该词的计算，如果没有进一步的进展，根据Lyee生成的代码尝试以下目的，即词的输出。将值的输出作为目的的谓语向量被称为输出向量(output vector)。在W02模块中，存在将使值与输入词相关连为目的的2个谓语向量。为了说明简洁，对处理输入、输出以及保存的初始化的谓语向量在其它的详细说明中省略。最后，在W03模块中，谓语向量的目的是如图6所示，在判定必要条件中指定的前提条件。在此，对该图的各步骤的详细说明符合上述专利文献1至6，所以在此省略。
最后，表1给出的必要条件相关的Lyee程序如表3所示。
(3)处理路径图
前部分示出的基本结构(Scenario Function方案函数)在任意的必要条件的简单的情况、特别是所有的输入及输出词属于同一画面、不使用数据基础的情况下，其自身就是完整的程序。但是，需要输入输出数据基础或相互有关连的属于不同的画面的词时，情况变得稍微复杂。为说明简洁，以下只处理有多个画面情况。例如，假设有图7所示的相互连接的3个画面，用户由一个画面转到其它画面，在这些中的任意一个中，用户能够输入、运算、输出多个词。因此用户在说明书中需要给出这些画面如何结合。
(表4)
  模块   程序   命令
  W04   Call S4DoCall L4_aCall L4_bwhile a fixed point is not reachedCall O4Call R4   存储器初始化计算a计算b输出结果到W02
  W02   DoCall L2_eCall L4_cwhile a fixed point is not reachedCall I2Call R2 输出结果到W03
  W03   DoCall L3_aCall L3_bwhile a fixed point is not reachedCall R3 计算a_cond计算b_cond到W04
然后，为计算在所有的画面上定义的所有的词，只定义一个基本结构(方案函数)是不合适的。实际上，画面中可能有在程序的任意的执行中未被执行的画面，该情况下，进行那些画面的词的值的计算就浪费时间了。由上述理由，Lyee将各画面与该画面被执行时执行的担当基本结构相关连。示出与画面相关连的基本结构相互连接、如何由相同的画面中的一个转到别的画面。若以Lyee术语来说，相互连接的多个基本结构集中，作成如图8所示的处理路径图(process routediagrams)。
总起来说，在Lyee方法论中程序通常包含多个处理路径图。这些处理路径图各自都是1组内部相连接的基本结构群，并且，各自的基本结构包含内部相连接的3个模块，即W02模块、W03模块及W04模块。
(4)Lyee方法论的改进点
尽管Lyee方法论的简洁程度与Lyee的方法论对软件开发周期的所有步骤有几个影响，但是Lyee方法论对生成代码容量上具有重要的改进点。实际上，对于必要条件中给出的各个词Lyee分配几个存储区域。作为保存被消耗的正确容量的详情参考上述的非专利文献6及7。
以下，展示通过静态分析的技术如何将Lyee程序改进为具有更快运行并且保存空间的消耗更小等更优良的质量的软件。
以下，参考附图说明涉及关于Lyee必要条件的静态分析的本发明的实施方式。
软件的静态分析(参考非专利文献1及4)意思一般是不实际执行程序而进行关于程序的代码的验证。若按照经验所示，通过静态分析能够控制、改良设计书与代码中的多个质量特征。特别的，根据静态分析的技术能够制作更快运行、保存空间的耗费更少的程序，发现程序的错误。若对必要条件进行静态分析，能够在代码生成前发现理论的错误与欠缺的地方，其结果能够使用户节约用于开发及测试的宝贵的时间。
在本说明书中，展示能够改良Lyee必要条件与该生成代码列的质量的几个静态分析的技术。
一般的，所谓程序的优化是指通过施加一系列的变化来缩小代码列的大小、其执行时间、耗费保存等。明确了所给予的代码列的优化是最大的目的，但是即使任何情况下也不应该改变最初程序的意思。
1.古典的优化
在本部分中，说明几种古典优化技术(参考非专利文献3及8)以及这些优化对于保存耗费量和Lyee程序的执行时间的很大效果。
(1-1)常数传送分析(Constant Progagation)
这个简单的技术检出程序中的常数，按照使用它们的表达式传送那些常数的值，最后消除这些常数。例如，表1的例子中，常数传送前的必要条件中，将5赋予词a的定义。词b的定义为a+3*5，通过代入a＝5，进行常数的传送时，词b的定义为20。词d的定义为e+b*a，所以代入a＝5、b＝20，进行常数的传送，该定义式成为e+100。这样常数传送的结果、初始必要条件就成为表5的“常数传送分析后”所示。定义为常数的声明不需要生成值，所以由必要条件中除去。
(表5)
  词   定义   条件   IO   ...
  a   5
  b   a+3*5
  d   e+b*a
  e   IO
<常数传送分析前>
  词   定义   条件   IO   ...
  d   e+100
  e   IO
<常数传送分析后>
(1-2)模式检出
模式是在程序中重复数次的基准表达式。这意味着各自的基准表达式都计算数次。因此，模式如果存在于必要条件中，一般地，将各个模式替换为基准表达式只计算一次的暂时的变量，因此能够减少与这些相关连的代码的执行时间。表6是给出基准表达式″b*c″作为模式的例子。
(表6)
  词   定义   条件   IO   ...
  a   b*c+5
  e   a+b*c+1
  d   e+b*c   b+c＞2
<模式传送分析前>
  词   定义   条件   IO   ...
  t   b*c
  a   t+5
  e   a+t+1
  e   e+t
<模式传送分析后>
然后，说明使用这些简单的古典优化技术能够如何改良通过Lyee生成的代码的保存空间与执行时间。熟知的事实是这些优化技术由几乎所有可能利用的程序编译器给出。在此基础上，可以得出如下结论：由于Lyee一般通过COBOL等高级程序语言生成代码，如果由人来生成Lyee的高级代码，因此用于生成低级代码的编译器要对这些进行优化。但是，深入研究这个问题，显示这个结论并非完全正确。实际上，Lyee用于生成代码的方法可能将寻找这些古典优化时的编译器的操作变得复杂。
为了对其进行确认，我们使用C语言来编写了执行简单的必要条件的两个程序。我们分别对其中之一给出由LyeeALL(注册商标)工具生成、同样结构的第二个为通常的结构。由程序编译器对两个程序进行优化编译后，我们发现，在具有Lyee结构的程序中程序编译器越来越不能适用常数传送技术，在第二个程序中始终能够进行优化。即，我们得到结论：一旦必要条件由用户给出，Lyee方法论中代码生成前使用这些优化的技术更有益、更简单。
2. Lyee必要条件静态分析中的基本分析
在这部分中，为简化本说明书中明确的静态分析技术的大部分的说明，进行几个非常有益的基本的分析的定义。
(2-1)Def/Ues分析
(2-1-1)Def/Ues分析的非正式的定义
任意的Lyee必要条件中的各声明s为定义新的词，在定义式或条件式中使用几个词。在定义式或条件式汇总使用的词的集合称为Use(s)，新定义的词称为Def(s)。
表7是Def/Ues概念的具体例。
(表7)
Def/Ues概念的具体例
                           声明   Def   Use
  词   定义   条件   IO   类型   安全
  e   IS   int   public   {e}   {}
  b   3   e＞0   OS   int   public   {b}   {e}
  c   2*b   e＞2   OS   int   public   {c}   {b，e}
  a   b+c   OS   int   public   {a}   {b，c}
(2-1-2)Def/Ues的正式的定义
s是声明(wrd、Def、Cond、io、type、SecType)。由Def(s)表示的声明s的Def只是wrd。并且，以Use(s)来表示的声明s的Use如下定义。
<声明的Use>
Use(s)＝Use(Def)∪Use(Cond)
<表达式的Use>
      Use(val)＝_
      Use(Id)＝{Id}
  Use(Op Exp)＝Use(Exp)_Use(Exp1·Op Exp2)＝Use(Exp1)∪Use(Exp2)
上述的定义为如下的意思。
1)声明的Use
Use(s)＝Use(Def)∪Use(Cond)：声明s的定义以及条件中使用的词(Use(s))是该定义的定义与条件中使用的词(Use(Def))以及该条件的定义与条件中使用的词(Use(Cond))的并集。定义与条件二者都是表达式，即，为结束任意的声明Use的定义，可以只定义表达式Use。为此，对于各类型的表达式，必须明确其Use。
2)表达式Use
·Use(val)＝0：
表达式若是值(val)，其Use为空白栏。即，没有定义以及条件中使用的词。
·Use(Id)＝{Id}：
表达式若是标识符(Id)，其Use为标识符其自身。
·Use(Op Exp)＝Use(Exp)：
表达式″Op Exp″若是(后面伴随表达式(Exp)的单项运算符(Op))的形式，其Use与表达式(Exp)相等。
·Use(Exp1 Op Exp2)＝Use(Exp1)∪Use(Exp2)
表达式若是″Exp1 Op Exp2″，该Use为表达式1(Exp1)的Use与表达式2(Exp2)的Use的并集。
(2-2)直接及间接Use
如前项中所述，必要条件的各个声明s通过词的集合Use(s)来定义的、使用几个词的情况。将该词的集合称为声明s的直接Use。实际上，属于Use(s)的各个词是该定义式或者条件式的声明s中直接使用的。
除直接Use的词以外，声明s有时也间接地使用其它词。例如，如果声明s直接使用词″a″，并且定义词″a″的声明使用词″b″，此时，可以说声明s间接地使用词″b″。并且，如果定义词b的声明s使用词c，同样，可以说声明s间接地使用词c。
表8示出用于明确间接Use的概念的具体例。
(表8)间接Use的概念的具体例
                            声明   Def   Use   间接Use
  词   定义   条件   IO   类型   安全
  e   IF   int   public   {e}   {}   {}
i e int public   {i}   {e}   {}
b i i＞0 OS int public   {b}   {i}   {e}
  c   2*b   b＞2   OF   int   public   {c}   {b}   {e，i}
  a   b   c＞0   OS   int   public   {a}   {b，c}   {e，i}
在表8的例中，词e为输入词，所以该Use为(直接Use。以下，直的接Use只记为″Use″)空白栏，因此间接Use也为空白栏。词i是作为其Use的词e为输入词，其定义以及条件为空白栏，所以间接Use为空白栏。词b是作为其Use的词i的Use是词，所以间接Use为词e。词c的作为其Use的词b的Use为词i以及其间接Use为词e，所以词c的间接Use为词e以及词i。词a的作为该Use的词b的Use为词i、并且间接Use为词e，并且作为另一个Use的词c的Use为词b、并且间接Use为词e与词i，因此词a的间接Use为词e以及词i(词b为直接Use，所以不加到间接Use上)。
按照下述的函数UseDirectAndIndirect(s，S)的算法，能够得到任意的Lyee必要条件S(声明的集合)中的任意1个声明s的Use与间接Use二者。
UseDirectAndIndirect(s：statement，S：set of statements)

   Var W_Old，W_New：set of words

   Begin

       W_Old←Use(s)

       W_New←W_Old

       Fix_Point←False

       While(Fix_Point＝False)

          For all a∈Use(s)∩Word(S)

               W_New←W_New∪Use(Statement(a，S))

           EndFor
        <!-- SIPO <DP n="22"> -->
        <dp n="d22"/>
       If(W_New＝W_Old)

           Then Fix_Point←True

       Else W_Old←W New

       EndIf

    EndWhile

    return W_New

 End
上述函数UseDirectAndIndirect(s，S)的算法的意思如下。s是声明，S是必要条件的声明的集合。变量W_Old与变量W_New是词的集合。
<开始>
变量W_Old中保存Use(s)[作为声明s的直接Use的词(群)]
变量W_New中保存变量W_Old的值
变量Fix_Point中保存值False
<While语句开始>变量Fix_Point的值为Flase时，执行下述程序。
<For语句开始>对于所有的词a，作为属于必要条件的声明s的Use的情况执行以下程序。
变量W_New中保存变量W_New保存的词(群)以及作为属于必要条件的词a的声明的Use的词(群)。
<For语句结束>
<If语句开始>如果变量W_New的值与变量W_Odl的值相等，变量Fix_Point中保存值True。
否则，变量W_Old中保存变量W_New的值。
<If语句结束>
<While语句结束>
<结束>
在上述算法中，函数Statement(a，S)是返回定义Lyee必要条件S中的词a的声明的函数。即，返回如Def(sa)＝{a}(表示词a的声明sa的Def是词a)的声明sa∈S(必要条件包含的词a的声明s)。
如图9，在流程图中显示上述函数UseDirectAndIndirect(s，S)的算法的。如下顺次说明图9的处理步骤。变量W_Old的区域中保存Use(s)[声明s的直接Use，即词(群)]的结果(步骤101)，变量W_New的区域中复制W_Old的值(步骤102)。然后，区域Fix_Point中保存″假(flase)″(步骤103)。
通过步骤104的条件判定，若Fix_Point的值为假则前进到步骤105。
在步骤105中，″Use(s)的结果与Word(s)的结果的和[声明s的Use与必要条件S的全部声明的词]的词的集合中是否有步骤106未执行的词a″的判定中，若结果为真则前进到步骤106。在步骤106中，变量W_New的区域保存变量W_New的值与Use(Statement(a，S))[词a的声明的Use]的值。
步骤106结束后，返回步骤105再次执行判定。只要步骤105判定结果为真，就重复由步骤105到步骤106的第1重新开始处理(111)。
在步骤105的判定中，结果为假时，即，Use(s)的结果Word(s)的结果的和[声明s的Use与必要条件S的全部声明的词]的词的集合中，没有未被执行的词a时，前进到步骤107。在步骤107中，″变量W_New的值是否与变量W_Old相等″的判定中，结果为假的情况下，前进到步骤108，将变量W_New的值复制到变量W_Old的区域中，结果为真的情况下，前进到步骤109，在区域Fix_Point中保存真。步骤108或步骤109结束后，返回到步骤104再次进行判定。只要步骤104的判定结果为真，重复进行步骤104到步骤109的第2重新开始处理(112)。
Fix_Point的值为真且步骤104的判定结果为假时，由步骤104前进到步骤110，作为函数UseDirectanIndirect(s，S)的结果，返回变量W_New的值。
3.必要条件调试
(3-1)非活性声明(Dead Statements)
如果某个声明一定不执行，就认为该声明为非活性的。非活性的声明由很多的原因引起。被熟知的原因之一是声明中存在不相容的前提条件。实际上，与给出的声明相关联的前提条件总是出现错误，这个声明就没有意义，作为结果与其相关联的谓语向量(predicatevectors)完全不能被执行。这是由方法的错误引起的，所以必须告知用户。为检出这种类型的非活性的代码，可以只分析与声明相关联的前提条件。与给出的声明相关联的前提条件总为假时，如果能在静态下证明(进行评价时，被提醒到得到前提条件中被使用的所有的词的值的是不必要的。即，若条件″Φ∧_Φ″与Φ值无关、常为假)，该声明就为非活性的。而且，使用非活性声明的其它声明都是非活性的。若更正式的表示，若声明s为非活性的，s’≤s中的s’也为非活性的(≤表示左边的声明的词包含在右边的声明的Use中)。
(3-2)循环声明(Cyclic Statements)
(3-2-1)循环声明的非正式的定义
任意的声明的词的直接或者间接的定义包含该词自身的情况下，称声明为循环的。换言之，就是任意词″a″的定义中需要″a″的情况。以下，示出几个具体的例子。
表9是″a″使用其自身进行定义的直接循环的例子。
(表9)
循环声明：词a
  词   定义   条件   IO   类型   安全
  i   IF   int   secret
  a   a*i   i≠0   OF   int   secret
其次示出间接循环的例子。表10中，词″a″的定义除了其它的词以外还需要词″b″的定义。但是，词″b″的定义也需要词″a″的定义。因此，词″a″与″b″陷入间接循环中。
(表10)
循环声明：词″a″、词″b″
  词   定义   条件   IO   类型   安全
  i   I S   int   public
  a   i+1   OS   int   public
  b   2*a   OS   int   public
(3-2-2)循环声明的正式定义
以下示出循环声明的正式定义。S作为声明的集合，与下述的条件一致时，声明s∈S(声明s属于必要条件S)进行循环。
Def(s)∈UseDirectAndIndirect(s，S)
即，Def(s)∈UsedirectAndIndirect(s，S)形式上表示″声明s的Def包含在属于必要条件S的声明s的直接以及间接Use中″。
根据下述函数CyclicStatements(S)的算法，能够检出任意的Lyee必要条件S中的循环声明。
CyclicStatements(S：set of statements)

  Var CyclicSet：set of statements

  Begin

     CyclicSet←_

     For all s∈S do

       If(Def(s)∈UseDirectAndIndirect(s))

          Then CyclicSet←CyclicSet∪{s}

       EndIf

    EndFor

    return CyclicSet

  End
上述函数CyclicStatements(S)的算法为如下意思。
S是作为必要条件的声明的集合。变量CyclicSet是声明的集合。
<开始>
变量CyclicSet中保存″0″。
<For语句开始>对于属于声明的集合S的所有的声明s，执行以下语句。
<If语句开始>若Def(s)[声明s的词]包含在UseDirectAndIndirect(s)[声明s的直接以及间接Use]中
变量CyclicSet中保存变量CyclicSet的值与{s}″声明s″。
<If语句结束>
<For语句开始>
返回变量CyclicSet的值。
<结束>
图10是表示该函数CyclicStatements(S)的算法的流程图。以下s依次说明图10的处理步骤。首先，变量CyclicSet的区域保存″0″(步骤201)，进行″声明的集合S中是否有未执行步骤202处理的声明s″的判定(步骤202)。判定为真的情况下，进行″Def(s)[声明s的词]是否属于UseDirectAndIndirect(s)[声明s的直接以及间接Use]″的判定(步骤203)，判定为真的情况下，变量CyclicSet的区域保存CyclicSet的值与声明s(步骤204)，返回步骤202的判定。步骤203的判定为假的情况下，直接返回步骤202的判定并再次执行。只要步骤202的判定为真，重复进行步骤202到204的重新开始处理(206)。
步骤202的判定结果为假时，前进到步骤5，作为函数CyclicStatement测得结果，返回变量CyclicSet的值(声明的集合)。
循环声明的验证必须是应该在声明上进行的最初的静态分析，这点是重要的。因此，本说明书中，以下所述的静态分析前提是分析结果中没有循环。
(3-3)不完全声明(Incomplete Statements)
(3-3-1)不完全声明的非正式定义
声明S的集合(Lyee必要条件)，如果其至少包含一个使用一个以上在S中未直接和间接定义的词的声明s，可以称为不完全的。上述定义抓住″所有被使用的词必须要定义″的原则。
表11是不完全声明的具体例子。在此，词″a″使用词″i″，但词″i″还未被定义。
不完全声明
  词   定义   条件   IO   类型   安全
  a   i+1   OS   int   public
  b   2*a   OS   int   public
(表)11
为简单说明不完全声明的概念，最初引入下面的表述法。Defined(S)：
存在任意的声明的集合S(必要条件S)时，函数Defined(S)返回在S中定义完成的词的集合。更加正式的如以下的表述。
Defined ( S ) = &cup; s &Element; S Def ( s )
上述表示函数Defined(S)是″作为属于必要条件S的所有的声明s的Def的结果的词的全体集合″的。但是，所谓定义完成是存在该词的声明，并不是声明的所有项目的必要信息都满足。例如，也有尽管是输出词，但定义式与条件式是未定义的情况。这样的声明为Use(s)＝{}。不完全声明中即使是定义完成，也能包含未输入的未定义的定义式以及条件式。
使用下图说明不完全声明的定义。
X是作为必要条件S的所有的声明s的直接以及间接Use的词的集合。Y是必要条件S中定义完成的词的集合。Z是X与Y的交集，即，在必要条件S的任意一个声明中被使用并且作为定义完成的词的集合。W是必要条件的声明中被使用的词中的、在必要条件中未定义的词的集合。Q是″必要条件的任一声明中被使用，并且定义完成的词的集合″Z中、未定义声明的定义式以及条件式的未输入的词。
因此，不完全声明是″必要条件S的声明中使用的词中的、必要条件S中未定义的词的集合″W的声明和″必要条件S的任一的声明中使用比你关切定义完成的词的集合″Z中的未定义定义式以及条件式的未输入的词的集合Q的声明之和。
图11的流程图表示用于取出不完全声明的处理。首先，分别在变量IncompleteSet、变量X、变量q中保存值″0″(步骤301)。然后，在步骤302中判定″必要条件S中是否存在未执行步骤303处理的声明s″。如判定结果为真，前进到步骤303，变量X中保存变量X的值与UseDirectAndIndirect(s，S)的值。步骤303结束后，返回步骤302再次执行。只要步骤302的判断为真，则重复步骤302到步骤303的第1重新开始处理。
步骤302的判断结果为假的情况下，前进到步骤304，变量Y保存函数Definded(S)[返回必要条件中定义完成的词的集合]的结果，变量Z保存X∩Y[必要条件S的声明中使用的词，并且在必要条件S中定义完成的词的集合]，变量W保存X-Z[由必要条件S的声明中使用的词的集合减去Z的词的集合。即，为必要条件S的声明中使用的词，但在必要条件S中未定义的词的集合]。
然后，在步骤305中判断″必要条件S中是否存在未执行步骤306处理的词a″。若判断结果为真，在步骤306中判断″是否IO(Statement(a，S))≠IS或IF[词a未输入]，并且Use(Statement)(a，S)＝{}[词a的声明的直接Use为空，即未定义词a的定义式以及条件式]″。若判断结果为真，在步骤307中变量q保存变量q的值和词a，返回步骤305再次执行。只要步骤305的判断为真，则重复步骤305到步骤307的第2重新开始处理。
步骤305的判断为假的情况下，前进到步骤308，变量Q中保存Z∩q[必要条件S的声明中被使用并定义完成的词(＝Z)，并且未定义定义式以及条件式的未输入的词(＝q)]的值，变量IncompleteSet中保存W∪Q[必要条件S的声明中使用的但未定义的词(＝W)和上述Q的词]的所有的声明。最后，作为必要条件S中的不完全声明，返回变量IncompleteSet的值(步骤309)，结束处理。
(3-4)无用声明
(3-4-1)无用声明的非正式定义
任意的Lyee必要条件S中的声明s若对S的任何的输入词的定义没有直接或间接的贡献，该声明s被认为是无用的。该定义抓住″必须使用各定义完成的词″的原则。所谓“使用”是″直接或间接对输出词的定义有贡献″的意思。无用的定义和不完全的定义合起来，抓住以下的原则：定义了的必须全部使用，使用的必须全部定义。
表12是无用声明的具体例子。在此，词j对任何的输出词的定义没有直接或间接的贡献。因此，词j未对程序的执行带来否定的效果，所以可以从必要条件中去掉。
(表12)
无用声明
  字   定义   条件   IO   类型   安全
i IS int public
  J   2*i   int   public
  a   i+1   OS   int   public
  b   2*a   OS   int   public
为正式定义无用声明的概念，引入以下的概念。
OutputStatements(S)：
存在任意的声明的集合S时，函数OutputStatements(S)由S中返回作为输入/输出属性具有OS或OF的声明。正式的表述如以下定义。
OutputStatements(S)＝{s∈S|IO(S)＝OS or IO(S)＝OF}
上述正式的表述的意思是：函数OutputStatements(S)的结果是″属于声明的集合S的声明s，该声明s的该IO(输入输出属性)项目的值是OS(对画面的输出)或OF(对文件的输出)的声明″。
根据下述的函数OutputStatements(S)的算法，由任意的Lyee必要条件S中可以导出作为输出/输出属性为输出(OS或OF)的声明OutputStatements。
OutputStatements(S：set of statements)

   Var OututSet set of statements

   Begin

      OutputSet←_

      For all s∈S do

        If(IO(s)＝”OS”or IO(s)＝”OF”)

            Then OutputSet←OutputSet∪{s}

         EndIf

      EndFor

      return OutputSet

   End
上述函数OutputStatements(S)的算法的意思如下。
S是作为必要条件的声明的集合。变量OutputSet是声明的集合。
<开始>
变量OutputSet的区域中保存″0″。
<For语句开会>对属于声明的集合S的所有的声明s进行以下处理。
<If语句开始>若声明s的IO[输入输出属性]为OS[对画面的输出]或OF[对文件的输出]的情况下，
变量OutputSet的区域保存变量OutputSet的值和声明s。
<If语句结束>
<For语句结束>
作为函数OutputStatements(S)的结果，返回OutputSet的值(声明的集合)。
根据以上的定义，容易定义以下部分所示的正式的无用声明。
图12是表示该函数OutputStatements(S)的算法的流程图。以下说明图12的处理。首先，变量OutputSet的区域中保存″0″(步骤401)。然后，在步骤402中判断″声明的集合S中是否存在未进行步骤403处理的声明s″。步骤402的判断结果为真时，前进到步骤403，判断″声明s的IO[输入输出属性]是否是OS[对画面的输出]或OF[对文件的输出]″。步骤403的判断结果为真的情况下，变量OutputSet的区域保存变量OutputSet的值与声明s，返回到步骤402。步骤403的判断结果为假的情况下，直接返回到步骤402并在此执行。只要步骤402的判断结果为真，则重复步骤402到步骤404的重新开始处理。
若步骤402的结果为假，作为函数OutputStatement的结果，返回OutputSet的值。
(3-4-2)无用声明的正式定义
对无用声明的正式定义进行说明。将S作为声明的集合，S中的无用声明由SuperfluouStatements(S)表示，进行如下的正式定义。
SuperfluousStatements ( S ) = S - ( &cup; s &Element; OutputStatements ( S ) ( &cup; s &Element; UseDirectAnd ln dinect ( s , S ) Satement ( a , S ) )
上述正式的表述意思是：函数SuperfluousStatements(S)的结果是″由声明的集合S中除去属于S的所有的声明s的直接或间接Use的词的声明的集合，即如S的输出词的声明的声明的集合″。
通过下述函数SuperfluouStatements(S)的算法，能够检出任意的Lyee必要条件中的无用声明。
SuperfluousStatements(S：set of statements)

Var Super fluous′StatSet，ImportantStatSet，OutputStatSet：

                                            set of statements

Begin

    OutputStatSet←OutputStatements(S)

    ImportantStatSet←_

    For all s∈OutputStatSet.do

      For all a∈UseDirectAndIndirect(s，S)do

        ImportantStatSet←ImportantStatSet∪{Satement(a，S)}

      EndFor

    EndFor

    Super fluous StatSet←S-ImportantStatSet

    return Super fluous StatSet

  End
上述函数SuperfluousStatements(S)的算法的意思如下。
作为S必要条件是声明的集合。变量SuperfluousStatement、变量ImportantStatSet、变量OutputStatSet是声明的集合。
<开始>
变量OutputStatSet的区域保存函数OutputStatements(S)[属于必要条件的所有的声明]的结果。
变量ImportantStatSet中保存″0″。
<For语句开始>对属于OutputStatSet的所有的声明s进行以下的处理。
<For语句开始>对属于UseDirectAndIndirect(s，S)[必要条件S中的声明s的直接或间接Use]的所有的词a执行以下处理。
变量ImportantStatSet的区域保存变量ImportantStatSet的值和词a的声明。
<For语句结束>
<For语句结束>
变量SuperfluousSet的区域保存由必要条件S中除去变量ImportantStatSet的值的声明集合。
作为结果返回变量SuperfluousSet的值。
<结束>
图13是表示该函数SuperfluousStatements(S)算法的流程图。以下对图13的处理进行说明。首先，变量OutputStatSet的区域保存函数OutputStatements(S)[属于必要条件的所有的输出声明]的结果，变量ImportantStatSet中保存″0″(步骤501)。然后，判断“变量OutputStatSet中是否存在未执行步骤503的声明s”(步骤502)。步骤502的结果为真时，步骤503判断“UseDirectAndIndirect(s，S)[声明s的直接或间接Use中是否存在未执行步骤504的词a]”。若步骤503的结果为真，前进到步骤504，在变量ImportantStatSet的区域保存ImportantStatSet的值与Statement(a，S)[词a的声明]的结果。步骤504结束后，返回步骤503再次执行。只要步骤503的判断结果为真，则重复步骤503到504的第1重新开始处理。
步骤503的结果为假时，返回到步骤502再次执行。只要步骤503的结果为假，就重复步骤502到步骤504的第2重新开始处理。步骤502的结果为假时，前进到步骤505，在变量SuperfluousSet中保存由必要条件S中除去变量ImportantStatSet的值的声明的集合，在步骤506中作为函数SuperfluousStatements(S)的结果，返回变量SuperfluousSet的值。
4.声明列的最佳顺序
(4-1)通过谓语向量的顺序优化
如上所述，在Lyee方法论中用户输入的自己的必要条件的声明顺序对与这些相关的程序的执行结果没有任何影响。并且，该事实是该方法论的巨大贡献之一。尽管如此，我们建立的与这些相关的谓语向量的顺序可能对生成的代码的效率(执行时间)有相当的影响力。在具体例中进一步说明该问题。假设给出如表13的初期必要条件的情况。
(表13)
  词   定义   条件   IO
  a   b+c+d   OS
  b   d*c
  c   d+3
  d   5
另外，假设与这些各个声明相关连的生成的W04pallet的谓语向量如表14的(a)所示的顺序。(例如L4a是词a的谓语向量。)
(表14)
(a)未选择的谓语向量                                   (b)选择的谓语向量
以下，对表14的(a)的程序需要的执行时间进行简洁地说明。执行初始化向量(S4)后，在第一个重复中尝试程序执行L4a将值给予词a，取得值失败。因为，词a的计算需要还未计算的词b。因此，在该第一次重复中，处理词d，将值给予任何词的尝试都失败。在第二个重复中，程序将值分配给词c成功。在第三重复中，计算词b的值，最后在第四重复中算出词a的值。总之，该程序为算出所有的词的值，需要进行四次重复。
但是，由表14的(b)的程序替换表14的(a)的程序，彻底减少需要对所有的词赋值的重复的数。事实上，只在一次的重复中，程序能够计算对所有指定的词的值。由此可以得出结论：谓语向量的执行顺序对程序的执行时间有很大的影响。因此，对于由Lyee必要条件生成代码的工具(例如Lyee)，为减少执行时间，使谓语向量并列是有益的。并能够自动地并且在静态下生成谓语向量的最佳排列。即，对于Lyee必要条件的声明列进行最佳排列。
(4-2)最佳顺序的非正式定义
以下，非正式的定义最佳顺序的声明列。如果各词的定义在声明列S中在自身被使用前出现，声明列S，可以叫做最佳顺序。声明的条件是，定义任意的词的声明必须在声明列S中使用的该声明的所有的声明之前出现。
表15是未排顺序的声明列的具体例。
(表15)
未排顺序的声明
  字   定义   条件   IO   类型   安全
  b   2*a+j   OS   int   public
  j   2*i   int   public
i IS int public
  a   i+1   OS   int   public
一方面，表16是排列后的声明列。
(表16)
排列的声明
  字   定义   条件   IO   类型   安全
  i   IS   int   public
j 2*i int public
  a   i+1   OS   int   public
  b   2*a+j   OS   int   public
为了从形式上定义顺序排列的概念，引入以下函数的概念。
1)First
存在任意的声明的排列<s1...，sn>时，函数First返回作为该顺序的最初的要素s1。
2)AddFirst
存在任意的声明的排列<s1...，sn>与声明s0时，函数AddFirst返回<s0，s1...，sn>，即，这是在最初的顺序列的开头处添加s0。
3)Remove
存在任意的声明的排列S与声明s时，由函数Remove除去与s相同的声明(假定S不是多次含有相同的声明)。
4)Lower
存在任意2个声明s与s′时，如果Def(s)∈Use(s′)，则Lower(s，s′)为真。下述的函数Lower(s，s′)的算法提出该Lower的定义。
Lower(s，s′：statement)
  Begin
    If Def(s)∈Use(s′)
    Then return true
    Else return false
    EndIf
 End
上述函数Lower(s，s′)的算法的意思如下。“”
<开始>
<If语句开始>如果Def(s)[声明s的词]属于Use(s′)[声明s′的Use]，返回真(true)
否则返回假(flase)
<If语句结束>
<结束>
图14是表示该函数Lower(s，s′)的算法的流程图。如下说明图14的处理。首先，进行步骤601的判定″Def(s)[声明s的词]是否属于Use(s′)[声明s′的Use]″。判定结果为真时，作为函数的结果返回″真true″(步骤602)。判断结果为假时，作为函数的结果返回″假flase″(步骤603)。
5)Min
存在任意的声明的排列时，函数Min返回声明s，s是S中的声明，S中无其它的声明s′，使Lower(s，s′)为真。下述的函数Min(S)的算法提出该定义。
Min(S：not empty sequence of statements)

  Var s：a statement

  Begin

     s←First(S)

     For all s′∈S-{s}do

         If Lower(s′，s)

         Then s ←s′

         EndIf

       EndFor

       return s

    End
上述函数Min(S)的算法的意思如下。
S是不为空集合的声明列。变量s是一个声明。
<开始>
将函数First(S)[返回声明列的开头的声明]的结果保存在变量s中。
<For语句开始>对属于由声明列S中除去变量s的值(声明)的声明列的所有的声明s′执行以下程序。
<If语句开始>如果函数Lower(s，s′)为真[声明s′的词在变量s的声明的定义中被使用]，变量s中保存声明s′。
<If语句结束>
<For语句结束>
返回变量s的值
<结束>
图15是表示该函数Min(S)的算法的流程图。如下说明图15。首先，将First(S)[返回声明列的开头的声明]的结果保存在变量s中(步骤701)。其次，在步骤702中判定″在由声明列S中除去变量s的值(声明)的声明列中是否存在在步骤703中未执行的声明s′″。判定结果为真时，前进到步骤703，判定″函数Lower(s，s′)是否为真[声明s′的词在变量s中被使用]″，如果结果为真，在变量s中保存声明s′(步骤704)，返回到步骤702。如果步骤703的结果为假时，直接返回到步骤702。只要步骤702的结果为真，重复步骤702到步骤704的重新处理(706)。
如果步骤702的结果为假，前进到步骤705，作为函数Min(S)的结果返回变量s的值。
根据以上的定义，容易正式地定义声明列地最佳顺序。
(4-3)最佳顺序的正式定义
正式定义声明列的最佳顺序。S为声明列，属于由StatementOrdering(S)示出的S的声明列的顺序的排列，进行如下的正式定义。
StatememtOrderong ( S ) = < > ifS = < > AddFirst ( Min ( S ) , StatementOrdering ( Remove ( S , Min ( S ) ) ) )
上述形式的定义的意思是，函数StatementOrdering(S)的结果是″声明的排列S若为空，则函数的结果为空。否则，为AddFirst(Min(S)，StatementOrdering(Remove(S，Min(S))))″。关于AddFirst(Min(S)，StatementOrdering(Remove(S，Min(S))))的意思，通过后述的函数StatementOrdering(S)的流程图的说明进行详细叙述。
根据下述的函数StatementOrdering(S)的算法，可以进行声明列S的最佳排列。
StatementOrdering(S：sequence of statements)
   Var min：a statement
   Begin
      If S＝_
      Then return<>
      Else min←Min(S)
         return AddFirst(min，StatementOrdering(Remove(S，min)))
       EndIf
    End
上述函数StatementOrdering(S)的算法的意思如下。
S是声明列。变量min是一个声明。
<开始>
<If语句开始>声明列S若为空集合，则返回空。
否则，将Min(S)[在声明列S中，返回该定义中未使用其它的声明的声明]的结果的声明保存在变量min中，
返回函数AddFirst(min，StatementOrdering(Remove(S，min)))的值
<If语句结束>
<结束>
关于函数AddFirst(min，StatementOrdering(Remove(S，min)))，由以下的流程图进行详细说明。
图16是表示该函数StatementOrdering(S)的算法的流程图。图16的说明如下。首先，进行步骤801的″必要条件的声明列S是否为空集合″的判定，判定结果若为真，作为函数StatementOrdering(S)的结果，返回空并进行处理。
步骤801的判定结果若为假，前进到步骤802，变量min的区域内保存函数Min(S)[在声明列S中，返回该定义中未使用其它任意声明的声明]的结果，前进到步骤803。在步骤803中，执行函数Remove(S，min)[由声明列S中除去变量min的值的声明]，前进到步骤804。在步骤804中判定″函数Remove(S，min)的结果S′是否为固定值″，若判定结果为假，返回步骤803并再次执行。只要步骤804的结果为假，就重复由步骤803到步骤804的第一重新处理(811)。
步骤804的判定结果为真时，前进到步骤805。在步骤805中执行函数StatementOrdering(S′)，前进到步骤806。在步骤806中，判定″函数StatementOrdering(S′)的结果是否为固定值″，若判定结果为假，返回步骤801，并再次执行步骤801。只要步骤806的结果为假，就重复步骤801到步骤806的第2重新开始处理(812)。
步骤806的结果为真时，前进到步骤807，执行函数AddFirst(min，S”)，然后前进到步骤808。在步骤808中，判定″函数AddFirst(min，S”)的结果S_是否达到固定值″，若判定结果为假，返回步骤807并再次执行。只要步骤808的判定结果为假，就重复由步骤807到步骤808的第3重新开始处理(813)。
步骤808的判定结果为真时，前进到步骤809，作为函数StatementOrdering(S)的结果，返回声明列S_的值，结束函数处理。
5.分断(Slicing)
程序的分断技术可追溯到非专利文献12。分断是由将程序缩小为与特定的计算相关连的声明的程序的抽取来考虑。在传统的程序语言中，分断将程序读解与调试作为″分断、支配″的途径(更小的程序块，即分断块比大的程序容易理解)长时间使用。另外，很多应用程序的分析始终被使用，其目的各种各样。例如，包括结合度的判定、算法的调试、反向管理、部分再使用、自动并行化、程序合并以及补助验证。
在Lyee必要条件中，分断可以起到由不同的观点分析必要条件的作用。特别是根据分断，可以从以下的观点进行分析。
1.对任意的词的定义，直接或间接由贡献的声明是哪个？
2.能够生成可以并行执行的子程序块的必要条件中，独立的部分是哪个？
使用自动工具，由上述的第1观点进行分析，为理解、维护Lyee软件(必要条件)非常有用。实际上，由必要条件给出的声明的数重大时(数百条)，为通观整体来理解、维护软件，寻找依存于谁的何种定义，只要不慎重、操作麻烦，就容易引起错误。
(5-1)单一分断
(5-1-1)单一分断的非正式定义
存在任意的词a与声明的集合S时，Slice(a，S)是直接或间接对词a的定义由贡献的S中的所有的声明。为明确分断的概念，举具体例。
表17是作为声明的集合的Lyee的必要条件。
(表17)
Lyee必要条件
  字   定义   条件   IO   类型   安全
  a   b+c   OS   int   public
  g   IS   int   public
  c   IS   int   public
  d   e*g   g≠0   float   public
  e   IS   int   public
  b   4*c   int   public
S如果是在表17中给出的声明的集合，词a的分断Slice(a，S)在表18中示出。
(表18)
词a的分断Slice(a，S)
  词   定义   条件   IO   类型   安全
  c   IS   int   public
  b   4*c   int   public
  a   b+c   OS   int   public
分断其自身是必要条件的完全的集合，这是重要点。该分断的概念可以考虑为所说的″分断克服″的技术，对理解或维护Lyee必要条件，特别是其包含大量声明的情况非常有用。
(5-1-2)单一分断的正式定义
存在任意的词a与声明的集合S时，与S中的词a相关的分断由Slice(a，S)示出，进行如下定义。
Slice ( a , S ) = Satement ( a , S ) &cup; ( &cup; b &Element; UseDirectAnd ln direct ( | Satement ( a , S ) , S ) { Satement ( b , S ) } )
上述的正式定义的意思是，函数Slice(a，S)的结果是″属于声明的集合S的词a的声明与属于该词a的声明的直接或间接Use的所有的词b的声明的集合的合集″。
根据下述的函数Slice(a，S)的算法，能够生成与Lyee必要条件(声明的集合)中的任意的词相关的分断。
Sllce(a：word，S：set of statements)

   Var slice_s：set of statements

     s：statement

    Begin

        s←Satement(a，S)

        slice_s←{s}

        For all b∈UseDirectAnd Indirect(s，S)do

            slice_s←slice_s∪{Satement(b，S)}

          EndFor

          return slice_s

       End
上述的函数Slice(a，S)的算法的意思如下。
a为词，S为作为必要条件的声明的集合。变量slice_s是声明的集合，变量s为一个声明。
<开始>
变量s中保存函数Statement(a，S)[返回属于必要条件S的词a声明]的结果。
变量slice_s中保存变量s的值。
<For语句开始>对属于函数UseDirectAndIndirect(s，S)[返回属于必要条件S的声明s的直接或间接Use]的结果的所有的词b执行以下程序。
变量slice_s中保存变量slice_s的值与函数Statement(b，S)[返回属于声明S的词的声明]的结果。
<For语句结束>
返回变量slice_s的值
<结束>
图17是表示该函数Slice(a，S)的算法的流程图。以下说明图17。首先，在步骤901中，变量s保存函数Statement(a，S)[返回属于必要条件S的词a的声明]的结果，保存函数Statement(a，S)[返回属于必要条件S的词a的声明]的结果。然后，前进到步骤902，进行″函数UseDirectAndIndurect(s，S)[返回属于必要条件的声明s的直接或间接Use]的结果中是否存在未执行的词b″的判断。若判定结果为真，前进到步骤903，变量slice_s保存变量slice_s的值与函数Statement(b，S)[返回属于必要条件的词b的声明]的结果的声明，返回步骤902并再次执行。只要步骤902的结果为真，就重复由步骤902到步骤903的重新处理(905)。
步骤902的判定结果为假时，前进到步骤904，作为函数Slice(a，S)的结果，返回变量slice_s的值。
最重要的分断是与一般输出词相关的分断。根据下述的函数ALLoutputSlice(S)的算法，能够生成与任意的Lyee必要条件中的各输出词相关的分断。
AllOutputSlices(S：set of statements)
   Var sliceSet：set of slices
   Begin
      sliceSet←_
      For all s ∈OutputStatements(S)do
          sliceSet←sliceSet∪(Slice(Word(s)，S))}
      EndFor
      return sliceSet
   End
上述的函数ALLoutputSlice(S)的算法的意思如下。
S是作为必要条件的声明的集合。变量sliceSet是分断的集合。
<开始>
变量sliceSet的区域中保存″0″。
<For语句开始>对属于函数OutputStatement(S)[返回必要条件S的所有的输出词的声明]的所有的声明s执行以下程序。
变量sliceSet中保存变量sliceSet的值与函数Slice(Word(s)，S)[返回属于必要条件的声明s的词的分断]的结果。
<For语句结束>
返回变量sliceSet的值。
<结束>
图18是表示该函数ALLOutputSlice(S)的算法的流程图。以下说明图18。首先，变量sliceSte的区域保存值″0″(步骤1001)。然后，在步骤1002中，判断″函数OutputStatements(S)[返回必要条件中的所有的输出词的声明]″中是否存在未执行的声明s。若判定结果为真，前进到步骤1003，变量sliceSet的区域保存变量sliceSet的值与函数SliceSet(Word(s)，S)[返回属于必要条件S的声明s的词的分断]的结果。步骤1003结束后，返回到步骤1002并再次执行。步骤1002的结果为假时，前进到步骤1004，返回变量sliceSet的值。(5-2)独立分断(Independent Slice)
分断的技术也能容易地用在为了知道必要条件中独立部分上。作为另一个″分断克服″技术，寻找任意的必要条件中的独立部分，对程序的理解与自动并行化(parallelization)是有用方法。
(5-2-1)独立分断的非正式定义
2个分断结合S1与S2如果不存在与S1和S2二者有关系的声明，则作为独立声明。示出独立分断的具体例。S为表17中示出的声明的集合时，Slice(d，S)如表19所示。
(表19)
词d的分断Slice(d，S)
  字   定义   条件   IO   类型   安全
  e   IS   int   public
  g   IS   int   public
  d   e*g   g≠0   int   public
此时，与表18的Slice(a，S)以及表19的Slice(d，S)二者由关系的声明不存在。因此，能够得到2个分断Slice(a，S)与Slice(d，S)独立，并且能够并列执行的结论。
(5-2-2)独立分断的正式定义
如果以下的条件成立，2个分断集合S1和S2相独立。
S1∩S2＝Φ
上述表示不存在是S1的要素、并且是S2的要素的分断(声明的集合)。
考虑只有1个分断集合，把握哪个分断是否独立于其它的分断的部分集合的情况。例如，我们生成与各自的输出词相关的分断，检测这些分断的独立部分的情况。首先，介绍几个对理解分断的独立部分集合的概念有帮助的定义。
2个独立的分断集合：
将S1和S2作为2个分断集合。如果分断S1∈S1(属于分断集合S1的分断S1)与分断S2∈S2(属于分断集合S2的分断S2)相独立，则分断集合S1和S2相独立。
最佳分断集合：
将S作为分断集合。S1≠0且S2≠0，S1_S(分断S1属于分断集合S)的所有的S1并且S2_S(分断S2属于分断集合S)中，如果S1与S2不相互独立，则S为最佳分断集合。
最佳并且独立的分断集合：
将S1...Sn作为n个固定的分断集合。如果，i为1≤i≤n的所有的Si为最佳分断集合，j为1≤j≤n并且i≠j的Sj时，如果所有的Si与Si为独立分断，S1...Sn为最佳并且独立分断集合。
通过下述的函数IndependenSetOfSlice(S)的算法，能够抽取输出词的分断，并将其分离为最佳并且独立分断集合。
IndependentSetOfSlices(S：set of statements)

   Var sliceMultiSet：set of set of slices

       sliceSet：set of slices

       OutputWords：set of words

       NotTreatedWords：set of words

   Begin

       sliceMultiSet←_

       OutputWords←Word(OutputStatements(S))

       For all a∈OutputWords do

          sliceSet←Slice(a，S)

          OutputWords←OutputWords-{a}

          NotTreatedWords←OutputWords

          For all b∈NotTreatedWords do

              If(UseDirectAndIndirect(Slice(b，S))∪{b})∩

                 (UseDirectAndIndirect(Slice(a，S))∪{a})≠_

                sliceSet←sliceSet∪Slice(b，S)

                NotTreatedWords←NotTreatedWords-{b}

            EndIF

         EndFor

         sliceMultiSet←sliceSet

       EndFor

       return sliceMultiSet

    End
上述的函数IndependenSetOfSlice(S)的算法的意思如下。
S是作为必要条件的声明的集合。变量sliceMultiSet是分断集合。变量sliceSet是分断的集合。变量OutputWord、变量NotTreadWords是词的集合。
<开始>
变量sliceSet的区域保存值″0″。
变量OutputWord的区域保存函数Word(OutputStatements(S))[返回必要条件S的所有的输出词的声明的词]的结果。
<For语句开始>对属于变量OutputWords的值的所有的词a执行以下程序。
变量sliceSet保存函数Slice(a，S)[返回属于必要条件S的词a的分断]的值。
变量OutputWords的区域保存由变量OutputWords的值除去词a的词的集合。
变量NotTeateWords的区域保存变量OutputWords的值。
<For语句开始>变量NotTeateWords的区域保存变量NotTeateWords的值。
<If语句开始>如果，函数UseDirectAndIndirect(Slice(b，S))[词b的分断[在词b的定义中使用的词的声明的集合]的直接和间接Use]与b的合集和函数UseDirectAndIndirect(Slice(a，S))[词b的分断[词a的定义中使用的词的声明的集合]的直接或间接Use]与词a的合集，两个集合的交集不为空，即，如果有同时属于2个集合的词，
变量sliceSet的区域保存变量sliceSet的值与函数Slice(b，S)，
变量NotTeateWords的区域保存由变量NotTeateWords的值除去词b的词的集合。
<If语句结束>
<For语句结束>
变量sliceMultiSet的区域保存变量sliceSet的值。
<For语句结束>
返回变量sliceMultiSet的值
<结束>
图19是表示该函数IndependenSetOfSlice(S)的算法的流程图。以下说明图19。首先，变量sliceSet的区域保存值″0″，变量OutputWords的区域保存函数Word(OutputStatements(S))[返回必要条件的所有输出词的声明的词]的结果(步骤1101)。然后，在步骤1102中判定″在变量OutputWords的值中是否存在未执行的词a″，如果判定结果为真，前进到步骤1103。在步骤1103中，变量sliceSet保存函数Slice(a，S)[返回属于必要条件S的词a的分断]的结果，变量OutputWords的区域保存由变量OutputWords的值除去词a的词的集合，变量NotTreatedWords的区域保存变量OutputWords的值。
然后，在步骤1104中，判定″变量NotTreatedWords的值中是否存在未执行的词b″，如果结果为真，前进到步骤1105。
步骤1105判定″函数UseDirectAndIndirect(Slice(b，S))[词b的分断[词b的定义中使用的词的声明的集合]的直接或间接Use]与b的并集和函数UseDirectAndIndirect(Slice(a，S))[词b的分断[词a的定义中使用的词的声明的集合]的直接或间接Use]与词a的并集，2个集合是否存在交集(即，是否存在同时属于2个集合的词)″。如果判定结果为真，前进到步骤1106，变量sliceSet的区域保存变量sliceSet的值与函数Slice(b，S)，变量NotTreatedWords的区域保存由变量NotTreatedWords的值除去词b的词的集合。步骤1106结束后，返回到步骤1104并再次执行。只要步骤1104的判定未真，就重复步骤1104到步骤1106的第一重新处理(1109)。
步骤1104的判定结果为假时，前进到步骤1107，变量sliceMultiSet的区域保存变量sliceSet的值。步骤1107结束后，返回步骤1102并再次执行只要步骤1102的判定结果为真，则重复由步骤1102到步骤1107的第2重新开始处理。
步骤1102的判定结果为假时，前进到步骤1108，作为函数IndependentSetOfSlice(S)的结果，返回变量sliceMultiSet的值。(5-2-3)最佳独立分断集合的例
表示了最佳并且独立的分断集合的具体例子。表20是以S表示的声明的集合。
表(20)
必要条件
  字   定义   条件   IO   类型   安全
  a   b   c＝3   IS   int   public
  b   c   c＝2   OS   float   secret
  c   l   3＝3   OS   int   public
  e   f   g＝3   IS   int   public
  f   g   2＝2   OS   float   secret
  g   l   3＝3   OS   int   public
  h   f   f＝g   OS   int   public
(1)输出词的分断
由S表示的、对应S的输出词的分断的集合如下。
S＝{Slice(b，S)，Slice(c，S)，Slice(f，S)，Slice(g，S)，Slice(h，S)}
并且，这些分断如以下的表所示。
(表21)词b的分断slice(b，S)
  字   定义   条件   IO   类型   安全
  c   l   3＝3   OS   int   public
  b   c   c＝2   OS   float   secret
(表22)词c的分断slice(c，S)
  字   定义   条件   IO   类型   安全
  c   l   3＝3   OS   int   public
(表23)词f的分断slice(f，S)
  字   定义   条件   IO   类型   安全
  g   l   3＝3   OS   int   public
  i   g   2＝2   OS   Hoat   secret
(表24)词g的分断slice(g，S)
  字   定义   条件   IO   类型   安全
  g   l   3＝3   OS   int   public
(表25)词h的分断slice(h，S)
  字   定义   条件   IO   类型   安全
  g   l   3＝3   OS   int   public
  f   g   2＝2   OS   float   secret
  h   f   f＝g   OS   int   public
(2)最佳并且独立分断集合
可以由S中抽取的最佳并且独立集合如以下所述。
·S1＝{Slice(b，S)，Slice(c，S)}
以及
·S2＝{Slice(f，S)，Slice(g，S)， Slice(h，S)}
6.键入(Typing)
键入(参考非专利文献12以及11)主要使用于在静态下保证程序的几个动态的好的动作特性。如果进行键入，能够在编译时检测程序执行时频繁发生的错误。另外，键入技术经常使用于开发的软件确实进行对几个安全问题的处理(参考非专利文献11)。
在这部分中，示出为进行用于与检测Lyee必要条件的词的类型相关的错误的分析、Lyee必要条件的简化(即使步指定输出词的类型，也能够由输入的类型自动地生成中间词和输出词的类型)，能够怎样的使用键入技术。并且，示出为处理与软件开发相关的安全问题(例如，不使几个机密信息由于软件的原因而泄漏)，如何简单扩大Lyee方法论。
键入的目的在于检测由于类型的不正确处理引起的错误。通过键入，在可能的情况下能进行类型的修正或不足类型的生成。例如，用户可以只指定输入词的类型的指定时，相应地所有词的类型能够自动生成。为进行类型错误的检测、更正错误的类型或生成不足的类型，需要在最初明确定义被包含的运算对象(operand)的类型。任意Lyee必要条件的键入在本部分以前说明的各种优化或分析后进行非常有益，这是重要点。换言之，在键入开始前，必须确认任意的Lyee必要条件中不包含循环声明、无用声明、非循环性声明。
(6-1)键入规则
键入的技术一般包含以下要素的使用。
(6-1-1)基本键入
在该项中，定义属于任意的Lyee必要条件包含的词、常数、运算符的类型的不同的种类。
<值类型>
为简单化，词与定义的类型为逻辑型(boolean)、整数型或浮点型(floating point number)。为方便，将这些类型进行如下再编。
Tval::＝Tnum|Tbool
Tnum::＝int|float
Tbool::＝bool
上述定义可以理解为：Tval(值的类型)是Tnum(数值的类型)或Tbool(逻辑值的类型)。Tnum是整数型或浮点型。最后，Tbool对应逻辑型。
<运算符的类型>
同样，必须明确任意的Lyee必要条件中包含的逻辑以及算术运算符的类型。关于个运算符，该操作数(运算对象)的类型和该结果的类型必须正确。任意的运算符的类型一般取T1→T2的形式。为直观理解，其意思是，运算符被考虑为：是作为输入取类型T1的要素、并且返回类型T2的要素的函数。
当然，几个运算符具有1个以上的操作数。因此，如果考虑1个类型其自身也具有2个类型的组的情况，考虑该事实简单。总之，某类型是Tval(值的类型)、2个类型的组T1×T2或T1→T2。如果更正式的表示，可以写为以下形式。
T::＝Tval|T1×T2|T1→T2
上述正式的表述的意思是，″任意的类型T是Tval(值的类型)、2个类型的组T1×T2或T1→T2″。
(6-1-2)常数键入(Constant Typing)
Lyee必要条件的键入中，符合声明中包含的常数的类型如下。
Figure A0382643500551
上述表述的意思是，true或flase(真假值)的类型为bool(逻辑型)，num(数值)的类型为int(整数型)，num.num(浮点数值)的类型为float(浮点型)。
更加准确地，如后述，为使1个类型与任意地常数相关连，使用下述的函数。
TypeOfOst(cst：constant)
  Begin
    Switch(cst)
case true , false : return bool case num : return int case num . num : return float
    EndSwifch
  End
上述函数TypeOfCst(cst)的意思如下。
函数的自变量cst是常数。
<开始>
函数Switch(cst)的执行
自变量常数cst为true或flase(真假值)时，返回值bool(逻辑型)。
自变量常数cst为num(数值)时，返回值int(整数型)。
自变量常数cst为num.num(浮点数值)时，返回值float(浮点型)。
函数Switch结束
<结束>
常数键入可以根据以下的规则正式化。
上述正式的表述的常数的键入规则表示″属于任意的Lyee必要条件ε的常数c的类型是不需前提条件只由函数TypeOfCst(c)返回的值″。(这以前的说明中，作为表示Lyee必要条件符号使用S，但是，在键入技术中习惯使用ε，所以使用ε。)
(6-1-3)词的键入(Word Typing)
无论对于何种输入词，用户都必须绝对正确键入该类型。对于输入词以外的词，其类型被自动地算出，并且保存在定义这些词的声明的″类型″区域中。存在所有知道的词的情况下，如下述定义返回该类型的函数TypeOfWrd：
TypeOfWrd(w：word，ε：List of statements)
  begin
     return Type(Statement(w，ε))
  End
上述函数TypeOfWrd(w，ε)的意思如下。
函数的变量w是属于声明表ε的词。
<开始>
算出词w的声明(Statement(w，ε))，返回算出的声明(Statement(w，ε)的结果设为s)的类型(Type(s))。
<结束>
词的键入能根据以下的规则形式化。
上述形式化记述所示的词的键入规则表示″将任意的Lyee必要条件ε作为待词的环境的词w的类型，是不需前提条件只由函数TypeOfWrd(w，ε)返回的值″。
(6-1-4)运算符的键入(Operator Typing)
关于程序中使用的各运算符的类型，需要更加严密。实际上，因为有以下的情况：某个运算符需要逻辑型的变量返回逻辑型的结果，但是，别的运算符需要其它类型的变量返回别的类型的结果。参与Lyee必要条件的各运算符的更加严密的类型，可以如下述的正式化。
Figure A0382643500572
Figure A0382643500573
Figure A0382643500576
Figure A0382643500577
上述形式化的定义意思如下。运算符1)和2)作为输入取1个值，返回1个值，运算符3)到6)因为作为结果返回1个值，所以作为输入需要2个值。
1)-u
一元运算符-u的类型是给出Tnum(数值的类型)和返回Tnum(数值的类型)的函数。
2)not
逻辑型运算符的1个not(逻辑否定的运算符)的类型是给出逻辑型(bool)和返回逻辑型(bool)的函数。例如，如果将true(逻辑型)给予运算符not，″not true″的结果为flase(逻辑型)，如果给予flase(逻辑型)，″not flase″的结果为true(逻辑型)。
3)+、-b、*
运算符+(加法)、-b(减法)、*(乘法)的类型是给出Tnum(数值的类型)与Tnum(数值的类型)的组和返回1个Tnum(数值的类型)的函数。
4)＜、＜＝、＞＝、＞
运算符＜(左边小于右边)、＜＝(左边小于右边或等于右边)、＞＝(左边比右边大或等于右边)、＞(左边大于右边)的类型是给出Tnum(数值的类型)与Tnum(数值的类型)的组和返回1个Tnum(数值的类型)的函数。
5)or、and
作为逻辑型的运算符的or(逻辑和的运算符)和and(逻辑积的运算符)的类型是给出bool(逻辑型)与bool(逻辑型)的组和返回1个bool(逻辑型)的函数。例如，将true(逻辑型)与true(逻辑型)给予逻辑和的逻辑运算符or，″true or true″的结果为true(逻辑型)。
6)＝、＜＞
运算符＝(左边等于右边)、＜＞(左边不同于右边)是给出Tval(值的类型)与Tval(值的类型)的组和返回1个bool(逻辑型)的函数。
更具体的，返回任意的运算符的类型的函数TypeOfOp可以进行如下的定义。
TypeOfO(op：operator)
  Begin
    Switch(op)
case - a : return T num &RightArrow; T num case not : returnbool &RightArrow; bool case + , - b : return T num &times; T num &RightArrow; T num case < , < = , > = , > : return T num &times; T num &RightArrow; bool case or , and : returnbool &times; bool &RightArrow; bool case = , < > : return T val &times; T val &RightArrow; bool
    EndSwitch
  End
上述的函数TypeOfOp(Op)的意思如下。
自变量op为运算符。
<开始>
函数Switch(op)的执行
自变量的运算符op为-u(一元运算符)时，返回Tnum→Tnum(取数值的类型，返回数值的类型的函数型)。
自变量的运算符op为not(逻辑运算符)时，返回bool→bool(取逻辑型，返回逻辑型函数型)。
自变量的运算符op为+和-b时，返回Tnum×Tnum→Tnum(取2个数值
的类型的组，返回数值的类型的函数型)。
自变量的运算符op为＜、＜＝、＞＝、＞时，返回Tnum×Tnum→bool(取2个数值的类型的组，返回逻辑型的函数型)。
自变量的运算符op返回bool×bool→bool(取2个逻辑型的组，返回逻辑型的函数型)。
自变量的运算符op返回Tval×Tval→Tval(取2个值的类型的组，返回值的类型的函数型)。
函数Switch结束
<结束>
运算符键入可以通过以下规则形式化。
上述形式化的技术表示的规则意味着，将任意的Lyee必要条件ε作为键入的环境的的运算符op的类型是不需前提条件只由函数TypeOfOp(op)返回的值。
(6-1-5)表达式的键入(Expression Typing)
示出判定各种表达式的类型的方法。为简化表达式的键入的说明，需要引入如下所示的以_表示的类型间的半顺序关系。
Figure A0382643500602
Figure A0382643500603
Figure A0382643500604
Figure A0382643500608
在此，注意t rue(真)_flase(假)与flase(假)_true(真)二者成立时，意思是true＝flase。
使用上述的顺序关系，可以将2个类型的上位的类型进行以下定义。
Figure A0382643500609
上述记述意思是″T1和T2中上位的类型(Sup(T1，T2))，T1_T2时为T2，T2_T1时为T1″。
表达式Exp是如以下定义所示的″val(值)″、″id(识别符)″、″(Exp)(括号表达式)″、″op Exp(运算符表达式)″、″Expop Exp(表达式运算符表达式)″的任意一个，所以
Exp：＝val|id||(Exp)|op Exp|Exp op Exp
根据以下函数，每个表达式的种类能够关连1个类型。
TypeOfExp(e：expression，ε：List of staternents)
  Begin
     Switch(e)
       case c    ：return TypeOfCst(c)
       case w    ：return TypeOfWrd(w)
       case(e1)  ：return TypeOfExp(e1，ε)
       case op e1：(T1，T2)←TypeOfOp(op)
                   T′←TypeOfExp(e1，ε)
Figure A0382643500611
                   then return T′
                   else print ErrMsg，return TypErr
                   EndIfcase e1 op e2：(T1，T2，T3)←TypeOfOp(op)
            T′1←TypeOfExp(e1，ε)
            T′2←TypeOfExp(e2，ε)
            then if(T3≠bool)
                    then return Sup(T′1，T′2)
                     else return bool
                    EndIf
               else print ErrMsg，return TypErr
               EndIf
     EndSwitch
 End
上述的函数TypeOfExp(e，ε)的意思如下。函数的自变量e是属于声明表ε的表达式。
<开始>
函数Switch(e)的执行
自变量e为c(常数)时，返回TypeOfCst(c)的值
自变量e为w(词)时，返回TypeOfWrd(w)的值
自变量e为″e1″型(表达式)的表达式时，返回TypeOfExp(e1，ε)的值
自变量e为″op e1″型(一元运算符表达式)的表达式时，
TypeOfOp(op)的值保存在(T1，T2)中，TypeOfExp(e1，ε)的值保存在T’中。
<If处理开始>如果为T’_T1(T1大于T’)的关系，返回T1。
否则，打印错误信息(ErrMsg)，返回TypErr。
自变量e为″e1 op e2″型(表达式二元运算符表达式)时，
TypeOfOp(op)的值保存在(T1，T2，T3)中，TypeOfExp(e1，ε)的值保存在T’1中，TypeOfExp(e2，ε)的值保存在T’2中。
<If处理开始>如果为T’1_T1(T1比T’1大)并且T’2_T2(T2
比T’2大)的关系，
        <If处理开始>并且，如果T3不是逻辑型，返回
        Sup(T’1，T’2)。
        否则，返回bool。
        <If处理结束>
    否则，打印错误信息(ErrMsg)，返回″TypErr″
    <If处理结束>
函数Switch结束
<结束>
图20是表示该函数TypeOfExp(e，ε)的流程图。如下说明图20。首先，判定″表达式e是否为常数″(步骤1201)，若结果为真，返回函数TypeOfCst(c)[返回常数c的类型]的结果(步骤1202)，结束处理。
如果步骤1201的结果为假，前进到步骤1203，判定″表达式e是否为词″，若判定结果为真，返回函数TypeOfWord(w)[返回词w的类型]的结果(步骤1204)，结束处理。
如果步骤1203的结果为假，前进到步骤1205，判定″表达式e是否为″e1″型(表达式)的表达式″，结果若为真，返回函数TypeOfExp(e1，ε)[返回属于声明表ε的的表达式e1的类型]的结果(步骤1206)，结束处理。
如果步骤1205的结果为假，前进到步骤1207，判定″表达式是否为″op e1″型(一元运算符表达式)的表达式″，若判定结果为真，函数TypeOfOp(op)[返回运算符op的类型]的值保存在(T1，T2)中，函数TypeOfExp(e1，ε)[返回属于声明表ε的的表达式e1的类型]的值保存在T’中(步骤1208)。步骤1208结束后，在步骤1209中判定″T’_T1[T1的类型比T’的类型大]是否为真″，若为真，在步骤1210中返回T’的值，结束处理。步骤1209的判定结果若为假，在步骤1211中输出错误信息(ErrMsg)并返回″TypErr″，结束处理。
步骤1207的判定结果若为假，前进到步骤1212。在步骤1212中判定″表达式e是否为″e1 op e2″型(表达式二元运算符表达式)的表达式″，若判定结果为真，在步骤1213中，函数TypeOfOp(op)[返回运算符op的类型函数]的值保存在(T1，T2，T3)中，函数TypeOfExp(e1，ε)[返回属于声明表ε的的表达式e1的类型]的值保存在T’1中，函数TypeOfExp(e2，ε)[返回属于声明表ε的的表达式e2的类型]的值保存在T’2中。步骤1213结束后，在步骤1214中，判定″是否为T’1_T1(T1的类型比T’1类型大)并且T’2_T2(T2的类型比T’2类型大)″。判定结果若为真，前进到步骤1215，判定″T’3的类型是否不为逻辑型″，判定结果若为真，在步骤1216中返Sup(T’1，T’2)[返回T’1和T’2的2个类型的最上位的类型](步骤1216)，结束处理。步骤1215的结果为假时，在步骤1217中返回逻辑型，结束处理。步骤1214的结果为假时，在步骤1218中输出错误信息(ErrMsg)并返回″TypErr″，结束处理。
步骤1212的结果若为假，结束处理。
该函数有怎样的功能，举具体例进行说明。
表达式为″a+b″，″a″和″b″为类型为整数型(int)的输入词，该表达式具有″e1 op e2(表达式1运算符表达式2)″型，该表达式的情况为″e1＝a″、″op＝+″、″e2＝b″。
因此，由于TypeOfOp(+)＝Tnum×Tnum→Tnum(运算符+的类型是取2个数值类型的组、返回数值类型的函数型)，所以(T1，T2，T3)＝(Tnum，Tnum，Tnum)，由于TypeOfExp(a)＝TypeOfExp(b)＝int(表达式a、表达式b都是类型为整数型的词，所以TypeOfExp(a)＝TypeOfWrd(a)＝int、TypeOfExp(b)＝TypeOfWrd(b)＝int)，所以T’1＝int、T’2＝int，根据上述的类型的半顺序定义，能够推导出int_Tnum(数值的类型与整数型相比为上位)，所以T’1_T1(T’1＝int、T1＝Tnum)且T’2_T2(T’2＝int、T2＝Tnum)的条件成立，由于T3＝Tnum，所以T3≠bool也成立。
因此，作为函数TypeOfExp(a+b)的最终结果返回的Sup(T’1，T’2)为Sup(int，int)，所以能够导出如下的最终结果。
TypeOfExp(a+b)＝int(表达式a+b的类型为整数型int)
再举1例，如果″a″的类型为浮点型(浮点数)时，此时表达式″a+b″的类型为浮点型。
因此，在TypeOfExp(a+b)中，a＝float、b＝float时，有(T1，T2，T3)＝(Tnum，Tnum，Tnum)，因为TypeOfExp(a)＝float、TypeOfExp(b)＝int(表达式a是类型为浮点型float的词，表达式b是类型为整数型int的词，所以，有TypeOfExp(a)＝TypeOfWrd(a)＝float、TypeOfExp(b)＝TypeOfWrd(b)＝int)，所以T’1＝float、T’2＝int，根据上述的类型的办顺序定义，因为int_float并且float_Tnum(数值的类型与整数型相比为上位)，所以T’1_T1(T’1＝float、T1＝Tnum)并且T’2_T2(T’2＝int、T2＝Tnum)的条件成立，因为T2＝Tnum，T3≠bool也成立。
因此，作为函数TypeOfExp(a+b)的最终结果返回的Sup(T’1，T’2)为Sup(float，int)＝float(浮点型和整数型中上位的类型是浮点型)。
更形式化的表示表达式的类型能够通过以下键入规则获得。
Figure A0382643500641
上述形式化的记述所示的规则如下。
(Cst)表达式为常数时的规则：
将任意的Lyee必要条件ε作为键入环境的常数c的类型是不需前提条件函数TypeOfCst(c)返回的值。
(Wrd)表达式为词时的规则：
将任意的Lyee必要条件ε作为键入环境的词w的类型是不需前提条件函数TypeOfWrd(w，ε)返回的值。
(Op)表达式为运算符时的规则：
将任意的Lyee必要条件ε作为键入环境的运算符Op的类型是不需前提条件函数TypeOfOp(Op)返回的值。
(ExpP)表达式为括号表达式时的规则：
在前提条件″将任意的Lyee必要条件ε作为键入环境的表达式Exp的类型为T″成立时，将任意的Lyee必要条件ε作为键入的环境的表达式(Exp)的类型为T。
(ExpU)表达式为″op Exp″时的规则：
将前提条件″将任意的Lyee必要条件ε作为键入环境、运算符op的类型为T1→T2、表达式Exp的类型为T’1、T’1_T1时的类型为T″成立时，将任意的Lyee必要条件ε作为键入的环境的表达式op Exp的类型是T’1。
(ExpBA)表达式为″Exp op Exp″，运算结果不为逻辑型时的规则：
前提条件″将任意的Lyee必要条件ε作为键入环境、运算符op的类型为T1×T2→T3、表达式Exp1的类型为T’1、表达式Exp2的类型为T’2、T’1_T1、T’2_T2并且T3≠bool″成立时，将任意的Lyee必要条件ε作为键入环境的表达式Exp1 op Exp2的类型是Sup(T’1、T’2)。
(ExpBB)表达式为″Exp op Exp″，运算结果为逻辑型时的规则：
前提条件″将任意的Lyee必要条件ε作为键入环境、运算符op的类型为T1×T2→bool、表达式Exp1的类型为T’1、表达式Exp2的类型为T’2、T’1_T1并且T’2_T2″成立时，将任意的Lyee必要条件ε作为键入的环境的表达式Exp1 op Exp2的类型是bool。
(6-1-6)声明的键入
如果知道表达式的类型判定方法，进行Lyee必要条件的任意的声明的键入非常容易。以下的函数判定Lyee必要条件中的任意的声明s的类型。
TypeOfStat(Id，Exp，Cand，io，T，Tsec)：statement，ε：List of statements)

   Begin

     If(io＝IF)or(io＝IS)and(r＝””)
     Then print ErrMsg

         return 0

     Else If(TypeOfExp(Exp)！＝TypErr)and(TypeOfExp(Cond)＝bool)

         return(Id，Cond，io，TypeOfExp(Exp)，Tsec)

         EndIf

     EndIf

  End
上述函数TypOfStat((Id，Exp，Cond，io，T，Tsec)，ε)的意思如下。函数的自变量(Id，Exp，Cond，io，T，Tsec)是构成将任意的Lyee必要条件的声明表ε作为键入环境的任意的声明的项目的值(id＝词的识别符、Exp＝定义式、Cond＝定义式执行条件式、io＝输入输出属性、T＝词的值的类型、Tsec＝表示词的值的安全水平的类型)。
<开始>
<If处理开始>
如果oi＝If或io＝IS并且T为空[即，如果声明为输入字，所以没
有类型信息]，打印错误信息，返回″0″[即，不能进行类型判定]。
否则[即，声明如果是输出词]
<If处理开始>如果函数TypeOfExp(Exp)[返回定义式Exp的类型]的结果为TypErr[定义式的类型为TypErr，即类型不能判定]，并且，函数TypeOfExp(Cond)[返回条件式Cond的类型]的值若为逻辑型，
作为结果，返回(Id，Exp，Cond，io，TypeOfExp(Exp)，Tsec)。
<If处理结束>
<If处理结束>
<结束>
图21是表示该函数TypeOfStat((Id，Exp，Cond，io，T，Tsec)，ε)的流程图。以下说明图21。首先，判定″声明的io项目是IF[对文件的输入]或IS[对画面输入]，并且项目T是否为空[无类型信息]″(步骤1301)。如果判定的结果为真前进到步骤1302，打印错误信息(ErrMsg)并返回″0″，结束处理。
判定结果如果为假，前进到步骤1303，判定″是否函数TypeOfExp(Exp)[返回定义式的类型]的结果为TypErr[即，类型不能判定]，并且，函数TypeOfExp(Cond)[返回条件式Cond的类型]的值为逻辑型″。判定结果为真，在步骤1304中，返回(Id，Exp，Cond，io，TypeOfExp(Exp)，Tsec)的值，结束处理。判定结果若为假，结束处理。
如果形式化表述，该函数的键入规则如下。
Figure A0382643500671
上述形式化记述表示的规则是：″前提条件‘将任意的Lyee必要条件的声明表ε作为键入环境、定义式Exp的类型为T1、同样，定义式执行条件式的类型为逻辑型、输入输出属性不是IS以及IF’成立时，将声明的序列ε作为键入环境的声明(Id，Exp，Cond，io，T，Tsec)的类型是(Id，Exp，Cond，io，T1，Tsec)。″
(6-1-7)Lyee必要条件的键入
存在任意的排列的声明的序列ε时，该表的类型判定如下。
TypeiOfLyee(<s1，...，sn>：list of statements)
  Varε0：list of statements
 Begin
    ε0←<s1，...，sn>
   For i＝1 to n
s i &prime; &LeftArrow; TypeOfStat ( s i , &epsiv; i - 1 ) &epsiv; i &LeftArrow; &epsiv; i - 1 replacethe i th elememt of &epsiv; i by s i &prime;
   EndFor
   return εn
End
上述的函数TypeOfLyee(<s1，...，sn>)的意思如下。
自变量<s1，...，sn>为Lyee必要条件的声明的序列，变量ε0为声明的序列。
<开始>
变量ε0的区域保存声明的序列<s1，...，sn>
<For处理开始>将1到n代入i，执行以下程序
s’i中保存TypeOfStat(si，εi-1)的结果
εi中保存εi-1的结果
εi的i号要素置换为s’i
<For处理结束>
返回εn的值
<结束>
例如，n＝3的函数TypeOfLyee(<s1，s2，s3>)如下。
变量ε0的区域中保存声明的序列<s1，s2，s3>
<For处理开始>i＝1时，
s’1中保存TypeOfStat(s1，ε0)
ε1中保存ε0的结果
ε1的1号要素s1以s’1的值置换
i＝2时
s’2中保存TypeOfStat(s2，ε1)的结果
ε2中保存ε1的结果
ε2的2号要素s2以s’2的值置换
i＝3时
s’3中保存TypeOfStat(s3，ε2)的结果
ε3中保存ε2的结果
ε3的3号要素s3以s’3的值置换
<For语句结束>
作为结果，返回ε3的值<s’1，s’2，s’3>
<结束>
图22是表示该函数TypeOfLyee(<s1，...，sn>)的流程图。以下说明图22。首先，变量ε0的区域保存声明的序列<s1，…，sn>(步骤1401)。然后，将1加到i中(步骤1402)，前进到步骤1403。在步骤1403中，判定″i的值是否为n″，结果若为假，s’i中保存TypeOfStat(si，εi-1)的结果，εi的i号要素置换为s’i(步骤1404)。步骤1404结束后，返回步骤1402并再次执行。只要步骤1403的结果为假，就重复由步骤1402到步骤1404的重新开始处理(1406)。
步骤1403的结果为真时，在步骤1405中返回εn的值，结束处理。此时，εn的值为<s’1，...，s’n>。
如果形式化表示，与该函数相关连的键入规则如下。
上述形式化记述表示的规则的意思是，″前提条件‘将作为Lyee必要条件的声明的序列ε作为键入环境的声明s1的类型为s’1，将s’1代入s1后的声明的序列ε作为键入环境的<s2，...，s’n>的类型为<s’2，...，s’n>’成立时，将作为Lyee必要条件的声明的序列ε作为键入环境的声明的序列<s1，...，sn>的类型为<s’1，...，s’n>″。
最终，与被排列的Lyee必要条件相关连的类型判定的完全的系统如下。
Figure A0382643500695
Figure A0382643500696
上述形式化记述表示规则如下。
(Cst)表达式为常数时的规则：
将作为Lyee必要条件的声明的序列ε作为键入环境的常数c的类型，是不需前提条件函数TypeOfCst(c)返回的值。
(Wrd)表达式为词时的规则：
将作为Lyee必要条件的声明的序列ε作为键入环境的词w的类型，是不需前提条件函数TypeOfWrd(w)返回的值。
(Op)表达式为运算符时的规则：
将作为Lyee必要条件的声明的序列ε作为键入环境的运算符Op的类型，是不需前提条件函数TypeOfOp(Op)返回的值。
(Expp)表达式为括号表达式时的规则：
前提条件‘将作为Lyee必要条件的声明的序列ε作为键入环境的表达式Exp的类型为T’成立时，将作为Lyee必要条件的声明的序列ε作为键入环境的表达式(Exp)的类型为T。
(ExpU)表达式为″op Exp″时的规则：
前提条件‘将作为Lyee必要条件的声明的序列ε作为键入环境、运算符op的类型为T1→T2、表达式Exp的类型为T’1、T’1_T1’成立时，将作为Lyee必要条件的声明的序列ε作为键入环境的表达式op Exp的类型为T’1。
(ExpBA)表达式为″Exp op Exp″，运算结果不为逻辑型时的规则：
前提条件‘将作为Lyee必要条件的声明的序列ε作为键入环境、运算符op的类型为T1×T2→T3、表达式Exp1的类型为T’1、表达式Exp2的类型为T’2、T’1_T1、T’2_T2并且T3≠bool’成立时，将作为Lyee必要条件的声明的序列ε作为键入环境的表达式Exp1 op Exp2的类型为Sup(T’1，T’2)。
(ExpBB)表达式为″Exp op Exp″，运算结果为逻辑型时的规则：
前提条件‘将作为Lyee必要条件的声明的序列ε作为键入环境、运算符op的类型为T1×T2→bool、表达式Exp1的类型为T’1、表达式Exp2的类型为T’2、T’1_T1并且T’2_T2’成立时，将作为Lyee必要条件的声明的序列ε作为键入环境的表达式Exp1 op Exp2的类型为bool。
(6-2)个案研究
以下，示出表示在Lyee必要条件中应用键入的重要性的2个例子。第1例表示键入系统如何正确检测与类型违反相关的错误。第2例表示键入系统由键入系统的类型的自动生成。
<例I>
给出如表26的初始必要条件。如上所述，类型的验证前，首先需要声明的最佳排列。因此，对于表27所示的必要条件的排列后的形式进行类型的验证。
(表26)
初始条件
  字   定义   条件   IO   类型   安全
  a   true   IS   int   secret
  b   c   2＝2   OS   bool   public
  c   a＝6   2＝3   int   public
  c   true   IS   int   public
  f   g   true   OS   float   secret
  d   true+6   true   int   public
  g   d＝9   2＝3   OS   int   public
  h   f   f＝g   OS   int   public
(表27)
排列后的必要条件
  字   定义   条件   IO   类型   安全
  a   true   IS   int   secret
  c   a＝6   2＝3   int   public
  b   c   2＝2   OS   bool   public
  e   true   IS   int   public
  d   True+6   true   int   public
  g   d＝9   2＝3   OS   int   public
  f   g   true   OS   float   secret
  h   f   f＝g   OS   int   public
对表27的排列后的必要条件进行键入分析，返回的结果表示在必要条件中存在如下的类型错误。
·声明d的错误：表达式(true)不是数值(int或float)。
·对声明c的警告：类型(int)被修正为(bool)。
·对声明g的警告：类型(int)被修正为(bool)。
·对声明f的警告：类型(float)被修正为(bool)。
·对声明h的警告：类型(int)被修正为(bool)。
通过键入生成正确类型的必要条件如表28所示。
(表28)
键入后的必要条件
  字   定义   条件   IO   类型   安全
  a   true   IS   int   secret
  c   a＝6   2＝3   bool   public
  b   c   2＝2   OS   bool   public
  e   true   IS   int   public
  d   true+6   true   int   public
  g   d＝9   2＝3   OS   bool   public
  f   g   true   OS   bool   secret
  h   f   f＝g   OS   bool   public
<例II>
如上述，键入系统可以自动生成输入词以外的所有的词的类型。其特征如以下具体例所示。
如表29所示，给出的类型只是输入词的类型。对将该必要条件进行排列后的必要条件(表30)应用类型检验的系统，如表31的结果。
(表29)
初始必要条件
  字   定义   条件   IO   类型   安全
  a   true   IS   int   secret
  b   c   2＝2   OS   public
  c   a＝6   2＝3   public
  e   true   IS   int   public
  f   g   true   OS   secret
  d   a+6   true   public
  g   d＝9   2＝3   OS   public
  h   f   f＝g   OS   public
(表30)
排列后的必要条件
  字   定义   条件   IO   类型   安全
  a   true   IS   int   secret
  c   a＝6   2＝3   public
  b   c   2＝2   OS   public
  e   true   IS   int   public
  d   a+6   true   public
  g   d＝9   2＝3   OS   public
  f   g   true   OS   seeret
  h   f   f＝g   OS   public
(表31)
键入后的必要条件
  字   定义   条件   IO   类型   安全
  a   true   IS   int   secret
  c   a＝6   2＝3   bool   public
  b   c   2＝2   OS   bool   public
  e   true   IS   int   public
  d   a+6   true   int   public
  g   d＝9   2＝3   OS   bool   public
  f   g   true   OS   bool   secret
  h   f   f＝g   OS   bool   public
7.安全键入
下面，我们介绍对Lyee方法论处理安全等、软件开发的其它的很多的情况如何处理。实际上，为了证明程序在敌对的环境被执行时生成的代码满足数据机密性和完整性等的何种的安全方针，能够简单地扩大应用以上示出的键入技术。其主要目标是使以下情况成为可能，用户将表示安全必要条件的安全标号(″公开″以及″非公开″)与安全方针(例如，公开的词不能保存非公开的词的值等)一起明确给予各自定义的词。由这些给出的信息，为使有发生安全违反的余地的微妙的设计上的缺陷明显，可以使用自动的程序检验用键入技术。
例如，由在表32中给出的声明中所示的安全标号，扩大必要条件。
(表32)
  字   定义   条件   IO   安全   ...
  a   b+c   b＞2   Output   public   ...
  c   Input   public   ...
  b   c+5   c＞0   Output   secret   ...
安全方针是禁止非公开的词的值对公开的词的影响。此外，必须认为非公开的值加上别的值(非公开的或公开的)的结果也是非公开的。因此，其中公开的词a接受非公开的值，所以在表32中所示的必要条件明显不遵守安全方针。
(7-1)安全键入原则
与键入的验证相同，安全的验证也使用下述的要素。在该部分中，定义属于任意的Lyee必要条件中出现的词、常数、运算符的不同的类型。
(7-1-1)基本的安全类型
<值的安全类型>
为简单化，词和常数的安全类型定为public(公开)和secret(非公开)。
TSval::＝public|secret
上述定义意思是″值的安全类型(Tsval)是public(公开)和secret(非公开)″。
<运算符的安全类型>
同样，必须明确包括在Lyee必要条件中的逻辑运算符以及算术运算符的安全类型。关于各运算符，需要明确该运算符的安全类型和其结果的类型。任意的运算符的安全类型通常取Ts1→Ts2的形式。
为直观理解，形式化的记述意思是，1个运算符可以看成是取作为输入的安全类型Ts1时，返回安全类型Ts2的函数。当然，几个运算符取1个以上的操作数。因此，安全类型若看作其自身也存在1对安全类型，说明这样的例子容易。
总之，安全类型是Tsval(1个值的安全类型)、1对安全类型Ts1×Ts2或Ts1→Ts2。
若更形式化表示，可以写成如下的形式。
TS::＝TSual|TS1×TS2|TS1→TS2
上述正式的记述意思是″安全类型(Ts)是Tsval、Ts1×Ts2或Ts1→Ts2″。
(7-1-2)常数的安全类型
进行Lyee必要条件的安全检查时，声明中被发现的常数的安全类型是如下述所示只是public。
Figure A0382643500761
Figure A0382643500762
Figure A0382643500763
即，常数为t rue(真)或flase(假)、num(数值)、num.num(浮点数)时，安全类型都为public(公开)。与键入的验证相同，可以通过以下的函数判定任意的常数的安全类型。
SecTypeOfCst(cst：constant)
   Begin
      return public
   End
上述函数SecTypeOfCst(cst)的意思如下。
函数的自变量cst意思是常数。
<开始>
返回值public
<结束>
常数的安全类型可以通过以下的规则正式化。
Figure A0382643500764
上述正式的记述的意思是″作为Lyee必要条件的声明的序列ε作为安全类型环境的常数c的安全类型，是不需前提条件SecTypeOfCst(c)的结果的值″。
(7-1-3)词的安全类型
无论怎样的输入词，用户对于其安全类型必须绝对正确键入。关于其它的词，安全类型自动被算出并保存在定义这些词的声明的区域″安全″中。存在已经知道的词时，如下定义返回词的安全类型的函数SecTypeOfWrd。
SecTypeOfWrd(w：word，ε：List of statements)
Begin
   return Securlty(Statement(w，ε))
End
上述函数SecTypeOfWord(w，ε)的意思如下。
函数的自变量意思是属于必要条件ε的任意的词。
<开始>
返回属于必要条件ε的词w的声明(Statement(w，ε))的安全类型的值(Security(*)、*是由Statement(w，ε)求出的声明)
<结束>
词的安全类型可以通过以下的规则正式化。
Figure A0382643500771
上述正式的记述的意思是″将作为Lyee必要条件的声明的序列ε作为安全键入环境的词w的安全类型，是不需前提条件SecTypeOfWrd(w，ε)的结果的值″。
(7-1-4)表达式的安全类型
下面，示出判定各类表达式的安全类型的方法。
为简化表达式的安全类型的说明，需要引入以安全类型间的_s表述的半顺序关系。
Figure A0382643500772
使用上述的半顺序关系，可以如下定义2个安全类型中的上位的安全类型。
上述记述的意思是″Ts1和Ts2中的上位的类型(SecSup(Ts1，Ts2))，在Ts1_sTs2时为Ts1，在Ts2_sTs1时为Ts2″。
表达式为以下中的1个，即，val(值)、id(词的识别符)、(Exp)(括号表达式)、op Exp(运算符表达式)或Exp op Exp(表达式运算符表达式)，
Exp：＝val|id|(Exp)|op Exp|Exp op Exp
通过以下函数，每个表达式的各类能够与安全类型相关连。
SecTypeOfExp(e：expression，ε：List of statements)

  Begin

    Switch(e)
        case c        ：return SecTypeOfCst(c)

        case w        ：return SecTypeOfWrd(w)

        case(e1)      ：return SecTypeOfExp(e1，ε)

        case op e1    ：return SecTypeOfOp(e1)

        case e1 op e2 ：TS1←SecTypeOfExp(e1，ε)

                        TS2←SecTypeOfExp(e2，ε)

                        returnSecSup(TS1，TS2)

       EndSwitch

    End
上述函数SecTypeOfExp(e，ε)的意思如下。
函数的自变量e是属于必要条件ε的任意的表达式。
<开始>
函数Switch(e)的执行
自变量e为c(常数)时，返回SecTypeOfCst(cst)的结果的值
自变量e为w(词)时，返回SecTypeOfWrd(w)的结果的值
自变量e为e1(表达式)时，返回SecTypeOfExp(e1，ε)的结果的
值
自变量e为op e1时(运算符表达式)时，返回SecTypeOfExp(e1)的结果的值
自变量e为e1 op e1时(表达式运算符表达式)时，
Ts1中保存SecTypeOfExp(e1，ε)
Ts2中保存SecTypeOfExp(e2，ε)
返回SecSup(Ts1，Ts2)
函数Switch结束
<结束>
图23是表示该函数SecTypeOfExp(e，ε)的流程图。首先，判定″表达式e是否为常数″(步骤1501)，结果若为真，返回函数SecTypeOfCst(c)[返回常数c的安全类型]的结果(步骤1502)，结束处理。
步骤1501的结果若为假，前进到步骤1503，判定″表达式e是否为词″，判断结果若为真，返回函数SecTypeOfWrd(w)[返回词w的安全类型]的结果(步骤1504)，结束处理。
步骤1503的结果若为假，前进到步骤1505，判定″表达式e是否为″e1″型的表达式″，结果若为真，返回函数SecTypeOfExp(e1，ε)[返回属于声明的序列ε的表达式e1的安全类型]的结果(步骤1506)，结束处理。
步骤1505的结果若为假，前进到步骤1507，判定″表达式e是否为″op e1″型(一元运算符表达式)的表达式″，判定结果若为真，返回函数SecTypeOfExp(e1)[返回表达式e1的安全类型]的结果(步骤1508)。
步骤1507的判定结果若为假，前进到步骤1509。在步骤1509中，判定″表达式e是否为″e1 op e2″型(表达式二元运算符表达式)的表达式″，判定结果若为真，在步骤1510中，Ts1中保存SecTypeOfExp(e1，ε)、Ts2中保存SecTypeOfExp(e2，ε)，并且返回SecSup(Ts1，Ts2)，结束处理。
步骤1509的结果若为假，结束处理。
更形式化表示，则表达式的安全类型可以通过以下的规则获得。
Figure A0382643500802
Figure A0382643500804
上述形式化记述表示规则如下。
(Cst)表达式为常数时的规则：
将作为Lyee必要条件的声明的序列的ε作为安全键入环境的常数c的类型，是不需前提条件函数SecTypeOfCst(c)返回的值。
(Wrd)表达式为词时的规则：
将作为Lyee必要条件的声明的序列的ε作为安全键入环境的词w的类型，是不需前提条件函数SecTypeOfWrd(w，ε)返回的值。
(ExpP)表达式为括号表达式时规则：
前提条件″将作为Lyee必要条件的声明的序列的ε作为安全键入环境的表达式Exp的类型为Ts″成立时，将作为Lyee必要条件的声明的序列的ε作为安全键入环境的表达式(Exp)的类型为Ts。
(ExpU)表达式为″Op Exp″时的规则：
前提条件″作为Lyee必要条件的声明的序列ε作为安全键入环境的Exp(表达式)的类型为Ts″成立时，将作为Lyee必要条件的声明的序列ε作为安全键入环境的Op Exp(运算符表达式)的类型为Ts。
(ExpB)表达式为″Exp op Exp″时的规则：
前提条件″作为Lyee必要条件的声明的序列ε作为安全键入环境、表达式Exp1的类型为Ts1、表达式Exp2的类型为Ts2″成立时，将作为Lyee必要条件的声明的序列ε作为安全键入环境的表达式Exp1op Exp2的类型是Sup(Ts1，Ts2)。
(7-1-5)声明的安全键入
以下函数将安全类型与Lyee必要条件ε中的任意的声明s相关连。
SecTypeOfStat((Id，Exp，Cond，io，T，Tsec)：statement，
    Begin                                        ε：List of statement)
      If(io＝IF)or(io＝IS)and(Tsec＝””)
      Then print ErrMsg
          return 0
Figure A0382643500811
          Then return(Id，Exp，Cond，io ，T，Tsec)
          EndIf
                                                        or(io≠OF))
          Then return(Id，Exp，Cond，io，T，Tsec)
          Else return ErrMsg
      EndIf
   EndIf
End
上述函数的SecTypeOfStat((Id，Exp，Cond，io，T，Tsec)，ε)的意思如下。函数的自变量(Id，Exp，Cond，io，T，Tsec)是构成属于Lyee必要条件ε的任意的声明的项目的值(Id＝词的识别符、Exp＝定义式、Cond＝定义式执行条件、io＝输入输出属性、T＝词的值的类型、Tsec＝表示词的安全级别的类型)。
<开始>
<If语句开始>如果io＝IF或io＝IS，并且Tsec为空，[即，如果输入输出属性io为输入、未给出安全类型的信息]，打印ErrMsg，返回″0″[因为不能判定安全类型，所以打印错误信息，返回0]否则，
<If语句开始>如果SecTypeOfExp(Exp)_Tsec[声明的安全类型与定义式的安全；类型相比为上位]，并且，io≠OS且io≠OF[io不是输出，即，为输入]，返回(Id，Exp，Cond，io，T，Tsec)
<If处理结束>
<If语句开始>如果SecTypeOfExp(Exp)_STsec≠secret[声明的安全类型(不是secret)与定义式的安全类型相比为上位]，并且，io＝OS或io≠OF[io是对画面的输出或对文件的输出]，
返回(Id，Exp，Cond，io，T，Tsec)
否则，返回ErrMsg(错误信息)
<If处理结束>
<If处理结束>
<结束>
图24是表示该函数SecTypeOfStat((Id，Exp，Cond，io，T，Tsec)，ε)的流程图。以下说明图24。首先，判定″声明的io项目是IF[对文件的输出]或IS[对画面的输出]，并且项目T是否为空[无类型信息]″(步骤1601)。判定的结果若为真，前进到步骤1602，打印错误信息(ErrMsg)并返回″0″，结束处理。判断结果若为假，前进到步骤1603，判定″是否有SecTypeOfExp(Exp)_STsec[声明的安全类型与定义式的安全类型相比为上位]，并且，io≠OS且io≠OF[io不是输出，即，是输入]″。判定结果若为真，在步骤1604中返回(Id，Exp，Cond，io，T，Tsec)，结束处理。
步骤1603的判定结果为假，前进到步骤1605，判定″SecTypeOfExp(Exp)_STsec≠secret[是否声明的安全类型(不是secret)与定义式的安全类型相比为上位]，并且，io＝OS或IO≠OF[io是对画面输出或对文件的输出]″。结果若为真，在步骤1606中返回(Id，Exp，Cond，io，T，Tsec)的值，结束处理。
步骤1605的结果若为假，返回错误信息(ErrMsg)(步骤1607)，结束处理。
形式化的记述，与该函数相关的键入规则如下。
Figure A0382643500821
Figure A0382643500822
即，上述形式化的记述意思如下。
(Stat1)生成缺少输出词的安全类型信息时：
前提条件‘将作为Lyee必要条件的声明的序列ε作为安全键入环境的定义式Exp的类型为Ts1，声明的输入输出属性不是输入(io≠IS且io≠IF)’成立时，将作为Lyee必要条件的声明的序列ε作为安全键入环境的声明(Id，Exp，Cond，io，T，“”)的类型为(Id，Exp，Cond，io，T，Ts1)。
(Stat2)检查、修正输出词的安全类型信息时：
前提条件‘将作为Lyee必要条件的声明的序列ε作为安全键入环境、定义式Exp的类型为Ts1、该Ts1与声明的安全类型的值相比为上位(Ts1_STsec)、输入输出属性不为输入(io≠IS且io≠IF)’成立时，将作为Lyee必要条件的声明的序列ε作为安全键入环境的声明(Id，Exp，Cond，io，T，Tsec)的类型为(Id，Exp，Cond，io，T，Ts1)。
(7-1-6)Lyee必要条件的安全键入
存在排列后的声明的序列的ε，通过下述的函数，可以将安全类型与其各个声明相关连。
SecTypeOfLyee(<s1，...，sn>：list of statements)
   Varε0：list of statements
  Begin
     ε0←<s1，...，sn>
     For i＝1 to n
s i &prime; &LeftArrow; SecTypeOfStat ( s i , &epsiv; i - 1 ) &epsiv; i &LeftArrow; &epsiv; i - 1 replacethe i th elememt of &epsiv; i by s i &prime;
     EndFor
     return εn
   End
上述的函数SecTypeOfLyee(<s1，...，sn>)的意思如下。函数的自变量<s1，...，sn>是任意的声明的序列。变量ε0的值是声明的序列。
<开始>
ε0中保存声明的序列<s1，...，sn>。
i取由1到n时，执行以下程序
s’i中保存SecTypeOfStat(si，εi-1)
εi中保存εi-1的值
εi的i号要素由s’i替换。
<For处理结束>
返回εn
<结束>
图25是表示该函数SecTypeOfLyee(<s1，...，sn>)的流程图。以下说明图25。首先，在变量ε0的区域保存声明的序列<s1，...，sn>(步骤1701)。然后，对i加1(步骤1702)，前进到步骤1703。在步骤1703中，判定″i的值是否为n″，结果若为假，在s’i中保存SecTypeOfStat(si，εi-1)的结果，在εi中保存εi-1的结果，εi的i号要素由s’i替换(步骤1704)。步骤1704结束后，返回步骤1702比你跟再次执行。只要步骤1703的结果为假，就重复由步骤1702到步骤1704的重新开始处理(1706)。
步骤1703的结果为真时，在步骤1705中返回εn，结束处理。此时，εn的值为<s’1，...，s’n>。
正式的记述，上述函数的安全键入规则如下。
上述正式的记述表示的规则的意思是″前天条件‘将作为Lyee必要条件的声明的序列ε作为安全键入环境的声明s1的安全类型为s’1，s’1代入s1后的声明序列ε作为安全类型的环境的<s2，...，s’n>的安全类型为<s’2，...，s’n>’成立时，将作为Lyee必要条件的声明的序列ε作为安全键入环境的声明的序列<s1，...，sn>的安全类型是<s’1，...，s’n>″。
Figure A0382643500853
最后，与排列后的Lyee必要条件的完全的安全类型系统如下。
(Cst)表达式为常数时的表达式的安全类型：
将作为Lyee必要条件的声明的序列ε作为安全键入环境的常数c的类型，是不需前提条件函数SecTypeOfCst(c)返回的值。
(Wrd)表达式为词时的表达式的安全类型：
将作为Lyee必要条件的声明的序列ε作为安全键入环境的词w的类型，是不需前提条件函数SecTypeOfWrd(w，ε)返回的值。
(ExpP)表达式是括号表达式时的表达式的安全类型：
前提条件‘将作为Lyee必要条件的声明的序列ε作为安全键入环境的表达式Exp的类型为Ts’成立时，将作为Lyee必要条件的声明的序列ε作为安全键入环境的表达式(Exp)的类型为Ts。
(ExpU)表达式为″Op Exp″时的表达式的安全类型：
前提条件‘将作为Lyee必要条件的声明的序列ε作为安全键入环境的表达式(Exp)的类型为Ts’成立时，将作为Lyee必要条件的声明的序列ε作为安全键入环境的Op Exp(运算符表达式)的类型为Ts。
(ExpB)表达式为″Exp op Exp″时的表达式的安全类型：
前提条件‘将作为Lyee必要条件的声明的序列ε作为安全键入环境、表达式Exp1的类型为Ts1、表达式Exp2的类型为Ts2’成立时，将作为Lyee必要条件的声明的序列ε作为安全键入环境的表达式Exp1op Exp2的类型是Sup(Ts1，Ts2)。
(Stat1)生成缺少输出词的安全类型信息时：
前提条件‘将作为Lyee必要条件的声明的序列ε作为安全键入环境的定义式Exp的类型为Ts1，声明的输入输出属性不是输入(io≠IS并且io≠IF)’成立时，将作为Lyee必要条件的声明的序列ε作为安全键入环境的声明(Id，Exp，Cond，io，T，“”)的类型为(Id，Exp，Cond，io，T，Ts1)。
(Stat2)检查、修正输出词的安全类型信息时：
前提条件‘将作为Lyee必要条件的声明的序列ε作为安全键入环境、定义式Exp的类型为Ts1、该Ts1与声明的安全类型的值Tsec相比为上位(Ts1_STsec)、输入输出属性不是输入(io≠IS并且io≠IF)’成立时，将作为Lyee必要条件的声明的序列ε作为安全键入环境的声明(Id，Exp，Cond，io，T，Tsec)的类型是(Id，Exp，Cond，io，T，Ts1)。
(Req)排列后的Lyee必要条件的安全类型：
前提条件‘将作为Lyee必要条件的声明的序列ε作为安全键入环境的声明s1的安全类型为s’1、s’1代入s1后的声明的序列ε作为安全类型的环境的<s2，...，s’n>的安全类型为<s’2，...，s’n>’成立时，将作为Lyee必要条件的声明的序列ε作为安全键入环境的声明的序列
<s1，...，sn>的安全类型为<s’1，...，s’n>。
(7-2)个案研究
上述的表31的Lyee必要条件中，进行安全键入，检测出以下的错误。
·声明c的错误：词c的类型为public(公开)，但是，定义式包含secret(非公开)的词(定义式a＝6的词a为secret)，由于受其影响，所以矛盾。
·声明b的错误：词b的类型为public(公开)，但是，定义式间接包含secret(非公开)的词(定义式c的词c的定义式a＝6的词a为secret)，由于受其影响，所以矛盾。
·声明d的错误：词d的类型为public(公开)，但是，定义式包含secret(非公开)的词(定义式a+6的词a为secret)，由于受其影响，所以矛盾。
·声明g的错误：词g的类型为public(公开)，但是，定义式间接包含secret(非公开)的词(定义式d ＝9的词d的定义式a+6的词a为secret)，由于受其影响，所以矛盾。
·声明f的错误：词f的类型为secret(非公开)，但是，词f是输出之一，所以矛盾(因为有作为安全类型的值不输出的方针)。
·声明h的错误：词h的类型为public(公开)，但是，定义式间接包含secret(非公开)的词(定义式f的词f的定义式为g，词g的定义式为d＝9，词d的定义式为a+6，词a为secret)，由于受其影响，所以矛盾。
8. Lyee必要条件分析器
Lyee必要条件分析器是为部分实现我们以前讨论的静态分析技术产生的原型。其作为输入理解Lyee必要条件，作为输出给出适于以LyeeAll工具的优化的代码的生成的分断和排列顺序的必要条件。然后，它能够执行常数传送等的其它的必要条件优化。如图26所示，该原型的基本构成要素如下：
●词汇以及语法的分析器：这部分作为输入的Lyee必要条件，给出作为输出的一般的被称为中间表现的语法树形结构。必要条件的该新的表现方法是我们希望进行的所有的静态分析记述的出发点。而且，分析Lyee必要条件时，能够检测词汇或语法上的错误并传达给用户。
●流程基础分析器：流程基础分析要素由在以前部分中进行的中间的表现开始，生成与由1必要条件到另1必要条件的数据流程控制的循环有关的所有的信息。这些分析的结果由控制流程图(Control FlowGraph：CFG)以及数量流程图(Data-Flow Graph：DFG)构成。
●优化：在其它之中，该要素执行常数的传送技术，生成LyeeAll工具适于生成能够更快地执行并消耗地保存更少地程序、适当地简单化的声明的系列。
●限制器：该要素作为输入取与根据流程基础分析要素以及限制评价标准生成的流程相关(与各词相关连的Def/Use等)的信息，作为输出，给出与这些给出的评价标准对应的分断。
9.结论和对将来的展望
我们在本文中发表了对Lyee必要条件使用静态分析技术和其影响。首先，我们提出常数传送或模式检测等的古典的优化的技术能够如何改良Lyee程序的执行时间。此外，我们介绍如何发现必要条件中的错误(死的定义。周期的定义、不完全或多余的定义)。第2，我们讨论所谓分断的技术能够如何改良Lyee系统的理解和维护。而且，我们示出，如何通过使用该分断技术发现可以并行执行的Lyee系统中的独立的部分。第3，我们提出能够发现键入错误和自动生成媒介以及词的类型的类型系统。第4，我们举例证明Lyee方法论如何适于安全方面等的一些扩大。被提出的静态分析技术中，现在存在以称为Lyee必要分析器的原型执行的技术。
并且，作为今后的工作，我们首先完成Lyee必要条件分析工具，调查用于改良Lyee方法论的其它的方面的其它的静态分析技术。
10.
如以上详细的说明，根据涉及本实施方式的本发明的静态分析方法，对Lyee必要条件使用静态分析的方法，所以能够改善根据Lyee必要条件和Lyee生成的代码列二者的质量，因此，Lyee方法论中生成具有更高质量(更少的保存和执行时间的耗费)的代码成为可能。(7)作为发展形态，通过对Lyee必要条件(要求定义)使用上述的静态分析方法或静态分析器，能够得到更加改善的Lyee必要条件，通过以上述的″Lyee必要条件″对其进行说明的方法，或专利文献1、2、4到6中记载的Lyee的软件生成方法，进一步对专利文献3记载的软件生成装置进行输入，能够实现以更少的保存空间和处理时间由Lyee生成所希望的软件的方法或生成的生成装置。
即，若在作为Lyee的软件生成的上流阶段的Lyee必要条件的阶段实现效率化，对其后的处理应用已有的Lyee方法论，因此能够得到作为更加高质量的最终产品的软件。
关于得到这样的Lyee必要条件(要求定义)后的阶段的方法或装置的详细说明，作为在上述的″Lyee发明的概要″中说明内容或专利文献1至6中记载的方法的说明，在此省略。
此外，根据本发明，通过使用古典的静态分析的技术，能够更加增进Lyee方法论。
并且，与根据涉及本发明的Lyee指向软件相关的静态分析器，接受Lyee必要条件，能够将适于以LyeeAll工具生成的优化代码的分断和调整顺序的必要条件作为输出给出。并且，其能够执行常数传送等其它必要条件的优化。
本发明的许多特征及优点通过说明书的详细说明得以明确。进而，对于该技术领域中的具有常识的人来说，能够容易地做很多修正及改变，所以不希望本发明限于与图示及记述没有一点不同结构及动作，所有适当的变形例及等价例都看成为包含在本发明的范围内。虽然根据上述涉及本发明的实施方式的说明以及图例进行了详细记述，但是在不仅限于附加的专利权利要求范围内，还不超出涉及本发明公开的全部内容中定义的本发明的范围的情况下，可以进行很多修改、替换及变更。
此外，涉及本申请的发明，在其应用上，并不限于是否在上述记述中进行了说明或图示要素的详细解释及组合中。本发明可以是其它实施方式，可以在各种方法中使用或实施。此外，在此使用的语法以及术语以说明为目的，不能作为限定的功能。
因此，在该技术领域中的具有常识的人应将作为本发明的基本概念理解为：将用于实施本发明的某些目的的其它结构、方法及系统作为设计用的基础，能容易地被利用。因此，只要在不脱离本发明的宗旨及范围内，都可以看作是本申请的专利权利要求的范围包含那样的等价解释。
此外，上述主要说明Lyee方法论中软件的静态分析法以及静态分析器，无需赘言，涉及本发明的技术思想，例如也为计算机软件的自动开发装置、自动开发程序、保存自动开发程序的存储介质、传送介质、纸介质，此外，所谓注册自动开发程序的计算机装置、执行自动开发程序的客户服务器形式等的种类中，也可以实现利用。
并且，本发明不限于具备单一处理器、单一硬盘驱动以及单一本地保存器的计算机系统，作为该系统的选择，也适于装备任意多个或组合处理器或保存设备。计算机系统包含精密的计算器、掌上电脑、膝上型电脑/笔记本电脑、迷你电脑、大型计算机、超级计算机、以及这些处理系统网络组合。能够由按照本发明原理工作的任意适当的处理系统代替，此外也可以和这些组合使用。
此外，涉及本发明的技术思想，当然可适用于所有类型的程序语言。并且，涉及本发明的技术思想也可适用于所有种类功能的应用软件。
此外，进而涉及本申请发明在该技术思想的同样以及等价的范围中，允许各种变形、再增加、置换、扩大、缩小等。此外，使用本申请发明制作的软件在其2次产品中注册、商品化时，分申请发明的价值没有任何减少。
生产上的可利用性
在本发明中，通过对Lyee必要条件使用静态分析方法，能改善Lyee必要条件和根据Lyee生成的代码列的二者的质量，因此，通过Lyee方法论中生成具有更高质量(更少的保存和执行时间的耗费)的代码成为可能，由此带来软件制作效率大幅提高、生产能力提高、质量提高等的软件产业上的重大的效果。

Claims (9)

1.一种关于Lyee指向软件的静态分析方法，其特征在于，具备：
为按照Lyee方法论制作软件，得到包含每个词的定义式的要求定义的步骤；
将上述得出的要求定义作为关键词检测常数的步骤；
按照使用上述检出的常数的定义式传送该常数的步骤。
2.一种关于Lyee指向软件的静态分析方法，其特征在于，具备：
为按照Lyee方法论制作软件，得到包含每个词的定义式的要求定义的步骤；
从上述得到的要求定义的定义式中检测模式的步骤；
以该检测模式作为置换式的表现替换上述要求定义的步骤。
3.一种关于Lyee指向软件的静态分析方法，其特征在于，具备：
为按照Lyee方法论制作软件，得到包含每个词的定义式以及前提条件的要求定义的步骤；
基于上述要求定义，得到遵守BNF语法记述至少涉及上述词的识别符、上述定义式以及上述前提条件的声明的步骤；
对上述得到的每个声明定义Def/Use函数的步骤；
由上述定义的Def/Use函数间的顺序关系得到上述声明间的顺序关系的步骤。
4.一种关于Lyee指向软件的静态分析方法，其特征在于，具备：
为按照Lyee方法论制作软件，得到包含每个词的定义式以及输入输出属性的要求定义的步骤；
基于上述要求定义，得到记述至少涉及上述词的识别符、上述定义式以及输入输出属性的声明的步骤；
由上述得到的声明(第1声明)，引导对涉及该声明的词的定义有贡献的另外的声明(第2声明)，对该所有的声明执行将该第1以及第2声明作为同一声明群的分断函数的步骤；
由上述分断函数得到相互独立的分断的步骤。
5.一种关于Lyee指向软件的静态分析方法，其特征在于，具备：
为按照Lyee方法论制作软件，得到包含每个词的定义式以及输入输出属性的要求定义的步骤；
基于上述要求定义，得到记述至少涉及上述词的识别符、上述定义式以及输入输出属性的声明；
基于对上述得到的声明的规定的分析，检测上述要求定义中的错误的步骤。
6.根据权利要求5所述的关于Lyee指向软件的静态分析方法，其特征在于：
对上述声明的规定的分析是根据算出非活性声明、循环声明、不完全声明或多余声明中的至少1个得出的。
7.一种关于Lyee指向软件的静态分析方法，其特征在于，具备：
为按照Lyee方法论制作软件，得到包含每个词的定义式以及输入输出属性的要求定义的步骤；
基于上述要求定义，得到记述至少涉及上述词的识别符、上述定义式以及输入输出属性的声明的步骤；
对上述得到的声明、该声明中的运算符以及数据，定义各个类型代数的步骤；
对上述定义的类型代数，使用相关的环境以及规定的类型规则，发现上述要求定义中的类型错误的步骤。
8.一种关于Lyee指向软件的静态分析方法，其特征在于，具备：
为按照Lyee方法论制作软件，得到包含每个词的定义式以及输入输出属性的要求定义的步骤；
基于上述要求定义，得到记述至少涉及上述词的识别符、上述定义式以及输入输出属性的声明的步骤；
对上述得到的声明、该声明中的运算符以及数据，定义各个类型代数的步骤；
基于上述定义的类型代数，使用规定的环境以及类型规则，由上述要求定义中的输入词生成媒介以及输出词的类型的步骤。
9.一种关于Lyee指向软件的静态分析方法，其特征在于，具备：
为按照Lyee方法论制作软件，得到包含每个词的定义式以及输入输出属性的要求定义的步骤；
基于上述要求定义，得到记述至少涉及上述词的识别符、上述定义式、输入输出属性以及安全标号的声明的步骤；
使用表示上述得到的声明中的安全标号间的关系网络，在上述词的值中定义与安全标号相关连的标号函数的步骤；
基于上述定义的标号函数，使用规定的安全方针，算出不遵守规定的安全方针的程序的步骤。
CN03826435.8A 2003-03-10 2003-09-25 关于Lyee指向软件的静态分析方法 Pending CN1788254A (zh)

Applications Claiming Priority (2)

Application Number Priority Date Filing Date Title
JP2003064220 2003-03-10
JP064220/2003 2003-03-10

Publications (1)

Publication Number Publication Date
CN1788254A true CN1788254A (zh) 2006-06-14

Family

ID=32984464

Family Applications (1)

Application Number Title Priority Date Filing Date
CN03826435.8A Pending CN1788254A (zh) 2003-03-10 2003-09-25 关于Lyee指向软件的静态分析方法

Country Status (8)

Country Link
US (1) US20070006194A1 (zh)
EP (1) EP1637990A1 (zh)
JP (1) JPWO2004081788A1 (zh)
KR (1) KR20050118177A (zh)
CN (1) CN1788254A (zh)
AU (1) AU2003272890A1 (zh)
CA (1) CA2518498A1 (zh)
WO (1) WO2004081788A1 (zh)

Families Citing this family (13)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
AU2003224850A1 (en) * 2002-04-08 2003-10-27 Topcoder, Inc. System and method for soliciting proposals for software development services
KR20060121880A (ko) * 2003-09-22 2006-11-29 카테나 가부시키가이샤 소프트웨어 생성방법
US7661097B2 (en) * 2005-04-05 2010-02-09 Cisco Technology, Inc. Method and system for analyzing source code
US7975257B2 (en) 2006-06-13 2011-07-05 Microsoft Corporation Iterative static and dynamic software analysis
US20080307397A1 (en) * 2007-06-08 2008-12-11 Bill Angell Program Analysis by Partial Emulation
JP2009237762A (ja) * 2008-03-26 2009-10-15 Toshiba Corp プログラム解析装置、プログラム解析方法および解析プログラム
US8527965B2 (en) * 2008-04-14 2013-09-03 Oracle America, Inc. Layered static program analysis framework for software testing
US8875100B2 (en) 2011-06-17 2014-10-28 Microsoft Corporation Pattern analysis and performance accounting
US8984495B2 (en) 2013-01-03 2015-03-17 International Business Machines Corporation Enhanced string analysis that improves accuracy of static analysis
US9256512B1 (en) 2013-12-13 2016-02-09 Toyota Jidosha Kabushiki Kaisha Quality analysis for embedded software code
US10275333B2 (en) 2014-06-16 2019-04-30 Toyota Jidosha Kabushiki Kaisha Risk analysis of codebase using static analysis and performance data
US9535934B1 (en) * 2015-11-17 2017-01-03 International Business Machines Corporation Schema lifecycle manager
US10990073B2 (en) * 2016-08-30 2021-04-27 Mitsubishi Electric Corporation Program editing device, program editing method, and computer readable medium

Family Cites Families (9)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JPH07239788A (ja) * 1994-02-28 1995-09-12 Hokuriku Nippon Denki Software Kk 不要変数型宣言チェック機能付きコンパイラ
JP3650649B2 (ja) * 1995-06-16 2005-05-25 松下電器産業株式会社 最適化装置
JPH0950379A (ja) * 1995-08-09 1997-02-18 Atr Tsushin Syst Kenkyusho:Kk プログラム意味保存コード移動装置
US6138268A (en) * 1995-10-30 2000-10-24 Information System Development Institute Software production method, processing apparatus and recording medium
US6532586B1 (en) * 1995-10-30 2003-03-11 Information System Development Institute Software producing method, processor, processing method and recording medium
KR0179794B1 (ko) * 1995-12-28 1999-03-20 문정환 반도체 소자의 웰 형성방법
JPH10307727A (ja) * 1997-05-08 1998-11-17 Nec Corp ソフトウェア構築装置及び型チェック方法
CA2324455A1 (en) * 1998-03-20 1999-09-30 Information System Development Institute Apparatus for producing software and method for producing software
JP2001005651A (ja) * 1999-06-21 2001-01-12 Institute Of Computer Based Software Methodology & Technology ソフトウェアの決定方法、ソフトウェアの使用方法、記録媒体、処理装置、ソフトウェアの保守方法、ソフトウェアの移植方法、ソフトウェアの管理方法、処理経路図の作成方法、パレット関数の作成方法、パレットの領域の決定方法、パレット連鎖関数の作成方法、位相要素の作成方法、論理要素の作成方法、作用要素の作成方法、ソフトウェアの実装方法、ソフトウェア開発方法、データ構造の置換方法、データ値の置換方法、従来型プログラムの分析方法、ソフトウェア開発管理方法、ソフトウェアの運用管理方法、並列コンピュータ及び判断補助装置

Also Published As

Publication number Publication date
JPWO2004081788A1 (ja) 2006-06-15
KR20050118177A (ko) 2005-12-15
US20070006194A1 (en) 2007-01-04
EP1637990A1 (en) 2006-03-22
AU2003272890A8 (en) 2004-09-30
CA2518498A1 (en) 2004-09-23
AU2003272890A1 (en) 2004-09-30
WO2004081788A1 (ja) 2004-09-23

Similar Documents

Publication Publication Date Title
CN1875345A (zh) 在编译过程中表示和检查程序组件的一致性的可扩展类型系统
CN1609855A (zh) 查询优化系统和方法
CN1073276A (zh) 语言的中性对象
CN1073540A (zh) 管理类方法名
CN1788254A (zh) 关于Lyee指向软件的静态分析方法
CN1689022A (zh) 可扩展标记语言流化转换器
CN1279477C (zh) 检索关键字分析系统和方法
CN100338568C (zh) 开发片上系统用的开发环境的生成方法
CN1110757C (zh) 处理两种文字对照的数据库的方法与装置
CN1155884C (zh) 通过大范围的同值关系的解析来消除传输命令的优化装置
CN1479904A (zh) 利用有向无环图配置产品的方法
CN1750003A (zh) 信息处理装置,信息处理方法,和程序
CN101040292A (zh) 数据管理装置及其方法
CN1592905A (zh) 自动产生数据库查询的系统和方法
CN1246772C (zh) 处理器
CN1910601A (zh) 限制条件解决方法、限制条件解决装置、以及限制条件解决系统
CN1744036A (zh) 报告软件中支持定制图形表示的系统和方法
CN1668996A (zh) 解大型连续性或离散性最佳化问题的动态方法
CN1768275A (zh) 测试摸拟装置、测试模组模拟装置以及记录此程式的记录媒体
CN1942932A (zh) 信号分离装置、信号分离方法、信号分离程序及记录媒体
CN1629869A (zh) 产生和管理商业过程集成解决方案的系统和方法
CN1577324A (zh) 文档管理方法和程序、记录介质和文档管理装置
CN1624696A (zh) 信息处理设备、方法及其程序、信息处理系统及其方法
CN1774712A (zh) 在数据表中管理递归可缩放模板实例中的插入操作的系统和方法
CN1766886A (zh) 用于数据管理和/或转换的数据结构、数据库系统及方法

Legal Events

Date Code Title Description
C06 Publication
PB01 Publication
C10 Entry into substantive examination
SE01 Entry into force of request for substantive examination
C02 Deemed withdrawal of patent application after publication (patent law 2001)
WD01 Invention patent application deemed withdrawn after publication