JP2534360B2 - 接続方法、ノ―ド接続方法、デ―タ処理方法、及び木内にノ―ドを挿入する方法 - Google Patents

Description

【発明の詳細な説明】 A.産業上の利用分野 本発明は情報処理システム、特に関連するデータを操
作するためのコンピュータ・システムに関するものであ
り、詳細にいえばデータと関係をノードを形成するデー
タ要素、及び木構造内のノードの配置を定義する関係と
によって、階層ないし木として表わすことのできる関係
するデータを編集するためのエディタに関するものであ
る。木構造によって表わされるデータ及び関係を「木構
造データ」と呼ぶ。

B.従来技術 エディタは通常、ユーザからのコマンドを受け入れ、
処置の結果を表示するユーザ・インターフェース、必要
な編集機能を遂行するデータ操作工程、データ及び関係
を維持するデータ記憶手段、ならびに要求さた位置を検
証する際に、データ操作工程により使用するためのデー
タ・ノード間の有効な関係を表わす（オプションの）構
文規則で構成されている。

木構造で表わされたデータの操作は以下の機能を含ん
でいる。

−新しいデータ・ノードまたはノードのセットの木構造
への挿入 −データ・ノードまたはノードのセットからの木構造か
らの削除 −データ・ノードまたはノードのセットの構造内の新し
い位置への複写 −データ・ノードまたはノードのセットの構造内の新し
い位置への移動 操作機能は挿入、削除、複写、移動されるノードのセ
ット間の関係を含む、ノードの間に存在している関係を
保存しなければならない。

木構造データを編集するために多くのシステムが、開
発されている。一般に構造エディタと呼ばれるこれらの
システムは主として、形式的に記述されたプログラミン
グ言語を編集することに関するものである。これらのエ
ディタはデータ・ノードの間の有効な関係を表わす構文
規則を守らせる。多くの現代のプログラミング言語、及
び正規の言語は一般に、パーズ木といわれる木として表
わされる、ステートメントの基礎構造ないし階層を処理
する。木を形成する関係はデータを操作する自然な方法
を提供する。

プログラミング言語は関係、すなわちその言語に有効
な、木を支配する構文規則を有している。これらの規則
を厳密に遵守しなければ、プログラムは無意味なものと
なる。したがって、プログラムを作成する言語の規則を
守らせ、かつプログラムの基礎構造の理解に基づいてデ
ータの操作の選択を可能とすることによって、プログラ
ムの作成及び保守を援助するエディタが開発された。こ
れらのエディタは「言語ベース・エディタ」または「構
文制御形エディタ」などと呼ばれている。

本発明者らが知っているもののようなエディタの実施
形態は、おおまかに２つのクラスに分けられる。最初の
ものは標準的なラインまたはキャラクタ指向テキスト・
エディタときわめて類似したユーザ・インターフェース
を提供する。編集はプログラムのテキスト記述を対象と
するものであり、これから各編集操作後に構造が再生成
される。構造が再生成できない場合、あるいは再生成さ
れた構造が何らかの構文規則に違反している場合には、
エディタは編集操作を拒絶したり、あるいは結果をどの
ように形成するかについて最善の推測を行ない、有効な
構造を再生成できるようにする。

このような手法の利点は、これがきわめて一般的なも
のであって、編集操作に使用できる文字セットについて
何の制約もないこと、及び現在単純なテキスト・エディ
タで作業をしているプログラマにとってきわめてなじみ
やすい編集モデルを作れることである。プログラマが与
えた無効な構造から、エディタが有効な構造を作成しよ
うとした場合、エディタがプログラマの意図している構
造を生成している限り、プログラマの作業の多くは自動
的に行なうことができる。しかしながら、これらの利点
は同時に、この手法の欠点ともなる。絶対的な普遍性
は、構文制御形エディタがないと起こしてしまうのと同
じ誤りを、プログラマに簡単に起こさせてしまうもので
あり、これらの誤りは入力の時点で見つかり、作業を中
断し、誤りを修正せざるをえなくする。さらに、エディ
タがそれ自体で誤りを修正しようとした場合、エディタ
は厳密な修正を行ないながら、プログラマが意図してい
ないことも行なってしまうことがある。修正がプログラ
マの考えている方向と同じでない場合には、プログラマ
は自分自身の誤りを修正するだけではなく、エディタが
生成した間違った情報の修正も行なわなければならなく
なる。既存の構造を利用して新しい構造を再生成し、エ
ディタの部分の作業を重複させるという利点がほとんど
ないため、この手法はかなり効率が悪い。編集の過程
で、プログラマが中間段階の早い時期に正しくないプロ
グラムを作成することがきわめてしばしばある。この種
のエディタはこれらの段階を認めることも、それを自身
で修正することもなく、これを間違って行なう可能性が
ある（上述のように）。このようなエディタの例は、コ
ーネル大学（Cornell University）のリチャード・コン
ウェイ他（Richard Conway et al.）が開発したCOPEプ
ログラミング環境にある。

他のクラスの構文制御形エディタは木の構造を直接操
作する。このクラスのユーザ・インターフェースは通常
グラフィカルなもので、ユーザはプログラム・ステート
メントのグループを表わすグラフィック・イメージを用
いて作業を行なうことができる。グラフィック・イメー
ジは指定された階層関係にしたがって、接続された木と
して表示される。有効な木をもたらす操作のみを、完了
することができる。操作は完全なサブツリーによって指
定される（完全なサブツリーはノード、及びその子、こ
れらの子の子など、他の子が得られなくなるまでのすべ
ての子によって構成される）。これらのサブツリーを移
動または複写して、他のノードのサブツリーにしてもよ
いし、また完全に削除してもよい。新しいノードまたは
定義済みサブツリーを、既存のノードの子として挿入す
ることもできる。

このクラスのエディタは、木の構造のみを操作するた
め、きわめて効率がよい。また、完全なサブツリーのみ
が移動されるので、多くの一般的な誤りが生じるのも防
止する。残念ながら、エディタとして日常に使用するに
は、きわめて制限が強い。サブツリーはプログラムの適
切な取扱いにきわめて基本的なものではあるが、単一の
完全なサブツリーが役に立つことはほとんどない。プロ
グラマがノードの階層からレベルを除去したり、挿入し
たりしようとすることがしばしばある。この操作はプロ
グラマを作成しようと考えてからほんの５分程度で終わ
ることがよくある、プログラム作成の最も最初の段階以
降のプログラム編集の基本である。この欠点はこの方法
を、基本編集モデルとして役立つものとするのを妨げて
いる主要な欠点である。

さらに、プログラマはほとんど常に、複数のサブツリ
ーのいくつかの範囲（行の範囲に対応している）を扱っ
ているが、単純なサブツリー操作モデルはしばしばこの
ような操作をサポートしない。いくつかのエディタの機
能を強化したものは前のサブツリーに続くサブツリー
を、その前のサブツリーの最後の子として表わす。これ
は任意のスタート位置から、階層のそのレベルにおける
順序の終りまでの「順次」リストを適切なサブツリーと
して表示することを可能とする。最後の子を取り扱うサ
ブツリーから分離したものとみなすことを可能とする他
の機能強化は、部分サブツリーとみなせる順次ステート
メントを、他の制限なしで、１回の操作で移動させるの
を可能とする。しかしながら、これらの機能強化は完全
なサブツリーに基づく編集モデルに適合させにくい。こ
れらの機能強化を行なっても、モデルはまだ制限の多い
ものであって、たとえば、ノードを追加できるのは、既
存のノードのサブツリーとしてだけであって、既存のノ
ードの親としてではない。

このモデルを使用するエディタの例としては、コーネ
ル大学（Cornell University）のティム・テイトルバウ
ム他（Tim Teitlebaum et al.）が開発したコーネル・
プログラム・シンセサイザ（Cornell Program Synthesi
zer）、及びジノテック・リサーチ・インク（Xinotech
Research,Inc.）が開発したジノテック・プログラム・
コンポーザ（Xinotech Program Composer）がある。

C.発明が解決しようとする問題点 本発明は完全なサブツリーの操作に限定されない構造
エディタを提供することに関するものである。好ましい
実施例は１つまたは複数のサブツリーで動作するデータ
操作方法を提供する。この方法はデータの挿入、削除、
複写及び移動を実現するものであり、操作のためのデー
タを選択するための汎用化されたスコープ指定方法を改
善したものであり、また結果として得られたデータの位
置及び関係を指定するための汎用化されたターゲット指
定方法を改善したものである。さらに好ましい実施例
は、スコープを包含しているサブツリーのセットの収
集、スコープを包含しているノードの削除、汎用のター
ゲットで示された点におけるスコープを包含しているノ
ードの接合と含むサブオペレーションの組合せによっ
て、ノードの挿入、削除、複写及び移動を行なうことに
関するものである。好ましい実施例の拡張は、指定され
た構文規則を遵守させる構文制御形エディタに関する。
好ましい実施例の方法は、各種のユーザ・インターフェ
ース、データ記憶手法、及び構文規則の指定で操作でき
るものである。

したがって、本発明の目的は、木の有効な構造を維持
しながら、構造エディタにおいて融通性の高い挿入、移
動、複写、及び削除操作を提供することである。他の目
的は以下の事項を行なえるようにすることである。

−完全なサブツリーだけではなく、ツリー内のノードの
任意の選択物の移動、複写、及び削除。

−選択されたノード及び選択されないノードの両方の相
対構造（すなわち、ネスティング及び左から右への関
係）の維持。

−選択されたノードの、既存のノードの親としての移
動、複写、及び挿入（すなわち、既存のノードの周囲へ
の新しいノードの挿入）。

−選択されたノードの、既存のノードのすべての子とし
ての移動、複写、及び挿入（すなわち、親ノードとその
子の間への新しいノードの挿入）。

−選択されたノードの、既存のノードの子としての移
動、複写、及び挿入。

−これらの操作及び他の操作を行なった場合の、木の有
効な構造に関する規則の維持。

本発明のさらに他の目的は、木の有効な構造を維持し
ながら、メモリの有効なパーズ木に高速な接合及び置換
操作を提供することである。

本発明のさらに他の目的は、以下の事項を行なえるよ
うにすることである。

−ｎ元のノード（すなわち、任意の数のノードが接続さ
れたノード）を使用した木の記憶、したがって記憶空間
の大幅な節約。

−パーズ木内のノードの子が有効なタイプのものであ
り、かつ有効な順序であることの効率的なチェック。

−ノードの特定な子の後へのサブツリーのリストの接
合、ならびに結果として得られるノード及びその子が構
文的に正しいことの確認。

−特定のノードの下のサブツリーのリストの、サブツリ
ーの新しいリストとの置換、ならびに結果として得られ
るノード及びその子が構文的に正しいことの確認。

D.問題点を解決するための手段 本発明の一態様によれば、以降の操作のために、１つ
または複数の関連するｎ元のデータ要素ないしノードの
１つまたは複数のグループを収集する編集方法が提供さ
れる。収集される木内のすべてのノードが選択され、こ
のように選択された各最高位のノードが識別される。識
別された最高位のノードについて、すべての選択された
子孫が識別される。子孫は次いで最高位のノードに接続
され、相対階層が子孫と最高位ノードの間のものとして
保存される単純に接続されたサブツリーを形成する。

本発明の他の態様によれば、１つまたは複数の単純に
接続されたｎ元のデータ要素ないしノードの１つまたは
複数のグループを、木から削除する編集方法が提供され
る。上記の木の１つまたは複数の単純に接続されたノー
ドの１つまたは複数のグループは、削除するために選択
される。ノードの各選択されたグループの最上位のノー
ドの親ノードが識別される。ノードの各選択されたグル
ープの子も識別される。次いで、ノードの選択されたグ
ループが削除される。最後に、ノードの各削除されたグ
ループの子は、各削除されたグループの最上位ノードの
親に接続される。

本発明のさらに他の態様によれば、ｎ元のデータ要素
ないしノードのサブツリーを、選択されたノードを中心
とする木に挿入する方法が提供される。サブツリーのリ
ストが提供され、ターゲット・ノードが選択される。タ
ーゲット・ノードの親ノードとの接続が断たれる。サブ
ツリーのリストが親ノードに、その子として接続され
る。最後に、接続が断たれたターゲット・ノードが、タ
ーゲット・ノード及びその子を接続できる親ノードの最
下位ノードの最初のものを判断するための所定の順序の
テストによって、サブツリーのリストに接続される。子
のような接続を行なえるという判断が行なわれた場合
に、ターゲット・ノードが接続される。

本発明のさらにまた他の態様によれば、ｎ元のデータ
要素ないしノードの１つまたは複数のサブツリーを、選
択されたノードに接続された木に挿入する方法が提供さ
れる。１つまたは複数のサブツリーのリストが提供さ
れ、ターゲット・ノードが選択される。ターゲット・ノ
ードの子の接続が断たれる。サブツリーのリストがター
ゲット・ノードへ、その子として接続される。最後に、
接続の断たれた子を接続できるサブツリーのリストの最
下位のノードの最初のものを判断するための所定の順序
のテストによって、接続の断たれた子がサブツリーのリ
ストに接続される。このような接続を行なえるという判
断が行なわれた場合に、子が接続される。

本発明のさらにまた他の態様によれば、一連の規則に
したがって木構造を形成するために相互接続されるノー
ドを生成し、取り扱う構造エディタにおいて、最初のノ
ードを２番目のノードに接続できるかどうかを判断する
方法が提供される。本発明のこの態様によれば、木を形
成する一連のノードの少なくとも若干のものに対して、
ノードのタイプ、及びノードに対してその子として接続
することが可能なノードの配列に関する、上述の規則の
セットからの規則の１つまたは複数のサブセットが定義
される。ただし、規則が第１及び第２レベルのものであ
るというように、ノードのタイプは相互に異なっている
可能性のあるものである。第１レベルの規則はその規則
を適用した場合に、他の規則を適用せずに所定のノード
が接続できるかどうかを判断するものである。第２レベ
ルの規則は他の第２レベルの規則を介して、所定のノー
ドが接続できるかどうかを判断するための第１レベルの
規則の少なくとも１つを、直接または間接に参照する。
２つまたはそれ以上のノードの接続を必要とする操作を
実施した場合、他のノードが接続されるノードに基づい
て、これらの規則が適用される。

最後に、本発明のさらにまた他の態様によれば、デー
タ要素ないしノードが複写、削除、移動または挿入され
る構造エディタにおいて、ノードを互いに接続するため
の方法が提供される。木に接続されるノードが選択され
る。階層関係、及び選択されたノードと既存の木の間の
順序関係に関する第１セットの規則が提供される。第１
セットの規則が選択されたノードに関して使用されて、
木のノードに対する１つまたは複数の接続を識別する。
木内のノードに認められる配列に関する第２セットの規
則が提供される。第２セットの規則を使用して、識別さ
れた接続をテストし、第２セットの規則が接続で満たさ
れるかどうかを判定する。第２セットの規則が満たされ
れば、接続が行なわれる。

それ故、本発明が構造エディタの編集操作の融通性を
大幅に改善する手法を提供することが、理解されよう。
木内のノードの任意の選択を、収集、削除、または挿入
などの操作のために識別できる。さらに、構文が強制さ
れるエディタにおいて、本発明は、基礎となる構文を維
持しながら、これらのきわめて融通性の高い操作を可能
とする強力な手法を提供する。

E.実施例 E1.好ましい実施例の概要 本発明は構造エディタにおける融通性の高いスコープ
編集方法に関する。構造エディタを含む典型的な編集シ
ステム構造の構成要素を、第１図に示す。編集システム
はユーザ・インターフェース21、データ操作処理部26、
データ構造記憶装置28、及びオプションの構造構文規則
30を有している。ユーザ・インターフェース21は通常、
編集対象の構造またはステートメントを表示するための
ビデオ表示画面20または類似の装置、情報を入力するた
めのキーボード22、及び画面の表示からデータ項目を選
択するためのマウスなどのポインティング装置24を含ん
でいる。データ操作処理部26は記憶装置28に記憶すべき
データを作成または変更する構造の編集を含む編集機能
を行なう。１実施例において、データ構造を支配する構
文規則は、データ記憶装置30に記憶されている。データ
記憶装置28及び30は固定またはフレキシブル磁気ディス
ク、磁気テープなどの装置である。これが本発明方法を
実施できる環境のひとつに過ぎず、本方法の用途を限定
することを目的とするものでないことが、理解された
い。

好ましい実施例はデータ操作処理部26の一部として、
新規な融通性の高いスコープ編集方法を備えている。融
通性の高いスコープ編集方法は、階層または木構造化デ
ータのデータ・ノードの挿入、削除、複写、または移動
を行なう手段を提供する。本発明は融通性の高いスコー
プ指定（すなわち、たとえば、サブツリーを完成させる
ために制限のない編集操作のためのデータ・ノードの選
択）、及び汎用化されたターゲット指定の提供に関す
る。好ましい実施例を実現するエディタは構造化データ
を、ビデオ表示装置20にグラフィック的に表示すること
ができる。グラフィック表示装置は第2a図の形態を取る
ことができるが、多くの他の形態が可能である。スコー
プ指定及びターゲット指定のためのデータ選択は、ポイ
ンティング装置24を使用し、適切なデータ・ノードを示
すことによって行なわれる。しかしながら、当分野の技
術者には、本発明がグラフィック表示装置を使用した適
用例に限定されるものではなく、ポインティング装置を
使用しないテキスト表示装置を使用して実施できること
が理解されよう。

汎用構造編集操作には、２つの主要なアイディア、す
なわちスコープとターゲットがある。汎用構造編集操作
はデータの構造（すなわち、サブツリー法が行なうのと
同様に、データの間の関係）を直接扱う。さらに、好ま
しい実施例の方法は融通性の高いスコープ指定及び汎用
のターゲットを備えている。すなわち、選択されたデー
タ（スコープ）の間の関係、及びこのデータの移動先ま
たは複写先の位置（ターゲット）に何の制限も課さな
い。

好ましい実施例の汎用のスコープは以降の編集操作の
ために選択された一連のノードである。ノードを選択す
るためのユーザ・インターフェースは、上述のように、
標準インターフェースまたはカストム化インターフェー
スである。ただし、以下の選択操作は、ノードをスコー
プ・セットに追加、または除去するために提案されるも
のである。

scopeSubtree ノードを与え（たとえば、ポインティン
グ装置で示して）、このノード及びすべてのその子孫を
スコープを構成するノードのセットに追加する。ただ
し、与えられたノードが最初のスコープのセット内にあ
った場合には、このノード及びその子をスコープ・セッ
トから除去する。

scopeNode ノードを与え、これをスコープに追加す
る。スコープ・セットに既に存在していた場合には、こ
れをセットから除去する。

scopeRange ２つのノードを与え、この２つのノード
を含む列の下にあるサブツリーを含んでいる兄弟（兄弟
は共通の親を共有するノードであり、この親の下にある
ノードの列のあるノードの次のノードである）の最小の
列を見つけだし、２つのうち最初のノードが既にスコー
プ・セットにある場合には、サブツリーのこの列をスコ
ープ・セットから除去し、それ以外の場合には、これを
セットに追加する。

好ましい実施例の汎用ターゲットは、ノード及びこの
ノードに対する関係として指定される。スコープはター
ゲットに対して複写、または移動され、また指定された
関係にしたがって挿入される。関係は次のようになる。

Left ターゲット・ノードの兄弟として Right ターゲット・ノードの兄弟として Around ターゲット・ノードの親として Within すべてのターゲット・ノードの子が新し
いノードの子となるという、ターゲット・ノードの子と
して 本発明の好ましい実施例の方法は、任意のノードのセ
ット（スコープ）を与えた場合に、移動、複写、挿入、
及び削除操作を提供し、かつ（移動、複写及び挿入の場
合に）汎用のターゲットの指定を行なう。汎用ターゲッ
トは木に対する複雑な変更を１回の自然な工程で行なえ
るようにするが、これは従来技術の方法では、２回の工
程を必要とするものであった。汎用スコープはきわめて
強力な編集操作をもたらすが、これは直感的なものと考
えられるが、他の方法では多くの直感に反した操作を必
要とするものである。

好ましい実施例に含まれる概念は、ノードを単純に接
続するというものである。あるノードから始めて、１つ
または複数の単純な接続を横切ることによって、すべて
の他のノードに到達できるという単純な接続が、ノード
の間に存在する場合、ノードのグループを単純に接続す
ることができる。単純な接続はあるノードから他のノー
ドへのポインタである。

最高のレベルにおいて、本方法は移動、複写、挿入、
及び削除を次の３つの工程に分割する。

1.サブツリーの収集。スコープから作成できるサブツリ
ーのリストを収集する。2.削除。スコープを構成するノ
ードを削除する。3.貼付け。サブツリーのリストをター
ゲット位置に貼り付ける。貼込み操作は汎用ターゲット
を使用し、サブツリーの収集及びスコープのノードの削
除は融通性の高い範囲指定を含んでいる。基本的な移
動、複写、削除、及び挿入操作は、上述の工程の１つま
たは複数を組み合わせることによって遂行される。

これらの基本操作は図面に示されている例によって、
最も良く表わされる。第2a図は以降の操作の範囲に含め
るために選択された８つのノードを有する木を示してい
る。（スコープ・ノードはアステリスクによって示され
ている。）スコープの収集は、第2b図に示すサブツリー
の３要素リストをもたらす。プライム符号（たとえば、
G2′）は、これがオリジナルのノードの複写であること
を示す。（収集及び削除操作が１つの工程に組み合わさ
れた場合、実際のノードは複写ではなく、収集され
る。） スコープを削除すると、第３図に示す構造がもたらさ
れる。

ノードとして第３図のE2を、また汎用ターゲットの関
係として「Around」を選択し、汎用ターゲットにしたが
ってスコープを貼り込むと、第４図に示す構造がもたら
される。

サブツリーの収集を削除と組み合わせ、その後貼込み
を行なった最終結果は、両方の次元におけるこれらの相
対関係（先祖関係及び左から右への兄弟関係）を維持し
ながらの、スコープ・ノードをターゲット位置への移動
となる。削除が行なわれないと、結果は複写操作とな
る。削除だけを行なうと、結果は削除操作となる。さら
に、ノードを木の外部で作成し（スコープに基づかない
で）、次いで貼り込むと、結果はそのノードの木への挿
入となる。

本発明による融通性の高いスコープ編集方法の好まし
い実施例を説明する。本方法の工程の開示に使用される
記述言語の説明を行なう。次いで、好ましい実施例で使
用されるユーティリティ機能すなわち方法、ユーティリ
ティ機能に基づく基本機能、及び融通性の高いスコープ
編集方法の主な工程を説明する主要関数を説明する。主
要関数に続き、構文規則、及び有効な構造に対する構文
チェックを組み込んだ、好ましい実施例の拡張機能を説
明する。次いで、好ましい実施例の拡張機能のユーティ
リティ関数、データ、基本関数及び主要関数の説明を行
なう。詳細にいえば、拡張機能の主要関数は、すべての
構文規則が遵守されていることを確実とする接合及び置
換関数を提供する。

E2.記述言語 本発明の詳細な段階を説明するために、単純な指定言
語を本明細書全体にわたって使用する。関数の説明、関
数の入力及び出力の定義、関数を遂行するのに必要な方
法の工程を含め、本発明を実施する関数を提示する。こ
の言語は以下のステートメントを認める。

割当て ｘ＝ｙの形式の単純な割当てが認められ
る。

If/Otherwise テストを「＝」、「＜＝」などの標準関
係演算子とともに、英語で表現する。テスト結果が真で
あれば、If節のステートメントが実行される。テスト結
果が偽であれば、Otherwise節のステートメントが実行
される。

Caseの式 式のいくつかの相互排除値の間で選択が
行なわれる。式と合致する値のステートメントが実行さ
れる。

While いくつかの条件が真である限り、多数の
ステートメントを実行する。

Return サブルーチンからの成功した戻り。

Fail サブルーチンからの不成功の戻り。戻り
の変更は、これらが項目になる条件に対するルーチンで
行なわれる。

成功または失敗が明示的に検証されない限り、失敗し
たルーチンは呼出しルーチンが失敗したことも意味す
る。成功または失敗が明示的に検証された場合、特定の
呼出しが失敗したときに、検証された状態に基づいた代
替処理が行なわれる。

注釈は角かっこで囲まれる。

変数を宣言する必要はなく、また何らかの特定の値に
初期設定されるとはみなされない。変数はこれらが使用
される方法によって、これらに関連付けられるタイプ
（たとえば、整数対ストリング）を有している。

サブルーチンは名前、ならびに入力または出力パラメ
ータを有するものとして指定され、この後にかっこに入
れられたパラメータが付けられる。サブルーチンは他の
サブルーチンと同じ名前を持っていてもかまわないが、
そのサブルーチンに与えられるパラメータのタイプ及び
数によって区別される。

好ましい実施例に使用されるユーティリティ関数 以下の基本操作が好ましい実施例を実現するのに利用
でき、かつ、たとえば、周知のユーティリティ関数によ
って提供されるものと想定する。

−木を操作するための関数。操作が以下にリストする単
純なものに限定されている限り、木の操作は周知の分野
である。

graft サブツリーのリストをノードの「リーフ」として、そ
のノードの特定の子の後に挿入する（空の子は操作が最
初の子の前に行なわれることを示す）。構文制御形エデ
ィタにおける構文チェックのため、この操作は失敗する
ことがある。好ましい実施例の方法は、graftが構文を
チェックした場合に、この方法が構文的に正しい木を構
築するようになされている。ただし、この方法はgraft
が構文をチェックするか、否かを扱う。

（graft操作内で構文をチェックする方法を提供す
る、好ましい実施例の拡張機能は好ましい実施例の移
動、複写、挿入及び削除操作を説明した後、説明す
る。） replace サブツリーの包括的な範囲を所定の親ノードから切り
放し、次いでこれをサブツリーのリストと置き換える。
構文制御形エディタ内の構文チェックによって、replac
eが失敗することがある。この方法はreplaceが構文をチ
ェックした場合に、この方法が構文的に正しい木を構築
するようになされている。ただし、この方法はreplace
が構文をチェックするか、否かを扱う。

（replace操作内で構文をチェックする方法を提供す
る、好ましい実施例の拡張は好ましい実施例の移動、複
写、挿入及び削除操作を説明した後、説明する。） copyNode 所定のノードと同一な、新しい子のないノードを形成
する。

destroyNode ノードにマークを付け、delete操作の終了時にこれを
破壊できるようにする。この方法は破壊されたノードの
子がどうなるかについて、仮定を行なわない。

createNode 所定のタイプの子のないノードを作成する。単純な構
造化エディタにおいては、すべてのノードは同一のタイ
プのものである。

copySubtree 所定のサブツリーと同一な、新しいサブツリーを作成
する。

destroySubtree サブツリー内のすべてのノードにマークを付け、dele
te操作の終了時にこれを破壊できるようにする。

getParent 所定のノードの親ノードを返すか、あるいはそのノー
ドが親を持っていない場合には、空文字を返す。

getFirstChild 所定のノードの最初の子を返すか、あるいはそのノー
ドが子を持っていない場合には、空文字を返す。

getLastChild 所定のノードの最後の子を返すか、あるいはそのノー
ドが子を持っていない場合には、空文字を返す。

getRightSibling ノードの右側の兄弟を返すか、あるいはそのノードが
その親の最後の子である場合には、空文字を返す。

getLeftSibling ノードの左側の兄弟を返すか、あるいはそのノードが
その親の最初の子である場合には、空文字を返す。

getFirstLeaf サブツリーが与えられた場合、このサブツリー内の最
初のリーフ（子のないノード）を返す。サブツリーのル
ートに子がない場合には、空文字を返す。

getNextLeaf サブツリーとリーフ・ノードが与えられた場合、この
サブツリーの次のリーフ・ノードを返すか、あるいは他
のリーフがない場合には、空文字を返す。

getSubtreeNodes サブツリー内のノードを、セットに追加する。

−セット、特にノードのセットを操作する機能。

create 新しい空のセットを作成する。

copy 何らかの既存のセットのコピーである新しい空のセッ
トを作成する。

destroy 既存のセットを完全に除去する。

insert セットに項目を挿入する。

delete セットから項目を削除する。

query 項目がセットにあるかどうかを判定する。

makeEmpty 与えられたセットを空にする。

isEmpty 与えられたセットが空であるかどうかを判定する。

getFirst セットに項目を返す。任意の項目であってもかまわな
い。

getNext 項目が与えられた場合、最後のgetFirst以降に返され
ていないセットに、任意の項目を返す。なにも残ってい
ない場合には、空文字を返す。

difference あるセットから、これが第２のセットを共通に持って
いる要素を除去する。

−項目のリスト、特にサブツリーのリストを操作する関
数 create 新しい空のリストを作成する。

destroy リストを完全に破壊する。

append 項目を、リストの最後に付加する。

prepend 項目を、リストの最初に付加する。

getFirst リストの最初の項目を返す。

getNext リストとそのリストの項目が与えられた場合、リスト
の次の項目を返すか、あるいは与えられた項目が最後の
ものの場合には、空文字を返す。

基本関数の定義 本発明の好ましい実施例の方法の工程を記述するのに
使用されるサブルーチンの定義を、以下で行なう。

I.findFirstScoped（root,scope,scopeUnder,node）。
サブツリーのルート（このサブツリーの最も上のノー
ド）を与えた場合、スコープ内のノードを示すノード識
別子のセット、どのノードがスコープ内にある子孫を有
しているかを示すノード識別子のセットを与えた場合、
スコープに含まれているサブツリーの最初のノードを返
す。ただし、この場合、「最初」とは子がスコープ内に
あれば、与えられたサブツリーのルートの最も左側の子
として、子がスコープ内にないのであれば、与えられた
サブツリーのルートの最も左側のサブツリーにある最初
のスコープが指定されたノードとして再帰的に定義され
るものである。また、何もないのであれば、前のテスト
を、与えられたサブツリーのルートの残りの子に適用す
る。最初のスコープが指定されたノードの前に残ってい
る子が見つからなければ、与えられたサブツリーのルー
トの下にはスコープが指定されたノードが存在しない。

第２図ないし第４図を参照して説明した前の例に戻る
と、スコープのセットはB1、B3、C2、E1、F1、F2、G1、
及びG2である。scopeUnderのセット（スコープ・セット
内に子孫を持っているノード）はA1、B1、B3、B4、C2及
びD2を含んでいる。サブツリーのルートとしてB1の与え
られた関数findFirstScopedは、最初のスコープが指定
されたノードとしてC2を返す。B2がルートとして指定さ
れた場合、関数は空文字を返す（B2の下には、スコープ
が指定されたノードがない）。B3が指定された場合、こ
の関数はG1を返す。

入力： root ノードで、この下にスコープの最初のノードがあるこ
とが望まれるもの。

scope スコープ内にあるノードのセット。

scopeUnder スコープが指定されたノードの親であるノードのセッ
ト 出力： node 定義にしたがった最初のスコープが指定されたノード 方法： 1.query（scopeUnder,root）が真である場合（ルートの
下にスコープが指定されたノードがある場合） a.child＝getFirstChild（root） b.子が空でなければ［探すことのできる子がまだあれ
ば］ １）query（scope,child）真の場合（子がスコープ内に
ある） ａ）node＝child［子が最初のスコープが指定されたノ
ードである］ ｂ）return ２）それ以外の場合［その子がスコープ内になければ、
その下の最初のスコープが指定されたノードを探す］ ａ）findFirstScoped（chile,scope,scopeUnder,node）
［その子の下の最初のスコープが指定されたノードを探
す］ ｂ）ノードが空でなければ［スコープが指定されたノー
ドが見つかれば］ i.Return［ノードがルートの下の最初のスコープが指定
されたノードであるから、操作を終わる］ ｃ）それ以外であれば［ルートのこの子の下の最初のノ
ードを見つけない］ i.child＝getRightSibling （child）［ルートの次の子を試す］ c.node＝null［最初の子がどこにも見つからなかった］ d.Return 2.それ以外の場合［そのノードの下には、スコープが指
定されたノードが何もない］ a.node＝null［このノードの下には最初のサブツリーが
ない］ II.findNextScoped（root,scope,scopeUnder,prev,nod
e）。サブツリーのルート、スコープのセット、scopeUn
derセット、及び以前のノードを与えた場合、そのルー
トの下の次のスコープが指定されたノードを返す。

第2a図の木の例を想定して、ルートB1及び以前のノー
ドC2を与えた場合、次のノードは空である。ルートB3及
び以前のノードG1を与えた場合、次のノードはG2であ
る。

入力： root ノードで、この下にスコープの次のノードがあること
が望まれるもる。

scope スコープ内にあるノードのセット。

scopeUnder その下にスコープが指定されたノードがあるノードの
セット prev 後で次のスコープが指定されたノードを見つけようと
思うノード 出力： node 定義にしたがった次のスコープが指定されたノード 方法： 1.prevがルートと異なっている場合［他に何か探せるも
のがなければならない］ a.rsib＝getRightSibling（prev） b.rsibが空でない場合（試みることのできる他の兄弟が
ある］ 1.query（scope,rsib）が真であれば［兄弟がスコープ
にある］ ａ）node＝rsib［兄弟が次のスコープが指定されたノー
ドである］ ｂ）Return 2.それ以外の場合［兄弟がスコープ内にないので、その
下の最初のスコープが指定されたノードを見つけだす］ ａ）findFirstScoped（rsib,csope,scopeUnder,node）
［この兄弟の下の最初のスコープが指定されたノードを
見つけだす］ ｂ）ノードが空でない場合［スコープが指定されたノー
ドが見つかった］ i.Return［ノードがprevの後のルートの下の次のスコー
プが指定されたノードであるから、操作を終了する］ ｃ）それ以外の場合［prevのこの兄弟の後に最初のノー
ドが見つからない］ i.rsib＝getRightSibling （rsib）［次の兄弟を試みる］ c.prev＝getParent（prev）［prevの次のどこにも最初
の子が見つからないので、prevの親を試みる］ 2.node＝null［スコープが指定されたノードが見つから
ずにルートに到達したので、prevの後には何もない］ 3.Return III.getFirstSubtree（root,scope,scopeUnder,compSub
trees,Sub,top）。サブツリーのルート・ノード、スコ
ープ・セット、scopeUnderセット、及び完全にスコープ
が指定されたサブツリー・セットを与えた場合、ルート
の下のすべてのスコープが指定されたノードで形成され
た最初に収集されたサブツリーの新しいコピー、及び複
写されたサブツリーの元の木のトップ・ノード識別子を
返す。

第2a図及び第2b図の例の木を想定し、B1を与えた場
合、C2′で始まる新しい「サブ」ツリー及びC2を返す。

入力： root ノードで、この下に最初のスコープが指定されたサブ
ツリーがあることが望まれるもの。

scope スコープ内にあるノードのセット。

scopeUnder その下にスコープが指定されたノードがあるノードの
セット compSubtrees スコープが指定されたノードだけで、そのサブツリー
が作られているノードのセット 出力： sub 見つかった最初の新しいサブツリー top 最初のスコープが指定されたサブツリーの一番上にあ
る古いノード 方法： 1.findFirstScoped（root,scope,scopeUnder,top）［最
初のサブツリーの一番上を捕捉する］ 2.topが空の場合［第２のスコープが指定されたノード
が見つからなかったので、サブツリーが何もない］ a.sub＝null［サブツリーがない］ b.Return 3.それ以外の場合［サブツリーのtopが見つかったの
で、その下のサブツリーを収集する］ a.query（compSubtrees,top）の場合［完全なサブツリ
ーがスコープ指定されているかどうか、調べる］ １）copySubtree（top,sub）［完全なサブツリーを複写
する］ b.それ以外の場合［topの下のサブツリー全体がスコー
プ指定されていない。スコープが指定されたサブツリー
の断片を収集する］ １）sub＝copyNode（top）［一番上のスコープが指定さ
れたノードの新しいコピーを作成する］ ２）create（list）［リストを取って、これにサブツリ
ーを収集する］ ３）addSubtrees（top,scope,scopeUnder,compSubtree
s,list） ４）isEmpty（list）の場合［収集するサブツリーがな
い］ ａ）Return［subが存在しているすべてのサブツリーで
ある］ ５）それ以外の場合 ａ）graft（sub,null,list,status）［サブツリーのリ
ストを最初のバンチとして、subに置く］ ｂ）destroy（list）［もはや、リストは必要ない］ ｃ）Return IV.getNextSubtree（root,scope,scopeUnder,compSubtr
ees,prev,sub,top）。サブツリーのルート・ノード、ス
コープ・セット、scopeUnderセット、完全にスコープが
指定されたサブツリーのセット、及び以前のノード識別
子を与えた場合、prevの後のルートの下のすべてのスコ
ープが指定されたノードで形成された、次の収集された
サブツリーの新しいコピー、及びサブツリーが複写され
た元の木のトップ・ノードの識別子を返す。

第2a図及び第2b図の例の木を想定し、ルートとしてB3
を、またprevとしてG1を与えた場合、このルーチンはG
2′で始まる新しい「サブ」ツリー及びG2を返す。ある
いは、ルートとしてB1を、またprevとしてC2を与えた場
合、このルーチンはサブツリーとして、またtopとして
空文字を返す。

入力： root ノードで、この下にスコープが指定された最初のノー
ドがあることが望まれるもの。

scope スコープ内にあるノードのセット。

scopeUnder その下にスコープが指定されたノードがあるノードの
セット compSubtrees スコープが指定されたノードだけで、そのサブツリー
が作られているノードのセット prev 以前のサブツリーの一番上のノード 出力： sub prevの後で見つかった次の新しいサブツリー top prevの後の次のスコープが指定されたサブツリーのto
pである古いノード 方法： 1.findNextScoped（root,scope,scopeUnder,prev,top）
［次のサブツリーのtopを捕捉する］ 2.topが空の場合［スコープが指定されたノードが見つ
からなかったので、サブツリーが何もない］ a.sub＝null［サブツリーがない］ b.Return 3.それ以外の場合［サブツリーのtopが見つかったの
で、その下のサブツリーを収集する］ a.query（compSubtrees,top）の場合［完全なサブツリ
ーがスコープ指定されているかどうか、調べる］ １）copySubtree（top,sub）［完全なサブツリーを複写
する］ b.それ以外の場合［topの下のサブツリー全体がスコー
プ指定されていない。スコープが指定されたサブツリー
の断片を収集する］ １）sub＝copyNode（top）［一番上のスコープが指定さ
れたノードの新しいコピーを作成する］ ２）create（list）［リストを取って、これにサブツリ
ーを収集する］ ３）addSubtrees（top,scope,scopeUnder,compSubtree
s,list） ４）isEmpty（list）の場合［収集するサブツリーがな
い］ ａ）Return［subが存在しているすべてのサブツリーで
ある］ ５）それ以外の場合 ａ）graft（sub,null,list,status）［サブツリーのリ
ストを最初のバンチとして、subに置く］ ｂ）destroy（list）［もはや、リストは必要ない］ ｃ）Return V.addSubtees（root,scope,scopeUnder,compSubtrees,l
ist）。所定のサブツリーのルート・ノード、スコープ
・セット、scopeUnderセット、完全にスコープが指定さ
れたサブツリーのセット、及びサブツリーのリストを与
えた場合、スコープが指定されたノードから収集された
ルートの下のサブツリーを、リストに追加する。

第2a図及び第2b図の例の木を想定し、B1と空のリスト
を与えた場合、このルーチンはC2′がトップとなったサ
ブツリーを含んでいるリストを返す。B2と空のリストを
与えた場合、これは空のリストを返す。B3と空のリスト
を与えた場合、これはG1′及びG2′を含んでいるリスト
を返す。

入力： root ノードで、この下にサブツリーを収集しなければなら
ないもの。

scope スコープ内にあるノードのセット。

scopeUnder その下にスコープが指定されたノードがあるノードの
セット compSubtrees スコープが指定されたノードだけで、そのサブツリー
が作られているノードのセット list 新しいサブツリーが追加されるリスト 出力： list 新しいサブツリーが追加されるリスト 方法： 1.getFirstSubtree（root,scope,scopeUnder,compSubtr
ees,sub,top）［最初のサブツリーのtopを捕捉する］ 2.subが空でない場合［まだ、サブツリーが残ってい
る］ a.append（list,sub）［サブツリーをリストに追加す
る］ b.getNextSubtree（root,scope,scopeUnder,compSubtre
es,top,sub,top）［次のサブツリーを取得して、追加す
る］ VI.buildScopeUnder（scope,scopeUnder）。スコープ・
セットを与えた場合、その下にスコープが指定されたノ
ードを有するノードのセットを返す。

サンプルの入力と出力については、 findFirstScopedの例を参照されたい。

入力： scope スコープ内にあるノードのセット。

出力： scopeUnder その下にスコープが指定されたノードがあるノードの
セット 方法： 1.node＝getFirst（scope）［スコープからノードを取
り出す］ 2.ノードが空でない場合［まだ、スコープにノードが残
っている］ a.parent＝getParent（node） b.親が空でなく、query（scopeUnder,parent）が真でな
い場合［これまでに追加されていなかった、追加される
親が残っている］ １）insert（scopeUnder,parent）［ノードをセットに
追加する］ ２）parent＝getParent（parent）［次の親を取得し
て、追加する］ c.node＝getNext（scope）［次の任意のノードをスコー
プから引き出す］ VII.collectTrees（tree,scope,compSubtrees,list）。
完全な木のルート・ノード、スコープ内にあるノード識
別子のセット、及び完全にスコープが指定されたサブツ
リーのセットを与えた場合、スコープ内のノードから収
集された複写されたサブツリーのリストを返す。

第2a図及び第2b図の例の木を想定し、A1に基づく木、
ならびにB1、B3、C2、E1、F1、F2、G1、及びG2を含んで
いるセットをスコープとして与えた場合、このルーチン
はサブツリーB1′、B3′及びE1′をこの順序で含んでい
るリストを返す。

入力： tree サブツリーを収集する木のルート scope スコープ内にあるノードのセット。

compSubtrees スコープが指定されたノードだけで、そのサブツリー
が作られているノードのセット list 新しいサブツリーが追加されるリスト 方法： 1.create（scopeUnder）［その下にスコープが指定され
たノードを有しているノードを保持するセットを作成す
る］ 2.buildScopeUnder（scope,scopeUnder）［scopeUnder
セットを作成する］ 3.addSubtrees（tree,scope,scopeUnder,compSubtrees,
list）［サブツリーをリストに入れる］ VIII.deleteConnected（node,scope,compSubtrees,lis
t）。木内でスコープが指定されたノード、スコープが
指定されたノード識別子のセット、完全にスコープが指
定されたサブツリーのセット、及びサブツリーのリスト
を与えた場合、識別されたノード、及びノード自身に接
続されたスコープが指定されたノードを削除し、削除さ
れたノードを差し引いたスコープのセットを返し、あら
ゆる孤児のサブツリーをリストに付け加える（孤児のサ
ブツリーとは、親が削除されてしまったサブツリーであ
る）。

第2a図の例の木を想定し、B1を与えた場合、このルー
チンはB1、C2、F1、及びF2を削除し、未変更のリストを
返す。B3を与えた場合、このルーチンはB3を削除し、D1
及びD2をリストの終りに追加する。

入力： node 削除が開始されるノード scope スコープ内にあるノードのセット。

compSubtrees スコープが指定されたノードだけで、そのサブツリー
が作られているノードのセット list スコープが指定されたノードが削除された後残ってい
るサブツリーが追加されるリスト 出力： scope スコープ内にあるノードのセット。

list スコープが指定されたノードが削除された後残ってい
るサブツリーが追加されるリスト 方法： 1.query（compSubtrees,node）の場合［完全なサブツリ
ーがスコープ指定されているかどうか、調べる］ a.getFirstChild（node）が空の場合［サブツリーがノ
ードだけで構成されているかどうか、調べる］ １）delete（scope,node）［ノードは子を持っていな
い。単純なdeleteを使用して、これをスコープから除去
する］ ２）desroyNode（node） b.それ以外の場合［サブツリーに２つ以上のノードがあ
る］ １）create（subtreeNodes）［サブツリーにノードを保
持するセットを作成する］ ２）getSubtreeNodes（node,subtreeNodes）［サブツリ
ー内のノードのセットを取得する］ ３）difference（scope,subtreeNodes）［スコープから
ノードを除去する］ ４）destroy（subtreeNodes） ５）destroySubtree（node）［サブツリーを削除する］ 2.それ以外の場合 a.delete（scope,node）［このノードをスコープから除
去する］ b.child＝getFirstChild（node）［ノードの子を取得す
る］ c.子が空でない場合［また子が残っている］ １）query（scope,child）が真の場合［子がスコープ内
にある］ ａ）deleteConnected（child,scope,compSubtrees,los
t）［再帰して、子に接続されているノードを削除し、
リストに追加する］ ２）それ以外の場合［子がスコープ内にない］ ａ）append（list,child）［leftoverノードをleftover
ノード・リストに追加する］ ３）child＝getRightSibling（child）［次の子を取得
する］ d.destroyNode（node）［削除したノードを破壊する］ IX.deleteTrees（tree,scope,compSubtrees）。木全体
のルート、削除を試みるスコープが指定されているノー
ド識別子のセット、及び完全にスコープが指定されたサ
ブツリーのセットを与えた場合、スコープ・セットで識
別されたノードを、木から削除し、空のセットを返す。

入力： tree 削除が行なわれる木のルート scope スコープ内にあるノードのセット。

compSubtrees スコープが指定されたノードだけで、そのサブツリー
が作られているノードのセット 出力： scope スコープ内に残っているノードのセット（削除後は何
もなくなる） 方法： 1.create（orphanList）［削除されたノードの子のリス
トを作成する］ 2.isEmpty（scope）が真でない場合［まだ削除できるノ
ードがある］ a.node＝getFirst（scope）［開始するノードを取得す
る］ b.parent＝getParent（node）［親ノードを取得する］ c.親が空でなく、query（scope,parent）が真の場合
［削除するノードの一番上まで上昇する］ １）node＝parent（ノードが一番上でなかった］ ２）parent＝getParent（node） d.親が空の場合［ルートがスコープ指定されており、削
除された］ １）Fail［ルートを削除するのは違法であり、失敗す
る］ e.lastToReplace＝getLastChild（parent） f.query（scope,lastToReplace）でない場合［スコープ
が指定された最後の子を見つける］ １）lastToReplace＝getLeftSibling（lastToReplace） g.firstToReplace＝getFirstChild（parent） h.query（scope,firstToReplace）でない場合［スコー
プが指定される最初の子を見つける］ １）firstToReplace＝getRightSibling（firstToReplac
e） i.child＝firstToReplace j.prevChild＝null k.prevChildがlastToReplaceでない場合［親の最初にス
コープが指定された子と、最後にスコープが指定された
子の間の範囲をループ。スコープ内のノードを削除し、
親が養子にしなければならない孤児になったサブツリー
を収集する］ １）query（scope,child）［子にスコープが指定されて
いるかどうか調べる］ a.deleteConnected（shild,scope,compSubtrees,orphan
List）［子の下のスコープが指定されたノードを、子を
含めて削除する。孤児になったサブツリーを収集する］ ２）それ以外の場合［子にスコープが指定されていな
い］ a.append（orphanList,child）［firstToReplaceとlast
ToReplaceの間のノードの範囲を置き換えのノードのリ
ストに、子を追加する］ ３）prevChild＝child ４）child＝getRightSibling（child） l.replace（parent,firstToReplace,lastToReplace,orp
hanList,Status）［firstToReplaceとlastToReplaceの
間のノードを、orphanListのノードと置き換える］ m.makeEmpty（orphanList）［孤児のリストのクリーン
アップを行なう］ 3.destroy（orphanList） X.removeScoped（root,scope,scopeUnder,compSubtree
s,unremovedList）。所定のサブツリーに対するスコー
プが指定されたルートのノード、スコープ・セット、sc
opeUnderセット、完全にスコープが指定されたサブツリ
ーのセット、及び未除去サブツリーのリストを与えた場
合、未除去のサブツリーのリストに、除去されないルー
トの下のあらゆるサブツリーを付け加え、ルートの下の
すべてのスコープが指定されたノードを木から除去す
る。

第2a図の例の木を想定し、B1及び空の未除去リストを
与えた場合、このルーチンは未除去のリストにC1を返
し、B1、C2、F1、及びF2を除去する。B3及び空の未除去
リストを与えた場合、D1及びD2を返し、B3、G1、及びG2
を除去する。

入力： root ノードで、この下でスコープが指定されたノードが除
去されるもの。

scope スコープ内にあるノードのセット。

scopeUnder その下にスコープが指定されたノードがあるノードの
セット compSubtrees スコープが指定されたノードだけで、そのサブツリー
が作られているノードのセット unremovedList 未除去のサブツリーが追加されるリスト 出力： scope スコープ内にあるノードのセット。

unremovedList 新しい未除去のサブツリーが追加されたリスト 方法： 1.query（compSubtrees,root）の場合［サブツリー全体
にスコープが指定されているかどうかを調べる。指定さ
れている場合には、スコープの更新だけを行なう］ a.getFirstChild（root）が空の場合［サブツリーがル
ートだけで構成されているかどうかを調べる］ １）delete（scope,root）［ルートに子がない。単純な
deleteを使用して、スコープからこのルートを除去す
る］ b.それ以外の場合［サブツリーに２つ以上のノードがあ
る］ １）create（subtreeNodes）［サブツリー内でノードを
保持するセットを作成する］ ２）getSubtreeNodes（root,subtreeNodes）［サブツリ
ー内のノードのセットを取得する］ ３）difference（scope,subtreeNodes）［ノードをスコ
ープから除去する］ ４）destroy（subtreeNodes） 2.それ以外の場合 a.delete（scope,root）［このノードをスコープから除
去する］ b.create（removedList）［除去されたサブツリーをル
ートの下に保持するリストを作成する。これらのサブツ
リーを収集してから、ルートに接続する］ c.lastToReplace＝getLastChild（root） d.lastToReplaceが空でなく、query（scope,lastToRepl
ace）の場合［スコープが指定されていない最後の子を
見つける］ １）lastToReplace＝getLeftSibling（lastToReplace） e.lastToReplaceが空でない場合［すべての子にスコー
プが指定されている場合、lastToReplaceは空となり、
この場合、子はどれも置換されない］ １）firstToReplace＝getFirstChild（root） ２）query（scope,firstToReplace）の場合［範囲が指
定されていない最初の子を見つける］ ａ）firstToReplace＝getRightSibling（firstToReplac
e） f.child＝getFirstChild（root） g.replaceRange＝false h.子が空でない場合 １）query（scope,child）［子にスコープが指定されて
いるかどうか調べる］ ａ）removeScoped（child,scope,scopeUnder,compSubtr
ees,unremovedList）［接続されたスコープが指定され
たノードの除去を再帰する］ ｂ）replaceRange＝trus［置換される子の範囲内にある
かどうかを調べる］ i.append（removedList,child）［すべてが行なわれた
場合に、子をルートに接続しなければならない。この子
を、再接続される子のリストに追加する］ ２）それ以外の場合 ａ）child＝lastToReplace i.replaceRange＝false［もはや、置換される子の範囲
にはない］ ｂ）それ以外の場合 i.replaceRange＝true［置換する必要のある子の範囲内
にある］ ｃ）query（scopeUnder,child）の場合［子の子孫にス
コープが指定されているかどうか調べる］ i.removeSubtrees（child,scope,scopeUnder,compSubtr
ees,removedList）［スコープの指定されたノードを除
去し、ルートに接続される除去されたサブツリーを収集
する］ ｄ）append（unremovedList,child）［子が除去されな
いので、この子に未除去のサブツリーのリストを追加す
る］ ３）child＝getRightSibling（child）［次の子を処理
する］ i.lastToReplaceが空でない場合［ルートが少なくとも
１つのスコープが指定されていない子を持っている場合
には、置換だけを行なう］ １）replace（root,firstToReplace,lastToReplace,rem
ovedList）［除去されたノードのリストを有しているル
ートの子を置換し、これによって除去されたサブツリー
を作成する］ j.destroy（removedList） XI.removeImmediate（root,firstScopedChild,scope,sc
opeUnder,compSubtrees,list）。スコープが指定されて
いる子を有しているスコープが指定されていないルート
のノード、ルートの最初のスコープが指定された子、ス
コープ・セット、scopeUnderセット、完全にスコープが
指定されたサブツリーのセット、及びサブツリーのリス
トを与えた場合、リストに、最初のスコープが指定され
た子の下で、その右側にあるスコープが指定されたノー
ドから収集されたルートの下のサブツリーに付け加え、
スコープが指定されたノードをルートの下から除去す
る。

第２図の例の木を想定し、A1、B1及び空のリストを与
えた場合、このルーチンはB1、B3、及びE1を含むリスト
を返し、B1、B3、C2、E1、F1、F2、G1及びG2を削除す
る。D2、G1及び空のリストを与えた場合、G1及びG2を含
むリストを返し、G1及びG2を木から除去する。

入力： root ノードで、この下からサブツリーが除去されるもの。

firstScopedChild スコープが指定されるルートの下のfirstScopedChild scope スコープ内にあるノードのセット。

scopeUnder その下にスコープが指定されたノードがあるノードの
セット compSubtrees スコープが指定されたノードだけで、そのサブツリー
が作られているノードのセット list 新しいサブツリーが追加されるリスト 出力： scope スコープ内にあるノードのセット。

list 新しいサブツリーが追加されたリスト 方法： 1.create（unremovedList）［木から除去されないが、
収集されなければならないサブツリーを保持するリスト
を作成する］ 2.lastToReplace＝getLastChild（root） 3.query（scope,lastToReplace）でない場合［スコープ
が指定される最後の子を見つける］ a.lastToReplace＝getLeftSibling（lastToReplace） 4.child＝firstScopedChild 5.replaceRange＝false 6.子が空でない場合［子を通ってループする。各子の下
のスコープが指定されたノードを除去する］ a.query（scope,child）の場合［子はスコープが指定さ
れたか］ １）child＝lastToReplaceの場合 ａ）replaceRange＝false［もはや、置換される子の範
囲にはない］ ２）それ以外の場合 ａ）replaceRange＝true［置換する必要のある子の範囲
内にある］ ３）removeScoped（child,scope,scopeUnder,compSubtr
ees,unremovedList）［スコープが指定されたノード、
及びそのスコープが指定された子孫のすべてを除去す
る。すべての未除去のサブツリーをリストに付け加え
る］ ４）append（list,child）［子を、除去されたサブツリ
ーのリストに追加する］ b.それ以外の場合 １）query（scopeUnder,child）［子はスコープが指定
された子孫を持っているか］ ａ）removeSubtrees（child,scope,scopeUnder,compSub
trees,list）［スコープが指定された子孫を除去する］ ２）replaceRange＝trueの場合［置換される子の範囲内
にあるかどうかを調べる］ ａ）append（unremovedList,child）［子の除去を行な
ってから、この子を、親の下に再挿入する］ c.child＝getRightSibling（child）［次の子を処理す
る］ 7.replace（root,firstScopedChild,lastToReplace,unr
emovedList）［スコープが指定された子を含んでいる子
の範囲を、その範囲からのすべての未除去のサブツリー
と置き換える］ 8.destroy（unremovedList） XII.removeSubtrees（root,scope,scopeUnder,compSubt
rees,list）。所定のサブツリーのスコープが指定され
ていないルート・ノード、スコープ・セット、scopeUnd
erセット、完全にスコープが指定されたサブツリーのセ
ット、及びサブツリーのリストを与えた場合、リスト
に、スコープが指定されたノードから収集されたルート
の下のサブツリーを付け加え、ルートの下からスコープ
が指定されたノードを除去する。

第２図の例の木を想定し、B2及び空のリストを与えた
場合、このルーチンは空のリストを返す。D2及び空のリ
ストを与えた場合、G1及びG2を含んでいるリストを返
し、木からG1及びG2を削除する。

入力： root ノードで、この下からサブツリーが除去されるもの。

scope スコープ内にあるノードのセット。

scopeUnder その下にスコープが指定されたノードがあるノードの
セット compSubtrees スコープが指定されたノードだけで、そのサブツリー
が作られているノードのセット list 新しいサブツリーが追加されるリスト 出力： scope スコープに残っているノードのセット（removeの後に
は何もない） list 新しいサブツリーが追加されたリスト 方法： 1.getFirstScoped（root,scope,scopeUnder,top）。
［最初のサブツリーのtopを捕捉する］ 2.topが空でない場合［まだ他にサブツリーが残ってい
る］ a.parent＝getParent（top） b.removeImmediate（parent,top,scope,scopeUnder,com
pSubtrees,list）［親の残っているスコープが指定され
た子孫を除去し、リストを更新する］ c.それ以外の場合 １）getNextScoped（root,scope,scopeUnder,parent,to
p）［追加する次のサブツリーを取得し、topが（親のす
べての他のスコープが指定された子孫とともに）除去さ
れているので、親から探索を開始する］ XIII.removeTrees（tree,scope,compSubtrees,list）。
木全体のルート、除去を試みるノード識別子のセット、
及び相補のスコープが指定されたサブツリーのセットを
与えた場合、スコープが指定されたノードから収集され
たサブツリーのリストを返し、スコープの指定されたノ
ードを木から削除する。removeTreesはcollectTreesを
呼び出し、次いでdeleteTreesを呼び出すのと同じ機能
を果たすが、removeTreesの方が効率がよい。

第２図の例の木を想定し、A1に基づく木、ならびにB
1、B3、C2、E1、F1、F2、G1、及びG2を含むセットをス
コープとして与えた場合、このルーチンはサブツリーC
2、C3、及びE1をこの順序を含んでいるリストを返し、B
1、B3、C2、E1、F1、F2、G1、及びG2を木から削除す
る。

入力： tree 木のルートで、これから木が除去される scope スコープ内にあるノードのセット。

compSubtrees スコープが指定されたノードだけで、そのサブツリーが
作られているノードのセット 出力： scope スコープに残っているノードのセット （removeの後には何もない） list 木から除去されたサブツリーのリスト 方法： 1.create（scopeUnder）［その下にスコープが指定され
たノードを有しているノードを保持するセットを作成す
る］ 2.buildScopeUnder（scope,scopeUnder） ［scopeUnderセットを作成する］ 3.query（scope,tree）の場合［トップ・ノードにスコ
ープが指定されているかどうか調べる］ a.parernt＝getParent（tree）［ノードにスコープが指
定されている。その親を取得する］ b.親が空の場合［木がルートであるかどうか調べる］ １）Fail［ルートを除去できない］ c.create（unremovedList） d.removeScoped（tree,scope,scopeUnder,compSubtree
s,unremovedList）［トップ・ノード及びそのスコープ
が指定された子孫を除去し、未除去のサブツリーのリス
トを返す］ e.replace（parent,tree,tree,unremovedList,status）
［木を未除去のサブツリーと置き換える］ f.append（list,tree）［木を除去されたサブツーのリ
ストに入れる］ g.destroy（unremovedList） 4.それ以外の場合 a.removeSubtrees（tree,scope,scopeUnder,compSubtre
es,list）［トップ・ノードにスコープが指定されてい
ない。サブツリーを除去し、これらをリストに入れる］ XIV.insertLeft（node,list）。サブツリーのリストを
木の所定のノードの左側へ挿入する。

入力： node 左側へ挿入するノード list 挿入するサブツリーのリスト 方法： 1.parent＝getParent（node）［ノードの親を見つけ
る］ 2.prev＝getLeftSibling（node）［その後に挿入を行な
うノードを決定する］ 3.graft（parent,prev,list,status）［木を挿入する］ XV.insertRight（node,list）。サブツリーのリストを
木の所定のノードの右側へ挿入する。

入力： node 右側へ挿入するノード list 挿入する木のリスト 方法： 1.parent＝getParent（node）［ノードの親を見つけ
る］ 2.graft（parent,node,list,status）［木を挿入する］ XVI.insertAround（node,list）。サブツリーのリスト
を、リストのサブツリーの１つのリーフの１つの子とし
て、所定のノードを有しているそのノードの親の子とし
て挿入する。選択されたリーフは、所定のノードが適合
する最初のリーフである。

入力： node 周囲へ挿入されるノード list 挿入する木のリスト 方法： 1.parent＝getParent（node）［ノードの親を見つけ
る］ 2.prev＝getLeftSiblig（node）［その後に挿入を行な
うノードを決定する］ 3.create（childList）［接合するダミーのリスト］ 4.append（childList,node）［後で接合するためにノー
ドを記憶する］ 5.replace（parent,node,node,list,status）［ノード
を除去し、これをリストと置き換える］ 6.tree＝getFirst（list） 7.木が空でない場合［リスト内の木を繰り返す］ a.leaf＝getFirstLeaf（tree） b.リーフが空でない場合［木のリーフを繰り返す］ １）graft（leaf,null,childList,status） ２）status＝okの場合 ａ）return［周囲への挿入の成功］ ３）left＝getNextLeaf（tree,leaf）［次の木を試み
る］ c.tree＝getNext（list,tree）［次の木を試みる］ 8.fail［試みることのできる木が他にない。不成功］ XVII.insertWithin（node,list）。サブツリーのリスト
を、リストのサブツリーの１つのリーフの１つの子とし
て、所定のノードの子を有しているそのノードの子とし
て挿入する。選択されたリーフは、子が適合する最初の
リーフである。

入力： node 内部へ挿入されるノード list 挿入する木のリスト 方法： 1.parent＝node［内部に挿入される親を見つける］ 2.create（childList） 3.node＝getFirstChild（node）［最初の子を見つけだ
す］4.ノードが空でない場合［子を走査する］ a.append（childList,node）［子を思い出す］ b.node＝getRightSibling（node）［次の子］ 5.replace（parent,getFirstChild（parent）,getLastC
hild（Parent）,list,status）［子をすべてリストと置
き換える］ 6.tree＝getFirst（list） 7.木が空でない場合［リストの木を繰り返す］ a.leaf＝getFirstLeaf（tree） b.リーフが空でない場合［木のリーフを繰り返す］ １）graft（leaf,null,childList,status） ２）status＝okの場合 ａ）Return［内部への挿入の成功］ ３）leaf＝getNextLeaf（tree,leaf）［次のリーフを試
みる］ c.tree＝getNext（list,tree）［次の木を試みる］ 8.fail［試みることのできる木が他にない。不成功］ XVIII.insertTrees（node,relation,list）。ターゲッ
ト・ノード、このターゲット・ノードとの関係、及び挿
入されるサブツリーのリストを与えた場合、ターゲット
・ノードに対する関係で、サブツリーを挿入する。

入力： node 内部へ挿入されるノード relation ノードに対するターゲットの関係 list 挿入する木のリスト 方法： 1.次のCaseの関係 a.left １）insertLeft（node,list） b.right １）insertRight（node,list） c.around １）insertAround（node,list） d.within １）insertWithin（node,list） XIX.checkcompSubtree（node,scope,sompSubtrees,alre
adyChecked）。ノード、スコープ・セット、完全にスコ
ープが指定されたサブツリーを持っていることが既にわ
かっているノードのセット、及び完全なスコープが指定
されたサブツリーについて既にチェック済みのノードの
セットを与え場合、ノードの下のサブツリーがスコープ
の指定されたノードだけで作成されているかどうかを示
す。

入力： node チェックの対象となるサブツリーのルート scope スコープ内にあるノードのセット。

compSubtrees スコープが指定されたノードだけで構成されているサブ
ツリーを有していることが既にわかっているノードのセ
ット alreadyChecked 既にcheckCompSubtreeによってチェックされているスコ
ープ内のノードのセット 出力： compSubtrees スコープが指定されたノードだけで構成されているサブ
ツリーを有していることがわかっているノードのセット alreadyChecked checkCompSubtreeによってチェックされているスコープ
内のノードのセット 方法： 1.query（scope,node）の場合［ノードがスコープ内に
あるかどうか調べる］ a.query（alreadyChecked,node） ［checkCompSubtreeが既にこのノードをチェックしたか
どうかを調べる］ １）return b.Insert（alreadyChecked,node）［ノードを、checkCo
mpSubtreeがチェックを行なったノードのセットに追加
する］ c.child＝getFirstChild（node） d.子が空でない場合［ノードの子がまだある間ループす
る］ １）checkCompSubtree（child,scope,compSubtrees,Alr
eadyChecked）［子の下のサブツリーに完全にスコープ
が指定されているかどうかをチェックし、指定されてい
る場合には、ノードをcompSubtreesに追加する］ ２）query（compSubtrees,child）でない場合 a.return ３）child＝getRightSibling（child） ［次の子をチェックする］ e.insert（compSubtrees,node）［ノードにスコープが
指定されており、すべてのその子のサブツリーにスコー
プが指定されているのであるから、ノードのサブツリー
にはスコープが指定される］ XX.buildcompSubtrees（scope,compSubtrees）。スコー
プ・セットを与えた場合、スコープが指定されているノ
ードだけで構成されているサブツリーのルートであるノ
ードのセットを返す。どのサブツリーにスコープが完全
に指定されているかを判断するが、これは完全なサブツ
リーとともに操作した場合に、collectTrees,removeTre
es及びdeleteTrees操作が近道を通れるからである。

第２図の例の木を想定した場合、このノードのセット
はC2、F1、F2、G1、G2、及びE1を含む。

入力： scope スコープ内にあるノードのセット。

出力： compSubtees スコープが指定されたノードだけで、そのサブツリーが
作られているノードのセット 方法： 1.create（alreadyChecked）［完全なサブツリーについ
てチェックされたノードのセットを初期設定する］ 2.node＝getFirst（scope）［ノードをスコープから取
り出す］ 3.ノードが空でない場合［スコープ内に他のノードがあ
る間ループする］ a.checkCompSubtree（node,scope,compSubtrees,alread
yChecked）［ノードの下のサブツリーに完全にスコープ
が指定されているかどうかをチェックし、指定されてい
る場合には、ノードをcompSubtreesに追加する］ b.node＝getNext（scope）［次の任意のノードをスコー
プから取り出す］ 4.destroy（alreadyChecked） 主な関数 以下の関数は上述のサブルーチンを使用して定義され
る。これらの関数は汎用化された構造編集操作、すなわ
ち削除、複写、移動、挿入の高レベルの視点を提供す
る。第11図は以下で説明する処理の流れを示す。データ
を取り扱う工程を中心に検討を行なうが、スコープ、操
作のタイプ、ターゲット・ノード、及びターゲット・ノ
ードに対する関係を指定するのに必要なユーザの対話に
ついては検討しない。

A.Delete（tree,scope）。スコープを木から削除する。

入力： tree 削除を開始する木のルート scope スコープ内のノードのセット 出力： scope スコープ内に残っているノードのセット［削除後は何も
残らない］ 方法： 1.create（compSubtrees）［サブツリーに完全にスコー
プが指定されているノードに対するセットを作成する］ 2.buildCompSubtrees（scope,compSubtrees）［サブツ
リーに完全にスコープが指定されているノードのセット
を構築する］ 3.deleteTrees（tree,scope,compSubtrees）［木を削除
する］ 4.destroy（compSubtrees） B.Copy（tree,scope,node,relation）。スコープをター
ゲット位置に複写する。

入力： tree 削除を開始する木のルート scope スコープ内のノードのセット node ターゲット・ノード relation ノードに対するターゲットの関係 出力： scope スコープ内に残っているノードのセット［複写後は何も
残らない］ 方法： 1.create（treelist）［スコープを構成する木のリス
ト］ 2.create（compSubtrees）［サブツリーに完全にスコー
プが指定されているノードに対するセットを作成する］ 3.buildCompSubtrees（scope,compSubtrees）［サブツ
リーに完全にスコープが指定されているノードのセット
を構築する］ 4.collectTrees（tree,scope,compSubtrees,treeList）
［スコープが指定されたサブツリーを収集する］ 5.insertTrees（node,relation treeList）［収集され
た木を、ターゲットに挿入する］ 6.makeEmpty（scope）［スコープをクリアする］ 7.destroy（compsubtrees） 8.destroy（treeList） c.Move（tree,scope,node,relation）。スコープをター
ゲット位置へ移動する。

入力： tree 削除を開始する木のルート scope スコープ内のノードのセット node ターゲット・ノード relation ノードに対するターゲットの関係 出力： scope スコープ内に残っているノードのセット［移動後は何も
残らない］ 方法： 1.create（treelist）［スコープを構成する木のリス
ト］ 2.create（compSubtrees）［サブツリーに完全にスコー
プが指定されているノードに対するセットを作成する］ 3.buildCompSubtrees（scope,compSubtrees）［サブツ
リーに完全にスコープが指定されているノードのセット
を構築する］ 4.removeTrees（tree,scope,compSubtrees,treeList）
［スコープが指定されたサブツリーを収集し、これらを
木から削除する］ 5.insertTrees（node,relation treeList）［収集され
た木を、ターゲットに挿入する］ 6.destroy（compSubtrees） 7.destroy（treeList） D.Insert（tree,node,relation,nodeType）。所定のタ
イプの新しいノードを、ターゲット位置に挿入する。

入力： tree 削除を開始する木のルート node 内部に挿入されるノード relation ノードに対するターゲットの関係 nodeType 作成されるノードのタイプ 方法： 1.create（treelist）［スコープを構成する木のリス
ト］ 2.createNode（newNode,nodeType）［適切なタイプでノ
ードを作成する］ 3.append（treeList,newNode） 4.insertTrees（node,relation,treeList） 5.destroy（treeList） 好ましい実施例の拡張 木構造のデータを処理するための多くの編集システム
が開発されているが、本発明者はｎ元の木を処理し、こ
のような木に構文規則を強制する先行技術を知らない。
好ましい実施例のこの拡張を、以下で説明する。

従来技術において、構文制御形エディタによって処理
された木は、バッカス・ナウル形式（BNF）の構造を内
部木に直接適用した形式を取る。BNFは一連のデータ内
に有効な関係を指定する手段である。何らかの言語に属
するものと認識できる正しい順序を定義するために、BN
Fは開発された。言語の文法関係を説明する中間段階を
表わすのに木を使用することは、その後に行なわれるよ
うになった。

BNFはプロダクションという規則で構成されている。
各プロダクションは何らかの区切り文字、一般には矢
印、またはストリング「::＝」によって分離された右辺
と左辺を有している。左辺は単一のワードからなってい
る。（常にそうなのではない。BNFの最も一般的な記述
は、プロダクションの両辺に列を入れることを認めるも
のである。しかしながら、この機能は実際のシステムに
使用するには困難過ぎるものであり、またプログラミン
グ言語などの正式な言語には不必要なものである。）こ
のワードは非端末ワードである。右辺はゼロ個または複
数個のワードからなっており、これらは非端末ワードで
あっても、端末ワードであってもかまわない。端末ワー
ドがプロダクションの左辺に現れることはまったくな
い。木のノードが各非端末ワードに対して生成された場
合には、左辺としてこの非端末ワードを有しているプロ
ダクションの右辺は、このノードに対する正しい子を定
義する。

非端末ワードを２つ以上のプロダクションの左辺に入
れてもかまわない。この場合、右辺が等しい必要はな
い。すなわち、ノードの単一のタイプは異なる時点で、
異なるタイプの子を有することができる。

非端末ワードをプロダクションの左辺及び右辺の両方
に入れてもよく、あるいは文法の依存関係内で深くネス
トしてもよい。この帰納は列をBNFで表現する方法であ
る。たとえば、下記はステートメントの列を帰納的に定
義する。ここで定義されたステートメントの列が、長さ
ゼロにならないことに留意されたい。

statements ::＝ statement statements ::＝ statement statement statement ::＝ ifStatement statement ::＝ whileStatement ifStatement ::＝ ‘IF' condition ‘THEN' statement ifStatement ::＝ ‘IF' condition ‘THEN' statement ‘ELSE' statement whileStatement ::＝ ‘WHILE' condition ‘DO' statements ‘END' 言語全体の規則を単純なBNFで書くのは、効率が悪い。B
NFを普遍的に拡張し、規則の簡潔な表現ができるように
する。拡張は垂直のバー「｜」を用いて、端末ワード及
び非端末ワードの間での選択を示し、角かっこ「［］」
を使用して、オプションの端末または非端末ワードを示
し、かつ中かっこ「｛｝」を使用して、長さが０ないし
ｎのステートメントの例を示すことを含んでいる（ただ
し、ｎは任意の整数である）。これらの拡張の正確な意
味の定義は、実施形態ごとに異なる。たとえば、上記の
６つのプロダクションを次のものによって置き換えるこ
とができる。

statements ::＝ statement｛statement｝ statement ::＝ ifStatement| whileStatement ifStatemet ::＝ ‘IF' condition ‘THEN' statement［‘ELSE' statement］ whileStatement ::＝ ‘WHITE' condition ‘DO' statements ‘END' これらの拡張はBNFの表現力を拡張するものではなく、
書きやすくするだけのものである。これらの拡張の単純
なBNFへの変形は、簡単である。このため、BNFの拡張は
くだけた言い方で、「構文の砂糖」と呼ばれるが、これ
はこれらがBNFの構文を理解しやすくするからである。

木の各ノードが単純なBNFのいくつかのプロダクショ
ンの特定の場合を表わすように構築された木を、パーズ
木という。本明細書で提示する簡単な文法お使用して、
ステートメントの有効な列を表わすパーズ木を、第５図
に示す。

使用されている中間ノードの数に留意されたい。本発
明者が認識している先行技術において、構文制御形エデ
ィタによって処理される木は、単純なBNF構造を直接内
部木に表現した形態を取っている。これは木のノードの
各タイプが、一定数の子を持っていることを必要とす
る。

本発明の好ましい実施例は、ノードが可変数の子を有
することを可能とし、また拡張BNFとまったく等しい形
態で木を維持することによって、中間ノードの必要性を
除去する。さらに、拡張BNFの中間物であるいくつかの
ノードが、木に存在する必要はない。この改善された木
の表現を使用すると、以前の単純な文法を第６図に示す
ように表わすことができる。

この表現では、多くの小さいノードが必要なことに留
意されたい。列の「バックホーン」として用いる中間ノ
ードが多くなればなるほど、構文制御形エディタのユー
ザが関心を持つデータ、すなわち最低レベルのステート
メント自体に利用できる記憶域は少なくなる。さらに、
エイダ・プログラミング言語のような大規模で、複雑な
言語では、共通言語構成を定義するのに必要な中間プロ
ダクションの数は、きわめて多くなる。これらのノード
すべてを処理するには、時間がかかり、ユーザの処置に
対するエディタの応答時間が遅くなる。

好ましい実施例のこの拡張の背景をなす基本的な概
念、すなわち構造エディタの構文の正しさを維持する
（それ故、このエディタを構文制御形エディタとする）
方法は、「ソケット」を使用することである。ソケット
はノードのタイプ、及び所定のノードと関連付けること
のできる関係を定義する。

本実施例はデータ及び関係お表わすｎ元の木を維持す
る。換言すると、各ノードはこれに関連する任意の数を
他のノードを有することができる。各ノード（正確に言
えば、各タイプのノード）は一定数のソケットまたは許
容可能な関係を有する。しかしながら、ソケットの基準
を満たす任意の数のノードを、このソケットを介して、
所定のノードと関連付けることもできる。

以下の文法の例を使用して、ソケットの概念の説明を
援助する。「｜」、「［］」及び「｛｝」はこの文法に
おいて、拡張BNFの場合と同じことを意味する。この文
法は木の処理のためだけに使用されるものであるから、
非端末ワードは示されない。

block ::＝ ｛DECLARE｝｛statemet｝ DECLARE ::＝ VARPART TYPEPART VARPART ::＝ TYPEPART ::＝ statement ::＝ IFSTATEMENT | WHILESTATEMENT IFSTATEMENT ::＝ CONDITION THENPART ［ELSEPART］ CONDTION ::＝ THENPART ::＝ ｛statemet｝ ELSEPART ::＝ ｛statemet｝ WHILESTATEMENT ::＝ CONDITION nullorblock nullorblock ::＝ NULLSTATEMET | block NULLSTATEMENT ::＝ 各右辺の非端末ワードは左辺と関連するソケットを表
わす。各ソケットは言語定義テーブルで定義された２つ
の属性を有している。この２つの属性は、ソケットに接
続できるノードの数を判断するソケット・タイプ、及び
他のどのノードのタイプをこのソケットに接続できるか
を判断するこのソケットに対する接続規則である。ノー
ド・タイプ（左辺で定義される）のすべてのノードは、
そのソケットの同一の定義を共有する。

ソケットに有効なタイプは次のとおりである。

必須 接続規則に合致するノードを、常にソケットに接続し
なければならない。必須ソケットは文法では、「｛｝」
または「［］」で囲まれていない右辺の非端末ワードと
して表わされる。たとえば、DECLAREプロダクションは
２つの必須ソケット、VARPART及びTYPEPARTを有してい
る。

オプション 接続規則に合致するノードをソケットに接続すること
も、空にしておくこともできる。オプションのソケット
に対して行なえる接続は、最大１セットである。オプシ
ョンのソケットは文法では、「［］」で囲まれた右辺の
非端末ワードとして表わされる。たとえば、IFSTATEMEN
Tプロダクションをオプションのソケット、［ELSEPAR
T］を有している。

ｎ元 接続規則に合致するノードをソケットに接続すること
も、空にしておくこともできる。ｎ元のソケットに対し
て行なえる接続のセットの数に制限はない。ｎ元のソケ
ットは文法では、「｛｝」で囲まれた右辺の非端末ワー
ドとして表わされる。たとえば、blockプロダクション
は２つのｎ元のソケット、｛DECLARE｝及び｛statemen
t｝を有している。

各ソケットはソケットで表わされる非端末ワードを定
義するプロダクションで決定された単一の接続規則属性
を有している。接続規則は認められる接続の性格を定義
する。接続規則のタイプは４つだけである。すなわち、
単純なタイプ２つと、複雑なタイプ２つである。単純な
タイプは次のとおりである。

構成 構成規則は言語の抽象概念の定義ないし中間定義と対
照をなすものとして、基本的な言語構成、すなわち言語
の使用中に現われる語または句を定義する。構成規則は
言語の指定によって定義される。構成規則は木内に実際
に現われるノードを定義する唯一の規則である。文法例
において、構成規則は大文字の非端末ワードによって識
別される（DECLARE、VARPART、TYPEPART...）。ソケッ
トが構成コネクタ規則名を含んでいる場合、これは構成
コネクタ規則によって定義されたノードを、ソケットの
下に挿入しなければならないことを意味する。たとえ
ば、IFSTATEMENTノードは構成接続規則による３つのソ
ケット、すなわちCONDITIONに対するもの、THENPARTに
対するもの、及びELSEPARTに対するオプションのもので
ある。（第７図のノード４はIFSTATEMETである。） ノードのタイプには、その構造を定義する構成規則と
同じ名前が与えられる。たとえば、IFSTATEMENT規則で
定義されたノードは、IFSTATEMENTのノード・タイプを
有している。

コネクタ・セット コネクタ・セット規則は多くの接続規則タイプの１つ
のノードが、ソケットに接続することを可能とする。
（ソケットが必須またはオプションのタイプを有してい
る場合、このソケットに接続できるノードの最大数が１
であって、各種類に１つではないことに留意された
い。）コネクタ・セット規則は文法の例では、次のよう
に表わされている。

1hs ::＝ rh1 | rh2 | rh3 | rh4 | ... ただし、すべての「rhx」は構成規則タイプを有する単
一の必須ソケットである。文法の例において、唯一のコ
ネクタ・セットは「statement」である。「nullorbloc
k」は「block」が構成規則でないので、コネクタ・セッ
トではない。「block」が２つ以上のソケットをその右
辺に持っており、「DECLARE」と「statement」が必須ソ
ケットではなく、かつ「statement」が構成規則ではな
いので、「block」はコネクタ・セットではない。

各構成規則に整数値お割り当てることにより、各構成
規則に対するビット位置を含んでいるビット・アレイと
して、コネクタ・セットを言語定義テーブルに実現でき
る。コネクタ・セット規則が参照する各構成規則に対す
るそれぞれのビット位置に、１が入れられ、他のビット
は０にセットされる。文法解析アルゴリズムは次いで、
きわめて迅速なビット・アレイ検索を行なうことによっ
て、与えられた構成規則がコネクタ・セット内にあるか
どうかをチェックできる。コネクタ・セットは標準BNF
の言語抽出概念または中間ノードを表わす。

複雑な接続規則タイプは編集中の工程に対して高価な
ものにつく。しかしながら、これらは言語の定義ではは
るかにまれなものである。上述の２つの規則はきわめて
効率がよく、実際の言語の事例の90％超をカバーしてい
る。エイダ・プログラミング言語に類似した言語のテス
ト・ケースの文法では、接続規則の97％が構成規則また
はコネクタ・セット規則であった。これらの単純な規則
のタイプを、以下で説明する方法とともに使用した場
合、子のノードを子のノード当たりきわめて少ないテー
ブル・検索で、親のノードに接合することができる。

以下の複雑な接続規則タイプは、単一のソケット内に
ネストされたソケットに対する機構を提供する。これら
の接続規則はきわめて標準的なパーサを定義し、さまざ
まな規則タイプがさまざまな効率を得ることを可能とす
る。

コネクタ 合致する接続規則タイプが構成規則に限定されないと
いう点以外は、コネクタはコネクタ・セットと類似して
いる。コネクタ・セット規則と同様に、コネクタ規則は
文法の例では、次のように現われる。

1hs ::＝ rh1 | rh2 | rh3 | rh4 | ... 相違点は、各「rhx」が構成規則を有する単一の必須
ソケットである必要がないところである。コネクタ・セ
ット、コネクタ、または配列コネクタの接続規則タイプ
を有する、単一の必須ソケットでもよい。文法の例にお
いて、 「nullorblock」はコネクタ規則である。

配列コネクタ 配列コネクタ規則はソケットを、サブソケットに分割
する。各サブソケットは任意のタイプのものでよく、か
つ任意のタイプの接続規則を有することができる。
「｜」というBNFの符号は配列コネクタ規則では認めら
れない。すなわち、サブセットの代替定義はない。文法
の例において、「block」は配列コネクタ規則である。

本発明の方法は、サブツリーのリストまたは範囲を使
用する、接合及び置換を含む編集操作によって、これら
の構成規則を維持する方法を画定する。

以下の例は接合操作及び置換操作の結果を示す。これ
らの例は第７図に示した初期木を有する文法の例に基づ
くものである。

この木から開始すると、IFSTATEMENT及びWHILESTATEM
ENTがノード９の下、及びノード11の後ろに接合され
る。その結果を第８図に示す。

第９図はIFSTATEMENT及びWHILESTATEMENTと、ノード
１の下のノード３及び４を置き換えた結果を示す。

第10図は文法の例に含まれている情報の表形式、なら
びに本発明の好ましい実施例の実施態様を示す。これを
使用して、上記の接合及び置換操作を行なう。

表には、文法のあらゆるプロダクションに対する行が
１つある。

「規則のタイプ」という欄は各プロダクションがどの
タイプの規則であるかを示している。

「子は複雑か？」という欄はコネクタまたは配列コネ
クタ規則が、構成規則のソケットのいずれかに対する接
続規則として使用されているかどうかを示す。使用され
ていれば、ソケットに接続されている子は複雑（真）で
あり、使用されていなければ、複雑ではない（偽）。
「子は複雑か？」フィールドは、高速ではあるが、融通
性のない接合または置換アルゴリズムを使用できるかど
うか（複雑でない子）、あるいは遅いが、融通性のある
アルゴリズムを使用しなければならないかを判断するた
めに使用される。

「ソケットの数」という欄は、構成、コネクタ、また
は配列コネクタ規則に対して、ソケットがいくつ定義さ
れているかを示す。

構成、コネクタ、または配列コネクタ規則に対する
「ソケットまたはビット・アレイ」という欄は、ソケッ
トのリストを含んでいる。各ソケットはソケットのタイ
プ（必須（ｒ）、オプション（ｏ）、ｎ元（ｎ））及び
接続規則の数で構成されている。

コネクタ・セット規則に対する「ソケットまたはビッ
ト・アレイ」という欄は、ビット・アレイを含んでい
る。ビット・アレイは各規則に１つのビットで構成され
ている（規則の数０ないしｎが付けられている）。ビッ
トの１という値は、対応する規則によって定義されたノ
ードを接続できることを示す。第10図において、規則
４、IFSTATEMENT規則に対応するビット（ビット番号
５）及びWHILESTATEMENT規則（ビット番号９）は１にセ
ットされる。

上述の接合操作、すなわち第８図に示す構造をもたら
す第７図のノード９の下、及びノード11の後にIFSTATEM
ENT及びWHILESTATEMENTを接合する操作に含まれる工程
は、以下のとおりである。

1.プロダクションの定義（第10図）から、THENPARTノー
ド９が複雑な子を有していない（複雑な子は偽である）
ことを判断する。これは高速接合アルゴリズムを使用で
きることを意味する。（高速アルゴリズムは新しい子
が、ターゲット・ソケットに適合するかどうかをチェッ
クするだけである。低速アルゴリズムはノードのすべて
の子について、あるソケットから、他のソケットに、そ
のいずれかを移動する必要があるかどうかをチェックす
る。） 2.ノード11を含んでいるソケット（「後に挿入された」
もの）がｎ元であるかどうかを判断する。ｎ元であれ
ば、新しいノードを挿入でき、そうでなければ、ソケッ
トが既に占有されているから、接合は失敗する。

3.ソケットに対する接続規則が、接合されるノードのタ
イプの挿入を許容するかどうか判断する。ノード９のソ
ケットは「statement」ソケット（接続規則４）であっ
て、コネクタ・セット接続規則タイプを有している。規
則４のコネクタ・セットに関連するビット・アレイは、
IFSTATEMENT及びWHILESTATEMENTノードをこのソケット
に接続できることを指定する。挿入される最初のノード
（ノード15）はIFSTATEMENTノードである。第２のノー
ド（ノード16）はWHILESTATEMENTノードである。それ
故、両方のノードをソケットに挿入できる。

4.ノードをソケットに挿入する。

第７図のノード３及び４を、第９図をもたらすIFSTAT
EMENT及びWHILESTATEMENTと置き換えることに関係する
工程は次のとおりである。

1.（WHILESTATEMENTノード１）が複雑な子を有している
かどうか判断する。有している場合には、低速アルゴリ
ズムを使用しなければならない。（低速アルゴリズム
は、ノードのすべての子について、あるソケットから、
他のソケットに、そのいずれかを移動する必要があるか
どうかチェックする。） 2.CONDITIONノード２、IFSTATEMENTノード15、WHILESTA
TEMENTノード16、及びWHILESTATEMENTノード５を含んで
いる childrenListを構築する。これらは置換後、ノード１の
新しい子になるノードである。

3.CONDTIONノード２がWHILESTATEMENTノード１の最初の
ソケットに適合するかどうかを判断する。これはWHILES
TATEMENTの最初のソケットが、CONDTION構成に接続する
必須ソケットだからである。これはノード１の最初のソ
ケットを満たす。

4.ノード１に残っているソケットが１つだけであるか
ら、ノード15、16、及び５を第２のソケットに挿入する
ことが試みられる。このソケットに対する接続規則は、
規則10、nullorblockである。nullorblockがコネクタ構
成規則タイプであるから、新しいノードを適正に挿入で
きるものが見つかるまで、新しいノードの仮想ソケット
への挿入を試みる。（コネクタ規則のソケットを仮想ソ
ケットと呼ぶが、これはこれらのソケットが結果として
生じる木のソケットに対応していないからである。） a.unllorblockの最初の仮想ソケットは構成規則11NULLS
TATEMENTである。挿入される次のノード、IFSTATEMENT
ノード15がNULLSTATEMENTではないので、このテストは
失敗する。

b.nullorblockの次の仮想ソケットは、配列コネクタ規
則０のブロックである。配列コネクタ規則の文法解析
は、構成規則の文法解析にきわめて類似している。途中
でノードを挿入しながら、配列コネクタの仮想ソケット
の左から右へ移動が行なわれる。

１）規則０のブロックの最初の仮想ソケットは接続規則
DECLAREを有するｎ元である。次のノードIFSTATEMENTノ
ード15はDECLAREでないので、仮想ソケットに挿入する
ことはできない。しかし、ｎ元のソケットは子を持つこ
とができないので、テストは失敗しない。

２）ブロックの第２のソケットは接続、またはステート
メントの規則を有するｎ元である。ステートメントはIF
STATEMENTまたはWHILESTATEMENTのいずれかを受け入れ
るコネクタ・セット規則タイプである。次の３つのノー
ド（ノード15、16及び５）はすべてIFSTATEMENTまたはW
HILESTATEMENTであるから、これらはこの仮想ソケット
内で有効である。文法解析はこれで終了し、ノード２、
15、16及び５をノード１のソケットに接続する方法が決
定された。

5.すべての子を、WHILESTATEMENTノード１ソケットから
除去する。

6.CONDITIONノード２を、WHILESTATEMENTノード１の最
初のソケットに接続し、IFSTATEMENT及びWHILESTATEMET
ノード15、16、及び５を、WHILESTATEMENTノード１の第
２のソケットに接続する。

好ましい実施例の拡張で使用されるユーティリティ関数 以下の基本操作がユーティリティ関数によって利用で
きるものと想定する。

− 木を操作する関数。木の操作は公知の分野である。
操作は以下に挙げる単純なものに限定される。

getFirstChild 与えられたノードの最初の子を返すか、ノードに子が
ない場合には、空文字を返す。

getLastChild 与えられたノードの最後の子を返すか、ノードに子が
ない場合には、空文字を返す。

getRightSiblig ノードの右側の兄弟を返すか、ノードがその親の最後
の子である場合には、空文字を返す。

getLeftSibling ノードの左側の兄弟を返すか、ノードがその親の最初
の子である場合には、空文字を返す。

insertNode 親のノードの下、及び左側の兄弟の後ろにノードを挿
入する。

removeNode ノードを親のノードの下から除去する。

− 項目のリスト、特にサブツリーを操作する関数。

create 新しい空のリストを作成する。

destroy リストを完全に破壊する。

append 項目をリストの終りに追加する。

prepend 項目をリストの最初に追加する。

getFirst リストの最初の項目を返す。

getNext リスト及びリストの項目を与えた場合、リストの次の
項目を返すか、あるいは与えられた項目が最後のもので
ある場合には、空文字を返す。

これらの関数はすべて充分に定義されており、業界で
周知のものである。

好ましい実施例の拡張に必要なデータ ノードには２つの関連するデータ、すなわちノード・
タイプとソケット番号が必要である。ノード・タイプは
IFSTATEMENTノードまたはWHILESTATEMENTノードなどの
ノードのタイプを定義する。ソケット番号は特定のノー
ドによって占有されているその親のソケットを識別す
る。この方法は各ノードのタイプ及びその親のタイプを
使用して、ノードをソケットに割り当てる。ノードをソ
ケットに割り当てることができない場合には、操作は失
敗する。

ノード・タイプ・フィールド（ノードを定義する接続
規則と同じもの）は、言語定義テーブル・アレイに対す
る指標である。ソケット・フィールドは整数であって、
ノードが現在割り当てられているソケットを示す。

以下の操作がノード・データを操作するために提供さ
れる。

getNodeType ノードを与えた場合、そのタイプを返す。

getParentSocket ノードを与えた場合、それが割り当てられているソケ
ットを返す。

setParentSocket ノード及びソケットの指標を与えた場合、そのノード
をそのソケットに割り当てる。この関数はソケットが子
の間に順序よく割り当てられているかどうかのチェック
は行なわない。これを行なうのは、接合及び刈込み操作
の責任である。

言語定義テーブルは接続規則番号の指標が付いた構想
の配列である（ノードを関連させた場合、ノード・タイ
プと呼ぶ。以下の説明では、これらの２つの語は、互い
に置き換えて使用される。）ノードに実際に割り当てら
れるので、構成接続規則タイプを有する接続規則だけで
あるということに留意されたい。他の規則はソケットに
割当て工程で、接続規則として使用される。構造に含ま
れているデータは、接続規則の各タイプごとに異なって
いる。接続規則のタイプ、すなわちは構成、コネクタ・
セット、コネクタ、または配列コネクタは、この構造に
常に存在している。

以下の関数は与えられた接続規則番号に対して、接続
規則のタイプを返す。

getRuleType 接続規則番号を与えた場合、その接続規則のタイプを
返す。

規則がコネクタ・セット・タイプである場合には、こ
のコネクタ・セットに対する有効な構成ノードの表わす
ビットマップが、構成の他のものに含まれる。以下のル
ーチンを定義して、コネクタ・セットの項目からデータ
を抽出する。

inConnSet コネクタ・セットを指示するノード・タイプ、及びテ
ストするノード・タイプを与えた場合、テストするノー
ド・タイプが有効なノード・タイプのセット内にあれ
ば、真を返し、それ以外の場合には、偽を返す。

規則のタイプがコネクタ・セット以外のものである場
合には、構造はこの規則に対して定義されたソケットの
番号、及びソケット記述子のリストを含む。しかしなが
ら、これらは規則のタイプに基づいて別々に解釈され
る。各ソケット記述子はソケット・タイプ・フィールド
（必須、オプション、及びｎ元）と、このソケットに使
用される接続規則を定義する接続規則番号を有してい
る。以下の関数を定義して、これらの項目からデータを
抽出する。

getNumSockets ノード・タイプを与えた場合、この項目に関連したソ
ケットの番号を返す。この番号はゼロであってもかまわ
ない。

getSocketType ノード・タイプとソケットの指標を与えた場合、この
指標によって参照されるソケットのタイプ（必須、オプ
ション、またはｎ元）を返す。

getRule ノード・タイプとソケットの指標を与えた場合、この
ソケットに対して指定された接続規則を返す。

上記の関数の他に、テーブルの項目が構成規則に対す
るものの場合には、テーブルは構成のソケットのいずれ
かがコネクタを使用しているか、あるいは配列コネクタ
規則を使用しているかを示す。この情報が利用できるの
は、コネクタ及び配列コネクタ規則が使用されている場
合、接合及び置換アルゴリズムがショート・カットを行
なえるからである。

complexChildren ノード・タイプを与えた場合、複雑な接続規則（コネ
クタ規則または配列コネクタ規則）が、そのノード・タ
イプのいずれかのソケットに対する接続規則として使用
されているかどうかを返す。

好ましい実施例の拡張に対する基本関数の定義 好ましい実施例の方法の拡張を記述するのに使用され
るサブルーチンの定義は以下のとおりである。

I.parseSoket（parentType,socket,child,children,sta
tus）。

サブツリーのリストからサブツリーの文法分析を行な
って、これらがソケットに適合するかどうか調べる。

parseSocketはどのタイプの接続規則を、ソケットに
関連付けられるか、また該当するルーチンへの分岐を決
定する。

入力： parentType 下にある子の文法解析を試みる親ノードのタイプ socket 下にある子の文法解析を試みるソケット child 子のリストからのサブツリーのトップ。childはソケ
ットの下の文法解析を行なう最初のサブツリーのトップ
である。

children 文法解析を行なうサブツリーのリスト 出力： status 操作が成功したかどうかを調べる。文法の構文規則に
したがって子の文法解析を行なえない場合には、操作は
失敗する。

child 子のリストからのサブツリーのトップ。childは文法
解析の行なわれる次のサブツリーのトップである。

方法： 1.case getRuleType（getRule（parentType,soket））
［どのタイプの規則がソケットを定義しているかに応じ
て、適切なタイプの文法解析を実行する］ a.構成規則 １）parseConstruct（parentType,socket,child,childr
en,status） b.コネクタ・セット規則 １）parseConnSet（parentType,socket,child,childre
n,status） c.コネクタ規則 １）parseConn（parentType,socket,child,children,st
atus） d.配列コネクタ規則 １）parseOrdconn（parentType,socket,child,childre
n,status） II.parseConstruct（parentType,socket,child,childre
n,status）。

ソケットの下の特定の構成タイプの子の文法解析を行
なう。

入力： parentType 下にある子の文法解析を行なう親のノードのタイプ socket 下にある子の文法解析を行なうソケット child 子のリストからのサブツリーのトップ。childはソケ
ットの下の文法解析を行なう最初のサブツリーのトップ
である。

出力： status 操作が成功したかどうかを調べる。文法の構文規則に
したがって子の文法解析を行なえない場合には、操作は
失敗する。

child 子のリストからのサブツリーのトップ。childは文法
解析の行なわれる次のサブツリーのトップである。

方法： 1.case getSocketType（parentType,socket）［ソケッ
トが必須、オプション、またはｎ元であるかに応じて、
適切なタイプの文法解析を行なう］ a.必須 １）子が空である場合［必須ソケットに入れられる子が
ない］ ａ）status ＝ syntax error ２）それ以外の場合 ａ）getNodeTpye（child）＝getRule（parentType,sock
et）の場合［子のノードが、そのソケットに対して指定
されている規則と同じタイプであるかどうかを調べる］ i.status ＝ ok［文法解析のこの部分は成功した］ ii.child ＝ getNext（children,child）［次の子の文
法解析を準備する］ ｂ）それ以外の場合 i.status ＝ syntax error［間違ったタイプのソケッ
ト］ b.オプション １）子が空でない場合 ａ）getNodeType（child）＝getRule（parentType,sock
et）の場合［子のノードが、そのソケットに対して指定
されている規則と同じタイプであるかどうかを調べる］ i.child ＝ getNext（children,child）［次の子の文法
解析を準備する］ ２）status ＝ ok［オプションのソケットは空にできる
から、失敗を引き起こすことはない］ c.n元 １）ｎ−aryDone ＝ false ２）ｎ−aryDoneが偽の場合 ａ）子が空の場合 i.n−aryDoneが真の場合 ｂ）それ以外の場合 i.getNodeType（child） ＝ getRule（parentType,soc
ket）の場合［子のノードが、そのソケットに対して指
定されている規則と同じタイプであるかどうかを調べ
る］ ｉ）child ＝ getNext（children,child）［次の子の文
法解析を準備する］ ii.それ以外の場合 ii）ｎ−aryDone ＝ true ３）status ＝ ok［ｎ元のソケットは空にできるから、
失敗を引き起こすことはない］ III.pareseConnset（parentType,socket,child,childre
n,status）。

コネクタ・セット規則に定義された構文にしたがって
下の文法解析を行なう。コネクタ・セット規則は、ソケ
ット内で有効な一連の構成規則番号で構成されている。
文法解析はきわめて単純である。すなわち、次の子のタ
イプが、コネクタ・セットで定義された有効な構成規則
番号の１つであるかどうかを判定する。

入力： parentType 下にある子の文法解析を試みる子のノードのタイプ socket 下にある子の文法解析を試みるソケット child 子のリストからのサブツリーのトップ。childはソケ
ットの下の文法解析を行なう最初のサブツリーのトップ
である。

children 文法解析を行なうサブツリーのリスト 出力： status 操作が成功したかどうかを示す。文法の構文規則にし
たがって子の文法解析を行なえない場合には、操作は失
敗する。

child 子のリストからのサブツリーのトップ。childは文法
解析の行なわれる次のサブツリーのトップである。

方法： 1.case getSocketType（parentType,socket）［ソケッ
トが必須、オプション、ｎ元であるかどうかに応じて、
適切なタイプの文法解析を行なう］ a.必須 １）子が空の場合 ａ）status ＝ syntax error ２）それ以外の場合 ａ）inConnSet（getRule（parentType,socket）,getNod
eType（child）） i.status ＝ ok［文法解析のこの部分は成功した］ ii.child ＝ getNext（children,child）［次の子の文
法解析を準備する］ ｂ）それ以外の場合 i.status ＝ syntax error b.オプション １）子が空でない場合 ａ）inConnSet（getRule（parentType,socket）,getNod
eType（child））の場合 i.child ＝ getNext（children,child）［次の子の文法
解析を準備する］ ２）status ＝ ok［オプションのソケットは空にできる
から、失敗を引き起こすことはない］ c.n元 １）ｎ−aryDone ＝ false ２）ｎ−aryDoneが偽の場合 ａ）子が空の場合 i.n−aryDoneは真である。

ｂ）それ以外の場合 i.inConnSet（getRule（parentType,socket）,getNodeT
ype（child））の場合 ｉ）child ＝ getNext（children,chile）［次の子の文
法解析を準備する］ ii.それ以外の場合 ｉ）ｎ−aryDone ＝ true ３）status ＝ ok［ｎ元のソケットは空にできるから、
失敗を引き起こすことはない］ IV.parseConn（parentType,socket,child,children,sta
tus）。

コネクタ規則に定義された構文にしたがって子の文法
解析を行なう。コネクタ規則は仮想ソケットのリストで
構成されている。（コネクタ規則が木にノードを定義し
ないので、仮想ソケットは子が有することのできる構文
を定義するだけであり、ノードが接続される実際のソケ
ットを定義しない。） 子はこれらの仮想ソケットの１つだけに対して文法解
析される。子の文法解析を行なうことのできる仮想ソケ
ットが見つかるまで、各仮想ソケットを最初から最後ま
で試みる。

入力： parentType 下にある子の文法解析を試みる子のノードのタイプ socket 下にある子の文法解析を試みるソケット child 子のリストからのサブツリーのトップ。childはソケ
ットのソケットの下の文法 解析を行なう最初のサブツ
リーのトップである。

children 文法解析を行なうサブツリーのリスト 出力： status 操作が成功したかどうかを示す。文法の構文規則にし
たがって子の文法解析を行なえない場合には、操作は失
敗する。

child 子のリストからのサブツリーのトップ。childは文法
解析の行なわれる次のサブツリーのトップである。

方法： 1.connParentType ＝ getRule（parentType,socket）
［コネクタ規則に対するテーブル項目に、指標をセット
する。この指標は、各コネクタ規則の仮想ソケットの下
の子の文法解析を行なうルーチンに渡される］ 2.case getSocketType（parentType,socket）［ソケッ
トが必須、オプション、またはｎ元であるかどうかにし
たがって、適正なタイプの文法解析を行なう］ a.必須またはオプション １）status ＝ syntax error［whileループに対して状
況を初期設定する］ ２）connSocket ＝ 1 ３）connSocket ＜＝ getNumSocket （connParentType）で、状況が構文エラーである場合
［いずれかの仮想ソケットが空になるか、構文エラーを
起こさずに、仮想ソケットの文法解析が行なえるまで、
各仮想ソケットの下で文法解析を試みる］ ａ）connChild ＝ ［子の局所コピーを作成し、状況が
okでない場合に、parseSocketが子の更新を行なわない
ようにする。子が更新されるのは、子のグループの文法
解析が、仮想ソケット内で適正に行なわれたことがわか
っている場合だけである］ ｂ）parseSocket（connParentType,connSocket,connChi
ld,children,status）［仮想ソケットの下で文法解析を
試みる］ ｃ）connSocket ＝ connSocket ＋ 1 ４）状況がokの場合 ａ）child ＝ connChild［次の子の文法解析の準備をす
る］ ５）それ以外の場合 ａ）getSocketType（parentTpye,socket）がオプション
の場合 i.status ＝ ok［オプションのソケットが空である］ b.n元 １）ｎ−aryDone ＝ false ２）ｎ−aryDoneが偽の場合 ａ）status ＝ syntax error［whileループに対して状
況を初期設定する］ ｂ）connSocket ＝ 1 ｃ）connSocket ＜＝ getNumSocket（connParentType）
で、状況が構文エラーの場合［いずれかの仮想ソケット
が空になるか、構文エラーを起こさずに、仮想ソケット
の文法解析が行なえるまで、各仮想ソケットで文法解析
を試みる］ i.connChild ＝ child［子の局所コピーを作成し、状況
がokでない場合に、parseCocketが子の更新を行なわな
いようにする。子のグループの文法解析が、仮想ソケッ
ト内で適正に行なわれたことがわかっている場合だけ、
子を更新する］ ii.parseSocket （connParentType,connSocket,connChild,children,sta
tus）［仮想ソケットの下で、文法解析を試みる］ iii.connSocket ＝ connSocket ＋ 1 ｄ）状況がokでないか、connChild ＝ childの場合 i.n−aryDone ＝ true ｅ）それ以外の場合 i.child ＝ connChild［次の子の文法解析を準備をす
る］ ３）status ＝ ok［ｎ元のソケットは空にできるから、
失敗を引き起こすことはない］ V.parseOrdConn（parentType,socket,child,children,s
tatus）。

配列コネクタ規則に定義された構文にしたがって、子
の文法解析を行なう。配列コネクタ規則は仮想ソケット
のリストで構成されている。（配列コネクタ規則が木に
ノードを定義しないので、仮想ソケットは子を指定でき
る配列を定義するだけであり、ノードの接続される実際
のソケットを定義しない） 文法解析アルゴリズムはソケットを次々に文法解析し
ようとする。

入力： parentType 下にある子の文法解析を試みる親のノードのタイプ socket 下にある子の文法解析を試みるソケット child 子のリストからのサブツリーのトップ。childはソケ
ットの下の文法解析を行なう最初のサブツリーのトップ
である。

children 文法解析を行なうサブツリーのリスト 出力： status 操作が成功したかどうかを示す。文法の構文規則にし
たがって子の文法解析を行なえない場合には、操作は失
敗する。

child 子のリストからのサブツリーのトップ。childは文法
解析の行なわれる次のサブツリーのトップである。

方法： 1.ordConnParentType ＝ getRule（parentType,socke
t）［配列コネクタ規則に対するテーブル項目に、指標
をセットする。この指標は、各配列コネクタ規則の仮想
ソケットの下の子の文法解析を行なうルーチンに渡され
る］ 2.case getSocketType（parentType,socket）［ソケッ
トが必須、オプション、またはｎ元であるかどうかにし
たがって、適正なタイプの文法解析を行なう］ a.必須またはオプション １）ordConnChild ＝ child［子の局所コピーを作成
し、状況がokでない場合に、parseSocketが子の更新を
行なわないようにする。子のグループの文法解析が、配
列コネクタ規則全体の下で適正に行なわれたことがわか
っている場合だけ、子を更新する］ ２）status ＝ ok［whileループに対して状況を初期設
定する］ ３）ordConnSocket ＝ 1 ４）ordConnSocket ＜＝ getNumSockets（ordConnParen
tType）で、状況がokの場合［すべての仮想ソケットの
下で、いずれかの文法解析が終了するまで、あるいは構
文エラーが検出されるまで、各仮想ソケットの下で文法
解析を試みる］ ａ）parseSocket（ordConnParentType,ordConnSocket,o
rdConn child,Children,status）［配列コネクタ規則の
仮想ソケット内で、子の文法解析を試みる］ ｂ）ordConnSocket ＝ ordConnSocket ＋ 1 ５）状況がokの場合 ａ）child ＝ ordConnChild［次の子の文法解析の準備
をする］ ６）それ以外の場合 ａ）getSocketType（parentType,socket）がオプション
の場合 i.status ＝ ok［オプションのソケットは空である］ b.n元 １）ｎ−aryDone ＝ false ２）ｎ−aryDoneが偽の場合 ａ）ordConnChild ＝ child［子の局所コピーを作成
し、状況がokでない場合に、parseSocketが子の更新を
行なわないようにする。子のグループの文法解析が、配
列コネクタ規則の下で適正に行なわれたことがわかって
いる場合だけ、子を更新する］ ｂ）status ＝ ok［whileループに対して状況を初期設
定する］ ｃ）ordConnSocket ＝ 1 ｄ）ordConnSocket ＜＝ getNumSockets（ordConnParen
tType）で、状況がokの場合［すべての仮想ソケットの
下で、いずれかの文法解析が終了するまで、あるいは構
文エラーが検出されるまで、各仮想ソケットの下で文法
解析を試みる］ i.parseSocket（ordConnParentType,ordConnSocket,ord
ConnChild,Children,status）［配列コネクタ規則の仮
想ソケットの下で、子の文法解析を試みる］ ii.ordConnSocket ＝ ordConnSocket＋ 1 ｅ）状況がokであるか、ordConnChild ＝ childの場合 i.n−aryDone ＝ true ｆ）それ以外の場合 i.child ＝ ordConnChild［次の子の文法解析の準備を
する］ ３）status ＝ ok［ｎ元のソケットは空にできるから、
これらが失敗を引き起こすことはない］ VI.parseChildren（parentType,firstSocket,lastSocke
t,children,status）。

子のリストの文法解析を行なって、親のノード内のソ
ケットの範囲に適合するかどうか調べる。適合する場合
には、setParentSocket（）を呼び出して、どのソケッ
トにそれが所属しているのかを記録する。

入力： parentType 下にある子の文法解析を試みる親のタイプ。parentType
は常に、構成規則である。

firstSocket 内部の子の文法解析を試みるソケットの範囲の最初の
ソケット。firstSocketは整数である。

lastSocket 内部の子の文法解析を試みるソケットの範囲の最後の
ソケット。lastSocketは整数である。

children 文法解析を行なうサブツリーのリスト 出力： status 操作が成功したかどうかを示す。文法の構文規則にし
たがって新しいノードを挿入できない場合には、操作は
失敗する。

方法： 1.child ＝ getFirst（children） 2.status ＝ ok 3.socket ＝ firstSocket 4.socket ＜＝ lastSocketで、status ＝ okの場合 a.nextChild ＝ child［文法解析を開始した子を、開始
元として保管する。これはどのソケットを、子の内部に
入れるべきかを記録するのに必要である。

b.parseSocket（parentType,socket,child,children,st
atus）［ソケットの下の子の文法解析を試みる］ c.status ＝ okの場合 １）nextChildが子でない場合［文法解析を行なったば
かりの子をループする。各子の内部に入れるべきソケッ
トを記録する。

ａ）setParentSocket（nextChild,socket） ｂ）nextChild ＝ getNext（children,nextChild） d.socket ＝ socket ＋ 1 5.状況がokの場合 a.子が空でない場合［すべての子が文法解析に使用され
た場合、子は空となる］ ａ）status ＝ syntax error［すべての子は文法解析に
使用されてはおらず、これは構文エラーである］ VII.removeChildren（firstChild,lastChild）。親ノー
ドの下からサブツリーの範囲を除去する。結果の構文を
チェックしない。

入力： firstChild 除去すべき最初の子。

lastChild 除去すべき最後の子。

方法： 1.prevChild ＝ null 2.child ＝ firstChild 3.prevChildがlastChildでない場合［サブツリーを除去
する］ a.prevChild ＝ child b.child ＝ getRightSiblig（child） c.removeNode（prevChild） VIII.insertChildren（leftSibling,Children） 左側の兄弟の後にサブツリーのリストを挿入する。子の
構文をチェックしない。

入力 leftSibling サブツリーのリストの最も左側のノードの左側の兄弟に
なる親の子。リストを親の下の最も左側の子として挿入
すべきものである場合には、空となる。

children 挿入されるサブツリーのリスト。

方法： 1.prevChild ＝ leftSibling 2.child ＝ getFirst（children） 3.子が空でない場合［親の下にサブツリーを挿入する］ a.insertNode（prevChild,child） b.prevChild ＝ child c.child ＝ getNext（children,child） IX.insertFlexible（parent,leftSibling,newNodes,Sta
tus）。

親の下、及び左側の兄弟の後にサブツリーのリストを
挿入する。

サブツリーの一番上のノードは親の下のソケットに割
り当てられ、トップがこれらのソケットの接続規則に合
致するようにされる。サブツリーをソケットに割り当て
ることができない場合、挿入は失敗する。

insertFlexibleはinsertQuickと同じ機能を行なう
が、低速で融通性の高いアルゴリズムを使用する。

入力： parent その下にサブツリーのリストが挿入されるノード。

leftSibling サブツリーのリストの最も左側のノードの左側の兄弟
になる親の子。リストが親の下の最も左側の子として挿
入されるものであれば、これは空であってもかまわな
い。

newNodes 挿入されるサブツリーのリスト。

出力： status 操作が成功したかどうかを示す。文法の構文規則にし
たがって新しいノードを挿入できない場合には、操作は
失敗する。

方法： 1.create（childList）［親のすべての子を保持するリ
ストを作成する］ 2.childList ＝ newNodes 3.child ＝ leftSibling 4.子が空でない場合［新しいノードの左側になる子を、
前に付け加える］ a.prepend（childList,child） b.child ＝ getLeftSibling（child） 5.child ＝ getRightSibling（leftSibling） 6.子が空でない場合［新しいノードの右側になる子を付
け加える］ a.append（childList,child） b.child ＝ getRightSibling（child） 7.firstSocket ＝ 1 8.lastSocket ＝ getNumSockets（parent） 9.parentType ＝ getNodeType（parent） 10.parseChildren（parentType,null,firstSocket,last
Socket,childList,status）［子の構文が適正かどうか
を判断するために、文法解析を行なう］ 11.状況がokの場合 a.removeChildren（getFirstChild（parent）,getLastC
hild（parent）［親の下のすべての子を除去する］ b.insertChildren（null,childList）［新しい子を、親
の下に挿入する］ 12.destroy（childList） X.insertQuick（parent,leftSibling,newNodes,statu
s）。

親の下、及び左側の兄弟の後にサブツリーのリストを
挿入する。

サブツリーの一番上のノードは親の下のソケットに割
り当てられ、トップがこれらのソケットの接続規則に合
致するようにされる。サブツリーをソケットに割り当て
ることができない場合、挿入は失敗する。

insertQuickはinsertFlexibleと同じ機能を行なう
が、高速で融通性の低いアルゴリズムを使用する。

入力： parent その下にサブツリーのリストが挿入されるノード。

leftSibling サブツリーのリストの最も左側のノードの左側の兄弟
になる親の子。リストが親の下の最も左側の子として挿
入されるものであれば、これは空であってもかまわな
い。

newNodes 挿入されるサブツリーのリスト。

出力： status 操作が成功したかどうかを示す。文法の構文規則にし
たがって新しいノードを挿入できない場合には、操作は
失敗する。

方法： 1.parentType ＝ getNodeType（parent） 2.leftSiblingが空の場合 a.nextChild ＝ getFirstChild（parent）［前に挿入さ
れる子］ b.firstSocket ＝ 1［newNodesが親の下に、最初の子と
して挿入される。親の下の最初のソケットで挿入を開始
する］ 3.それ以外の場合 a.nextChild ＝ getRightSibling（child）［その前に
新しいノードが挿入される子を取得する］ b.childSocket ＝ getParentSocket（leftSibling）［l
eftSiblingが含まれるソケットを取得する］ c.getSocketType（parentType,childSocket）がｎ元の
場合［leftSiblingがｎ元のソケットの内部にあるかど
うかを調べる。挿入が行なえるのは、そうなっている場
合だけである］ １）firstSocket ＝ childSocket［leftSiblingと同じ
ソケットへの挿入を試みる］ d.それ以外の場合 １）firstSocket ＝ childSocket＋１［leftSiblingを
含んでいるものの後のソケットに挿入を試みる］ 4.nextChildが空の場合 a.lastSocket ＝ getNumSockets（parentType）［newNo
desが他のすべての子の後に挿入される。親の下の最後
のソケットで挿入を終了する］ 5.それ以外の場合 a.nextChildSocket ＝ getParentSocket（nextChild）
［nextChildを含んでいるソケットを取得する］ b.getSocketType（parentType,nextChildSocket）がｎ
元の場合［次の子がｎ元のソケット内にあるかどうかを
調べる。内部にある場合にのみ、挿入を行なえる］ １）lastSocket ＝ nextChildSocket［必要に応じ、nex
tChildを含んでいるソケットに挿入を試みる］ c.それ以外の場合 １）lastSocket ＝ nextChildSocket − 1［内部への挿
入を試みる最後のソケットは、nextChildSocketの前の
ものである］ 6.parseChildren（parentType,firstSocket,lastSocke
t,newNodes,status）［文法解析を行なって、newNodes
の子を親の下に適正に挿入できるかどうか判定する。ne
wNodesのノードを、これらがソケットの唯一のノードで
あるかのようにして、文法解析する。ソケット内のその
他の子は、コネクタ規則及び配列コネクタ規則が使用さ
れないことがわかっているので、無視できる。］ 7.状況がokの場合 a.insertChildren（leftSibling,newNodes） ［子を挿入する］ XI.replaceFlexible（parent,firstChild,lastChild,ne
wNodes,status）。

firstChildとlastChildの間の子を、newNodesのサブ
ツリーと置き換える。

サブツリーのトップのノードを親の下のソケットに割
り当て、トップがこれらのソケットの接続規則と合致す
るようにする。サブツリーをソケットに適切に割り当て
ることができない場合、置換は失敗する。

replaceFlexibleはreplaceQuickと同じ機能を実行す
るが、低速で融通性の高いアルゴリズムを使用する。

入力： parent その下でリスト置換を行なうノード。

firstChild 置換される子の範囲内の最初の子。

firstChildはlastChild、またはlastChildの左側のい
ずれかと等しくなければならない。

lastChild 置換される子の範囲内の最後の子。

newNodes 挿入されるサブツリーのリスト。

出力： status 操作が成功したかどうかを示す。文法の構文規則にし
たがって新しいノードを置換できない場合には、操作は
失敗する。

方法： 1.create（childList）［親のすべての子を保持するリ
ストを作成する］ 2.childList ＝ newNodes 3.child ＝ getLeftSibling（firstChild） 4.子が空でない場合［置換される範囲の左側になる子を
前に付け加える］ a.prepend（childList,child） b.child ＝ getLeftSibling（child） 5.child ＝ getRightSibling（lastChild） 6.子が空でない場合［置換される範囲の右側になる子を
付け加える］ a.append（childList,child） b.child ＝ getRightSibling（child） 7.firstSocket ＝ 1 8.lastSocket ＝ getNumSokets（parent） 9.parentType ＝ getNodeType（parent） 10.parseChildren（parentType,null,firstSocket,last
Socket,childList,status）［文法解析を行なって、子
の構文が正しいかどうか判定する］ 11.状況がokの場合 a.removeChildren（getFirstChild（parent）,getLastC
hild（parent））［すべての子を除去する］ b.insertChildren（null,childList）［すべての新しい
子を挿入する］ 12.destroy（childLsit） XII.replaceQuick（parent,firstChild,lastChild,newN
odes,status）。

firstChildとlastChildの間の子を、newNodesのサブ
ツリーと置き換える。

サブツリーのトップのノードを親の下のソケットに割
り当て、トップがこれらのソケットの接続規則と合致す
るようにする。ノードをソケットに適切に割り当てるこ
とができない場合、置換は失敗する。

replaceQuickはreplaceFlexibleと同じ機能を実行す
るが、高速で融通性の低いアルゴリズムを使用する。

入力： firstChild 置換される子の範囲内の最初の子。

firstChildはlastChild、またはlastChildの左側のいず
れかと等しくなければならない。

lastChild 置換される子の範囲内の最後の子。

newNodes 挿入されるサブツリーのリスト。

出力： status 操作が成功したかどうかを示す。文法の構文規則にし
たがって新しいノードを置換できない場合には、操作は
失敗する。

方法： 1.leftSibling ＝ getLeftSibling（firstChild） 2.rightSibling ＝ getRightSibling（lastChild） 3.parentType ＝ getNodeType（parent） 4.leftSiblingが空の場合 a.firstSocket ＝ 1［newNodesを親の下の最初の子とし
て挿入する］ 5.それ以外の場合 a.childSocket ＝ getParentSocket（leftSibling）［l
eftSiblingが含まれているソケットを取得する］ b.getSocketType（parentType,childSocket）がｎ元で
ある場合［leftSiblingがｎ元のソケット内にあるかど
うか調べる。内部にある場合にのみ、挿入を行なえる］ １）firstSocket ＝ childSocket［leftSiblingと同じ
ソケットを挿入することを試みる］ c.それ以外の場合 １）firstSocket ＝ childSocket＋１［ソケットを、le
ftSiblingを含んでいるものの後に挿入することを試み
る］ 6.rightSiblingが空の場合 a.lastSocket ＝ getNumSockets（parentType） ［親の下の最後の子としてnewNodesを挿入する］ 7.それ以外の場合 a.childSocket ＝ getParentSocket（rightSibling）
［右側の兄弟を含んでいるソケットを取得する］ b.getSocketType（parentType,childSocket）がｎ元の
場合［右側の兄弟がｎ元のソケット内にあるかどうかを
調べる。内部にある場合にのみ、挿入を行なえる］ １）lastSocket ＝ childsocket［rightSiblingを含ん
でいる子のところまで挿入を試みる］ c.それ以外の場合 １）lastSocket ＝ childSocket−１［内部へ挿入を試
みる最後のソケットは、rightSiblingを含んでいるソケ
ットの前のソケットである］ 8.parseChildren（parentType,firstSocket,lastSocke
t,newNodes,status）［文法解析を行なって、newNodes
の子を親の下に適正に挿入できるかどうか判定する。ne
wNodesのノードを、これらがソケットの唯一のノードで
あるかのようにして、文法解析する。ソケット内のその
他の子は、コネクタ規則及び配列コネクタ規則が使用さ
れないことがわかっているので、無視できる。］ 9.状況がokの場合 a.removeChildren（firstChild,lastChild）［指定され
た範囲の子を除去する］ b.insertChildren（leftSibling,newNodes）［置換の子
を挿入する］ 拡張の主要関数 上述のサブルーチンを使用して、以下の関数を定義す
る。これらの関数は好ましい実施例の拡張にしたがっ
て、高性能な接合及び置換操作の高レベルの視点を提供
する。（処理の流れを表わすフローチャートについて
は、第12図及び第13図を参照されたい。）接合及び置換
のこれらの構文チェック・バージョンは、構文制御形エ
ディタを作成するために好ましい実施例で使用される標
準的な接合及び置換関数に替わるものである。エディタ
の機能は同一であるが、３つの収集、貼込み、及び削除
という操作を行なえるのは、構文的に適正な構造がもた
らされる場合だけである。

A.graft（parent,leftSibling,newNodes,status）。

親、左側の兄弟、及びサブツリーのリストを与えた場
合、サブツリーのリストを左側の兄弟の後の親の下に挿
入する。

サブツリーのトップのノードを親の下のソケットに割
り当て、トップがこれらのソケットの接続規則と合致す
るようにする。ノードをソケットに割り当てることがで
きない場合、接合操作は失敗する。

入力： parent その下にサブツリーのリストを挿入するノード leftSibling サブツリーのリストの最も左側のノードの左の兄弟とな
る親の子。リストが親の下の最も左側の子として挿入さ
れるものである場合、これは空であってもかまわない。

newNodes 挿入されるサブツリーのリスト。

出力： status 接合が成功したかどうかを示す。新しいノードを文法
の構文規則にしたがって挿入できない場合には、接合は
失敗する。

方法： 1.complexChildren（getNodeType（parent））［親の下
の子を定義するのに、コネクタ規則または配列コネクタ
規則が使用されているかどうか調べる］ a.insertFlexible（parent,leftSibling,newNodes,stat
us）［低速で、融通性の高い文法解析アルゴリズムを使
用して、親の下にノードを挿入する］ 2.それ以外の場合［親の子の適切な構文を記述するの
に、コネクタもしくは配列コネクタ規則は使用されな
い。したがって、高速で、融通性の低い文法解析アルゴ
リズムを使用することができる。実際のプログラミング
言語においては、この経路に時間のほとんどがかかる］ a.insertQuick（parent,leftSibling,newNodes,statu
s）［低速で、融通性の高い文法解析アルゴリズムを使
用して、親の下にノードを挿入する］ b.状況が構文エラーの場合［しばしば、編集操作の順序
が、有効な挿入の場合であっても、insertQuickが失敗
を引き起こすことがある。したがって、すべての障害の
文法解析を、融通性に高いアルゴリズムを使用して再度
行なわなければならない。ほとんどの接合が成功するか
ら、この経路が頻繁に生じることはない］ １）insertFlexible（parent,leftSibling,newNodes,st
atus） ［融通性の高いアルゴリズムによって、文法解析を再度
行なう］ 3.状況がokでない場合 a.Fail B.replace（parent,firstChild,lastChild,newNodes,st
atus）。

親、範囲内の最初の子、範囲内の最後の子、及びサブ
ツリーのリストを与えた場合、子の範囲をサブツリーの
リストを置き換える。

サブツリーのトップのノードを親の下のソケットに割
り当て、トップがこれらのソケットの接続規則と合致す
るようにする。ノードをソケットに割り当てることがで
きない場合、置換操作は失敗する。

入力： parent その下にサブツリーのリストを挿入するノード firstChild 置換される子の範囲内の最初の子。

firstChildはlastChildと等しくなければならないか、
あるいはlastChildの右側でなければならないかのいず
れかである。

lastChild 置換される子の範囲内の最後の子。

newNodes 挿入されるサブツリーのリスト。

出力： status 置換が成功したかどうかを示す。新しいノードを文法に
構文規則にしたがって挿入できない場合には、置換は失
敗する。

方法： 1.complexChildren（getNodeType（parent））［親の下
の子を定義するのに、コネクタ規則または配列コネクタ
規則が使用されているかどうか調べる］ a.replaceFlexible（parent,firstChild,lastChild,new
Nodes,status）［低速で、融通性の高い文法解析アルゴ
リズムを使用して、親の下のノードを置換する］ 2.それ以外の場合［親の子の適切な構文を記述するの
に、コネクタもしくは配列コネクタ規則は使用されな
い。したがって、高速で、融通性の低い文法解析アルゴ
リズムを使用することができる。実際のプログラミング
言語においては、この経路に時間のほとんどがかかる］ a.replaceQuick（parent,firstChild,lastChild,newNod
es,status）［高速で、融通性の低いアルゴリズムを使
用して、親の下にノードを挿入する］ b.状況が構文エラーの場合［しばしば、編集操作の順序
が、有効な置換の場合であっても、replaceQuickが失敗
を引き起こすことがある。したがって、すべての障害の
文法解析を、融通性に高いアルゴリズムを使用して再度
行なわなければならない。ほとんどの置換が成功するか
ら、この経路が頻繁に生じることはない］ １）replaceFlexible（parent,firstChild,lastChild,n
ewNodes,status）［融通性の高いアルゴリズムによっ
て、文法解析を再度行なう］ 3.状況がokでない場合 a.Fail 好ましい実施例及び拡張の上述の説明は例として示さ
れたものである。他の代替策または改変は、当分野の技
術者には明らかであろう。

F.発明の効果 上述のように、本発明はデータ及び関係を階層または
木として表わすことができ、データ要素が木構造内のノ
ードの配置を画定するノード及び関係を形成している、
関係データを編集するためのエディタを提供する。

【図面の簡単な説明】

第１図は、本発明を組み込んだ編集システムの例であ
る。 第2a図は、スコープ指定を説明するために示された、構
造化エディタにおいて作成され、取り扱われるタイプの
木の例である。 第2b図は、第2a図に示した木に収集操作を適用した結果
生じる３つのサブツリーを示す図である。 第３図は、第１図でスコープ指定したノードにおける削
除操作後に生じる木を示す図である。 第４図は、第３図に示した木のE2ノードを中心として、
第２図に示したサブツリーのリストを貼り込んだ結果生
じる木を示す図である。 第５図は、単純なバックス・ナウル形（Backus Naur Fo
rm）の構造を使用して、ステートメントの典型的な有効
な順序を表わすパーズ木を示す図である。 第６図は、拡張されたBNFを使用した、第５図に示した
木の改善された表示の図である。 第７図は、「ソケット」の概念を説明する木構造であ
る。 第８図は、典型的な接合操作を行なった後の、第７図に
示したものと類似した木である。 第９図は、典型的な置換操作を行なった後の、第７図に
示したものと類似した木である。 第10図は、本発明の好ましい実施例の拡張の原理を説明
するのに役立つテーブルを示す図である。 第11図は、本発明の好ましい実施例の基本的な処理の流
れを示す流れ図である。 第12図は、好ましい実施例の拡張による接合操作の処理
の流れを示す流れ図である。 第13図は、好ましい実施例の拡張による置換操作の処理
の流れを示す流れ図である。 20……ビデオ表示画面、21……ユーザ・インターフェー
ス、22……キーボード、24……ポインティング装置、26
……データ操作処理部、28……データ構造記憶装置、30
……構造構文規則、30……データ記憶装置。

───────────────────────────────────────────────────── フロントページの続き (72)発明者 パトリツク・チヤールズ・マンクソ アメリカ合衆国マサチユーセツツ州ノー ス・アンドヴー、アパートメント３、ワ ーカー・ロード１番地 (72)発明者 フレデリツク・ポール・マラー アメリカ合衆国ニユーヨーク州レイク・ カトリン、アツパー・フレデリツクス・ ドライブ15番地 (72)発明者 カート・アレン・リイージエル アメリカ合衆国ニユーヨーク州キングス トン、サンセツト・カーデンズ・20シイ ー番地 (72)発明者 ロバート・チヤールズ・シイーコード アメリカ合衆国ペンシルバニア州ピツツ バーグ、ウツドハーベン・ドライブ221 番地 (72)発明者 デヴイド・ウールワース・スタフオード アメリカ合衆国ニユーヨーク州ストーニ イ・ポイント、イースト・メイン・スト リート１アール89番地

Claims (11)

(57)【特許請求の範囲】
1. 【請求項１】格納手段と処理手段と操作者との対話手段
   とを有するデータ処理システムにおいて、 第１データ要素と第２データ要素との間のシンタックス
   的に正しい接続を維持する方法であって、 許可されたデータ要素タイプのリストを生成するステッ
   プと、 前記格納手段に、前記リスト内の各データ要素タイプに
   対し確立し得る接続の数及び接続し得るデータ要素タイ
   プを定めた、データ要素タイプ間の関係を規定したシン
   タックス規則を格納するステップと、 前記第１データ要素タイプに対応する前記第１レベルの
   シンタックス規則の１つを見つけるステップと、 前記第２データ要素をテストし、前記第２データ要素が
   前記第１データ要素に接続され得るデータ要素であるか
   否かを判断するステップと、 接続され得ると判断された場合には、前記第１データ要
   素及び第２データ要素間の接続を確立するステップと を含む接続方法。
2. 【請求項２】データ要素を含む階層構造又は木を格納す
   る格納装置を有するデータ処理装置内の構造エディタに
   おいて、 異なるタイプのデータ要素又はノードは、前記階層構造
   又は木において追加、コピー、削除、移動又は挿入され
   る場合があり、 前記木に接続されるべきノードを選択するステップと、 前記格納装置に、前記木内のノード間において許可され
   た階層関係及び順序関係を指定した第１セットの規則を
   格納するステップと、 選択された前記ノードと前記木内のノードとの間に確立
   すべき関係を選択するステップと、 選択された前記関係を前記選択されたノードに適用され
   る第１セットの規則を用いてテストし、前記選択された
   ノードと前記木内のノード間の仮想接続を生成するステ
   ップと、 前記格納装置に、前記木内において接続し得るノードの
   タイプを指定した第２セットの規則を格納するステップ
   と、 生成された前記仮想接続を前記第２セットの規則を用い
   てテストし、前記第２セットの規則が前記生成された仮
   想接続により満足されているかを判断するステップと、 前記第２セットの規則が満足されている場合には、前記
   仮想接続を接続にするステップと を含むノード接続方法。
3. 【請求項３】単一のルート・データ要素と１以上のより
   低い階層の子データ要素とを含む階層構造又は木構造と
   して組織化されたデータを処理する方法であって、 子データ要素は、前記階層構造の１つ上位レベルのただ
   １つの親データ要素に関連しており、 前記データは、データ処理システム内の格納手段に格納
   されており、 前記データの処理は、操作者の命令に応答して前記デー
   タ処理システムにおいて実行されるものであり、 （ａ）前記階層的に組織化されたデータ要素から、処理
   のための複数のデータ要素を選択するステップと、 （ｂ）存在する階層的関係を維持したサブツリーとして
   収集リストに前記選択されたデータ要素を収集するステ
   ップであって、 前記サブツリーは単一のリンクで前記選択されたデータ
   要素を接続することにより形成され、 前記収集リストは各サブツリーに対し１のエントリを含
   んでおり、 （b1）選択された中で、最も高次のデータ要素を識別す
   るステップと、 （b2）前記最も高次のデータ要素のコピーを生成するス
   テップと、 （b3）前記最も高次のデータ要素に階層的に関連した、
   全ての選択されたデータ要素を識別するステップと、 （b4）前記関連するデータ要素をコピーするステップ
   と、 （b5）前記関連するデータ要素のコピーを前記最も高次
   のデータ要素のコピーに接続し、階層関係が保持される
   ようにサブツリーを形成するステップと を含む収集するステップと を含むデータ処理方法。
4. 【請求項４】（ｃ）ターゲット・データ要素と、前記選
   択されたデータ要素と前記ターゲット・データ要素間の
   関係を指定するステップと、 （ｄ）前記収集リストを、前記ターゲット・データ要素
   で前記階層構造に挿入し、前記関係を確立するステップ
   と をさらに含む請求項３記載のデータ処理方法。
5. 【請求項５】各データ要素が、型カテゴリに分類されて
   おり、 異なるタイプのデータ要素をいつ又はどのように接続す
   るのかを規定する、データ要素間で許可された関係を指
   定するステップをさらに含む請求項３記載のデータ処理
   方法。
6. 【請求項６】前記ステップ（ｂ）が、 最も高次のデータ要素に階層的に関係していると識別さ
   れた、各前記選択されたデータ要素が、前記最も高次の
   データ要素に前記許可された関係に従って接続可能であ
   るかを決定するステップを含む請求項５記載のデータ処
   理方法。
7. 【請求項７】単一のルート・データ要素と１以上のより
   低い階層の子データ要素とを含む階層構造又は木構造と
   して組織化されたデータを処理する方法であって、 子データ要素は、前記階層構造の１つ上位レベルのただ
   １つの親データ要素に関連しており、 前記データは、データ処理システム内の格納手段に格納
   されており、 前記データの処理は、操作者の命令に応答して前記デー
   タ処理システムにおいて実行されるものであり、 （ａ）前記階層構造として組織化されたデータ要素か
   ら、除去のためデータ要素を選択するステップと、 （ｂ）含まれている各データ要素が、存在する階層的関
   係を保持しつつ、その階層のすぐ上の階層にある多くと
   も１のデータ要素に接続されるように、前記選択された
   データ要素をグループにまとめるステップと、 （ｃ）各グループに対し、 （c1）前記グループの最高位のデータ要素を識別するス
   テップと、 （c2）前記最高位のデータ要素の親データ要素を識別す
   るステップと、 （c3）前記グループ内の選択されたデータ要素の１つに
   接続されているが、選択されていない全てのデータ要素
   を識別するステップと、 （c4）前記グループに含まれた全てのデータ要素を前記
   木から取り除くステップと、 （c5）前記最高位のデータ要素の親データ要素に、前記
   グループに接続されているが取り除かれていない全ての
   データ要素を接続するステップと を含むデータ処理方法。
8. 【請求項８】各データ要素が、型カテゴリに分類されて
   おり、 異なるタイプのデータ要素をいつ又はどのように接続す
   るのかを規定する、データ要素間で許可された関係を指
   定するステップをさらに含み、 前記ステップ（c5）が、そのような接続が前記許可され
   た関係を確立する場合にのみ行われることを特徴とする
   請求項７記載のデータ処理方法。
9. 【請求項９】単一のルート・データ要素と１以上のより
   低い階層の子データ要素を含む階層構造又は木構造とし
   て組織化されたデータを処理する方法であって、 子データ要素は、前記階層構造の１つ上位レベルのただ
   １つの親データ要素に関連しており、 前記データは、データ処理システム内の格納手段に格納
   されており、 前記データの処理は、操作者の命令に応答して前記デー
   タ処理システムにおいて実行され、 各データ要素は型カテゴリに分類されており、 （ａ）いつ又はどのように異なるタイプのデータ要素が
   接続し得るのかを規定する、データ要素間に許可された
   関係を特定するステップであって、 （a1）許可されたデータ要素の型を定義するステップ
   と、 （a2）許可された接続の性質を定義するステップと、 （a3）各データ要素に対し、前記データ要素タイプに接
   続し得るデータ要素の型及び接続の性質を特定するステ
   ップと を含む特定ステップと、 （ｂ）行われるべき操作を選択するステップと、 （ｃ）処理のための複数のデータ要素を、前記階層構造
   に組織化されたデータ要素から選択、又は生成するステ
   ップと、 （ｄ）そのような接続が前記データ要素間に許可された
   関係を確立する場合のみ前記選択又は生成されたデータ
   要素に前記選択された操作を施すステップと を含むデータ処理方法。
10. 【請求項１０】ノードを構成する単純に接続された複数
    のデータ要素を含むサブツリーのリストを、親ノードを
    有する選択されたターゲット・ノードに関連して、木内
    に挿入する方法であって、 前記サブツリーのリストは、データ処理システムの格納
    装置に格納されており、 （ａ）前記サブツリーのリストと前記ターゲット・ノー
    ドとの間の関係を特定するステップと、 （ｂ）前記関係が「レフト（left）」又は「ライト（ri
    ght）」として指定された場合、「レフト」の場合には
    前記サブツリーが前記ターゲット・ノードの前になるよ
    うに前記親ノードに接続され、「ライト」の場合には前
    記サフツリーが前記ターゲット・ノードの後になるよう
    に前記親ノードに接続されるよう、前記サブツリーのリ
    スト内の各サブツリーを前記親ノードに接続するステッ
    プと、 （ｃ）前記関係が「アラウンド（around）」として指定
    された場合、 （c1）前記親ノードから前記ターゲット・ノードを取り
    外すステップと、 （c2）前記サブツリーのリスト内の各サブツリーを前記
    親ノードに、その子データ要素として接続するステップ
    と、 （c3）取り外した前記ターゲット・ノードを前記サブツ
    リー内の各サブツリーに接続するステップと を含むステップと、 （ｄ）前記関係が「ウイズイン（within）」として指定
    された場合、 （d1）前記ターゲット・ノードの子データ要素を取り外
    すステップと、 （d2）前記サブツリーのリスト内の各サブツリーを前記
    ターゲット・ノードに、その子データ要素として接続す
    るステップと、 （d3）取り外された前記子データ要素を前記サブツリー
    のリスト内の各サブツリーに接続するステップと を含むステップと を含む木内にノードを挿入する方法。
11. 【請求項１１】前記サブツリー内の各データ要素は、型
    カテゴリに分類され、 接続し得るデータ要素の型及びデータ要素の型間で許可
    された関係の型を規定する、データ要素間の許可された
    関係を指定するステップをさらに含み、 許可された関係である場合にのみ、前記ステップ（ｂ）
    乃至（ｄ）を実施することを特徴とする請求項11記載の
    木内にノードを挿入する方法。