Changeset 321 for EcnlProtoTool/trunk/asp3_dcre/tecsgen/tecslib/core/componentobj.rb

Timestamp:

Aug 23, 2017, 9:27:43 AM (7 years ago)

Author:

coas-nagasima

Message:

文字コードを設定

File:

• EcnlProtoTool/trunk/asp3_dcre/tecsgen/tecslib/core/componentobj.rb (modified) (377 diffs, 1 prop)

EcnlProtoTool/trunk/asp3_dcre/tecsgen/tecslib/core/componentobj.rb

@@ -6 +6 @@
 #   Copyright (C) 2008-2016 by TOPPERS Project
 #--
-#   上記著作権è€
-は，以下の(1)～(4)ã®æ¡ä»¶ã‚’æº€ãŸã™å ´åˆã«é™ã‚Šï¼Œæœ¬ã‚½ãƒ•ãƒˆã‚¦ã‚§
-#   ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
-#   変・再é
-å¸ƒï¼ˆä»¥ä¸‹ï¼Œåˆ©ç”¨ã¨å‘¼ã¶ï¼‰ã™ã‚‹ã“とを無償で許諾する．
-#   (1) æœ¬ã‚½ãƒ•ãƒˆã‚¦ã‚§ã‚¢ã‚’ã‚½ãƒ¼ã‚¹ã‚³ãƒ¼ãƒ‰ã®å½¢ã§åˆ©ç”¨ã™ã‚‹å ´åˆã«ã¯ï¼Œä¸Šè¨˜ã®è‘—ä½œ
-#       権表示，この利用条件および下記の無保証規定が，そのままの形でソー
-#       スコード中に含まれていること．
-#   (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
-#       用できる形で再é
-å¸ƒã™ã‚‹å ´åˆã«ã¯ï¼Œå†é
-å¸ƒã«ä¼´ã†ãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆï¼ˆåˆ©ç”¨
-#       è€
-マニュアルなど）に，上記の著作権表示，この利用条件および下記
-#       の無保証規定を掲載すること．
-#   (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
-#       用できない形で再é
-å¸ƒã™ã‚‹å ´åˆã«ã¯ï¼Œæ¬¡ã®ã„ずれかの条件を満たすこ
-#       と．
-#     (a) 再é
-å¸ƒã«ä¼´ã†ãƒ‰ã‚­ãƒ¥ãƒ¡ãƒ³ãƒˆï¼ˆåˆ©ç”¨è€
-マニュアルなど）に，上記の著
-#         作権表示，この利用条件および下記の無保証規定を掲載すること．
-#     (b) 再é
-å¸ƒã®å½¢æ
-‹ã‚’，別に定める方法によって，TOPPERSプロジェクトに
-#         å ±å‘Šã™ã‚‹ã“ã¨ï¼Ž
-#   (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
-#       害からも，上記著作権è€
-およびTOPPERSプロジェクトをå
-è²¬ã™ã‚‹ã“と．
-#       また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
-#       由に基づく請求からも，上記著作権è€
-およびTOPPERSプロジェクトを
-#       å
-è²¬ã™ã‚‹ã“と．
+#   上記著作権者は，以下の(1)～(4)の条件を満たす場合に限り，本ソフトウェ
+#   ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+#   変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+#   (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+#       権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+#       スコード中に含まれていること．
+#   (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+#       用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+#       者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+#       の無保証規定を掲載すること．
+#   (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+#       用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+#       と．
+#     (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+#         作権表示，この利用条件および下記の無保証規定を掲載すること．
+#     (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+#         報告すること．
+#   (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+#       害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+#       また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+#       由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+#       免責すること．
 #  
-#   本ソフトウェアは，無保証で提供されているものである．上記著作権è€
-お
-#   よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
-#   に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
-#   アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
-#   ã®è²¬ä»»ã‚’è² ã‚ãªã„ï¼Ž
+#   本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+#   よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+#   に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+#   アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+#   の責任を負わない．
 #  
-#   $Id: componentobj.rb 1011 2016-07-11 02:20:01Z coas-nagasima $
+#   $Id$
 #++
 
 # STAGE:
-# このメンテナンス状況はよろしくない
-#  B    bnf.y.rb から呼出される
-#  P    parse 段階で呼出される（bnf.y.rb から直接呼出されるわけではないが、構文木生成を行う）
-#  S    P の中から呼出されるが、構文木生成するわけではなく意味チェックする
-#  G    コード生成（この段階で、構文木は完å
-¨ã§ã‚る．不完å
-¨ãªã‚‰ã‚¨ãƒ©ãƒ¼ã§æ‰“ちきられている）
-#                                                   factory の第一引数 "format" の後ろの引数
-
-# mikan 以下は ruby の mix in で実現できるかもしれない
-# Nestable ã‚’ç¶™æ‰¿ã—ãŸå ´åˆã€ã‚¯ãƒ©ã‚¹å¤‰æ•°ã¯ Nestable のものがå
-±æœ‰ã•ã‚Œã‚‹ï¼ˆåˆ¥ã«ã—たかった）
+# このメンテナンス状況はよろしくない
+#  B    bnf.y.rb から呼出される
+#  P    parse 段階で呼出される（bnf.y.rb から直接呼出されるわけではないが、構文木生成を行う）
+#  S    P の中から呼出されるが、構文木生成するわけではなく意味チェックする
+#  G    コード生成（この段階で、構文木は完全である．不完全ならエラーで打ちきられている）
+#                                                   factory の第一引数 "format" の後ろの引数
+
+# mikan 以下は ruby の mix in で実現できるかもしれない
+# Nestable を継承した場合、クラス変数は Nestable のものが共有される（別にしたかった）
 # class Nestable
 #   @@nest_stack_index = -1
@@ -90 +72 @@
 #  @name:: Symbol
 #  @global_name:: Symbol
-#  @function_head_list:: NamedList : FuncHead ã®ã‚¤ãƒ³ã‚¹ã‚¿ãƒ³ã‚¹ãŒè¦ç´ 
-#  @func_name_to_id::  {String}  :  関数名を添字とするé
-åˆ—で id を記憶する．id は signature ã®å‡ºç¾é †ç•ª (1から始まる)
-#  @context:: string : コンテキスト名
-#  @b_callback:: bool: callback : コールバック用のシグニチャ
-#  @b_deviate:: bool: deviate : 逸脱（pointer level mismatch を出さない）
-#  @b_checked_as_allocator_signature:: bool:  アロケータシグニチャとしてチェック済み
-#  @b_empty:: Bool: 空(関数が一つもない状æ
-‹)
+#  @function_head_list:: NamedList : FuncHead のインスタンスが要素
+#  @func_name_to_id::  {String}  :  関数名を添字とする配列で id を記憶する．id は signature の出現順番 (1から始まる)
+#  @context:: string : コンテキスト名
+#  @b_callback:: bool: callback : コールバック用のシグニチャ
+#  @b_deviate:: bool: deviate : 逸脱（pointer level mismatch を出さない）
+#  @b_checked_as_allocator_signature:: bool:  アロケータシグニチャとしてチェック済み
+#  @b_empty:: Bool: 空(関数が一つもない状態)
 
   @@nest_stack_index = -1
@@ -119 +99 @@
 
   # STAGE: P
-  # このメソッドは parse 中のみ呼び出される
+  # このメソッドは parse 中のみ呼び出される
   def self.get_current
     @@current_object
@@ -130 +110 @@
     @name = name
     Namespace.new_signature( self )
-    set_namespace_path # @NamespacePath の設定
+    set_namespace_path # @NamespacePath の設定
     if "#{Namespace.get_global_name}" == "" then
       @global_name = @name
@@ -152 +132 @@
     @function_head_list = function_head_list
 
-    # id を割付ける
+    # id を割付ける
     id = 1
     function_head_list.get_items.each{ |f|
@@ -166 +146 @@
   end
 
-  #=== Signature# signature の指定子を設定
+  #=== Signature# signature の指定子を設定
   # STAGE: B
   #spec_list::      [ [ :CONTEXT,  String ], ... ]
   #                     s[0]        s[1]
   def set_specifier_list( spec_list )
-    return if spec_list == nil  # 空ならば何もしない
+    return if spec_list == nil  # 空ならば何もしない
 
     spec_list.each { |s|
@@ -216 +196 @@
   end
 
-  #=== Signature# 関数名から signature å†
-の id を得る
+  #=== Signature# 関数名から signature 内の id を得る
   def get_id_from_func_name func_name
     @func_name_to_id[ func_name ]
   end
 
-  #=== Signature# context を得る
-  # context 文字列を返す "task", "non-task", "any"
-  # 未指定時のデフォルトとして task を返す
+  #=== Signature# context を得る
+  # context 文字列を返す "task", "non-task", "any"
+  # 未指定時のデフォルトとして task を返す
   def get_context
     if @context then
@@ -233 +212 @@
   end
 
-  #=== Signature# signaure のすべての関数のすべてのパラメータをたどる
-  #block:: ブロックを引数に取る
-  # ブロックは2つの引数を受け取る  Decl, ParamDecl     ( Decl: 関数ヘッダ )
-  # Port クラスにも each_param がある（同じ働き）
-  def each_param # ブロック引数 { |func_decl, param_decl| }
-    fha = get_function_head_array                       # 呼び口または受け口のシグニチャの関数é
-åˆ—
-    return if fha == nil                                # nil なら文法エラーで有効値が設定されなかった
-
-    pr = Proc.new   # このメソッドのブロック引数を pr に代å
-¥
-    fha.each{ |fh|  # fh: FuncHead                      # 関数é
-åˆ—ä¸­ã®å„é–¢æ•°é ­éƒ¨
-      fd = fh.get_declarator                            # fd: Decl  (é–¢æ•°é ­éƒ¨ã‹ã‚‰Declarotorを得る)
-      if fd.is_function? then                           # fd が関数でなければ、すでにエラー
-        fd.get_type.get_paramlist.get_items.each{ |par| # すべてのパラメータについて
+  #=== Signature# signaure のすべての関数のすべてのパラメータをたどる
+  #block:: ブロックを引数に取る
+  # ブロックは2つの引数を受け取る  Decl, ParamDecl     ( Decl: 関数ヘッダ )
+  # Port クラスにも each_param がある（同じ働き）
+  def each_param # ブロック引数 { |func_decl, param_decl| }
+    fha = get_function_head_array                       # 呼び口または受け口のシグニチャの関数配列
+    return if fha == nil                                # nil なら文法エラーで有効値が設定されなかった
+
+    pr = Proc.new   # このメソッドのブロック引数を pr に代入
+    fha.each{ |fh|  # fh: FuncHead                      # 関数配列中の各関数頭部
+      fd = fh.get_declarator                            # fd: Decl  (関数頭部からDeclarotorを得る)
+      if fd.is_function? then                           # fd が関数でなければ、すでにエラー
+        fd.get_type.get_paramlist.get_items.each{ |par| # すべてのパラメータについて
           pr.call( fd, par )
         }
@@ -255 +231 @@
   end
 
-  #=== Signature# 正当なアロケータ シグニチャかテストする
-  # alloc, dealloc 関数を持つかどうか、第一引き数がそれぞれ、整数、ポインタ、第二引き数が、ポインタへのポインタ、なし
+  #=== Signature# 正当なアロケータ シグニチャかテストする
+  # alloc, dealloc 関数を持つかどうか、第一引き数がそれぞれ、整数、ポインタ、第二引き数が、ポインタへのポインタ、なし
   def is_allocator?
 
-    # 一回だけチェックする
+    # 一回だけチェックする
     if @b_checked_as_allocator_signature == true then
       return true
@@ -265 +241 @@
     @b_checked_as_allocator_signature = true
 
-    fha = get_function_head_array                       # 呼び口または受け口のシグニチャの関数é
-åˆ—
-    if fha == nil then                                  # nil なら文法エラーで有効値が設定されなかった
+    fha = get_function_head_array                       # 呼び口または受け口のシグニチャの関数配列
+    if fha == nil then                                  # nil なら文法エラーで有効値が設定されなかった
       return false
     end
 
     found_alloc = false; found_dealloc = false
-    fha.each{ |fh|  # fh: FuncHead                      # 関数é
-åˆ—ä¸­ã®å„é–¢æ•°é ­éƒ¨
-      fd = fh.get_declarator                            # fd: Decl  (é–¢æ•°é ­éƒ¨ã‹ã‚‰Declarotorを得る)
-      if fd.is_function? then                           # fd が関数でなければ、すでにエラー
+    fha.each{ |fh|  # fh: FuncHead                      # 関数配列中の各関数頭部
+      fd = fh.get_declarator                            # fd: Decl  (関数頭部からDeclarotorを得る)
+      if fd.is_function? then                           # fd が関数でなければ、すでにエラー
         func_name = fd.get_name.to_sym 
         if func_name == :alloc then
@@ -284 +258 @@
                 ! params[0].get_type.get_original_type.kind_of?( IntType ) ||
                 params[0].get_direction != :IN then
-              # 第一引数が int 型でない
+              # 第一引数が int 型でない
               if ! params[0].instance_of?( ParamDecl ) ||
                   ! params[0].get_type.kind_of?( PtrType ) ||
@@ -290 +264 @@
                   params[0].get_type.get_type.get_type.kind_of?( PtrType ) ||
                   params[0].get_direction != :OUT then
-                # 第一引数がポインタ型でもない
+                # 第一引数がポインタ型でもない
                 cdl_error3( @locale, "S1003 $1: \'alloc\' 1st parameter neither [in] integer type nor [out] double pointer type", @name )
               end
@@ -298 +272 @@
                 params[1].get_type.get_type.get_type.kind_of?( PtrType ) ||
                 params[0].get_direction != :IN then
-              # (第一引数が整数で) 第二引数がポインタでない
+              # (第一引数が整数で) 第二引数がポインタでない
               cdl_error3( @locale, "S1004 $1: \'alloc\' 2nd parameter not [in] double pointer" , @name )
             end
@@ -313 +287 @@
                 params[0].get_direction != :IN then
               cdl_error3( @locale, "S1006 $1: \'dealloc\' 1st parameter not [in] pointer type" , @name )
-#            elsif params[1] != nil then    # 第二引き数はチェックしない
+#            elsif params[1] != nil then    # 第二引き数はチェックしない
 #              cdl_error3( @locale, "S1007 Error message is changed to empty" )
 #                 cdl_error3( @locale, "S1007 $1: \'dealloc\' cannot has 2nd parameter" , @name )
@@ -335 +309 @@
   end
 
-  #== Signature# 引数で参ç
-§ã•ã‚Œã¦ã„ã‚‹ Descriptor 型のリストを作成する
-  #RETURN:: Hash { Signature => ParamDecl }:  複数の ParamDecl から参ç
-§ã•ã‚Œã¦ã„ã‚‹å ´åˆã€æœ€å¾Œã®ã‚‚ã®ã—ã‹è¿”ã•ãªã„
+  #== Signature# 引数で参照されている Descriptor 型のリストを作成する
+  #RETURN:: Hash { Signature => ParamDecl }:  複数の ParamDecl から参照されている場合、最後のものしか返さない
   def get_descriptor_list
     desc_list = { }
     # p "has_desc #{@name}"
-    fha = get_function_head_array                       # 呼び口または受け口のシグニチャの関数é
-åˆ—
-    if fha == nil then                                  # nil ã®å ´åˆã€è‡ªå·±å‚ç
-§ã«ã‚ˆã‚‹ã‚±ãƒ¼ã‚¹ã¨ä»®å®š
+    fha = get_function_head_array                       # 呼び口または受け口のシグニチャの関数配列
+    if fha == nil then                                  # nil の場合、自己参照によるケースと仮定
       return desc_list
     end
     fha.each{ |fh|
-      fd = fh.get_declarator                            # fd: Decl  (é–¢æ•°é ­éƒ¨ã‹ã‚‰Declarotorを得る)
-      if fd.is_function? then                           # fd が関数でなければ、すでにエラー
+      fd = fh.get_declarator                            # fd: Decl  (関数頭部からDeclarotorを得る)
+      if fd.is_function? then                           # fd が関数でなければ、すでにエラー
         params = fd.get_type.get_paramlist.get_items
         if params then
@@ -369 +339 @@
   end
 
-  #=== Signature# 引数に Descriptor があるか？
+  #=== Signature# 引数に Descriptor があるか？
   def has_descriptor?
     # p "has_desc #{@name}"
-    fha = get_function_head_array                       # 呼び口または受け口のシグニチャの関数é
-åˆ—
-    if fha == nil then                                  # nil ã®å ´åˆã€è‡ªå·±å‚ç
-§ã«ã‚ˆã‚‹ã‚±ãƒ¼ã‚¹ã¨ä»®å®š
+    fha = get_function_head_array                       # 呼び口または受け口のシグニチャの関数配列
+    if fha == nil then                                  # nil の場合、自己参照によるケースと仮定
       return true
     end
     fha.each{ |fh|
-      fd = fh.get_declarator                            # fd: Decl  (é–¢æ•°é ­éƒ¨ã‹ã‚‰Declarotorを得る)
-      if fd.is_function? then                           # fd が関数でなければ、すでにエラー
+      fd = fh.get_declarator                            # fd: Decl  (関数頭部からDeclarotorを得る)
+      if fd.is_function? then                           # fd が関数でなければ、すでにエラー
         params = fd.get_type.get_paramlist.get_items
         if params then
@@ -399 +367 @@
   end
 
-  #=== Signature# コールバックか？
-  # 指定子 callback が指定されていれば true 
+  #=== Signature# コールバックか？
+  # 指定子 callback が指定されていれば true 
   def is_callback?
     @b_callback
   end
 
-  #=== Signature# 逸脱か？
-  # 指定子 deviate が指定されていれば true 
+  #=== Signature# 逸脱か？
+  # 指定子 deviate が指定されていれば true 
   def is_deviate?
     @b_deviate
   end
 
-  #=== Signature# 空か？
+  #=== Signature# 空か？
   def is_empty?
     @b_empty
   end
 
-  #=== Signature# Push Pop Allocator がå¿
-要か？
-  # Transparent RPC ã®å ´åˆ oneway かつ in のé
-åˆ—(size_is, count_is, string のいずれかで修飾）がある
+  #=== Signature# Push Pop Allocator が必要か？
+  # Transparent RPC の場合 oneway かつ in の配列(size_is, count_is, string のいずれかで修飾）がある
   def need_PPAllocator?( b_opaque = false )
-    fha = get_function_head_array                       # 呼び口または受け口のシグニチャの関数é
-åˆ—
+    fha = get_function_head_array                       # 呼び口または受け口のシグニチャの関数配列
     fha.each{ |fh|
       fd = fh.get_declarator
@@ -457 +422 @@
 # @factory_list::   Factory[]
 # @ct_factory_list::    Factory[] :    celltype factory
-# @cell_list:: Cell[] : 定義のみ (V1.0.0.2 以降)
+# @cell_list:: Cell[] : 定義のみ (V1.0.0.2 以降)
 # @singleton:: bool
 # @idx_is_id:: bool
 # @idx_is_id_act:: bool: actual value
 # @active:: bool
-# @b_reuse:: bool :  reuse 指定されて import された(template 不要)
-# @generate:: [ Symbol, String, Plugin ]  = [ PluginName, option, Plugin ] Plugin ã¯ç”Ÿæˆå¾Œã«è¿½åŠ ã•ã‚Œã‚‹
+# @b_reuse:: bool :  reuse 指定されて import された(template 不要)
+# @generate:: [ Symbol, String, Plugin ]  = [ PluginName, option, Plugin ] Plugin は生成後に追加される
 #
 # @n_attribute_ro:: int >= 0    none specified
@@ -470 +435 @@
 # @n_var:: int >= 0
 # @n_var_size_is:: int >= 0     # of [size_is] specified vars # mikan count_is
-# @n_var_omit:: int >= 0        # of [omit] specified vars # mikan var の omit は有？
+# @n_var_omit:: int >= 0        # of [omit] specified vars # mikan var の omit は有？
 # @n_var_init:: int >= 0        # of vars with initializer
 # @n_call_port:: int >= 0
 # @n_call_port_array:: int >= 0
-# @n_call_port_omitted_in_CB:: int >= 0   最適化で省略される呼び口
+# @n_call_port_omitted_in_CB:: int >= 0   最適化で省略される呼び口
 # @n_entry_port:: int >= 0
 # @n_entry_port_array:: int >= 0
 # @n_entry_port_inline:: int >= 0
-# @n_cell_gen:: int >= 0  ç”Ÿæˆã™ã‚‹ã‚»ãƒ«ã®æ•°ï¼Žã‚³ãƒ¼ãƒ‰ç”Ÿæˆã®é ­ã§ç®—å‡ºã™ã‚‹ï¼Žæ„å‘³è§£æžæ®µéšŽã§ã¯å‚ç
-§ä¸å¯
-# @id_base:: Integer : cell の ID の最小値(最大値は @id_base + @n_cell)
+# @n_cell_gen:: int >= 0  生成するセルの数．コード生成の頭で算出する．意味解析段階では参照不可
+# @id_base:: Integer : cell の ID の最小値(最大値は @id_base + @n_cell)
 #
-# @b_cp_optimized:: bool : 呼び口最適化実施
-# @plugin:: PluginObject      このセルタイプがプラグインにより生成された CDL ã‹ã‚‰ç”Ÿæˆã•ã‚ŒãŸå ´åˆã«æœ‰åŠ¹ã€‚
-#                              generate の指定は @generate にプラグインが保持される
+# @b_cp_optimized:: bool : 呼び口最適化実施
+# @plugin:: PluginObject      このセルタイプがプラグインにより生成された CDL から生成された場合に有効。
+#                              generate の指定は @generate にプラグインが保持される
 #
-# @included_header:: Hash :  include されたヘッダファイル
-# @domain_roots::Hash { DomainTypeName(Symbol) => [ Region ] }  ドメインタイプ名と Region のé
-åˆ— (optimize.rb で設定)
-#                                               ルートリージョンはドメイン名が　nil
+# @included_header:: Hash :  include されたヘッダファイル
+# @domain_roots::Hash { DomainTypeName(Symbol) => [ Region ] }  ドメインタイプ名と Region の配列 (optimize.rb で設定)
+#                                               ルートリージョンはドメイン名が　nil
 
   include PluginModule
@@ -553 +516 @@
 
     @plugin = Generator.get_plugin
-      # plugin ã®å ´åˆ PluginObject が返される
-    # å
-ƒã® Generator から呼出された Generator の中でパースおよび意味チェックされている
+      # plugin の場合 PluginObject が返される
+    # 元の Generator から呼出された Generator の中でパースおよび意味チェックされている
 
     # if @plugin then
-    #  # plugin 生成されるセルタイプは再利用ではない   #833 不å
-·åˆä¿®æ­£
+    #  # plugin 生成されるセルタイプは再利用ではない   #833 不具合修正
     #  @b_reuse = false
     # else
@@ -573 +534 @@
 
     Namespace.new_celltype( self )
-    set_namespace_path # @NamespacePath の設定
+    set_namespace_path # @NamespacePath の設定
     set_specifier_list( Generator.get_statement_specifier )
 
@@ -589 +550 @@
   end
 
-  #== Celltype#ドメインルートを返す
-  # @domain_roots の説明を参ç
-§
+  #== Celltype#ドメインルートを返す
+  # @domain_roots の説明を参照
   def get_domain_roots
     @domain_roots
@@ -598 +558 @@
   # Celltype# end_of_parse
   def end_of_parse
-    # 属性・変数のチェック
+    # 属性・変数のチェック
     check_attribute
 
-    # アロケータ呼び口をå†
-部生成
+    # アロケータ呼び口を内部生成
     generate_allocator_port
 
-    # リレーアロケータ、å†
-部アロケータの設定
+    # リレーアロケータ、内部アロケータの設定
     @port.each { |p|
       p.set_allocator_instance
@@ -666 +624 @@
       end
       if a.get_initializer then
-        # 登録後にチェックしても問題ない（attr を参ç
-§ã§ããªã„ので、自己参ç
-§ã—ない）
+        # 登録後にチェックしても問題ない（attr を参照できないので、自己参照しない）
         a.get_type.check_init( @locale, a.get_identifier, a.get_initializer, :ATTRIBUTE )
       end
@@ -674 +630 @@
   end
 
-  #=== Celltype# celltype の attribute/var のチェック
+  #=== Celltype# celltype の attribute/var のチェック
   # STAGE:  S
   #
-  # このメソッドは celltype のパースが完了した時点で呼出される．
+  # このメソッドは celltype のパースが完了した時点で呼出される．
   def check_attribute
-    # attribute の size_is 指定が妥当かチェック
+    # attribute の size_is 指定が妥当かチェック
     (@attribute+@var).each{ |a|
       if a.get_size_is then
         if ! a.get_type.kind_of?( PtrType ) then
-          # size_is がポインタ型以外に指定された
+          # size_is がポインタ型以外に指定された
           cdl_error( "S1011 $1: size_is specified for non-pointer type" , a.get_identifier )
         else
 
-          # 参ç
-§ã™ã‚‹å¤‰æ•°ãŒå­˜åœ¨ã—、計算可能な型かチェックする
-          size = a.get_size_is.eval_const( @name_list )  # C_EXP の可能性あり
+          # 参照する変数が存在し、計算可能な型かチェックする
+          size = a.get_size_is.eval_const( @name_list )  # C_EXP の可能性あり
           init = a.get_initializer
           if init then
             if ! init.instance_of?( Array ) then
-              # 初期化子がé
-åˆ—ではない
+              # 初期化子が配列ではない
               cdl_error( "S1012 $1: unsuitable initializer, need array initializer" , a.get_identifier )
             elsif size.kind_of?( Integer ) && size < init.length then
-              # size_is 指定された個数よりも初期化子のé
-åˆ—è¦ç´ が多い
+              # size_is 指定された個数よりも初期化子の配列要素が多い
               cdl_error( "S1013 $1: too many initializer, $2 for $3" , a.get_identifier, init.length, size )
-            # elsif a.get_size_is.eval_const( nil ) == nil  # C_EXP の可能性あり
+            # elsif a.get_size_is.eval_const( nil ) == nil  # C_EXP の可能性あり
             end
 
@@ -710 +663 @@
               ( a.get_initializer.instance_of?( Expression ) &&
                 a.get_initializer.eval_const2(@name_list).instance_of?( Array ) ) then
-            # size_is 指定されていないポインタが Array で初期化されていたら、エラー
+            # size_is 指定されていないポインタが Array で初期化されていたら、エラー
             cdl_error( "S1159 $1: non-size_is pointer cannot be initialized with array initializer" , a.get_identifier )
           end
@@ -722 +675 @@
   end
 
-  #=== Celltype# アロケータ呼び口を生成
-  #    send, receive 引数のアロケータを呼出すための呼び口を生成
+  #=== Celltype# アロケータ呼び口を生成
+  #    send, receive 引数のアロケータを呼出すための呼び口を生成
   def generate_allocator_port
     @port.each { |port|
-      # ポートのすべてのパラメータを辿る
+      # ポートのすべてのパラメータを辿る
       port.each_param { |port, fd, par|
-        case par.get_direction                        # 引数の方向指定子 (in, out, inout, send, receive )
+        case par.get_direction                        # 引数の方向指定子 (in, out, inout, send, receive )
         when :SEND, :RECEIVE
           if par.get_allocator then
-            cp_name = :"#{port.get_name}_#{fd.get_name}_#{par.get_name}"     # アロケータ呼び口の名前
-            #           ポート名          関数名         パラメータ名
-            # alloc_sig_path = [ par.get_allocator.get_name ]  # mikan Namespace アロケータ呼び口のシグニチャ #1
+            cp_name = :"#{port.get_name}_#{fd.get_name}_#{par.get_name}"     # アロケータ呼び口の名前
+            #           ポート名          関数名         パラメータ名
+            # alloc_sig_path = [ par.get_allocator.get_name ]  # mikan Namespace アロケータ呼び口のシグニチャ #1
             alloc_sig_path = par.get_allocator.get_namespace_path
-            array_size = port.get_array_size            # 呼び口または受け口é
-åˆ—のサイズ
-            created_port = Port.new( cp_name, alloc_sig_path, :CALL, array_size ) # 呼び口を生成
+            array_size = port.get_array_size            # 呼び口または受け口配列のサイズ
+            created_port = Port.new( cp_name, alloc_sig_path, :CALL, array_size ) # 呼び口を生成
             created_port.set_allocator_port( port, fd, par )
             if port.is_optional? then
@@ -745 +697 @@
               created_port.set_omit
             end
-            new_port( created_port )                    # ã‚»ãƒ«ã‚¿ã‚¤ãƒ—ã«æ–°ã—ã„å‘¼ã³å£ã‚’è¿½åŠ 
+            new_port( created_port )                    # セルタイプに新しい呼び口を追加
           # else
           #  already error "not found or not signature" in class ParamDecl
@@ -762 +714 @@
   end
 
-  #=== Celltype# 新しいå†
-部変数
+  #=== Celltype# 新しい内部変数
   #var:: [Decl]
   def new_var( var )
@@ -776 +727 @@
       @name_list.add_item( i )
 
-      # size_is 指定されたé
-åˆ—? mikan  count_is
+      # size_is 指定された配列? mikan  count_is
       if i.get_size_is then
         @n_var_size_is += 1
@@ -793 +743 @@
   end
 
-  #=== Celltype# celltype の指定子を設定
+  #=== Celltype# celltype の指定子を設定
   def set_specifier_list( spec_list )
     return if spec_list == nil
@@ -822 +772 @@
 
   def new_require( ct_or_cell_nsp, ep_name, cp_name )
-    # Require: set_owner するものがない
+    # Require: set_owner するものがない
     obj = Namespace.find( ct_or_cell_nsp )    #1
     if obj.instance_of? Celltype then
-      # Celltype 名で指定
+      # Celltype 名で指定
       ct = obj
     elsif obj.instance_of? Cell then
-      # Cell 名で指定
+      # Cell 名で指定
       ct = obj.get_celltype
     elsif obj == nil then
@@ -839 +789 @@
 
     if( ! ct.is_singleton? ) then
-      # シングルトンではない
+      # シングルトンではない
       cdl_error( "S1018 $1 : not singleton cell" , obj.get_name )
     end
 
-    # 受け口を探す
+    # 受け口を探す
     obj2 = ct.find( ep_name )
     if( ( ! obj2.instance_of? Port ) || obj2.get_port_type != :ENTRY ) then
@@ -854 +804 @@
 
     if obj2.get_signature == nil then
-      # signature が未定義：既にエラー
+      # signature が未定義：既にエラー
       return
     end
@@ -860 +810 @@
     require_call_port_prefix = :_require_call_port
     if cp_name == nil then
-      # 関数名重複チェック
+      # 関数名重複チェック
       @require.each{ |req|
         unless req[0].to_s =~ /^#{require_call_port_prefix}/ then
-          next     # 名前ありの require は関数名重複チェックしない
+          next     # 名前ありの require は関数名重複チェックしない
         end
         port = req[2]
         if port.get_signature == obj2.get_signature then
-          # 同じ signature （すべて同じ関数名を持つ）個別に出すのではなく、まとめてエラーとする
+          # 同じ signature （すべて同じ関数名を持つ）個別に出すのではなく、まとめてエラーとする
           cdl_error( "S1021 $1 : require cannot have same signature with \'$2\'" , obj2.get_name, port.get_name )
           next
         end
         port.get_signature.get_function_head_array.each{ |f|
-          # mikan ここは、namedList からの検索にならないの？（効率が悪い）
+          # mikan ここは、namedList からの検索にならないの？（効率が悪い）
           obj2.get_signature.get_function_head_array.each{ |f2|
             if( f.get_name == f2.get_name ) then
@@ -888 +838 @@
       b_has_name = true
     end
-    # require ã‚’è¿½åŠ 
+    # require を追加
     @require << [ cp_name, obj, obj2 ]  # [ lhs:cp_name, rhs:Celltype, rhs:Port ]
 
-    # require port ã‚’è¿½åŠ  (å‘¼ã³å£ã¨ã—ã¦è¿½åŠ ã™ã‚‹ã€‚ãŸã ã— require をセットしておく)
+    # require port を追加 (呼び口として追加する。ただし require をセットしておく)
     port = Port.new( cp_name, obj2.get_signature.get_namespace_path, :CALL )
     port.set_require( b_has_name )
@@ -913 +863 @@
   end
 
-  #=== Celltype# セルタイププラグイン (generate 指定子)
+  #=== Celltype# セルタイププラグイン (generate 指定子)
   def celltype_plugin
 
@@ -927 +877 @@
 
     begin
-      eval( eval_str )     # plugin を生成
+      eval( eval_str )     # plugin を生成
       plugin_object.set_locale @locale
       @generate[ 2 ] = plugin_object
@@ -939 +889 @@
   end
 
-  #=== Celltype# celltype に新しい cell ã‚’è¿½åŠ 
+  #=== Celltype# celltype に新しい cell を追加
   #cell:: Cell
-  # æ–°ã—ã„ã‚»ãƒ«ã‚’ã‚»ãƒ«ã‚¿ã‚¤ãƒ—ã«è¿½åŠ ï¼Ž
-  # セルの構文解釈の最後でこのメソドを呼出される．
-  # シングルトンセルが同じ linkunit に複数ないかチェック
+  # 新しいセルをセルタイプに追加．
+  # セルの構文解釈の最後でこのメソドを呼出される．
+  # シングルトンセルが同じ linkunit に複数ないかチェック
   def new_cell( cell )
-    # Celltype では Cell の set_owner しない
-    # ã‚·ãƒ³ã‚°ãƒ«ãƒˆãƒ³ã§ã€ãƒ—ãƒ­ãƒˆã‚¿ã‚¤ãƒ—å®£è¨€ã§ãªã„å ´åˆã€ã‚³ãƒ¼ãƒ‰ç”Ÿæˆå¯¾è±¡ãƒªãƒ¼ã‚¸ãƒ§ãƒ³ã®å ´åˆ
+    # Celltype では Cell の set_owner しない
+    # シングルトンで、プロトタイプ宣言でない場合、コード生成対象リージョンの場合
     if @singleton  then
       @cell_list.each{ |c|
@@ -960 +910 @@
   end
 
-  #=== Celltype# セルタイプは INIB を持つか？
-  # セルタイプが INIB を持つかどうかを判定する
-  # $rom == false のとき:  INIB を持たない． （すべては CB に置かれる）
-  # $rom == true のとき、INIB に置かれるものが一つでも存在すれば INIB を持つ
-  #   INIB に置かれるものは
-  #     attribute (omit のものは除く．現仕様では rw のものはない)
-  #     size_is を伴う var
-  #     呼び口（ただし、最適化で不要となるものは除く）
+  #=== Celltype# セルタイプは INIB を持つか？
+  # セルタイプが INIB を持つかどうかを判定する
+  # $rom == false のとき:  INIB を持たない． （すべては CB に置かれる）
+  # $rom == true のとき、INIB に置かれるものが一つでも存在すれば INIB を持つ
+  #   INIB に置かれるものは
+  #     attribute (omit のものは除く．現仕様では rw のものはない)
+  #     size_is を伴う var
+  #     呼び口（ただし、最適化で不要となるものは除く）
   def has_INIB?
 #    print "name=#{@name} @n_attribute_ro=#{@n_attribute_ro}  @n_var_size_is=#{@n_var_size_is} @n_call_port=#{@n_call_port} @n_call_port_omitted_in_CB=#{@n_call_port_omitted_in_CB} @n_entry_port_array_ns=#{@n_entry_port_array_ns}\n"
@@ -974 +924 @@
   end
 
-  #=== Celltype# セルタイプは CB を持つか？
-  # $rom == true のとき、いかのものが置かれる．それらの一つでも存在すれば CB を持つ
-  #   size_is が指定されていない var
-  #   rw 指定された attribute (現仕様では存在しない)
-  # $rom == false のとき、いかのものが置かれる．それらの一つでも存在すれば CB を持つ
+  #=== Celltype# セルタイプは CB を持つか？
+  # $rom == true のとき、いかのものが置かれる．それらの一つでも存在すれば CB を持つ
+  #   size_is が指定されていない var
+  #   rw 指定された attribute (現仕様では存在しない)
+  # $rom == false のとき、いかのものが置かれる．それらの一つでも存在すれば CB を持つ
   #   attribute
   #   var
-  #   呼び口（ただし、最適化で不要となるものは除く）
+  #   呼び口（ただし、最適化で不要となるものは除く）
   def has_CB?
     if $rom then
@@ -991 +941 @@
   end
 
-  #=== Celltype# SET_CB_INIB_POINTER, INITIALIZE_CB がå¿
-要か
+  #=== Celltype# SET_CB_INIB_POINTER, INITIALIZE_CB が必要か
   def need_CB_initializer?
     @n_var_init > 0 || has_CB?
   end
 
-  #=== Celltype# 逆require の結合を生成する
+  #=== Celltype# 逆require の結合を生成する
   def create_reverse_require_join cell
     @port.each{ |p|
@@ -1004 +953 @@
   end
 
-  #=== Celltype# singleton セルを得る
-  #region:: Region   : singleton を探す Region
-  # 距離が最も近いものを返す
-  # mikan 本当は region の範囲の singleton を探すå¿
-要がある
+  #=== Celltype# singleton セルを得る
+  #region:: Region   : singleton を探す Region
+  # 距離が最も近いものを返す
+  # mikan 本当は region の範囲の singleton を探す必要がある
   def get_singleton_cell region
     cell = nil
-    dist = 999999999 # mikan 制限値（これは十分すぎるほどデカイが）
-    # require: celltype で指定
+    dist = 999999999 # mikan 制限値（これは十分すぎるほどデカイが）
+    # require: celltype で指定
     @cell_list.each{ |c|
-      # 到達可能で最も近いセルを探す（複数の singleton があるかもしれない）
+      # 到達可能で最も近いセルを探す（複数の singleton があるかもしれない）
       d = region.distance( c.get_region )
       #debug
@@ -1033 +981 @@
   end
 
-  #=== Celltype# セルタイププラグインを得る
+  #=== Celltype# セルタイププラグインを得る
   def get_celltype_plugin
     if @generate then
@@ -1052 +1000 @@
   end
 
-  #=== Celltype# アクティブではないか
-  # このメソッドでは active の他に factory (singleton においては FACTORYを含む)がなければ inactive とする
+  #=== Celltype# アクティブではないか
+  # このメソッドでは active の他に factory (singleton においては FACTORYを含む)がなければ inactive とする
   def is_inactive?
     if @active == false && @factory_list.length == 0 &&
@@ -1074 +1022 @@
   end
 
-  #=== Celltype# コード生成するå¿
-要があるか判定
-  # セルの個数が 0 ならセルタイプコードは生成不要
+  #=== Celltype# コード生成する必要があるか判定
+  # セルの個数が 0 ならセルタイプコードは生成不要
   def need_generate?
     @n_cell_gen > 0
   end
 
-  #=== Celltype# require 呼び口の結合を行う
+  #=== Celltype# require 呼び口の結合を行う
   # STAGE: S
-  # セルタイプの require 呼び口について、結合を行う
-  # セルが生成されないかチェックを行う
+  # セルタイプの require 呼び口について、結合を行う
+  # セルが生成されないかチェックを行う
   def set_require_join
     @require.each{ |req|
@@ -1100 +1047 @@
   end
 
-  #=== Celltype# inline 受け口しかないか？
-  # å—ã‘å£ãŒç„¡ã„å ´åˆã€ã™ã¹ã¦ã®å—ã‘å£ãŒ inline とはしない
+  #=== Celltype# inline 受け口しかないか？
+  # 受け口が無い場合、すべての受け口が inline とはしない
   def is_all_entry_inline?
     @n_entry_port == @n_entry_port_inline && @n_entry_port > 0
@@ -1140 +1087 @@
 # @n_var:: int >= 0
 # @n_var_size_is:: int >= 0     # of [size_is] specified cells # mikan count_is
-# @n_var_omit:: int >= 0        # of [omit] specified  cells # mikan var の omit は有？
+# @n_var_omit:: int >= 0        # of [omit] specified  cells # mikan var の omit は有？
 # @n_call_port:: int >= 0
 # @n_call_port_array:: int >= 0
-# @n_call_port_omitted_in_CB:: int >= 0   最適化で省略される呼び口
+# @n_call_port_omitted_in_CB:: int >= 0   最適化で省略される呼び口
 # @n_entry_port:: int >= 0
 # @n_entry_port_array:: int >= 0
     (indent+1).times { print "  " }
     puts "@n_entry_port_inline #{@n_entry_port_inline}"
-# @n_cell:: int >= 0  ã‚³ãƒ¼ãƒ‰ç”Ÿæˆã®é ­ã§ç®—å‡ºã™ã‚‹ï¼Žæ„å‘³è§£æžæ®µéšŽã§ã¯å‚ç
-§ä¸å¯
-# @id_base:: Integer : cell の ID の最小値(最大値は @id_base + @n_cell)
+# @n_cell:: int >= 0  コード生成の頭で算出する．意味解析段階では参照不可
+# @id_base:: Integer : cell の ID の最小値(最大値は @id_base + @n_cell)
 
   end
@@ -1156 +1102 @@
 
 class Cell < NSBDNode # < Nestable
-# @name:: Symbol : composite celltype のå†
-側のインスタンスでは外のセル
-# @global_name:: Symbol : C で使える名前（namespace を含む）
-# @local_name:: str : cell celltype name { ... } の name
+# @name:: Symbol : composite celltype の内側のインスタンスでは外のセル
+# @global_name:: Symbol : C で使える名前（namespace を含む）
+# @local_name:: str : cell celltype name { ... } の name
 # @celltype:: Celltype | CompositeCelltype
 # @join_list:: NamedList
@@ -1166 +1111 @@
 # @b_prototype:: bool:  prototype specified in current parsing cell. (@b_defined is used to determine whether definition done)
 # @b_duplicate:: bool:  definition duplicate
-# @b_checked::   bool:  set_definition_join ãŒæ¸ˆã‚“ã§ã„ã‚‹å ´åˆ true
-# @require_joined_list:: {cp_name=>true}:  set_require_join が済んでいる呼び口は true
+# @b_checked::   bool:  set_definition_join が済んでいる場合 true
+# @require_joined_list:: {cp_name=>true}:  set_require_join が済んでいる呼び口は true
 # @f_ref:: refercenced from others
-# @entry_array_max_subscript:: { @port=>Integer } : 受け口é
-åˆ—のé
-åˆ—添数の最大値（添数無し受け口é
-åˆ—対応）
+# @entry_array_max_subscript:: { @port=>Integer } : 受け口配列の配列添数の最大値（添数無し受け口配列対応）
 # @plugin::     Plugin: avialble if cell is generated by plugin generated cdl code.
-# @referenced_port_list:: { Port => Integer } : 受け口の参ç
-§æ•°
-#                                               すべての意味解析(through, composite展開)が終わった後に設定する
-#                                               逆require ポートに対して複数の結合がないかチェックする
-# @generate:: [ Symbol, String, Plugin ]  = [ PluginName, option, Plugin ] Plugin ã¯ç”Ÿæˆå¾Œã«è¿½åŠ ã•ã‚Œã‚‹
+# @referenced_port_list:: { Port => Integer } : 受け口の参照数
+#                                               すべての意味解析(through, composite展開)が終わった後に設定する
+#                                               逆require ポートに対して複数の結合がないかチェックする
+# @generate:: [ Symbol, String, Plugin ]  = [ PluginName, option, Plugin ] Plugin は生成後に追加される
 #
-# composite のためインスタンス変数
+# composite のためインスタンス変数
 # @in_composite:: bool : true if in composite celltype
 # @compositecelltypejoin_list:: NamedList : item= CompositeCelltypeJoin ( if @in_composite )
 # @f_cloned:: bool : true if cloned (instantiate of composite consist cell)
-# @my_clone:: Cell : Composite cell で in_composite = true ã®å ´åˆã®ã¿æœ‰åŠ¹ï¼ˆç›´å‰ã® clone を一時記憶）
-# @cell_list:: Cell[local_name] : Composite cell で clone した後のリスト cell_list
-# @cell_list2:: [ Cell ] : Composite cell で clone した後のリスト cell_list
-#                          @cell_list2 は composite å†
-ã§ã®å‡ºç¾é †  
+# @my_clone:: Cell : Composite cell で in_composite = true の場合のみ有効（直前の clone を一時記憶）
+# @cell_list:: Cell[local_name] : Composite cell で clone した後のリスト cell_list
+# @cell_list2:: [ Cell ] : Composite cell で clone した後のリスト cell_list
+#                          @cell_list2 は composite 内での出現順  
 #
-# region のためのインスタンス変数
-# @region:: Region (属するregion)
+# region のためのインスタンス変数
+# @region:: Region (属するregion)
 #
-# allocator のためのインスタンス変数
+# allocator のためのインスタンス変数
 # @alloc_list::  [ [ NORMAL_ALLOC, ep_name, func_name, param_name, expr ], ... ]
-#   å—ã‘å£å´ã®ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿ã¸ã®çµåˆã‚’è¨˜æ†¶ã€‚ä»¥ä¸‹ã®ãƒ¡ã‚½ãƒƒãƒ‰ã§è¿½åŠ ã•ã‚Œã‚‹
-#      set_specifier … cell å®šç¾©æ™‚ã«ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿æŒ‡å®šã•ã‚Œã¦ã„ã‚‹å ´åˆ
-#      create_relay_allocator_join … ãƒªãƒ¬ãƒ¼ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿ã®å ´åˆ
+#   受け口側のアロケータへの結合を記憶。以下のメソッドで追加される
+#      set_specifier … cell 定義時にアロケータ指定されている場合
+#      create_relay_allocator_join … リレーアロケータの場合
 #
-# ID のためのインスタンス変数（optimize.rb にて設定）
-# @id:: Integer : コード生成直前に設定  (ãƒ—ãƒ­ãƒˆã‚¿ã‚¤ãƒ—å®£è¨€ã®å ´åˆã¯ -1 のまま放置)
-# @id_specified::Integer : 指定された id
+# ID のためのインスタンス変数（optimize.rb にて設定）
+# @id:: Integer : コード生成直前に設定  (プロトタイプ宣言の場合は -1 のまま放置)
+# @id_specified::Integer : 指定された id
 # @restrict_list::{ entry_name => { func_name, [ region_name, ... ] } }
 
 =begin
-# Cell クラスは、以下のものを扱う
-# 1)普通のセル
-# 2)composite セルタイプのセル
-# 3)composite セルタイプのå†
-側のセル (@in_composite)   # composite のå†
-側の composite セルタイプのセルもある
+# Cell クラスは、以下のものを扱う
+# 1)普通のセル
+# 2)composite セルタイプのセル
+# 3)composite セルタイプの内側のセル (@in_composite)   # composite の内側の composite セルタイプのセルもある
 #
-# 2) は CellOfComposite クラスとして分けたほうがよいかもしれない
-#    expand (composite セルの展開) は CellOfComposite にのみå¿
-要なメソッドである
-#    get_real_cell, get_real_port など @celltype.instance_of?( CompositeCelltype ) の判定がなくすっきりする
-#    ただ、分離しても、メンテナンスすべき範囲が切り離されてしまい、忘れやすくなる問題とのトレードオフかも
+# 2) は CellOfComposite クラスとして分けたほうがよいかもしれない
+#    expand (composite セルの展開) は CellOfComposite にのみ必要なメソッドである
+#    get_real_cell, get_real_port など @celltype.instance_of?( CompositeCelltype ) の判定がなくすっきりする
+#    ただ、分離しても、メンテナンスすべき範囲が切り離されてしまい、忘れやすくなる問題とのトレードオフかも
 #
-# 3) は CellInCompoiste クラスとして分けたほうがよいかもしれない
-#    @in_composite で判定している処理を切り離せる (上記 2) よりも分離は容易ではない)
-#    clone_for_composite は CellInCompoiste にのみå¿
-要なメソッドである
-#    ただし、clone 後に Cell, CellOfComposite に変化するå¿
-要があるので、clone ではなく new する実è£
-に変更するå¿
-要がある
+# 3) は CellInCompoiste クラスとして分けたほうがよいかもしれない
+#    @in_composite で判定している処理を切り離せる (上記 2) よりも分離は容易ではない)
+#    clone_for_composite は CellInCompoiste にのみ必要なメソッドである
+#    ただし、clone 後に Cell, CellOfComposite に変化する必要があるので、clone ではなく new する実装に変更する必要がある
 #
 =end
@@ -1235 +1168 @@
   @@current_object = nil
 
-  # å®šç¾©ã•ã‚ŒãŸã™ã¹ã¦ã®ã‚»ãƒ«ï¼ˆå‡ºç¾é †. namespace に影響されない）
-  @@cell_list = []     # composite のå†
-部のセルを含まない
-  @@cell_list2 = []    # composite のå†
-部のセルを含む (å
-ƒã®ã‚»ãƒ«ã‚’含む)
-                       # 意味解析後 make_cell_list2 にて設定される
+  # 定義されたすべてのセル（出現順. namespace に影響されない）
+  @@cell_list = []     # composite の内部のセルを含まない
+  @@cell_list2 = []    # composite の内部のセルを含む (元のセルを含む)
+                       # 意味解析後 make_cell_list2 にて設定される
 
   def self.push
@@ -1258 +1188 @@
 
 
-  # composite で clone されたもの（子孫まで含む）
-  # Join.change_rhs_port にて CompoisteCelltype å†
-の Join の結合å
-ˆã‚’変更する際に使用
+  # composite で clone されたもの（子孫まで含む）
+  # Join.change_rhs_port にて CompoisteCelltype 内の Join の結合先を変更する際に使用
   @@cloned_cell_list = {}
-  ### mikan BUG @@cloned_cell_list は composite の階層ごとに記憶していないため、同じ名前がå†
-部に現れると、うまく動作しない
-  # change_rhs_port の実è£
-は、こんな回りくどいことをするå¿
-要はなかった。右辺に現れるセル名には、composite のセル名を前につなげるだけでよかった
+  ### mikan BUG @@cloned_cell_list は composite の階層ごとに記憶していないため、同じ名前が内部に現れると、うまく動作しない
+  # change_rhs_port の実装は、こんな回りくどいことをする必要はなかった。右辺に現れるセル名には、composite のセル名を前につなげるだけでよかった
 
   def initialize( ct_path, in_composite = false )
@@ -1273 +1198 @@
     @region = Region.get_current
 
-    # celltype のplugin/存在をチェック
+    # celltype のplugin/存在をチェック
     object = Namespace.find( ct_path )    #1
     if object == nil then
-      # mikan celltype の名前が不完å
-¨ "::ct1ct2" になる
+      # mikan celltype の名前が不完全 "::ct1ct2" になる
       cdl_error( "S1027 \'$1\' celltype not found" , ct_path.get_path_str )
     elsif ! object.instance_of?( Celltype ) && ! object.instance_of?( CompositeCelltype ) then
-      # mikan celltype の名前が不完å
-¨
+      # mikan celltype の名前が不完全
       cdl_error( "S1028 \'$1\' not celltype" , ct_path.get_path_str )
     else
@@ -1329 +1252 @@
     end
 
-    # この時点ではプロトタイプか、定義か分らないが、自己参ç
-§ã®ãŸã‚ã«ç™»éŒ²
-    # set_f_def で再度登録しなおす
-    # Celltype への登録は、end_of_parse で行う
+    # この時点ではプロトタイプか、定義か分らないが、自己参照のために登録
+    # set_f_def で再度登録しなおす
+    # Celltype への登録は、end_of_parse で行う
     if @in_composite then
       cell_prev = CompositeCelltype.find( name )
@@ -1339 +1261 @@
       end
     else
-      # cell_prev = Namespace.find( [ name ] )   # 親まで捜しにいく
+      # cell_prev = Namespace.find( [ name ] )   # 親まで捜しにいく
       cell_prev = Namespace.get_current.find( name )
       if cell_prev == nil then
         Namespace.new_cell( self )
-        set_namespace_path # @NamespacePath の設定
+        set_namespace_path # @NamespacePath の設定
       end
     end
@@ -1350 +1272 @@
       if ! cell_prev.instance_of?( Cell ) then
         cdl_error( "S1029 $1 mismatch with previous one" , name )
-        # celltype が一致しているか ?
+        # celltype が一致しているか ?
       elsif get_celltype != cell_prev.get_celltype then
         cdl_error( "S1030 $1: celltype mismatch with previous one" , name )
       else
-        # region が一致しているか?
+        # region が一致しているか?
         if ! cell_prev.get_region.equal? get_region then
           cdl_error( "S1031 $1 region \'$2\' mismatch  with previous one \'$3\'" , name, @region.get_name, cell_prev.get_region.get_name )
@@ -1360 +1282 @@
 
         @@current_object = cell_prev
-        # この時点では、まだプロトタイプ宣言か定義か分らない
-        # ä»¥å‰ãŒå®šç¾©ã§ã‚ã£ã¦ã€ä»Šå›žã‚‚å®šç¾©ã®å ´åˆã€é‡è¤‡ã‚¨ãƒ©ãƒ¼ã§ã‚ã‚‹
+        # この時点では、まだプロトタイプ宣言か定義か分らない
+        # 以前が定義であって、今回も定義の場合、重複エラーである
       end
     end
@@ -1371 +1293 @@
     dbgPrint "Cell new_cell: #{@global_name} #{@in_composite} #{self}\n"
 
-    # å†
-部アロケータを @alloc_list ã«è¿½åŠ 
+    # 内部アロケータを @alloc_list に追加
     if @celltype.instance_of? CompositeCelltype then
       @celltype.get_internal_allocator_list.each{ |cell, cp_internal_name, port_name, fd_name, par_name, ext_alloc_ent|
         nsp = NamespacePath.new( @name, false )
-        rhs = Expression.new( [:OP_DOT, [:IDENTIFIER, nsp], Token.new( ext_alloc_ent.to_s.to_sym, nil, nil, nil ) ] )  #1 構文解析段階なので locale 不要
+        rhs = Expression.new( [:OP_DOT, [:IDENTIFIER, nsp], Token.new( ext_alloc_ent.to_s.to_sym, nil, nil, nil ) ] )  #1 構文解析段階なので locale 不要
 
         @alloc_list << [:NORMAL_ALLOC,port_name,nil,fd_name,par_name,rhs]
@@ -1384 +1305 @@
   end
 
-  #=== Cell# cell の定義
-  # 本体(join)の定義の直前に呼び出される
+  #=== Cell# cell の定義
+  # 本体(join)の定義の直前に呼び出される
   def self.new_def
     @@current_object.new_def
   end
 
-  #=== Cell# cell の定義
-  # 本体(join)の定義の直前に呼び出される
-  # このメソッドは cell tCelltype Cell { };  '{', '}' ã®éƒ¨åˆ†ãŒã‚ã‚‹å ´åˆã«å‘¼å‡ºã•ã‚Œã‚‹
+  #=== Cell# cell の定義
+  # 本体(join)の定義の直前に呼び出される
+  # このメソッドは cell tCelltype Cell { };  '{', '}' の部分がある場合に呼出される
   def new_def
     set_specifier_list( Generator.get_statement_specifier )
 
-    # prototype 指定子ないか
+    # prototype 指定子ないか
     if ! @b_prototype then
-      # 二重定義のチェック
+      # 二重定義のチェック
       if @b_defined == true then
         cdl_error( "S1032 $1: duplicate cell" , @name )
         dbgPrint "previous: #{@prev_locale[0]}: line #{@prev_locale[1]} '#{@name}' defined here\n"
 
-        # セルの重複定義エラーの処置
-        # 前の定義は捨てる
+        # セルの重複定義エラーの処置
+        # 前の定義は捨てる
         @join_list = NamedList.new( nil, "in cell '#{@name}'" )
       end
@@ -1417 +1338 @@
   end
 
-  #===  Cell# 新しい結合をチェック
+  #===  Cell# 新しい結合をチェック
   # STAGE:   P
   #
-  #join::  Join : 新しい結合
-  #b_regular:: bool : é€šå¸¸ã®å ´æ‰€ (bnf.y.rb)からならば true, それ以外(allocator, require) では false
+  #join::  Join : 新しい結合
+  #b_regular:: bool : 通常の場所 (bnf.y.rb)からならば true, それ以外(allocator, require) では false
   def new_join( join, b_regular = false )
     join.set_owner self
 
-    # composite の新文法対応．
-    # composite の中のセルで、attribute ã®å®šç¾©ã§ã‚ã‚‹å ´åˆ
-    # cell å†
-の attr_ext = composite.attr; 構文を処理
+    # composite の新文法対応．
+    # composite の中のセルで、attribute の定義である場合
+    # cell 内の attr_ext = composite.attr; 構文を処理
     if @in_composite then
       if @celltype then
-        if @celltype.find(join.get_name).instance_of?( Decl ) then # mikan a::b で指定されていたものがエラーにならないかも
+        if @celltype.find(join.get_name).instance_of?( Decl ) then # mikan a::b で指定されていたものがエラーにならないかも
           rhs = join.get_rhs
           if rhs.instance_of? Expression then
             ele = rhs.get_elements
-            if( ele[0]==:IDENTIFIER )then    #  attr = attr_ext （右辺単é 
-）か？ #1
-              if( CompositeCelltype.has_attribute?(ele[1].get_name ) )then    # mikan a::b.ePort がエラーにならないかも
-                ident = ele[1].get_name   # 右辺は attribute．
+            if( ele[0]==:IDENTIFIER )then    #  attr = attr_ext （右辺単項）か？ #1
+              if( CompositeCelltype.has_attribute?(ele[1].get_name ) )then    # mikan a::b.ePort がエラーにならないかも
+                ident = ele[1].get_name   # 右辺は attribute．
               else
-                # 右辺は attribute にないのであれば、定数のはず
-                # 定数は下へ渡す (cell の join にする)
+                # 右辺は attribute にないのであれば、定数のはず
+                # 定数は下へ渡す (cell の join にする)
                 ident = nil
               end
             else
-              if join.get_rhs.eval_const2(nil) == nil then   # 定数式ではないか？
-                # å³è¾ºãŒã€å˜ä¸€ã®ã‚·ãƒ³ãƒœãƒ«ã§ãªã„å ´åˆã€ç¾çŠ¶ã¯æ‰±ãˆãªã„
+              if join.get_rhs.eval_const2(nil) == nil then   # 定数式ではないか？
+                # 右辺が、単一のシンボルでない場合、現状は扱えない
                 cdl_error( "S1033 rhs expression is not supported. Only attribute is permitted on current version."  )
                 return
               else
-                # 定数は下へ渡す (cell の join にする)
+                # 定数は下へ渡す (cell の join にする)
                 ident = nil
               end
@@ -1456 +1375 @@
 
             if ident then
-              # attr = attr; のような参ç
-§ã¯ã‚¨ãƒ©ãƒ¼ (a = composite.a とするå¿
-要がある)
+              # attr = attr; のような参照はエラー (a = composite.a とする必要がある)
               if @celltype.find( ident ) then
                 cdl_error( "S1034 $1 : cannot refer to $2\'s attribute here. Use \'composite.$3\' to refer to composite celltype\'s" , ident, @celltype.get_name, ident )
@@ -1464 +1381 @@
             end
           elsif rhs.instance_of? Array then
-            if rhs[0] == :COMPOSITE then   # 右辺は composite.attr の形式
+            if rhs[0] == :COMPOSITE then   # 右辺は composite.attr の形式
               ident = rhs[1].to_sym
             else
-              ident = nil    # 右辺は { 10, -10 } の形式
+              ident = nil    # 右辺は { 10, -10 } の形式
             end
           else
-            ident = nil      # 右辺は C_EXP の形式
+            ident = nil      # 右辺は C_EXP の形式
           end
 
-          # ident が見つかった（右辺は単一の ident）
+          # ident が見つかった（右辺は単一の ident）
           if ident then
-            # composite の旧文法の構文処理へ渡す．セル外の attr_ext = Cell.attr; 構文の処理に渡す
+            # composite の旧文法の構文処理へ渡す．セル外の attr_ext = Cell.attr; 構文の処理に渡す
             #                        export_name, internal_cell_name, internal_cell_elem_name
-            decl = CompositeCelltype.new_join( ident, @name, join.get_name, :ATTRIBUTE )  # mikan a::b.ePort がエラーにならないかも
+            decl = CompositeCelltype.new_join( ident, @name, join.get_name, :ATTRIBUTE )  # mikan a::b.ePort がエラーにならないかも
             if ! decl.instance_of? Decl then
               return
@@ -1485 +1402 @@
               return
             end
-            # 以下の旧文法実è£
-に渡す．
-            # 旧文法では cell に初期値を与えることで、composite で属性の初期値を指定することができた
-            # attribute で指定された初期値を cell の属性として処理させる
+            # 以下の旧文法実装に渡す．
+            # 旧文法では cell に初期値を与えることで、composite で属性の初期値を指定することができた
+            # attribute で指定された初期値を cell の属性として処理させる
             join.change_rhs( ini )
           else
-            # ident がない．定数式
+            # ident がない．定数式
           end
         else
-          # celltype の属性として、この join の名前がない
-          # 以下の join.set_definition の中でエラーとなる
+          # celltype の属性として、この join の名前がない
+          # 以下の join.set_definition の中でエラーとなる
         end
       else
-        return    # celltype がない．すでにエラー
+        return    # celltype がない．すでにエラー
       end
     elsif join.get_rhs.instance_of? Array then
       rhs = join.get_rhs
       if rhs[0] == :COMPOSITE then
-        # composite の中でないのに attr = composite.attr が使われた
+        # composite の中でないのに attr = composite.attr が使われた
         cdl_error( "S1035 composite : cannot specify out of composite celltype definition"  )
         return
@@ -1509 +1425 @@
     end
 
-    # 以下 composite 文法変更前からある処理
-
-    # 既に左辺が同じ名前の初期化が存在するか？
-    j = @join_list.get_item( join.get_name )   # mikan NamespacePath がパスを持っている
-    if j.instance_of? Join then    # mikan ここでは j が Join or Nil 以外は、ないはず
+    # 以下 composite 文法変更前からある処理
+
+    # 既に左辺が同じ名前の初期化が存在するか？
+    j = @join_list.get_item( join.get_name )   # mikan NamespacePath がパスを持っている
+    if j.instance_of? Join then    # mikan ここでは j が Join or Nil 以外は、ないはず
 
       # debug
       dbgPrint "add_array_member: #{@name} port: #{j.get_port_name} rhs: #{j.get_rhs}, #{join.get_port_name} #{join.get_rhs}\n"
-      # 呼び口é
-åˆ—ï¼ˆã§ã‚ã‚‹ã¨ä»®å®šã—ã¦ï¼‰è¦ç´ ã‚’è¿½åŠ 
+      # 呼び口配列（であると仮定して）要素を追加
       j.add_array_member join
 
@@ -1526 +1441 @@
     end
 
-    # if get_owner then   # error S1030 発生時 get_owner が見つからなくて例外になる
+    # if get_owner then   # error S1030 発生時 get_owner が見つからなくて例外になる
     #   dbgPrint "Cell#new_join: #{get_owner.get_name}.#{@name}\n"
     # else
@@ -1540 +1455 @@
   end
 
-  #=== Cell.新しい逆結合
+  #=== Cell.新しい逆結合
   def self.new_reverse_join( reverse_join )
     @@current_object.new_reverse_join( reverse_join )
   end
 
-  #=== Cell#新しい逆結合
+  #=== Cell#新しい逆結合
   def new_reverse_join( reverse_join )
     dbgPrint( "new_reverse_join name=#{reverse_join.get_name}\n")
@@ -1570 +1485 @@
   end
 
-  #=== Cell#逆結合から結合を生成
+  #=== Cell#逆結合から結合を生成
   # STAGE: S
   def create_reverse_join
@@ -1580 +1495 @@
 #      @reverse_join_list.get_items.each{ |rj|
       @reverse_join_list.each{ |rj|
-        # 逆結合のæƒ
-å ±ã‚’å¾—ã‚‹
+        # 逆結合の情報を得る
         ep_name = rj.get_name
         ep_subscript, cp_cell_nsp, cp_name, cp_subscript = rj.get_rhs_cell_and_port
 
-        # 呼び口側のセルと、そのセルタイプ
+        # 呼び口側のセルと、そのセルタイプ
         cell = Namespace.find cp_cell_nsp
         if ! cell.instance_of? Cell then
@@ -1616 +1530 @@
   end
 
-  #=== Cell# cell å†
-に記述する呼び口の外部結合
-  # internal_cell_elem_name:: string : 呼び口名
-  # export_name:: string: composite の外部にå
-¬é–‹ã™ã‚‹å‘¼ã³å£å
-  #  呼び口を外部結合する．
-  #  このメソッドは、composite の中の cell でしか呼ばれない．
+  #=== Cell# cell 内に記述する呼び口の外部結合
+  # internal_cell_elem_name:: string : 呼び口名
+  # export_name:: string: composite の外部に公開する呼び口名
+  #  呼び口を外部結合する．
+  #  このメソッドは、composite の中の cell でしか呼ばれない．
   def external_join( internal_cell_elem_name, export_name, b_composite )
 
-    # cCall => composite.cCall; ではないか？
+    # cCall => composite.cCall; ではないか？
     if( b_composite == false )then
-      # cCall => cCall; ã®ã‚ˆã†ãªå ´åˆ
+      # cCall => cCall; のような場合
       if @celltype.find( export_name ) then
         cdl_error( "S1036 $1 : cannot refer to $2\'s here. Use \'composite.$3\' to refer to composite celltype\'s" , export_name, @celltype.get_name, export_name )
       end
     end
-    # composite の旧文法における、cell 外の cCall = Cell.cCall; の構文処理に渡す
+    # composite の旧文法における、cell 外の cCall = Cell.cCall; の構文処理に渡す
     CompositeCelltype.new_join( export_name, @name,  internal_cell_elem_name, :CALL )
   end
@@ -1644 +1556 @@
 
   def end_of_parse f_def
-    if @b_prototype then  # prototype 指定子あったか?
-      f_def = false       # プロトタイプ宣言とする
+    if @b_prototype then  # prototype 指定子あったか?
+      f_def = false       # プロトタイプ宣言とする
       @b_prototype = false
     end
     if f_def == false then
-      # cell tCelltype Cell; ã®å½¢å¼ã®å ´åˆ
-      # f_def == true ã®å ´åˆ new_def で、呼出される
+      # cell tCelltype Cell; の形式の場合
+      # f_def == true の場合 new_def で、呼出される
       set_specifier_list( Generator.get_statement_specifier )
     end
@@ -1660 +1572 @@
   end
 
-  #=== Cell# プロトタイプ宣言(false)か定義(true)かを設定
-  #    このメソッドは構文解釈の最後に呼出される
+  #=== Cell# プロトタイプ宣言(false)か定義(true)かを設定
+  #    このメソッドは構文解釈の最後に呼出される
   #f_def::     bool     false if prototype, true if definition
   def set_f_def f_def
@@ -1680 +1592 @@
     @f_ref = true
 
-    # composite のå†
-部セルを参ç
-§ã•ã‚ŒãŸã“とにする
-    # 今のところ問題ないが、未参ç
-§ã§ã‚るべきものまで参ç
-§ã•ã‚ŒãŸã“とになる
+    # composite の内部セルを参照されたことにする
+    # 今のところ問題ないが、未参照であるべきものまで参照されたことになる
     if @cell_list then
       @cell_list.each{ |cn,cell|
@@ -1693 +1601 @@
   end
 
-  #=== Cell# cell の指定子を設定
+  #=== Cell# cell の指定子を設定
   # STAGE:  B
   #
-  #    bnf.y.rb の statement_specifiler_list
+  #    bnf.y.rb の statement_specifiler_list
   #spec_list::      [ :ALLOCATOR, [ [ :NORMAL_ALLOC, ep_name, subscript, func_name, param_name, expr ], ... ] ]
   #                     s[0]      s[1]   a[0]        a[1]       a[2]        a[3]     a[4]       a[5]
-  #    セルに指定されたアロケータ指定子
-  #    a[1] の subscript はこのメソッドの中で Expression から Integer に評価される
-  #    受け口側に生成されるアロケータ呼び口の結合をå†
-部生成する
-  #    呼び口側は Port の create_allocator_join にて生成
-  #    ãƒªãƒ¬ãƒ¼ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿ã®å ´åˆ create_relay_allocator_join にて生成す
+  #    セルに指定されたアロケータ指定子
+  #    a[1] の subscript はこのメソッドの中で Expression から Integer に評価される
+  #    受け口側に生成されるアロケータ呼び口の結合を内部生成する
+  #    呼び口側は Port の create_allocator_join にて生成
+  #    リレーアロケータの場合 create_relay_allocator_join にて生成す
   def set_specifier_list( spec_list )
-    return if spec_list == nil  # 空ならば何もしない
+    return if spec_list == nil  # 空ならば何もしない
 
     dbgPrint( "set_spec_list: #{@name}\n" )
-    b_generate = false   # generate が指定された
+    b_generate = false   # generate が指定された
 
     spec_list.each{ |s|
       case s[0]             # statement_specifier
       when :ALLOCATOR       # [allocator(ePort.func.param=allocCell.eA,ePort.func2.param=allocCell.eA)]
-        s[1].each { |a|     # alloc_list : allocator のå†
-部の ',' で区切られた部分のé
-åˆ—
-          cp_name = :"#{a[0+1]}_#{a[2+1]}_#{a[3+1]}"    # アロケータ呼び口の名前：'=' の左辺を '.' に変えて '_' で連結
+        s[1].each { |a|     # alloc_list : allocator の内部の ',' で区切られた部分の配列
+          cp_name = :"#{a[0+1]}_#{a[2+1]}_#{a[3+1]}"    # アロケータ呼び口の名前：'=' の左辺を '.' に変えて '_' で連結
           # p "#{a[0]} #{a[0+1]} #{a[2+1]} #{a[3+1]} #{cp_name}"
           if a[1+1] then
@@ -1725 +1630 @@
             subscript = nil
           end
-          # アロケータ呼び口の結合を生成
-          join = Join.new( cp_name, subscript, a[4+1] )   # 構文解析段階なので locale 不要
+          # アロケータ呼び口の結合を生成
+          join = Join.new( cp_name, subscript, a[4+1] )   # 構文解析段階なので locale 不要
           dbgPrint( "new allocator join #{cp_name} #{subscript} #{a[4+1]}\n" )
           Cell.new_join( join )
@@ -1772 +1677 @@
   def get_allocator_list
 
-    # 意味チェック(set_definition)されていない？
-    # relay ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿ã®å ´åˆã€ã‚»ãƒ«ã®æ„å‘³ãƒã‚§ãƒƒã‚¯ãŒè¡Œã‚ã‚Œã¦ã„ãªã„ã¨ã€@alloc_list が完成しない
+    # 意味チェック(set_definition)されていない？
+    # relay アロケータの場合、セルの意味チェックが行われていないと、@alloc_list が完成しない
     if @b_checked == false then
       set_definition_join
@@ -1784 +1689 @@
   end
 
-  #=== id 指定子の値を設定
-  # このメソッドは、プラグインで cell ã®ç”Ÿæˆé †åºã‚’åˆ¶å¾¡ã—ãŸã„å ´åˆã®ãŸã‚ã«è¨­ã‘ãŸ
-  # 通常の id 指定子では使っていない
+  #=== id 指定子の値を設定
+  # このメソッドは、プラグインで cell の生成順序を制御したい場合のために設けた
+  # 通常の id 指定子では使っていない
   def set_specified_id id
     if Integer( id ) != id || id <= 0 then
@@ -1797 +1702 @@
   end
 
-  #=== Cell# セルタイププラグイン (generate 指定子)
+  #=== Cell# セルタイププラグイン (generate 指定子)
   def cell_plugin
 
@@ -1811 +1716 @@
 
     begin
-      eval( eval_str )     # plugin を生成
+      eval( eval_str )     # plugin を生成
       plugin_object.set_locale @locale
       @generate[ 2 ] = plugin_object
@@ -1827 +1732 @@
   end
 
-  #=== Cell# cell を composite セルタイプのセル用に clone する
-  #name::        string : 親 cell の名前  (cell tComposite cell1 での cell1)
-  #global_name:: string : 親 cell の global_name 
-  #join_array::  Join[] : composite の cell の join で、この cell に対応するもの
-  #ct_name::     string : 親セルのセルタイプ名
-  #region::      Region : å
-ƒã®ã‚»ãƒ«ãŒå±žã™ã‚‹ region
-  #このメソッドは CompositeCelltype の expand から呼出される
+  #=== Cell# cell を composite セルタイプのセル用に clone する
+  #name::        string : 親 cell の名前  (cell tComposite cell1 での cell1)
+  #global_name:: string : 親 cell の global_name 
+  #join_array::  Join[] : composite の cell の join で、この cell に対応するもの
+  #ct_name::     string : 親セルのセルタイプ名
+  #region::      Region : 元のセルが属する region
+  #このメソッドは CompositeCelltype の expand から呼出される
   def clone_for_composite( name, global_name, namespacePath, join_array, ct_name, region, plugin, locale )
 
@@ -1843 +1747 @@
     @@cloned_cell_list[ self ] = @my_clone
 
-    # clone したセルのå†
-部に持つ名前æƒ
-å ±ã‚’èª¿æ•´ã™ã‚‹
+    # clone したセルの内部に持つ名前情報を調整する
 
     @my_clone.set_cloned( name, global_name, namespacePath, join_array, ct_name, region, plugin, locale )
 
-    # @celltype == nil は以前にセルタイプ未定義エラー
+    # @celltype == nil は以前にセルタイプ未定義エラー
     if @b_defined == true && @celltype != nil then
       if @celltype.instance_of?( Celltype ) then
-        # celltype に登録（コード生成の対象となる）
+        # celltype に登録（コード生成の対象となる）
         @celltype.new_cell( @my_clone )
       end
@@ -1860 +1762 @@
   end
 
-  #=== Cell# clone されたセルのå†
-部に持つ名前æƒ
-å ±ã‚’èª¿æ•´ã™ã‚‹
-  #name::        string : 親 cell の名前  (cell tComposite cell1 での cell1)
-  #global_name:: string : 親 cell の global_name
-  #join_array::  Join[] : composite の cell の join で、この cell に対応するもの
-  #parent_ct_name:: string : 親セルのセルタイプ名（composite セルタイプ）
-  #  このメソッドはすぐ上の clone_for_composite から呼出され、clone されたセルを整える
+  #=== Cell# clone されたセルの内部に持つ名前情報を調整する
+  #name::        string : 親 cell の名前  (cell tComposite cell1 での cell1)
+  #global_name:: string : 親 cell の global_name
+  #join_array::  Join[] : composite の cell の join で、この cell に対応するもの
+  #parent_ct_name:: string : 親セルのセルタイプ名（composite セルタイプ）
+  #  このメソッドはすぐ上の clone_for_composite から呼出され、clone されたセルを整える
   def set_cloned( name, global_name, namespacePath, join_array, parent_ct_name, region, plugin, locale )
 
@@ -1884 +1784 @@
     @f_cloned = true
 
-    # Namespace.new_cell( self )  # mikan namespace 対応
-    region.new_cell( self )  # mikan  namespace に cell を置けないことを仮定
-
-    # join_list : NamedList の clone を作る
+    # Namespace.new_cell( self )  # mikan namespace 対応
+    region.new_cell( self )  # mikan  namespace に cell を置けないことを仮定
+
+    # join_list : NamedList の clone を作る
     if @celltype then
       dbgPrint "set_cloned: #{@celltype.get_name} #{@name} #{region.get_name}\n"
@@ -1900 +1800 @@
     @cell_list2 = []
 
-    # このセルのグローバル名を与える
-    # C_EXP の$id$ 置換はこのセルの名前になる
+    # このセルのグローバル名を与える
+    # C_EXP の$id$ 置換はこのセルの名前になる
     join_array.each { |j|
       @join_list.change_item j
     }
 
-    # clone しようとするセルが composit セルタイプ？
+    # clone しようとするセルが composit セルタイプ？
     if @celltype.instance_of?( CompositeCelltype ) then
-      # composite cell を再帰的に展開
+      # composite cell を再帰的に展開
       @cell_list, @cell_list2 = @celltype.expand( @name, @global_name, @NamespacePath, @join_list, @region, @plugin, @locale )
     end
@@ -1914 +1814 @@
   end
 
-  #=== Cell# clone された cell の join_list の右辺の変更
-  #  呼び口の右辺の cell を他の clone された cell に置換え
+  #=== Cell# clone された cell の join_list の右辺の変更
+  #  呼び口の右辺の cell を他の clone された cell に置換え
   def change_rhs_port
 
@@ -1927 +1827 @@
     if @celltype.instance_of?( CompositeCelltype ) then
 
-      # å
-¥ã‚Œå­ã®ã‚»ãƒ«ã«ã¤ã„ても変更
+      # 入れ子のセルについても変更
       @cell_list.each{ |name,c|
         c.change_rhs_port
@@ -1967 +1866 @@
   end
 
-  #=== Cell# 生成されるセルか？
-  # 最適化、コード生成中に、対象となる region ã«å±žã™ã‚‹å ´åˆ true を返す
+  #=== Cell# 生成されるセルか？
+  # 最適化、コード生成中に、対象となる region に属する場合 true を返す
   def is_generate?
     if $generating_region == nil then
-      # 構文解釈、意味解析段階で呼ばれると例外発生
+      # 構文解釈、意味解析段階で呼ばれると例外発生
       raise "is_generate? called before optimizing"
     end
@@ -1983 +1882 @@
   end
 
-  #=== Cell# composite å†
-部の複製されたセルか？
-  # composite 定義のå†
-部のセル (@in_composite = true) ではない
+  #=== Cell# composite 内部の複製されたセルか？
+  # composite 定義の内部のセル (@in_composite = true) ではない
   def is_cloned?
     @f_cloned
   end
 
-  #=== Cell# composite å†
-部のセルか？
+  #=== Cell# composite 内部のセルか？
   def is_in_composite?
     @in_composite
   end
 
-  # composite cell の port に対応するå†
-部の cell の port の名前（リンク時にå¿
-要な名前）
+  # composite cell の port に対応する内部の cell の port の名前（リンク時に必要な名前）
   def get_real_global_name port_name
     if @celltype.instance_of?( CompositeCelltype ) then
@@ -2027 +1921 @@
   end
 
-  #=== Cell# セルの受け口 port_name に対する実際のセル名、受け口名を '_' で連結
-  #    namespace 名 + '_' + セル名 + '_' + 受け口名   （このセルが composite ならば展開後のセル名、受け口名）
+  #=== Cell# セルの受け口 port_name に対する実際のセル名、受け口名を '_' で連結
+  #    namespace 名 + '_' + セル名 + '_' + 受け口名   （このセルが composite ならば展開後のセル名、受け口名）
   def get_real_global_port_name port_name
 
-    # composite か？
+    # composite か？
     if @celltype.instance_of?( CompositeCelltype ) then
 
@@ -2042 +1936 @@
       }
 
-      # セルタイプå†
-で port_name の CompositeCelltypeJoin を探す（コード生成段階ではå¿
-ず見つかる）
+      # セルタイプ内で port_name の CompositeCelltypeJoin を探す（コード生成段階では必ず見つかる）
       cj = @celltype.find_export( port_name )
 
@@ -2050 +1942 @@
       dbgPrint "   composite join name: #{cj.get_name}  cell: #{cj.get_cell_name}  cell elem: #{cj.get_cell_elem_name}\n"
 
-      # composite のå†
-部のセルに対し再帰的に get_real_global_port_name を適用
+      # composite の内部のセルに対し再帰的に get_real_global_port_name を適用
       name = @cell_list[ "#{cj.get_cell_name}" ].get_real_global_port_name( cj.get_cell_elem_name )
       return name
@@ -2063 +1954 @@
   end
 
-  #=== Cell# PORT (celltype の定義) を得る
+  #=== Cell# PORT (celltype の定義) を得る
   def get_real_port( port_name )
 
-    # composite か？
+    # composite か？
     if @celltype.instance_of?( CompositeCelltype ) then
 
-      # セルタイプå†
-で port_name の CompositeCelltypeJoin を探す（コード生成段階ではå¿
-ず見つかる）
+      # セルタイプ内で port_name の CompositeCelltypeJoin を探す（コード生成段階では必ず見つかる）
       cj = @celltype.find_export( port_name )
 
-      # composite のå†
-部のセルに対し再帰的に get_real_port を適用
+      # composite の内部のセルに対し再帰的に get_real_port を適用
       port = @cell_list[ "#{cj.get_cell_name}" ].get_real_port( cj.get_cell_elem_name )
       return port
@@ -2084 +1972 @@
   end
 
-  #=== Cell# cell を得る
-  #    composite でなければ自分自身を返す
+  #=== Cell# cell を得る
+  #    composite でなければ自分自身を返す
   def get_real_cell( port_name )
 
-    # composite か？
+    # composite か？
     if @celltype.instance_of?( CompositeCelltype ) then
 
-      # セルタイプå†
-で port_name の CompositeCelltypeJoin を探す（コード生成段階ではå¿
-ず見つかる）
+      # セルタイプ内で port_name の CompositeCelltypeJoin を探す（コード生成段階では必ず見つかる）
       cj = @celltype.find_export( port_name )
 
-      # composite のå†
-部のセルに対し再帰的に get_real_port を適用
+      # composite の内部のセルに対し再帰的に get_real_port を適用
       cell = @cell_list[ "#{cj.get_cell_name}" ].get_real_cell( cj.get_cell_elem_name )
       return cell
@@ -2107 +1992 @@
 
 
-  #=== Cell# 受け口のport の参ç
-§ã‚«ã‚¦ãƒ³ãƒˆã‚’アップする
-  #port_name:: Symbol  : ポート名
+  #=== Cell# 受け口のport の参照カウントをアップする
+  #port_name:: Symbol  : ポート名
   def port_referenced port
     if @referenced_port_list[ port ] then
@@ -2117 +2001 @@
     end
 
-    # composite か？
+    # composite か？
     if @celltype.instance_of?( CompositeCelltype ) then
 
-      # セルタイプå†
-で port_name の CompositeCelltypeJoin を探す（コード生成段階ではå¿
-ず見つかる）
+      # セルタイプ内で port_name の CompositeCelltypeJoin を探す（コード生成段階では必ず見つかる）
       cj = @celltype.find_export( port.get_name )
 
       dbgPrint " port_referenced: #{@celltype.get_name} #{@name} cj=#{cj&&(cj.get_name)||"nil"}\n"
 
-      if cj then  # 既にエラー
-        # composite のå†
-部のセルに対し再帰的に get_real_port を適用
+      if cj then  # 既にエラー
+        # composite の内部のセルに対し再帰的に get_real_port を適用
         cell = @cell_list[ "#{cj.get_cell_name}" ]
         if cell && cell.get_celltype then
@@ -2181 +2062 @@
   end
 
-  #=== Cell# 受け口é
-åˆ—の添数の最大値を設定
+  #=== Cell# 受け口配列の添数の最大値を設定
   def set_entry_port_max_subscript( port, num )
     dbgPrint( "set_entry_port_max_subscript: #{@name}.#{port.get_name}: #{num}\n" )
@@ -2193 +2073 @@
   end
 
-  #=== Cell# composite のå†
-側セルの受け口é
-åˆ—の添数の最大値を設定
+  #=== Cell# composite の内側セルの受け口配列の添数の最大値を設定
   def set_entry_inner_port_max_subscript( port, num )
-    if @cell_list == nil then   # mikan これって問題ない？
-      return    # プロトタイプ宣言しかされていなくて、å†
-側セルが展開されていない
-    end
-
-    # composite のå†
-側のセルに伝播
+    if @cell_list == nil then   # mikan これって問題ない？
+      return    # プロトタイプ宣言しかされていなくて、内側セルが展開されていない
+    end
+
+    # composite の内側のセルに伝播
     if @celltype.instance_of? CompositeCelltype then
       cj = @celltype.find_export port.get_name
@@ -2217 +2093 @@
   end
 
-  #=== Cell# 受け口é
-åˆ—の添数の最大値を返す
-  # 長さは +1 する
-  # 1ã¤ã‚‚ãªã„å ´åˆã¯ -1 を返す
+  #=== Cell# 受け口配列の添数の最大値を返す
+  # 長さは +1 する
+  # 1つもない場合は -1 を返す
   def get_entry_port_max_subscript( port )
     subscript = @entry_array_max_subscript[port]
@@ -2229 +2104 @@
   end
 
-  #=== Cell# リレーアロケータの結合を生成
+  #=== Cell# リレーアロケータの結合を生成
   # STAGE: S
-  # 呼び口側の結合をå
-ƒã«å—け口側の結合を生成
+  # 呼び口側の結合を元に受け口側の結合を生成
   def create_relay_allocator_join
 
-    # celltype がなければチェックしない（既にエラー）
+    # celltype がなければチェックしない（既にエラー）
     return if @celltype == nil
 
-    # relay allocator を生成
+    # relay allocator を生成
     @celltype.get_port_list.each { |p|
       ail = p.get_allocator_instance
@@ -2244 +2118 @@
         dbgPrint "create_relay_allocator_join: #{@name}, #{p.get_name}\n"
         if p.get_array_size then
-          # mikan relay allocator が array に対応できてもよいのでは？
+          # mikan relay allocator が array に対応できてもよいのでは？
           cdl_error( "S1040 array not supported for relay allocator"  )
           next
@@ -2252 +2126 @@
           if ai2[0] == :RELAY_ALLOC then
             dbgPrint "create_relay_allocator_join: #{@name}, #{name}\n"
-            # 呼び口側の結合を取り出す
+            # 呼び口側の結合を取り出す
             ja = @join_list.get_item( :"#{ai2[3]}_#{ai2[4]}_#{ai2[5]}" )
             if ja == nil then
-              # è¦‹ã¤ã‹ã‚‰ãªã„å ´åˆ
+              # 見つからない場合
               found = false
               
-              # composite å†
-で外部に結合されているか
+              # composite 内で外部に結合されているか
               if @in_composite then
                 @compositecelltypejoin_list.get_items.each { |cj|
@@ -2276 +2149 @@
                 cdl_error( "S1041 \'$1_$2_$3\': not joined. cannot create internal join for relay allocator" , ai2[3], ai2[4], ai2[5] )
                 print( "      In cell #{get_name}\n" )
-                # join が未結合であることのエラーは二度でる (S1043)
+                # join が未結合であることのエラーは二度でる (S1043)
               end
-              next    # 打ち切る
+              next    # 打ち切る
             end
 
             b_export = false
-            # composite å†
-のセルでエクスポートされているかチェック
-            #  mikan エクスポート側と、こちら側で、リレーå
-ˆãŒä¸€è‡´ã™ã‚‹ã‹ãƒã‚§ãƒƒã‚¯ãŒå¿
-要
+            # composite 内のセルでエクスポートされているかチェック
+            #  mikan エクスポート側と、こちら側で、リレー先が一致するかチェックが必要
             if @compositecelltypejoin_list then
-              # export されているか調べる
+              # export されているか調べる
               @compositecelltypejoin_list.get_items.each{ |cj|
-                # 属性名と composite の export する名前は一致するか
+                # 属性名と composite の export する名前は一致するか
                 if p.get_name == cj.get_cell_elem_name then
                   print "export : #{p.get_name}\n"
-                  b_export = true    # 属性は export されているので、とりあえず未初期化とはしない
+                  b_export = true    # 属性は export されているので、とりあえず未初期化とはしない
                   break
                 end
@@ -2300 +2170 @@
             end
 
-            # mikan é
-åˆ—
+            # mikan 配列
             am = nil
             if am then
@@ -2308 +2177 @@
                 subscript = ja2.get_subscript
                 if b_export == false then
-                  # CompositeCelltype ã®å ´åˆã€å†
-側のセルで生成させる
+                  # CompositeCelltype の場合、内側のセルで生成させる
                   join = Join.new( :"#{p.get_name}_#{ai2[1]}_#{ai2[2]}", subscript, rhs, @loacle )
                   # p ( "#{p.get_name}_#{ai2[1]}_#{ai2[2]}", subscript, rhs )
                   new_join( join )
                   join.set_definition( @celltype.find(join.get_name) )
-                  # mikan relay mismatch チェックができていない（下方を参ç
-§ï¼‰
+                  # mikan relay mismatch チェックができていない（下方を参照）
                 end
                 @alloc_list << [ :NORMAL_ALLOC, p.get_name, subscript, ai2[1], ai2[2], rhs ]
@@ -2321 +2188 @@
             else
               if b_export == false then
-                # CompositeCelltype ã®å ´åˆã€å†
-側のセルで生成させる
+                # CompositeCelltype の場合、内側のセルで生成させる
                 join = Join.new( :"#{p.get_name}_#{ai2[1]}_#{ai2[2]}", nil, ja.get_rhs, @locale )
                 new_join( join )
@@ -2332 +2198 @@
                                       "#{p.get_name}_#{ai2[1]}_#{ai2[2]}",
                                       "#{ai2[3]}_#{ai2[4]}_#{ai2[5]}" )
-                    # 本当は composite の呼び口と受け口の間で行うべきだが、å†
-éƒ¨ã§å¤šæ®µæŽ¥ç¶šã•ã‚Œã¦ã„ã‚‹å ´åˆ
+                    # 本当は composite の呼び口と受け口の間で行うべきだが、内部で多段接続されている場合
                   else
                     dbgPrint "relay success:  #{p.get_name}_#{ai2[1]}_#{ai2[2]}=>#{ai2[3]}_#{ai2[4]}_#{ai2[5]} #{jr.get_rhs_cell2.get_name}.#{jr.get_rhs_port2} \n"
@@ -2348 +2213 @@
   end
 
-  #=== Cell# @@cell_list2 を作る
-  # @@cell_list2 ã¯ã€å‡ºç¾é †ã« composite å†
-を含むセルのリスト
+  #=== Cell# @@cell_list2 を作る
+  # @@cell_list2 は、出現順に composite 内を含むセルのリスト
   def self.make_cell_list2
     @@cell_list.each{ |c|
@@ -2358 +2222 @@
   end
 
-  #=== Cell# @@cell_list2 を得る
-  # composite å†
-を含む (compositeも含む)
-  # 意味解析後に作成される
+  #=== Cell# @@cell_list2 を得る
+  # composite 内を含む (compositeも含む)
+  # 意味解析後に作成される
   def self.get_cell_list2
     @@cell_list2
   end
 
-  #=== Cell# @@cell_list を得る
-  #composite の中を含まない
+  #=== Cell# @@cell_list を得る
+  #composite の中を含まない
   def self.get_cell_list
     @@cell_list
   end
 
-  #=== Cell# reverse_join を生成する
+  #=== Cell# reverse_join を生成する
   def self.create_reverse_join
     @@cell_list.each{ |c|
@@ -2384 +2247 @@
   end
 
-  #=== Cell# reverse_require_join を生成する
+  #=== Cell# reverse_require_join を生成する
   def self.create_reverse_require_join
     @@cell_list2.each{ |c|
@@ -2390 +2253 @@
       # if c.is_generate? then
         if ct then
-          # self への呼び口側の結合を生成
+          # self への呼び口側の結合を生成
           ct.create_reverse_require_join c
         end
@@ -2397 +2260 @@
   end
 
-  #=== Cell# 受け口のport の参ç
-§ã‚«ã‚¦ãƒ³ãƒˆã‚’設定する
-  # self は呼びå
-ƒã®ã‚»ãƒ«
-  # 呼びå
-ˆã‚»ãƒ«ã®å—け口の参ç
-§ã‚«ã‚¦ãƒ³ãƒˆã‚’アップする
+  #=== Cell# 受け口のport の参照カウントを設定する
+  # self は呼び元のセル
+  # 呼び先セルの受け口の参照カウントをアップする
   def set_port_reference_count
     @join_list.get_items.each { |j|
       if j.get_definition.instance_of? Port then
         am = j.get_array_member2
-        if am then             # 呼び口é
-åˆ—
+        if am then             # 呼び口配列
           am.each { |j2|
-            next if j2 == nil    # optional ã§ä¸€éƒ¨ãŒæ¬ è½ã—ã¦ã„ã‚‹ã‚±ãƒ¼ã‚¹
+            next if j2 == nil    # optional で一部が欠落しているケース
             cell = j2.get_rhs_cell2
-            next if cell == nil     # 右辺が見つからなかった．既にエラー
+            next if cell == nil     # 右辺が見つからなかった．既にエラー
             port = cell.get_celltype.find( j2.get_rhs_port2 )
             dbgPrint( "set_port_reference_count: #{@name}.#{j2.get_name} => #{cell.get_name}.#{port.get_name}\n")
@@ -2420 +2278 @@
         else
           cell = j.get_rhs_cell2
-          next if cell == nil     # 右辺が見つからなかった．既にエラー
+          next if cell == nil     # 右辺が見つからなかった．既にエラー
           port = cell.get_celltype.find( j.get_rhs_port2 )
           dbgPrint( "set_port_reference_count: #{@name}.#{j.get_name} => #{cell.get_name}.#{port.get_name}\n")
@@ -2429 +2287 @@
   end
 
-  #=== Cell# 結合(Join)のチェック
-  #     Join は呼び口の結合または attribute の初期化
+  #=== Cell# 結合(Join)のチェック
+  #     Join は呼び口の結合または attribute の初期化
   #
-  #  mikan このメソッドは、以下の４つのチェックからなるが、分割したほうがより適切な長さのメソッドになる
-  #  ・リレーアロケータの生成 => create_relay_allocator_join
-  #  ・未結合の呼び口のチェック
-  #  ・ポインタ型がé
-åˆ—ã§åˆæœŸåŒ–ã•ã‚Œã‚‹å ´åˆã®ãƒã‚§ãƒƒã‚¯
-  #  ・未初期化の属性のチェック
+  #  mikan このメソッドは、以下の４つのチェックからなるが、分割したほうがより適切な長さのメソッドになる
+  #  ・リレーアロケータの生成 => create_relay_allocator_join
+  #  ・未結合の呼び口のチェック
+  #  ・ポインタ型が配列で初期化される場合のチェック
+  #  ・未初期化の属性のチェック
   def check_join
 
-    # celltype がなければチェックしない（既にエラー）
+    # celltype がなければチェックしない（既にエラー）
     return if @celltype == nil
     return if @b_defined == false
-    return if @f_cloned == true    # å†
-部セルについては、composite の定義時にチェックされている
+    return if @f_cloned == true    # 内部セルについては、composite の定義時にチェックされている
 
     # debug
@@ -2452 +2308 @@
     # end
 
-    # 未結合の呼び口のチェック
+    # 未結合の呼び口のチェック
     @celltype.get_port_list.each { |p|
 
-      # 呼び口でなければ、チェックしない
+      # 呼び口でなければ、チェックしない
       next if p.get_port_type != :CALL
 
@@ -2461 +2317 @@
       dbgPrint "check_join: #{@name} #{get_celltype.get_name} #{p.get_name}\n"
 
-      # 結合リストの中から呼び口名に一致するものを取りだす
+      # 結合リストの中から呼び口名に一致するものを取りだす
       j = @join_list.get_item( p.get_name )
 
       if j == nil then
-        # 未結合の呼び口
-
-        # composite celltype のå†
-éƒ¨ã®å ´åˆã€composite celltype が export する呼び口に結合されているか探す
+        # 未結合の呼び口
+
+        # composite celltype の内部の場合、composite celltype が export する呼び口に結合されているか探す
         found = false
         if @in_composite then
-          # composite celltype の export するものすべてから探す
-          # （export するものの右辺値から探すために get_item ではダメ）
+          # composite celltype の export するものすべてから探す
+          # （export するものの右辺値から探すために get_item ではダメ）
           @compositecelltypejoin_list.get_items.each{ |cj|
-            # 呼び口名と composite の export する名前は一致するか
+            # 呼び口名と composite の export する名前は一致するか
             if p.get_name == cj.get_cell_elem_name then
               found = true
@@ -2481 +2336 @@
         end
 
-        # 呼び口é
-åˆ—ã®å ´åˆ optional でå
-¨ã¦ã®è¦ç´ ãŒåˆæœŸåŒ–ã•ã‚Œãªã„å ´åˆã«ã€ã“ã“ã¸æ¥ã‚‹
+        # 呼び口配列の場合 optional で全ての要素が初期化されない場合に、ここへ来る
         if ! found && ! p.is_require? && ! p.is_optional? then
           if ! p.is_allocator_port? then
@@ -2492 +2345 @@
         end
       elsif p.get_array_size.kind_of? Integer then
-        # 添数あり呼び口é
-åˆ—ã®å ´åˆã€ã™ã¹ã¦ã®æ·»æ•°è¦ç´ が初期化されているかチェックする
+        # 添数あり呼び口配列の場合、すべての添数要素が初期化されているかチェックする
 
         am = j.get_array_member2
         if( am )then
-          # join はé
-åˆ—
-
-          # 呼び口é
-åˆ—定義でのé
-åˆ—の大きさ
+          # join は配列
+
+          # 呼び口配列定義での配列の大きさ
           length = p.get_array_size
 
-          # é
-åˆ—の大きさが呼び口é
-åˆ—定義と結合定義で一致するか？
+          # 配列の大きさが呼び口配列定義と結合定義で一致するか？
           if am.length != length then
             if ! p.is_optional? || am.length >= length then
-              # optional ã®å ´åˆã€è¦ç´ æ•°ãŒå°‘ãªã™ãŽã‚‹ã®ã¯ OK
+              # optional の場合、要素数が少なすぎるのは OK
               cdl_error( "S1044 $1: array initializer too many or few, $2 for $3" , p.get_name, am.length, length )
             end
 
-            # am ã®è¦ç´ ã« nil ã‚’è¿½åŠ ã—ã¦ãŠã (#_CPA_# のコード生成時、このé
-åˆ—è¦ç´ 数分生成)
+            # am の要素に nil を追加しておく (#_CPA_# のコード生成時、この配列要素数分生成)
             i = am.length
             while i < length
@@ -2523 +2369 @@
           end
 
-#          # é
-åˆ—è¦ç´ の抜けがないかチェック
-#          if am.length < length then  # æº€ãŸãªã„å ´åˆæ—¢ã«ã‚¨ãƒ©ãƒ¼ã ãŒè¦ç´ ã®ã‚ã‚‹ç¯„å›²ã§ãƒã‚§ãƒƒã‚¯
+#          # 配列要素の抜けがないかチェック
+#          if am.length < length then  # 満たない場合既にエラーだが要素のある範囲でチェック
 #            length = am.length
 #          end
@@ -2535 +2380 @@
               end
             else
-              # 生成されないリージョンへの結合かチェック
+              # 生成されないリージョンへの結合かチェック
               if ! @in_composite then
                 am[i].check_region2
@@ -2544 +2389 @@
 
         # else
-        # join が非é
-åˆ—であれば、既にエラー
+        # join が非配列であれば、既にエラー
         end
       elsif j.get_array_member then
-        # 添数なし呼び口é
-åˆ—ã®å ´åˆ
+        # 添数なし呼び口配列の場合
         am = j.get_array_member2
         length = am.length
@@ -2562 +2405 @@
         end
 
-        # 生成されないリージョンへの結合かチェック
+        # 生成されないリージョンへの結合かチェック
         if ! @in_composite then
           am.each { |join|
@@ -2571 +2414 @@
         end
       else
-        # 呼び口［é
-åˆ—ã€ã§ãªã„å ´åˆ
-
-        # 生成されないリージョンへの結合かチェック
+        # 呼び口［配列」でない場合
+
+        # 生成されないリージョンへの結合かチェック
         if ! @in_composite then
           j.check_region2
@@ -2582 +2424 @@
     }
 
-    # ポインタ型がé
-åˆ—ã§åˆæœŸåŒ–ã•ã‚Œã‚‹å ´åˆã®ãƒã‚§ãƒƒã‚¯
+    # ポインタ型が配列で初期化される場合のチェック
     (@celltype.get_attribute_list+@celltype.get_var_list).each { |a|
       if a.get_size_is then
 
         if a.instance_of? CompositeCelltypeJoin then
-          # 既にエラーになっている
+          # 既にエラーになっている
           # cdl_error( "S1047 size_is pointer cannot be exposed for composite attribute"  )
           next
@@ -2598 +2439 @@
           size = a.get_size_is.eval_const( @join_list, @celltype.get_name_list )
           a.get_type.set_scs( a.get_size_is, nil, nil, nil, false )
-          if( ! size.kind_of? Integer )then               # C_EXP の可能性あり
-            # mikan 多分ここでのエラー発生は不要、eval_const の中で変数が存在しない、型が不適切などのエラーになるはず
+          if( ! size.kind_of? Integer )then               # C_EXP の可能性あり
+            # mikan 多分ここでのエラー発生は不要、eval_const の中で変数が存在しない、型が不適切などのエラーになるはず
             cdl_error( "S1049 $1: size_is arg not constant" , a.get_name )
           else
@@ -2615 +2456 @@
               end
             else
-              # size_is 引数がセルで指定されていて、初期化子がセルタイプで指定されているケースのチェック
+              # size_is 引数がセルで指定されていて、初期化子がセルタイプで指定されているケースのチェック
               ini = a.get_initializer
               if ini.instance_of? Expression
@@ -2630 +2471 @@
       else
         if ! a.instance_of? CompositeCelltypeJoin then
-          # composite は size_is 指定できない
+          # composite は size_is 指定できない
           if a.get_type.kind_of?( PtrType ) then
             j = @join_list.get_item( a.get_identifier )
             if j && j.get_rhs.instance_of?( Array ) then
-              ## size_is 指定されていないポインタが Array で初期化されていたら、エラーとする
+              ## size_is 指定されていないポインタが Array で初期化されていたら、エラーとする
               cdl_error( "S1169 $1: non-size_is pointer cannot be initialized with array initializer" , a.get_identifier )
             end
@@ -2642 +2483 @@
     }
 
-    # 未初期化の属性をチェック
+    # 未初期化の属性をチェック
     @celltype.get_attribute_list.each { |a|
       b_init = false
       # self.show_tree 1
-      if a.get_initializer then                               # セルタイプで初期化されている
+      if a.get_initializer then                               # セルタイプで初期化されている
         b_init = true
-        # @in_composite で export ã•ã‚Œã¦ã„ã‚‹å ´åˆã«ã¯ã€ã“ã®åˆæœŸå€¤ã¯ä½¿ã‚ã‚Œãªã„
-        # export されている、いないに関わらず、初期化されていることが保証される
-      elsif @join_list.get_item( a.get_name ) then            # セルで初期化されている
+        # @in_composite で export されている場合には、この初期値は使われない
+        # export されている、いないに関わらず、初期化されていることが保証される
+      elsif @join_list.get_item( a.get_name ) then            # セルで初期化されている
         b_init = true
       elsif @in_composite && @compositecelltypejoin_list then
-        # 属性が export されているか調べる。export されていれば未初期化とはしない
-        # mikan リニアサーチ
+        # 属性が export されているか調べる。export されていれば未初期化とはしない
+        # mikan リニアサーチ
         @compositecelltypejoin_list.get_items.each{ |cj|
-          # 属性名と composite の export する名前は一致するか
+          # 属性名と composite の export する名前は一致するか
           if a.get_name.to_sym == cj.get_cell_elem_name.to_sym then
-            b_init = true    # 属性は export されているので、とりあえず未初期化とはしない
+            b_init = true    # 属性は export されているので、とりあえず未初期化とはしない
           end
         }
         if b_init then
-          # size_is の引数がマッチするかチェックする
-          # å†
-部セルの size_is をエクスポートする size_is とマッチするかチェックする
-          # å†
-部セルとエクスポートで名前を変えている可能性があるので、å†
-部セルの size_is の名前を変換した上でチェックする
+          # size_is の引数がマッチするかチェックする
+          # 内部セルの size_is をエクスポートする size_is とマッチするかチェックする
+          # 内部セルとエクスポートで名前を変えている可能性があるので、内部セルの size_is の名前を変換した上でチェックする
           if a.get_size_is then
             ### p "attr: get_size_is"
@@ -2673 +2511 @@
             if cj.get_port_decl.instance_of? Decl then
               ### p "attr: get_size_is 2"
-              # cj_size_is は、外部å
-¬é–‹ã•ã‚Œã‚‹ attr の size_is
+              # cj_size_is は、外部公開される attr の size_is
               cj_size_is = cj.get_port_decl.get_size_is
               if cj_size_is == nil then
@@ -2683 +2520 @@
               remain = exprs
               inner_to_export = {}
-                          ### exprs に含まれる識別子を抜き出し、対応する export される名前を探す
+                          ### exprs に含まれる識別子を抜き出し、対応する export される名前を探す
               while remain != "" && remain != nil
                 ### p "remain ", remain
-                remain =~ /([^\w]*)([_A-Za-z][\w\d]*)/   # 変数名文字列を取り出す 
+                remain =~ /([^\w]*)([_A-Za-z][\w\d]*)/   # 変数名文字列を取り出す 
                                 if $2 == nil then
                                                 break
@@ -2693 +2530 @@
                 remain = $'
                 ### p exprs, $1, $2, $'
-                # size_is に含まれる変数は、composite で export されているか
+                # size_is に含まれる変数は、composite で export されているか
                 cj2 = nil
                 @compositecelltypejoin_list.get_items.each{ |cj2t|
@@ -2706 +2543 @@
                 if cj2.get_port_decl.instance_of? Decl then
                    decl2 = cj2.get_port_decl
-                   # å†
-部の名前と外部の名前の対応関係を記憶
+                   # 内部の名前と外部の名前の対応関係を記憶
                    inner_to_export[arg_name] = decl2.get_name
-                # else cj2 は Port (既にエラー)
+                # else cj2 は Port (既にエラー)
                 end
               end
-              # å†
-部の名前を外部の名前で置換
+              # 内部の名前を外部の名前で置換
               inner_to_export.each{ |arg_name, exp_name|
                 ### p "changing #{arg_name}=>#{exp_name}"
                 # exprs.gsub!( Regexp.new("#{arg_name}[^0-9A-Za-z_]"), exp_name.to_s )
-                exprs.gsub!( Regexp.new("#{arg_name}(\\W)"), exp_name.to_s+"\\1" )  # 文字列末尾にないケース
-                exprs.gsub!( Regexp.new("#{arg_name}\\Z"), exp_name.to_s )          # 文字列末尾にあるケース
+                exprs.gsub!( Regexp.new("#{arg_name}(\\W)"), exp_name.to_s+"\\1" )  # 文字列末尾にないケース
+                exprs.gsub!( Regexp.new("#{arg_name}\\Z"), exp_name.to_s )          # 文字列末尾にあるケース
               }
               ### p "changed: #{exprs} #{cj_size_is.to_s}"
@@ -2724 +2559 @@
                 cdl_error( "S1172 \'$1\' size_is argument mismatch with exporting one \'$2\'", a.get_name, cj.get_name )
               end
-            # else cj は Port (既にエラー)
+            # else cj は Port (既にエラー)
             end
           end
@@ -2737 +2572 @@
   end
 
-  #=== Cell# 逆 require をチェックする
-  # 逆 require 指定された受け口に複数の結合がないかチェックする
-  # composite のå†
-部セル (f_cloned=true) もチェックする
+  #=== Cell# 逆 require をチェックする
+  # 逆 require 指定された受け口に複数の結合がないかチェックする
+  # composite の内部セル (f_cloned=true) もチェックする
   def check_reverse_require
-    # celltype がなければチェックしない（既にエラー）
+    # celltype がなければチェックしない（既にエラー）
     return if @celltype == nil
     return if @b_defined == false
 
     # p "check reverse require   #{@name}"
-    # 逆require 指定された受け口に複数の結合がないかチェック
+    # 逆require 指定された受け口に複数の結合がないかチェック
     @referenced_port_list.each{ |port,count|
       # p port.class, count
@@ -2757 +2591 @@
   end
 
-  #=== Cell# require 呼び口の結合を行う
+  #=== Cell# require 呼び口の結合を行う
   # STAGE: S
-  #cp_name:: Symbol           : 呼び口名
-  #cell_or_t:: Celltype|Cell  : celltype の require の右辺で指定されたセルタイプまたはセル
-  #port::  Port               : celltype の Port オブジェクト
+  #cp_name:: Symbol           : 呼び口名
+  #cell_or_t:: Celltype|Cell  : celltype の require の右辺で指定されたセルタイプまたはセル
+  #port::  Port               : celltype の Port オブジェクト
   def set_require_join( cp_name, cell_or_ct, port )
 
-    # set_require_join は2度呼び出される
-    # 2度目は post コードを生成した後       #####  いったん見合わせ（重複エラーを見逃す）
+    # set_require_join は2度呼び出される
+    # 2度目は post コードを生成した後       #####  いったん見合わせ（重複エラーを見逃す）
     # if @require_joined_list[ cp_name ] then
     #   return
@@ -2782 +2616 @@
       end
     else
-      # require: cell で指定
+      # require: cell で指定
       cell = cell_or_ct
       if @region.distance( cell.get_region ) == nil then
@@ -2792 +2626 @@
       cdl_warning( "W1003 $1 : require call port overridden in $2" , cp_name, @name )
     else
-      # require の join を生成(呼び口の結合)
+      # require の join を生成(呼び口の結合)
 #      rhs = Expression.new( [ :OP_DOT, [ :IDENTIFIER, Token.new( cell.get_name, nil, nil, nil ) ],
       nsp = NamespacePath.new( cell.get_name, false, cell.get_namespace )
@@ -2805 +2639 @@
   end
 
-  #=== Cell# Join の definition の設定とチェック
+  #=== Cell# Join の definition の設定とチェック
   # STAGE: S
   def set_definition_join
-    return if @celltype == nil    # 既にエラー：打ち切る
-    return if @b_defined == false # プロトタイプ宣言のみ
-    return if @b_checked == true  # 既に設定（チェック）済み
+    return if @celltype == nil    # 既にエラー：打ち切る
+    return if @b_defined == false # プロトタイプ宣言のみ
+    return if @b_checked == true  # 既に設定（チェック）済み
 
     dbgPrint "set_definition_join in #{@name}\n"
 
-    # relay allocator をたどって再å
-¥ã—ないよう、å
-ˆé ­ã§ @b_checked を true にする
+    # relay allocator をたどって再入しないよう、先頭で @b_checked を true にする
     @b_checked = true
 
@@ -2822 +2654 @@
       check_restrict_list
       
-      # compoiste セルのクローンされたものは、set_definition 不要
-      # å
-ƒã® join は既に definition されている
-      # å
-ƒã®ã‚»ãƒ«ã«ãŠã„て、代å
-¥ãƒã‚§ãƒƒã‚¯ã•ã‚Œã¦ã„るので、二重にチェック(through適用)されてしまう
+      # compoiste セルのクローンされたものは、set_definition 不要
+      # 元の join は既に definition されている
+      # 元のセルにおいて、代入チェックされているので、二重にチェック(through適用)されてしまう
       @join_list.get_items.each{ |join|
         dbgPrint " set_definition_join: checking #{@name}.#{join.get_name}\n"
@@ -2833 +2662 @@
           port = @celltype.find(join.get_name)
           join.get_array_member2.each { |am|
-            if am == nil then   # æœªçµåˆã®å ´åˆã€ã‚¨ãƒ©ãƒ¼ãƒã‚§ãƒƒã‚¯ã¯ check_join
+            if am == nil then   # 未結合の場合、エラーチェックは check_join
               if port && ! port.is_optional? then
-                # テスト用にエラーメッセージ出力
+                # テスト用にエラーメッセージ出力
                 # cdl_error( "TEMPORAL set_definition_join: uninitialized array member"  )
               end
@@ -2848 +2677 @@
     end
 
-    # リレー join は through プラグイン生成後にしかできない
-    # through 後に結合å
-ˆãŒå
-¥ã‚Œæ›¿ãˆã‚‰ã‚Œã‚‹ 
+    # リレー join は through プラグイン生成後にしかできない
+    # through 後に結合先が入れ替えられる 
     create_relay_allocator_join
 
-    # composite セルの展開
+    # composite セルの展開
     if ! @in_composite && ! @f_cloned && @celltype.instance_of?( CompositeCelltype ) then
-      # composite セルタイプå†
-の composite は展開しない
-      # compoiste セル展開中の composite は展開しない (CompositeCelltype::expand å†
-で再帰的に expnad)
+      # composite セルタイプ内の composite は展開しない
+      # compoiste セル展開中の composite は展開しない (CompositeCelltype::expand 内で再帰的に expnad)
       expand
     end
 
-    # celltype に generate が指定されされているか
+    # celltype に generate が指定されされているか
     celltype_plugin = @celltype.get_celltype_plugin
     if celltype_plugin then
@@ -2875 +2700 @@
   end
 
-  #=== Cell# composite セルの展開
-  # このセルが composite セルタイプ
+  #=== Cell# composite セルの展開
+  # このセルが composite セルタイプ
   def expand
 
@@ -2882 +2707 @@
     dbgPrint "expanding #{@name} #{@celltype.get_name}\n"
 
-    # 展開されたセルのリスト
+    # 展開されたセルのリスト
     @@cloned_cell_list = {}
 
-    # composite celltype の cell を展開
+    # composite celltype の cell を展開
     @cell_list, @cell_list2 = @celltype.expand( @name, @global_name, @NamespacePath, @join_list, @region, @plugin, @locale )
 
-    # プロトタイプが参ç
-§ã•ã‚Œã¦ã„ã‚‹å ´åˆã€å­ã‚‚å‚ç
-§ã•ã‚Œã¦ã„ることにする
+    # プロトタイプが参照されている場合、子も参照されていることにする
     if @f_ref then
       dbgPrint "expand: set_f_ref\n"
@@ -2896 +2719 @@
     end
 
-    # 呼び口の右辺のセルを clone したものに変更
+    # 呼び口の右辺のセルを clone したものに変更
     self.change_rhs_port
 
-    # ãƒ—ãƒ­ãƒˆã‚¿ã‚¤ãƒ—å®£è¨€ã§è¨­å®šã•ã‚Œã¦ã„ãŸã‚‚ã®ã‚’åæ˜ ã™ã‚‹
+    # プロトタイプ宣言で設定されていたものを反映する
     @entry_array_max_subscript.each{ |port,name|
       set_entry_inner_port_max_subscript( port, name )
@@ -2905 +2728 @@
   end
 
-  #=== Cell#restrict ã‚’è¿½åŠ 
+  #=== Cell#restrict を追加
   def add_restrict( entry_name, func_name, region_name_list )
     if @restrict_list[ entry_name ] then
@@ -2994 +2817 @@
       puts "entry array #{port.get_name}: max subscript=#{num}"
     }
-    if @cell_list then   # ここで @cell_list が nil なのは Bug
+    if @cell_list then   # ここで @cell_list が nil なのは Bug
       (indent+1).times { print "  " }
       puts "cloned cell list:"
@@ -3018 +2841 @@
           subscript = ""
         end
-        # アロケータ呼び口の結合を生成
+        # アロケータ呼び口の結合を生成
         (indent+2).times { print "  " }
         puts "#{cp_name}#{subscript} = #{a[4+1]}"
@@ -3042 +2865 @@
 # @real_singleton:: bool : has singleton cell in this composite celltype
 # @real_active:: bool : has active cell in this composite celltype
-# @name_list:: NamedList item: Decl (attribute), Port エクスポート定義
+# @name_list:: NamedList item: Decl (attribute), Port エクスポート定義
 # @internal_allocator_list:: [ [cell, internal_cp_name, port_name, func_name, param_name, ext_alloc_ent], ... ]
 
@@ -3082 +2905 @@
 
     Namespace.new_compositecelltype( self )
-    set_namespace_path # @NamespacePath の設定
+    set_namespace_path # @NamespacePath の設定
 
     @port_list = []
@@ -3098 +2921 @@
   def end_of_parse
 
-    # singleton に関するチェック
+    # singleton に関するチェック
     if @b_singleton && @real_singleton == nil then
       cdl_warning( "W1004 $1 : specified singleton but has no singleton in this celltype" , @name )
@@ -3107 +2930 @@
     end
 
-    # active に関するチェック
+    # active に関するチェック
     if @b_active && @real_active == nil then
       cdl_error( "S1054 $1 : specified active but has no active in this celltype" , @name )
@@ -3114 +2937 @@
     end
 
-    # @allocator_instance を設定する
+    # @allocator_instance を設定する
     @name_list.get_items.each{ |n|
       if n.instance_of? Port then
@@ -3121 +2944 @@
     }
 
-    # リレーアロケータの entry 側
+    # リレーアロケータの entry 側
     @port_list.each{ |p|
       if p.get_port_type == :ENTRY then
@@ -3135 +2958 @@
       end
     }
-    # mikan relay が正しく抜けているかチェックされていない
-
-    # 意味解析
+    # mikan relay が正しく抜けているかチェックされていない
+
+    # 意味解析
     @cell_list.get_items.each{ |c|
       c.set_definition_join
     }
 
-    # cell の未結合の呼び口がないかチェック
+    # cell の未結合の呼び口がないかチェック
     @cell_list.get_items.each{ |c|
       c.check_join
@@ -3148 +2971 @@
     }
 
-    # 呼び口の結合について、export とå†
-部結合の両方がないかチェック
-    # リレーアロケータ、å†
-部アロケータの設定
+    # 呼び口の結合について、export と内部結合の両方がないかチェック
+    # リレーアロケータ、内部アロケータの設定
     @port_list.each{ |p|
       p.check_dup_init
     }
 
-    # すべてのエクスポート定義に対応した呼び口、受け口、属性が存在するかチェック
+    # すべてのエクスポート定義に対応した呼び口、受け口、属性が存在するかチェック
     @name_list.get_items.each{ |n|
       if( @export_name_list.get_item( n.get_name ) == nil )then
@@ -3163 +2984 @@
     }
 
-    # å†
-部アロケータを設定する
+    # 内部アロケータを設定する
     @internal_allocator_list.each{ |cell, cp_internal_name, port_name, fd_name, par_name, ext_alloc_ent|
       res = ext_alloc_ent.get_allocator_rhs_elements( :INTERNAL_ALLOC )
@@ -3195 +3015 @@
     cell.set_owner self  # Cell (in_omposite)
     @cell_list.add_item( cell )
-    if cell.get_celltype then    # nil ならば、すでにセルタイプなしエラー
+    if cell.get_celltype then    # nil ならば、すでにセルタイプなしエラー
       if cell.get_celltype.is_singleton? then
         @real_singleton = cell
@@ -3213 +3033 @@
   end
 
-  #=== CompositeCelltype# CompositeCelltypeJoin を作成
+  #=== CompositeCelltype# CompositeCelltypeJoin を作成
   # STAGE: B
-  #export_name:: Symbol : 外部にå
-¬é–‹ã™ã‚‹åå‰
-  #internal_cell_name:: Symbol : å†
-部セル名
-  #internal_cell_elem_name:: Symbol : å†
-éƒ¨ã‚»ãƒ«ã®è¦ç´ åï¼ˆå‘¼ã³å£åã€å—ã‘å£åã€å±žæ€§åã®ã„ãšã‚Œã‹ï¼‰
-  #type::  :CALL, :ENTRY, :ATTRIBUTE ã®ã„ãšã‚Œã‹ï¼ˆæ§‹æ–‡è¦ç´ ã¨ã—ã¦ã‚ã‚‹ã¹ãã‚‚ã®ï¼‰
-  #RETURN:: Decl | Port : エクスポート定義
-  # new_join は
-  #   cCall => composite.cCall;     (セルå†
-)
-  #   attr = composite.attr;        (セルå†
-)
-  #   composite.eEnt => cell2.eEnt; (セル外)
-  # ã®æ§‹æ–‡è¦ç´ ã®å‡ºç¾ã«å¯¾ã—ã¦å‘¼ã³å‡ºã•ã‚Œã‚‹
+  #export_name:: Symbol : 外部に公開する名前
+  #internal_cell_name:: Symbol : 内部セル名
+  #internal_cell_elem_name:: Symbol : 内部セルの要素名（呼び口名、受け口名、属性名のいずれか）
+  #type::  :CALL, :ENTRY, :ATTRIBUTE のいずれか（構文要素としてあるべきもの）
+  #RETURN:: Decl | Port : エクスポート定義
+  # new_join は
+  #   cCall => composite.cCall;     (セル内)
+  #   attr = composite.attr;        (セル内)
+  #   composite.eEnt => cell2.eEnt; (セル外)
+  # の構文要素の出現に対して呼び出される
   def new_join( export_name, internal_cell_name,
                  internal_cell_elem_name, type )
@@ -3242 +3057 @@
 
     celltype = cell.get_celltype
-    return if celltype == nil   # celltype == nil ならすでにエラー
-
-    # å†
-éƒ¨ã‚»ãƒ«ã®ã‚»ãƒ«ã‚¿ã‚¤ãƒ—ã‹ã‚‰å¯¾å¿œè¦ç´ ã‚’æŽ¢ã™
-    # このメソッドは、構文上、呼び口、受け口、属性が記述できる箇所から呼出される
-    # æ§‹æ–‡ä¸Šã®å‘¼å‡ºã—ä½ç½®ï¼ˆè¨˜è¿°ä½ç½®ï¼‰ã¨ã€è¦ç´ ãŒå¯¾å¿œã—ãŸã‚‚ã®ã‹ãƒã‚§ãƒƒã‚¯
+    return if celltype == nil   # celltype == nil ならすでにエラー
+
+    # 内部セルのセルタイプから対応要素を探す
+    # このメソッドは、構文上、呼び口、受け口、属性が記述できる箇所から呼出される
+    # 構文上の呼出し位置（記述位置）と、要素が対応したものかチェック
     obj = celltype.find( internal_cell_elem_name )
     if obj.instance_of?( Decl ) then
@@ -3255 +3069 @@
       elsif type != :ATTRIBUTE then
         cdl_error( "S1059 \'$1\' : exporting attribute. write in cell or use \'=\' to export attribute" , export_name )
-        # return æ¬¡ã®ã‚¨ãƒ©ãƒ¼ã‚’é¿ã‘ã‚‹ãŸã‚ã«å‡¦ç†ç¶šè¡Œã—ã€ä»˜ã‘åŠ ãˆã¦ã¿ã‚‹
+        # return 次のエラーを避けるために処理続行し、付け加えてみる
       end
     elsif obj.instance_of?( Port ) then
       if obj.get_port_type != type then
         cdl_error( "S1060 \'$1\' : port type mismatch. $2 type is allowed here." , export_name, type )
-        # return æ¬¡ã®ã‚¨ãƒ©ãƒ¼ã‚’é¿ã‘ã‚‹ãŸã‚ã«å‡¦ç†ç¶šè¡Œã—ã€ä»˜ã‘åŠ ãˆã¦ã¿ã‚‹
+        # return 次のエラーを避けるために処理続行し、付け加えてみる
       end
     else
@@ -3268 +3082 @@
     end
 
-    # エクスポート定義と一致するかどうかチェック
+    # エクスポート定義と一致するかどうかチェック
     obj2 = @name_list.get_item( export_name )
     if( obj2 == nil )then
@@ -3284 +3098 @@
         elsif obj.get_signature != obj2.get_signature then
           if obj.get_signature != nil && obj2.get_signature != nil then
-            # nil ãªã‚‰ã°æ—¢ã«ã‚¨ãƒ©ãƒ¼ãªã®ã§å ±å‘Šã—ãªã„
+            # nil ならば既にエラーなので報告しない
             cdl_error( "S1066 $1 : signature \'$2\' mismatch with previous definition \'$3\'" , export_name, obj.get_signature.get_name, obj2.get_signature.get_name )
           end
@@ -3309 +3123 @@
     if obj.instance_of?( Decl ) then
       # attribute
-#      # å†
-部から外部へ複数の結合がないかチェック
+#      # 内部から外部へ複数の結合がないかチェック
 #      found = false
 #      @attr_list.each{ |a|
@@ -3323 +3136 @@
     else
       # call/entry port
-#      # å†
-部から外部へ複数の結合がないかチェック
+#      # 内部から外部へ複数の結合がないかチェック
 #      found = false
 #      @port_list.each{ |port|
@@ -3337 +3149 @@
     end
 
-    # join を @export_name_list に登録（重複チェックとともに，後で行われる CompositeCelltypeJoin の clone に備える）
+    # join を @export_name_list に登録（重複チェックとともに，後で行われる CompositeCelltypeJoin の clone に備える）
     if obj.instance_of?( Decl ) && @export_name_list.get_item( export_name ) then
-      # æ—¢ã«å­˜åœ¨ã™ã‚‹ã€‚è¿½åŠ ã—ãªã„ã€‚æ–°ä»•æ§˜ã§ã¯ã€@export_name_list に同じ名前が含まれることがある。
+      # 既に存在する。追加しない。新仕様では、@export_name_list に同じ名前が含まれることがある。
     elsif obj.instance_of?( Port ) && obj.get_port_type == :CALL && @export_name_list.get_item( export_name ) then
-      # æ—¢ã«å­˜åœ¨ã™ã‚‹ã€‚è¿½åŠ ã—ãªã„ã€‚æ–°ä»•æ§˜ã§ã¯ã€@export_name_list に同じ名前が含まれることがある。
+      # 既に存在する。追加しない。新仕様では、@export_name_list に同じ名前が含まれることがある。
     else
       @export_name_list.add_item( join )
     end
 
-    # export するポートに含まれる send/receive パラメータのアロケータ(allocator)呼び口をセルと結合
+    # export するポートに含まれる send/receive パラメータのアロケータ(allocator)呼び口をセルと結合
     if obj2.instance_of? Port then
       obj2.each_param{ |port, fd, par|
-        case par.get_direction                        # 引数の方向指定子 (in, out, inout, send, receive )
+        case par.get_direction                        # 引数の方向指定子 (in, out, inout, send, receive )
         when :SEND, :RECEIVE
-          cp_name = :"#{port.get_name}_#{fd.get_name}_#{par.get_name}"     # アロケータ呼び口の名前
-          #            ポート名         関数名         パラメータ名
+          cp_name = :"#{port.get_name}_#{fd.get_name}_#{par.get_name}"     # アロケータ呼び口の名前
+          #            ポート名         関数名         パラメータ名
           cp_internal_name = :"#{internal_cell_elem_name}_#{fd.get_name}_#{par.get_name}"
 
-          # リレーアロケータ or å†
-éƒ¨ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿æŒ‡å®šãŒãªã•ã‚Œã¦ã„ã‚‹å ´åˆã€ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿å‘¼ã³å£ã‚’è¿½åŠ ã—ãªã„
-          # この時点では get_allocator_instance では得られないため tmp を得る
+          # リレーアロケータ or 内部アロケータ指定がなされている場合、アロケータ呼び口を追加しない
+          # この時点では get_allocator_instance では得られないため tmp を得る
           if port.get_allocator_instance_tmp then
             found = false
@@ -3365 +3176 @@
 
                 if s[0] == :INTERNAL_ALLOC then
-                  # å†
-éƒ¨ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿ã®å ´åˆ    # mikan これはå†
-部のセルに直結する。外部のポートに改めるべき
+                  # 内部アロケータの場合    # mikan これは内部のセルに直結する。外部のポートに改めるべき
                   @internal_allocator_list << [ cell, cp_internal_name, port.get_name, fd.get_name, par.get_name, s[3] ]
                 end
@@ -3377 +3186 @@
           end
 
-          # å¤–éƒ¨ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿ã®å ´åˆ
+          # 外部アロケータの場合
           new_join( cp_name, internal_cell_name, cp_internal_name, :CALL )
         end
@@ -3383 +3192 @@
     end
 
-    # エクスポート定義を返す
+    # エクスポート定義を返す
     return obj2
   end
@@ -3405 +3214 @@
     @name_list.add_item port
 
-    # export するポートに含まれる send/receive パラメータのアロケータ呼び口の export ã‚’ç”Ÿæˆã—ã¦ãƒãƒ¼ãƒˆã«è¿½åŠ 
-    # この時点ではå†
-部アロケータかどうか判断できないので、とりあえず生成しておく
+    # export するポートに含まれる send/receive パラメータのアロケータ呼び口の export を生成してポートに追加
+    # この時点では内部アロケータかどうか判断できないので、とりあえず生成しておく
     port.each_param { |port, fd, par|
-      case par.get_direction                        # 引数の方向指定子 (in, out, inout, send, receive )
+      case par.get_direction                        # 引数の方向指定子 (in, out, inout, send, receive )
       when :SEND, :RECEIVE
-        #### リレーアロケータ or å†
-éƒ¨ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿æŒ‡å®šãŒãªã•ã‚Œã¦ã„ã‚‹å ´åˆã€ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿å‘¼ã³å£ã‚’è¿½åŠ ã—ãªã„
-        # å†
-éƒ¨ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿æŒ‡å®šãŒãªã•ã‚Œã¦ã„ã‚‹å ´åˆã€ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿å‘¼ã³å£ã‚’è¿½åŠ ã—ãªã„
-        # この時点では get_allocator_instance では得られないため tmp を得る
+        #### リレーアロケータ or 内部アロケータ指定がなされている場合、アロケータ呼び口を追加しない
+        # 内部アロケータ指定がなされている場合、アロケータ呼び口を追加しない
+        # この時点では get_allocator_instance では得られないため tmp を得る
         if port.get_allocator_instance_tmp then
           found = false
@@ -3430 +3236 @@
 
         if par.get_allocator then
-          cp_name = :"#{port.get_name}_#{fd.get_name}_#{par.get_name}"     # アロケータ呼び口の名前
-          #           ポート名          関数名         パラメータ名
-          alloc_sig_path = [ par.get_allocator.get_name ]  # mikan Namespace アロケータ呼び口のシグニチャ
-          array_size = port.get_array_size            # 呼び口または受け口é
-åˆ—のサイズ
-          created_port = Port.new( cp_name, alloc_sig_path, :CALL, array_size ) # 呼び口を生成
+          cp_name = :"#{port.get_name}_#{fd.get_name}_#{par.get_name}"     # アロケータ呼び口の名前
+          #           ポート名          関数名         パラメータ名
+          alloc_sig_path = [ par.get_allocator.get_name ]  # mikan Namespace アロケータ呼び口のシグニチャ
+          array_size = port.get_array_size            # 呼び口または受け口配列のサイズ
+          created_port = Port.new( cp_name, alloc_sig_path, :CALL, array_size ) # 呼び口を生成
           created_port.set_allocator_port( port, fd, par )
           if port.is_omit? then
             created_port.set_omit
           end
-          new_port( created_port )           # ã‚»ãƒ«ã‚¿ã‚¤ãƒ—ã«æ–°ã—ã„å‘¼ã³å£ã‚’è¿½åŠ 
+          new_port( created_port )           # セルタイプに新しい呼び口を追加
         # else
         #   already error
@@ -3457 +3262 @@
     attribute.each { |a|
       a.set_owner self   # Decl (CompositeCelltype)
-      # V1.1.0.10 composite の attr の size_is は可となった
+      # V1.1.0.10 composite の attr の size_is は可となった
       # if a.get_size_is then
       #  cdl_error( "S1070 $1: size_is pointer cannot be exposed for composite attribute" , a.get_name )
@@ -3468 +3273 @@
   end
 
-  #=== CompositeCelltype# 逆require の結合を生成する
+  #=== CompositeCelltype# 逆require の結合を生成する
   def create_reverse_require_join cell
     @name_list.get_items.each{ |n|
@@ -3493 +3298 @@
     return @name_list.get_item( name )
 
-    # 従来仕様
+    # 従来仕様
 #    cj = @export_name_list.get_item( name )
 #p "#{name}, #{cj.get_port_decl}"
@@ -3503 +3308 @@
   end
 
-  #=== CompositeCelltype# export する CompositeCelltypeJoin を得る
+  #=== CompositeCelltype# export する CompositeCelltypeJoin を得る
   #name:: string:
-  # attribute ã®å ´åˆã€åŒã˜åå‰ã«å¯¾ã—è¤‡æ•°å­˜åœ¨ã™ã‚‹å¯èƒ½æ€§ãŒã‚ã‚‹ãŒã€æœ€åˆã®ã‚‚ã®ã—ã‹è¿”ã•ãªã„
+  # attribute の場合、同じ名前に対し複数存在する可能性があるが、最初のものしか返さない
   def find_export name
     return @export_name_list.get_item( name )
   end
 
-  #=== CompositeCelltype# composite celltype の cell を展開
-  #name:: string: Composite cell の名前
-  #global_name:: string: Composite cell の global name (C 言語名)
-  #join_list:: NamedList : Composite cell に対する Join の NamedList
+  #=== CompositeCelltype# composite celltype の cell を展開
+  #name:: string: Composite cell の名前
+  #global_name:: string: Composite cell の global name (C 言語名)
+  #join_list:: NamedList : Composite cell に対する Join の NamedList
   #RETURN:
   # [ { name => cell }, [ cell, ... ] ]
-  #  戻り値 前は 名前⇒cloneされたå†
-部セル、後ろは composite ã®å‡ºç¾é †ã®ãƒªã‚¹ãƒˆ
+  #  戻り値 前は 名前⇒cloneされた内部セル、後ろは composite の出現順のリスト
   def expand( name, global_name, namespacePath, join_list, region, plugin, locale )
 
@@ -3526 +3330 @@
     }
   
-    # 展開で clone されたセルのリスト、右辺は Cell (composite ã®å ´åˆ composite な cell の clone)
+    # 展開で clone されたセルのリスト、右辺は Cell (composite の場合 composite な cell の clone)
     clone_cell_list = {}
     clone_cell_list2 = []
 
-    #  composite å†
-部のすべての cell について
+    #  composite 内部のすべての cell について
     @cell_list.get_items.each { |c|
 
@@ -3537 +3340 @@
       dbgPrint "expand : cell #{c.get_name}\n"
 
-      # Join のé
-åˆ—
+      # Join の配列
       ja = []
 
-      # CompositeCelltype が export する呼び口、受け口、属性のリストについて
+      # CompositeCelltype が export する呼び口、受け口、属性のリストについて
       # @export_name_list.get_items.each{ |cj|  # cj: CompositeCelltypeJoin
-      # 新仕様では、@export_name_list にå
-¥ã£ã¦ã„ない attr がありうる
+      # 新仕様では、@export_name_list に入っていない attr がありうる
       (@port_list+@attr_list).each{ |cj|        # cj: CompositeCelltypeJoin
 
@@ -3550 +3351 @@
         dbgPrint "        cj : #{cj.get_name}\n"
 
-        # CompositeCelltypeJoin (export) の対象セルか？
+        # CompositeCelltypeJoin (export) の対象セルか？
         if cj.match?( c ) then
 
-          # 対象セルå†
-の CompositeCelltype の export する Join (attribute または call port)
+          # 対象セル内の CompositeCelltype の export する Join (attribute または call port)
           j = join_list.get_item( cj.get_name )
 
@@ -3565 +3365 @@
 
           if j then
-            # å‘¼ã³å£ã€å±žæ€§ã®å ´åˆ
-            #  ComositeCell 用のもの(j) を対象セル用に clone (@through_list もコピーされる)
+            # 呼び口、属性の場合
+            #  ComositeCell 用のもの(j) を対象セル用に clone (@through_list もコピーされる)
             # p "expand: cloning Join #{j.get_name} #{@name} #{name}"
             jc = j.clone_for_composite( @name, name, locale )
@@ -3574 +3374 @@
             # p "cn #{jc.get_name} #{cj.get_cell_elem_name}"
 
-            # 対象セルの呼び口または属性の名前に変更
+            # 対象セルの呼び口または属性の名前に変更
             jc.change_name( cj.get_cell_elem_name )
 
-            # 対象セルに対する Join のé
-åˆ—
+            # 対象セルに対する Join の配列
             ja << jc
           end
@@ -3590 +3389 @@
       dbgPrint "expand : clone #{name}_#{c.get_name}\n"
 
-      # セルの clone を生成
+      # セルの clone を生成
 #      clone_cell_list[ "#{name}_#{c.get_name}" ] =  c.clone_for_composite( name, global_name, ja )
       c2 =  c.clone_for_composite( name, global_name, namespacePath, ja, @name, region, plugin, locale )
@@ -3600 +3399 @@
     clone_cell_list.each { |nm,c|
       dbgPrint "  cloned: #{nm} = #{c.get_global_name}\n"
-      # join の owner を clone されたセルに変更する V1.1.0.25
+      # join の owner を clone されたセルに変更する V1.1.0.25
       c.get_join_list.get_items.each{ |j|
         j.set_cloned( clone_cell_list[ "#{c.get_local_name}" ] )
@@ -3608 +3407 @@
   end
 
-  #=== CompositeCelltype 指定子リストの設定
+  #=== CompositeCelltype 指定子リストの設定
   def set_specifier_list( spec_list )
     return if spec_list == nil
@@ -3639 +3438 @@
 
   def get_var_list
-    []   # 空のé
-åˆ—を返す
+    []   # 空の配列を返す
   end
 
@@ -3647 +3445 @@
   end
 
-  #== CompositeCelltype# generate 指定子のæƒ
-å ±
-  # CompositeCelltype には generate が指定できないので nil を返す
-  # Celltype::@generate を参ç
-§ã®ã“と
+  #== CompositeCelltype# generate 指定子の情報
+  # CompositeCelltype には generate が指定できないので nil を返す
+  # Celltype::@generate を参照のこと
   def get_celltype_plugin
     nil
@@ -3664 +3460 @@
   end
 
-  #=== CompositeCelltype# アクティブではない
-  # active ã§ã¯ãªã„ã«åŠ ãˆã€å
-¨ã¦ã®å†
-部セルのセルタイプが inactive ã®å ´åˆã« inactive
-  # （å†
-部のセルが active または factory を持っている）
+  #=== CompositeCelltype# アクティブではない
+  # active ではないに加え、全ての内部セルのセルタイプが inactive の場合に inactive
+  # （内部のセルが active または factory を持っている）
   def is_inactive?
     if @b_active == false then
       @cell_list.get_items.each{ |c|
         if c.get_celltype && c.get_celltype.is_inactive? == false then
-          # c.get_celltype == nil ã®å ´åˆã¯ã‚»ãƒ«ã‚¿ã‚¤ãƒ—æœªå®šç¾©ã§ã™ã§ã«ã‚¨ãƒ©ãƒ¼
+          # c.get_celltype == nil の場合はセルタイプ未定義ですでにエラー
           return false
         end
@@ -3714 +3507 @@
 
 
-#== æ§‹æ–‡è¦ç´ ï¼šå£ã‚’è¡¨ã™ã‚¯ãƒ©ã‚¹ï¼ˆã‚»ãƒ«ã‚¿ã‚¤ãƒ—ã®å‘¼ã³å£ã€å—ã‘å£ï¼‰
+#== 構文要素：口を表すクラス（セルタイプの呼び口、受け口）
 class Port < BDNode
 # @name::  str
@@ -3720 +3513 @@
 # @port_type::  :CALL, :ENTRY
 # @array_size:: nil: not array, "[]": sizeless, Integer: sized array
-# @reverse_require_cell_path:: NamespacePath :     逆require呼びå
-ƒã‚»ãƒ«  mikan namespace (呼び口のみ指定可能)
-# @reverse_require_callport_name:: Symbol:  逆require呼びå
-ƒã‚»ãƒ«ã®å‘¼ã³å£å
+# @reverse_require_cell_path:: NamespacePath :     逆require呼び元セル  mikan namespace (呼び口のみ指定可能)
+# @reverse_require_callport_name:: Symbol:  逆require呼び元セルの呼び口名
 #
-# set_allocator_port ã«ã‚ˆã£ã¦è¨­å®šã•ã‚Œã‚‹ï¼Žè¨­å®šã•ã‚ŒãŸå ´åˆã€ã“ã®ãƒãƒ¼ãƒˆã¯ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿ãƒãƒ¼ãƒˆã§ã‚ã‚‹ã€‚
-# @allocator_port:: Port : この呼び口ができるå
-ƒã¨ãªã£ãŸå‘¼ã³å£ã¾ãŸã¯å—け口
-# @allocator_func_decl:: Decl : この呼び口ができるå
-ƒã¨ãªã£ãŸå‘¼ã³å£ã¾ãŸã¯å—け口の関数
-# @allocator_param_decl:: ParamDecl : この呼び口ができるå
-ƒã¨ãªã£ãŸå‘¼ã³å£ã¾ãŸã¯å—け口のパラメータ
+# set_allocator_port によって設定される．設定された場合、このポートはアロケータポートである。
+# @allocator_port:: Port : この呼び口ができる元となった呼び口または受け口
+# @allocator_func_decl:: Decl : この呼び口ができる元となった呼び口または受け口の関数
+# @allocator_param_decl:: ParamDecl : この呼び口ができる元となった呼び口または受け口のパラメータ
 #
-# set_specifier によって設定される(
+# set_specifier によって設定される(
 # @allocator_instance:: Hash : {"func_param" => [ :RELAY_ALLOC, func_name, param_name, rhs_cp_name, rhs_func_name, rhs_param_name ]}
 #                                               [:INTERNAL_ALLOC, func_name, param_name, rhs_ep_name ]
@@ -3739 +3527 @@
 #                                                                                    function    parameter   rhs
 #
-# @b_require:: bool : require により生成された call port ã®å ´åˆ true
-# @b_has_name:: bool : require : 名前ありのリクワイア呼び口
-# @b_inline:: bool : entry port のみ
-# @b_omit:: bool : omit 指定子が指定された (call port のみ)
-# @b_optional:: bool : call port のみ
-# @b_ref_des:: bool :  ref_desc キーワードが指定された
-# @b_dynamic:: bool :  dynamic キーワードが指定された (呼び口のみ)
+# @b_require:: bool : require により生成された call port の場合 true
+# @b_has_name:: bool : require : 名前ありのリクワイア呼び口
+# @b_inline:: bool : entry port のみ
+# @b_omit:: bool : omit 指定子が指定された (call port のみ)
+# @b_optional:: bool : call port のみ
+# @b_ref_des:: bool :  ref_desc キーワードが指定された
+# @b_dynamic:: bool :  dynamic キーワードが指定された (呼び口のみ)
 #
 # optimize::
-# @celltype:: 属するセルタイプ
+# @celltype:: 属するセルタイプ
 #
-# :CALL ã®å ´åˆã®æœ€é©åŒ–
-# @b_VMT_useless:: bool                     # VMT 関数テーブルを使用しない
-# @b_skelton_useless:: bool                 # スケルトン関数不要   (true の時、受け口関数を呼出す)
-# @b_cell_unique:: bool                     # 呼びå
-ˆã¯å”¯ä¸€ã®ã‚»ãƒ«
-# @only_callee_port:: Port                  # 唯一の呼びå
-ˆãƒãƒ¼ãƒˆ
-# @only_callee_cell:: Cell                  # 唯一の呼びå
-ˆã‚»ãƒ« (@b_PEPDES_in_CB_useless = true の時有効)
+# :CALL の場合の最適化
+# @b_VMT_useless:: bool                     # VMT 関数テーブルを使用しない
+# @b_skelton_useless:: bool                 # スケルトン関数不要   (true の時、受け口関数を呼出す)
+# @b_cell_unique:: bool                     # 呼び先は唯一のセル
+# @only_callee_port:: Port                  # 唯一の呼び先ポート
+# @only_callee_cell:: Cell                  # 唯一の呼び先セル (@b_PEPDES_in_CB_useless = true の時有効)
 #
-# :ENTRY ã®å ´åˆã®æœ€é©åŒ–ï¼ˆå‘¼ã³å£æœ€é©åŒ–ã¨åŒã˜å¤‰æ•°åã‚’ä½¿ç”¨ï¼‰
-# @b_VMT_useless:: bool                     # VMT 関数テーブルが不要
-# @b_skelton_useless:: bool                 # スケルトン関数不要
+# :ENTRY の場合の最適化（呼び口最適化と同じ変数名を使用）
+# @b_VMT_useless:: bool                     # VMT 関数テーブルが不要
+# @b_skelton_useless:: bool                 # スケルトン関数不要
 
   def initialize( name, sig_path, port_type, array_size = nil, reverse_require_cell_path = nil, reverse_require_entry_port_name = nil )
@@ -3778 +3563 @@
         @array_size = array_size.eval_const(nil)
       else
-        @array_size = array_size   # ã“ã‚Œã¯ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿å‘¼ã³å£ã®å ´åˆï¼ˆå
-ƒã®å‘¼ã³å£ã§æ—¢ã«è©•ä¾¡æ¸ˆã¿ï¼‰
+        @array_size = array_size   # これはアロケータ呼び口の場合（元の呼び口で既に評価済み）
       end
       if @array_size == nil then
@@ -3794 +3578 @@
     object = Namespace.find( sig_path )    #1
     if object == nil then
-      # mikan signature の名前が不完å
-¨
+      # mikan signature の名前が不完全
       cdl_error( "S1075 \'$1\' signature not found" , sig_path )
     elsif ! object.instance_of?( Signature ) then
-      # mikan signature の名前が不完å
-¨
+      # mikan signature の名前が不完全
       cdl_error( "S1076 \'$1\' not signature" , sig_path )
     else
@@ -3806 +3588 @@
     end
 
-    # 逆require
+    # 逆require
     @reverse_require_cell_path       = nil
     @reverse_require_entry_port_name = nil
@@ -3816 +3598 @@
         @reverse_require_entry_port_name = reverse_require_entry_port_name
 
-        # 受け口é
-åˆ—か？
+        # 受け口配列か？
         if array_size then
           cdl_error( "S1153 $1: cannot be entry port array for fixed join port", @name )
         end
 
-        # 呼び口のセルタイプを探す
+        # 呼び口のセルタイプを探す
         ct_or_cell = Namespace.find( @reverse_require_cell_path )  #1
         if ct_or_cell.instance_of? Cell then
@@ -3837 +3618 @@
 
         if ct == nil then
-          return    # 既にエラー
-        end
-
-        # 添え字なしの呼び口é
-åˆ—か？
+          return    # 既にエラー
+        end
+
+        # 添え字なしの呼び口配列か？
         port = ct.find( @reverse_require_entry_port_name )
         if port == nil || port.get_port_type != :CALL
@@ -3863 +3643 @@
   end
 
-  #=== Port#最適化に関する変数をリセットする
-  # Region ごとに最適化のやりなおしをするため、リセットする
+  #=== Port#最適化に関する変数をリセットする
+  # Region ごとに最適化のやりなおしをするため、リセットする
   def reset_optimize
     if @port_type == :CALL then
       # call port optimize
-      @b_VMT_useless = false                     # VMT 不要 (true の時 VMT を介することなく呼出す)
-      @b_skelton_useless = false                 # スケルトン関数不要   (true の時、受け口関数を呼出す)
-      @b_cell_unique = false                     # 唯一の呼びå
-ˆã‚»ãƒ«
-      @only_callee_port = nil                    # 唯一の呼びå
-ˆãƒãƒ¼ãƒˆ
-      @only_callee_cell = nil                    # 唯一の呼びå
-ˆã‚»ãƒ«
+      @b_VMT_useless = false                     # VMT 不要 (true の時 VMT を介することなく呼出す)
+      @b_skelton_useless = false                 # スケルトン関数不要   (true の時、受け口関数を呼出す)
+      @b_cell_unique = false                     # 唯一の呼び先セル
+      @only_callee_port = nil                    # 唯一の呼び先ポート
+      @only_callee_cell = nil                    # 唯一の呼び先セル
     else
       # entry port optimize
       if $unopt then
-        # 最適化なし
-        @b_VMT_useless = false                     # VMT 不要 (true の時 VMT を介することなく呼出す)
-        @b_skelton_useless = false                 # スケルトン関数不要   (true の時、受け口関数を呼出す)
+        # 最適化なし
+        @b_VMT_useless = false                     # VMT 不要 (true の時 VMT を介することなく呼出す)
+        @b_skelton_useless = false                 # スケルトン関数不要   (true の時、受け口関数を呼出す)
       else
-        # 最適化あり
-        @b_VMT_useless = true                      # VMT 不要 (true の時 VMT を介することなく呼出す)
-        @b_skelton_useless = true                  # スケルトン関数不要   (true の時、受け口関数を呼出す)
+        # 最適化あり
+        @b_VMT_useless = true                      # VMT 不要 (true の時 VMT を介することなく呼出す)
+        @b_skelton_useless = true                  # スケルトン関数不要   (true の時、受け口関数を呼出す)
       end
     end
@@ -3914 +3691 @@
   end
 
-  #=== Port# アロケータポートの設定
-  #port:: Port : send/receive のあった呼び口または受け口
-  #fd:: Decl : 関数の declarator
-  #par:: ParamDecl : send/receive のあった引数
-  # この呼び口が生成されるもとになった呼び口または受け口のæƒ
-å ±ã‚’è¨­å®š
+  #=== Port# アロケータポートの設定
+  #port:: Port : send/receive のあった呼び口または受け口
+  #fd:: Decl : 関数の declarator
+  #par:: ParamDecl : send/receive のあった引数
+  # この呼び口が生成されるもとになった呼び口または受け口の情報を設定
   def set_allocator_port( port, fd, par )
     @allocator_port = port
@@ -3951 +3727 @@
   end
 
-  #=== Port# require 呼び口が名前を持つ？
-  # require 限定
+  #=== Port# require 呼び口が名前を持つ？
+  # require 限定
   def has_name?
     @b_has_name
@@ -3965 +3741 @@
   end
 
-  #=== Port# omit 指定されている?
+  #=== Port# omit 指定されている?
   def is_omit?
     @b_omit || ( @signature && @signature.is_empty? )
@@ -3974 +3750 @@
   end
 
-  def set_VMT_useless                     # VMT 関数テーブルを使用しない
+  def set_VMT_useless                     # VMT 関数テーブルを使用しない
    @b_VMT_useless = true
   end
 
-  def set_skelton_useless                 # スケルトン関数不要   (true の時、受け口関数を呼出す)
+  def set_skelton_useless                 # スケルトン関数不要   (true の時、受け口関数を呼出す)
     @b_skelton_useless = true
   end
 
-  def set_cell_unique                     # 呼びå
-ˆã‚»ãƒ«ã¯ä¸€ã¤ã け
+  def set_cell_unique                     # 呼び先セルは一つだけ
     @b_cell_unique = true
   end
 
-  #=== Port# 呼び口/受け口の指定子の設定
-  # inline, allocator の指定
+  #=== Port# 呼び口/受け口の指定子の設定
+  # inline, allocator の指定
   def set_specifier spec_list
     spec_list.each { |s|
@@ -4033 +3808 @@
   end
 
-  #=== Port# リレーアロケータ、å†
-部アロケータのインスタンスを設定
-  # 呼び口の前方参ç
-§å¯èƒ½ãªã‚ˆã†ã«ã€ã‚»ãƒ«ã‚¿ã‚¤ãƒ—の解釈の最後で行う
+  #=== Port# リレーアロケータ、内部アロケータのインスタンスを設定
+  # 呼び口の前方参照可能なように、セルタイプの解釈の最後で行う
   def set_allocator_instance
     if @allocator_instance_tmp == nil then
@@ -4049 +3822 @@
       case alloc_type
       when :INTERNAL_ALLOC
-        if ! @owner.instance_of? CompositeCelltype then # ミスを防ぐために composite でなければとした
-          cdl_error( "S1081 self allocator not supported yet"  )   # mikan これはサポートされているはず。要調査 12/1/15
+        if ! @owner.instance_of? CompositeCelltype then # ミスを防ぐために composite でなければとした
+          cdl_error( "S1081 self allocator not supported yet"  )   # mikan これはサポートされているはず。要調査 12/1/15
           next
         end
@@ -4057 +3830 @@
         # OK
       when :NORMAL_ALLOC
-        # ここへ来るのは composite の受け口で右辺が "eEnt.func.param" å½¢å¼ã§æŒ‡å®šã•ã‚Œã¦ã„ãŸå ´åˆ
+        # ここへ来るのは composite の受け口で右辺が "eEnt.func.param" 形式で指定されていた場合
         cdl_error( "S1174 $1 not suitable for lhs, suitable lhs: 'func.param'", "#{ai[1]}.#{ai[3]}.#{ai[4]}" )
         next
@@ -4064 +3837 @@
       end
 
-      # '=' 左辺(func_name,param_name)は実在するか?
-      if @signature then       # signature = nil なら既にエラー
+      # '=' 左辺(func_name,param_name)は実在するか?
+      if @signature then       # signature = nil なら既にエラー
         fh = @signature.get_function_head( ai[1] )
         if fh == nil then
@@ -4073 +3846 @@
         decl = fh.get_declarator
         if ! decl.is_function? then
-          next   # 既にエラー
+          next   # 既にエラー
         end
         paramdecl = decl.get_type.get_paramlist.find( ai[2] )
@@ -4090 +3863 @@
       end
 
-      # 重複指定がないか?
+      # 重複指定がないか?
       if @allocator_instance[ "#{@name}_#{ai[1]}_#{ai[2]}" ] then
         cdl_error( "S1085 duplicate allocator specifier for \'$1_$2\'" , ai[1], ai[2] )
       end
 
-      # 右辺のチェック
+      # 右辺のチェック
       case alloc_type
       when :INTERNAL_ALLOC
@@ -4105 +3878 @@
         end
 
-        ep_name = ele[1]   # アロケータ受け口名
+        ep_name = ele[1]   # アロケータ受け口名
         ep = @owner.find ep_name.get_path[0]  # mikan "a::b"
         if ep == nil || ! ep.instance_of?( Port ) || ep.get_port_type != :ENTRY || ! ep.get_signature.is_allocator? then
           cdl_error( "S1175 $1 not found or not allocator entry port for $2" , ep_name, ai[1] )
         end
-        # 右辺チェック終わり
+        # 右辺チェック終わり
         # ai2 = [ :INTERNAL_ALLOC, func_name, param_name, rhs_ep_name ]
         ai2 = [ ai[0], ai[1], ai[2], ep_name ]
@@ -4122 +3895 @@
           #    ele[0]    ele[1][0]  ele[1][1][0]  ele[1][1][1]        ele[1][2]    ele[2]
           #      name_space_path.Token(1).Token(2) === call_port.func.param
-          #  mikan Expression#analyze_cell_join_expression の変種を作成して置き換えるべき
+          #  mikan Expression#analyze_cell_join_expression の変種を作成して置き換えるべき
 
           cdl_error( "S1176 rhs not in 'call_port.func.param' form for for $1_$2" , ai[1], ai[2] )   # S1086
@@ -4128 +3901 @@
         end
         func_name = ele[1][2]; cp_name = ele[1][1][1].get_name; param_name = ele[2].to_sym
-        cp = @owner.find cp_name    # リレーするå
-ˆã®å‘¼ã³å£
+        cp = @owner.find cp_name    # リレーする先の呼び口
         if cp then
-# mikan cp ãŒå‘¼ã³å£ã§ã‚ã‚‹ã“ã¨ã®ãƒã‚§ãƒƒã‚¯ï¼ˆå±žæ€§ã®å ´åˆã‚‚ã‚ã‚‹ï¼‰
-# mikan 受け口から受け口へのリレーへの対応 (呼び口から呼び口へのリレーはありえない)  <=== 文法にかかわる事é 
-（呼び口側でアロケータが決定される）
+# mikan cp が呼び口であることのチェック（属性の場合もある）
+# mikan 受け口から受け口へのリレーへの対応 (呼び口から呼び口へのリレーはありえない)  <=== 文法にかかわる事項（呼び口側でアロケータが決定される）
           sig = cp.get_signature
           if sig && @signature then
@@ -4143 +3914 @@
             decl = fh.get_declarator
             if ! decl.is_function? then
-              next   # 既にエラー
+              next   # 既にエラー
             end
             paramdecl = decl.get_type.get_paramlist.find( param_name )
@@ -4162 +3933 @@
 
             # else
-            # sig == nil ならば既にエラー
+            # sig == nil ならば既にエラー
           end
         else
@@ -4173 +3944 @@
           next
         end
-        # 右辺チェック終わり
+        # 右辺チェック終わり
         # ai2 = [ :RELAY_ALLOC, func_name, param_name, rhs_cp_name, rhs_func_name, rhs_param_name ]
         ai2 = [ ai[0], ai[1], ai[2], cp_name, func_name, param_name ]
@@ -4186 +3957 @@
   end
 
-  def is_VMT_useless?                     # VMT 関数テーブルを使用しない
+  def is_VMT_useless?                     # VMT 関数テーブルを使用しない
    @b_VMT_useless
   end
 
-  def is_skelton_useless?                 # スケルトン関数不要   (true の時、受け口関数を呼出す)
+  def is_skelton_useless?                 # スケルトン関数不要   (true の時、受け口関数を呼出す)
     @b_skelton_useless
   end
 
-  def is_cell_unique?                     # 呼びå
-ˆã®ã‚»ãƒ«ã¯ä¸€ã¤ï¼Ÿ
+  def is_cell_unique?                     # 呼び先のセルは一つ？
     @b_cell_unique
   end
 
-  #=== Port# 受け口最適化の設定
-  # この受け口を参ç
-§ã™ã‚‹å‘¼ã³å£ãŒ VMT, skelton をå¿
-要としているかどうかを設定
-  # 一つでも呼び口がå¿
-要としている（すなわち b_*_useless が falseï¼‰å ´åˆã¯ã€
-  # この受け口の最適化を false とする
+  #=== Port# 受け口最適化の設定
+  # この受け口を参照する呼び口が VMT, skelton を必要としているかどうかを設定
+  # 一つでも呼び口が必要としている（すなわち b_*_useless が false）場合は、
+  # この受け口の最適化を false とする
   def set_entry_VMT_skelton_useless( b_VMT_useless, b_skelton_useless )
     if ! b_VMT_useless then
@@ -4215 +3982 @@
   end
 
-  #=== Port# 唯一の結合å
-ˆã‚’設定
-  # 最適化で使用
-  #  b_VMT_useless == true || b_skelton_useless == true の時に設定される
-  #  optional ã®å ´åˆ callee_cell, callee_port が nil となる
+  #=== Port# 唯一の結合先を設定
+  # 最適化で使用
+  #  b_VMT_useless == true || b_skelton_useless == true の時に設定される
+  #  optional の場合 callee_cell, callee_port が nil となる
   def set_only_callee( callee_port, callee_cell )
     @only_callee_port = callee_port
@@ -4225 +3991 @@
   end
 
-  #=== Port# 唯一の結合å
-ˆãƒãƒ¼ãƒˆã‚’返す(compositeã®å ´åˆå®Ÿã‚»ãƒ«)
-  # optional å‘¼ã³å£ã§æœªçµåˆã®å ´åˆ nil を返す
+  #=== Port# 唯一の結合先ポートを返す(compositeの場合実セル)
+  # optional 呼び口で未結合の場合 nil を返す
   def get_real_callee_port
     if @only_callee_cell then
@@ -4234 +3999 @@
   end
 
-  #=== Port# 唯一の結合å
-ˆã‚»ãƒ«ã‚’返す(compositeã®å ´åˆå®Ÿã‚»ãƒ«)
-  # optional å‘¼ã³å£ã§æœªçµåˆã®å ´åˆ nil を返す
+  #=== Port# 唯一の結合先セルを返す(compositeの場合実セル)
+  # optional 呼び口で未結合の場合 nil を返す
   def get_real_callee_cell
     if @only_callee_cell then
@@ -4251 +4015 @@
   end
 
-  #=== Port# 逆require の結合を生成する
+  #=== Port# 逆require の結合を生成する
   # STAGE: S
   def create_reverse_require_join cell
@@ -4258 +4022 @@
     end
 
-    # 呼びå
-ƒã‚»ãƒ«ã‚’探す
+    # 呼び元セルを探す
     ct_or_cell = Namespace.find( @reverse_require_cell_path )   # mikan namespace    #1
     if ct_or_cell.instance_of? Cell then
@@ -4265 +4028 @@
       ct = cell2.get_celltype
       if ct == nil then
-        return    # 既にエラー
+        return    # 既にエラー
       end
     elsif ct_or_cell.instance_of? Celltype then
@@ -4275 +4038 @@
       ct = ct_or_cell
     else
-      # 既にエラー：無視
+      # 既にエラー：無視
       return
     end
 
-    # 結合を生成する
+    # 結合を生成する
     dbgPrint "create_reverse_require_join #{cell2.get_name}.#{@reverse_require_entry_port_name}[] = #{cell.get_name}.#{@name}"
     nsp = NamespacePath.new( cell.get_name, false, cell.get_namespace )
@@ -4291 +4054 @@
   end
 
-  #=== Port# signature のすべての関数のすべてのパラメータをたどる
-  #block:: ブロックを引数として取る(ruby の文法で書かない)
-  #  ブロックは3つの引数を受け取る(Port, Decl,      ParamDecl)    Decl: 関数ヘッダ
-  # Signature クラスにも each_param がある（同じ働き）
-  def each_param # ブロック引数{  |port, func_decl, param_decl| }
-    return if @signature == nil                         # signature 未定義（既にエラー）
-    fha = @signature.get_function_head_array            # 呼び口または受け口のシグニチャの関数é
-åˆ—
-    return if fha == nil                                # nil なら文法エラーで有効値が設定されなかった
-
-    pr = Proc.new   # このメソッドのブロック引数を pr に代å
-¥
+  #=== Port# signature のすべての関数のすべてのパラメータをたどる
+  #block:: ブロックを引数として取る(ruby の文法で書かない)
+  #  ブロックは3つの引数を受け取る(Port, Decl,      ParamDecl)    Decl: 関数ヘッダ
+  # Signature クラスにも each_param がある（同じ働き）
+  def each_param # ブロック引数{  |port, func_decl, param_decl| }
+    return if @signature == nil                         # signature 未定義（既にエラー）
+    fha = @signature.get_function_head_array            # 呼び口または受け口のシグニチャの関数配列
+    return if fha == nil                                # nil なら文法エラーで有効値が設定されなかった
+
+    pr = Proc.new   # このメソッドのブロック引数を pr に代入
     port = self
-    fha.each{ |fh|  # fh: FuncHead                      # 関数é
-åˆ—ä¸­ã®å„é–¢æ•°é ­éƒ¨
-      fd = fh.get_declarator                            # fd: Decl  (é–¢æ•°é ­éƒ¨ã‹ã‚‰Declarotorを得る)
-      if fd.is_function? then                           # fd が関数でなければ、すでにエラー
-        fd.get_type.get_paramlist.get_items.each{ |par| # すべてのパラメータについて
+    fha.each{ |fh|  # fh: FuncHead                      # 関数配列中の各関数頭部
+      fd = fh.get_declarator                            # fd: Decl  (関数頭部からDeclarotorを得る)
+      if fd.is_function? then                           # fd が関数でなければ、すでにエラー
+        fd.get_type.get_paramlist.get_items.each{ |par| # すべてのパラメータについて
           pr.call( port, fd, par )
         }
@@ -4315 +4075 @@
   end
 
-  #=== Port# 逆require指定されている？
+  #=== Port# 逆require指定されている？
   def is_reverse_required?
     @reverse_require_cell_path != nil
@@ -4357 +4117 @@
 #== Namespace
 #
-# root namespace だけ、Region クラスのインスタンスとして生成される
-# root namespace は、root region をå
-¼ã­ã‚‹ãŸã‚
+# root namespace だけ、Region クラスのインスタンスとして生成される
+# root namespace は、root region を兼ねるため
 #
-# @cell_list は Region ã®å ´åˆã«ã®ã¿æŒã¤ (mikan @cell_list 関連は Region に移すべき)
+# @cell_list は Region の場合にのみ持つ (mikan @cell_list 関連は Region に移すべき)
 #
 class Namespace < NSBDNode
-# @name::  Symbol     # root ã®å ´åˆ "::" (String)
+# @name::  Symbol     # root の場合 "::" (String)
 # @global_name:: str
 # @name_list:: NamedList   Signature,Celltype,CompositeCelltype,Cell,Typedef,Namespace
 # @struct_tag_list:: NamedList : StructType
-# @namespace_list:: Namespace[] : Region は Namespace の子クラスであり、含まれる
+# @namespace_list:: Namespace[] : Region は Namespace の子クラスであり、含まれる
 # @signature_list:: Sginature[]
 # @celltype_list:: Celltype[]
@@ -4374 +4133 @@
 # @cell_list:: Cell[]
 # @typedef_list:: Typedef[]
-# @decl_list:: ( Typedef | StructType | EnumType )[]   ä¾å­˜é–¢ä¿‚ãŒã‚ã‚‹å ´åˆã«å‚™ãˆã¦ã€é †ç•ªã©ãŠã‚Šã«é
-åˆ—ã«æ ¼ç´ mikan enum
+# @decl_list:: ( Typedef | StructType | EnumType )[]   依存関係がある場合に備えて、順番どおりに配列に格納 mikan enum
 # @const_decl_list:: Decl[]
-# @cache_n_cells:: Integer :  get_n_cells の結果をキャッシュする
-# @cache_generating_region:: Region :  get_n_cells の結果をキャッシュするしているリージョン
-
-  # mikan namespace の push, pop
-
-  # namespace 階層用のスタック
+# @cache_n_cells:: Integer :  get_n_cells の結果をキャッシュする
+# @cache_generating_region:: Region :  get_n_cells の結果をキャッシュするしているリージョン
+
+  # mikan namespace の push, pop
+
+  # namespace 階層用のスタック
   @@namespace_stack = []      # @@namespace_stack[0] = "::" (generator.rb)
   @@namespace_sp = -1
 
-  # Generator ネスト用のスタック (namespace 階層用のスタックを対比する)
+  # Generator ネスト用のスタック (namespace 階層用のスタックを対比する)
   @@nest_stack_index = -1
   @@nest_stack = []
@@ -4392 +4150 @@
   @@root_namespace = nil
 
-  # Generator ネスト用スタックの push, pop (クラスメソッド)
+  # Generator ネスト用スタックの push, pop (クラスメソッド)
   def self.push
     dbgPrint "push Namespace\n"
@@ -4412 +4170 @@
   end
 
-  # namespace 階層用スタックの push, pop (インスタンスメソッド)
+  # namespace 階層用スタックの push, pop (インスタンスメソッド)
   def push ns
     @@namespace_sp += 1
@@ -4434 +4192 @@
     if( name == "::" )then
       if( @@root_namespace != nil )then
-        # root は一回のみ生成できる
+        # root は一回のみ生成できる
         raise "try to re-create root namespace"
       end
@@ -4443 +4201 @@
       if ns.kind_of? Namespace then
         dbgPrint "namespace: re-appear #{@name}\n"
-        # 登録済み namespace の再登録
+        # 登録済み namespace の再登録
         ns.push ns
         return
@@ -4454 +4212 @@
     end
 
-    if @@namespace_sp >= 0 then   # root は除外
+    if @@namespace_sp >= 0 then   # root は除外
       @@namespace_stack[@@namespace_sp].new_namespace( self )
     end
     push self
 
-    @global_name = Namespace.get_global_name    # stack 登録後取る
+    @global_name = Namespace.get_global_name    # stack 登録後取る
     @name_list = NamedList.new( nil, "symbol in namespace '#{@name}'" )
     @struct_tag_list = NamedList.new( nil, "struct tag" )
@@ -4474 +4232 @@
     @cache_generating_region = nil
     if @NamespacePath == nil then
-      # root namespace ã®å ´åˆã¯è¨­å®šæ¸ˆ (親 namespace が見つからず例外になる)
-      set_namespace_path # @NamespacePath の設定
+      # root namespace の場合は設定済 (親 namespace が見つからず例外になる)
+      set_namespace_path # @NamespacePath の設定
     end
   end
@@ -4487 +4245 @@
   end
 
-  #=== Namespace:: global_name を得る
-  # parse 中のみこのメソッドは使える
+  #=== Namespace:: global_name を得る
+  # parse 中のみこのメソッドは使える
   # STAGE: P
-  def self.get_global_name    # parse 中有効
+  def self.get_global_name    # parse 中有効
     if @@namespace_sp <= 0 then
       return ""
@@ -4509 +4267 @@
   end
 
-  #=== Namespace#セルの個数を得る
-  # 子 region が linkunit, node 指定されていれば、含めない（別のリンク単位）
-  # プロトタイプ宣言のもののみの個数を含めない
-  # mikan namespace 下に cell を置けない仕様になると、このメソッドは Region のものでよい
-  # mikan ä¸Šè¨˜ã®å ´åˆ instance_of? Namespace の条件判定は不要となる
+  #=== Namespace#セルの個数を得る
+  # 子 region が linkunit, node 指定されていれば、含めない（別のリンク単位）
+  # プロトタイプ宣言のもののみの個数を含めない
+  # mikan namespace 下に cell を置けない仕様になると、このメソッドは Region のものでよい
+  # mikan 上記の場合 instance_of? Namespace の条件判定は不要となる
   def get_n_cells
     if @cache_generating_region == $generating_region then
-      # このメソッドは繰り返し呼び出されるため、結果をキャッシュする
+      # このメソッドは繰り返し呼び出されるため、結果をキャッシュする
       return @cache_n_cells
     end
@@ -4522 +4280 @@
     count = 0
     @cell_list.each{ |c|
-      # 定義かプロトタイプ宣言だけかは、new_cell の段階で判断できないため、カウントしなおす
+      # 定義かプロトタイプ宣言だけかは、new_cell の段階で判断できないため、カウントしなおす
       if c.get_f_def == true then
         # print "get_n_cells: cell: #{c.get_name}\n"
@@ -4533 +4291 @@
         count += ns.get_n_cells
       else
-        # ns は Region である
+        # ns は Region である
         rt = ns.get_region_type
         # print "get_n_cells: region: #{ns.get_name}: #{rt}\n"
         if rt == :NODE || rt == :LINKUNIT then
-          # 別の linkunit ãªã®ã§åŠ ç®—ã—ãªã„
+          # 別の linkunit なので加算しない
         else
           count += ns.get_n_cells
@@ -4549 +4307 @@
   end
 
-  #=== Namespace.find : in_path で示されるオブジェクトを探す
+  #=== Namespace.find : in_path で示されるオブジェクトを探す
   #in_path:: NamespacePath
-  #in_path:: Array : 古い形式
+  #in_path:: Array : 古い形式
   #  path [ "::", "ns1", "ns2" ]   absolute
   #  path [ "ns1", "ns2" ]         relative
@@ -4566 +4324 @@
       if name == "::" then
         i = 1
-        name = path[i]   # 構文的にå¿
-ず存在
+        name = path[i]   # 構文的に必ず存在
         object = @@root_namespace.find( name )  # root
       else
-        # 相対パス
+        # 相対パス
         i = 0
         object = @@namespace_stack[@@namespace_sp].find_one( name ) # crrent
@@ -4603 +4360 @@
 
       unless object.kind_of?( Namespace ) then
-        # クラスメソッドå†
-で cdl_error を呼び出すことはできない
-        # また、前方参ç
-§å¯¾å¿œå¾Œã€æ­£ç¢ºãªè¡Œç•ªå·ãŒå‡ºãªã„問題も生じる
+        # クラスメソッド内で cdl_error を呼び出すことはできない
+        # また、前方参照対応後、正確な行番号が出ない問題も生じる
         # cdl_error( "S1092 \'$1\' not namespace" , name )
-        # このメソッドから nil ãŒå¸°ã£ãŸå ´åˆ "not found" が出るので、ここでは出さない
+        # このメソッドから nil が帰った場合 "not found" が出るので、ここでは出さない
         return nil
       end
@@ -4624 +4379 @@
   end
 
-  #=== Namespace# namespace から探す。見つからなければ親 namespace から探す
+  #=== Namespace# namespace から探す。見つからなければ親 namespace から探す
   def self.find_one( name )
     return @@namespace_stack[@@namespace_sp].find_one( name )
@@ -4632 +4387 @@
 
     object = find( name )
-    # これは出すぎ
+    # これは出すぎ
     # dbgPrint "in '#{@name}' find '#{name}' object #{object ? object.class : "Not found"}\n"
 
@@ -4649 +4404 @@
 
   def self.find_tag( name )
-    # mikan tag : namespace の path に対応しない
-    # namespace の中にあっても、root namespace にあるものと見なされる
-    # よって カレント namespace ã‹ã‚‰æ ¹ã«å‘ã‹ã£ã¦æŽ¢ã™
+    # mikan tag : namespace の path に対応しない
+    # namespace の中にあっても、root namespace にあるものと見なされる
+    # よって カレント namespace から根に向かって探す
     i = @@namespace_sp
     while i >= 0
@@ -4727 +4482 @@
   end
 
-  #=== Namespace# 参ç
-§ã•ã‚Œã¦ã„るが、未定義のセルを探す
-  # プロトタイプ宣言だけで定義されていないケースをエラーとする
-  # 受動の未結合セルについて警告する
+  #=== Namespace# 参照されているが、未定義のセルを探す
+  # プロトタイプ宣言だけで定義されていないケースをエラーとする
+  # 受動の未結合セルについて警告する
   def check_ref_but_undef
     @cell_list.each { |c|
-      if ! c.get_f_def then   # Namespace の @cell_list にはプロトタイプが含まれるケースあり
+      if ! c.get_f_def then   # Namespace の @cell_list にはプロトタイプが含まれるケースあり
         if c.get_f_ref then
           cdl_error( "S1093 $1 : undefined cell" , c.get_namespace_path.get_path_str )
@@ -4753 +4507 @@
   end
 
-  #=== Namespace# セルの受け口の参ç
-§ã‚«ã‚¦ãƒ³ãƒˆã‚’設定する
+  #=== Namespace# セルの受け口の参照カウントを設定する
   def set_port_reference_count
     @cell_list.each { |c|
@@ -4770 +4523 @@
 
   def new_structtype( struct )
-    # struct.set_owner self   # StructType (Namespace) # StructType は BDNode ではない
+    # struct.set_owner self   # StructType (Namespace) # StructType は BDNode ではない
     dup = @struct_tag_list.get_item(struct.get_name)
     if dup != nil then
       if struct.same? dup then
-        # 同じものが typedef された
+        # 同じものが typedef された
         # p "#{struct.get_name}"
         return
@@ -4798 +4551 @@
       if typedef_type.get_type_str == dup_type.get_type_str &&
           typedef_type.get_type_str_post == dup_type.get_type_str_post then
-        # 同じものが typedef された
-        # ここへ来るのは C で関数ポインタを typedef しているケース
-        # ä»¥ä¸‹ã®ã‚ˆã†ã«äºŒé‡ã«å®šç¾©ã•ã‚Œã¦ã„ã‚‹å ´åˆã¯ type_specifier_qualifier_list として扱われる
+        # 同じものが typedef された
+        # ここへ来るのは C で関数ポインタを typedef しているケース
+        # 以下のように二重に定義されている場合は type_specifier_qualifier_list として扱われる
         #    typedef long LONG; 
         #    typedef long LONG;
-        # bnf.y.rb では declarator に TYPE_NAME を許さないので、ここへ来ることはない
+        # bnf.y.rb では declarator に TYPE_NAME を許さないので、ここへ来ることはない
         # p "#{typedef.get_declarator.get_type.get_type_str} #{typedef.get_name} #{typedef.get_declarator.get_type.get_type_str_post}"
         return
@@ -4844 +4597 @@
   def new_const_decl( decl )
     decl.set_owner self   # Decl (Namespace:const)
-    if ! decl.is_const? then                    # const 修飾さていること
+    if ! decl.is_const? then                    # const 修飾さていること
       if decl.is_type?( PtrType ) then
         cdl_error( "S1094 $1: pointer is not constant. check \'const\'" , decl.get_name )
@@ -4852 +4605 @@
     elsif ! decl.is_type?( IntType ) && ! decl.is_type?( FloatType ) &&
         ! decl.is_type?( BoolType ) && ! decl.is_type?( PtrType ) then
-                                            # IntType, FloatType であること
+                                            # IntType, FloatType であること
       cdl_error( "S1096 $1: should be int, float, bool or pointer type" , decl.get_name )
-    elsif decl.get_initializer == nil then   # 初期値を持つこと
+    elsif decl.get_initializer == nil then   # 初期値を持つこと
       cdl_error( "S1097 $1: has no initializer" , decl.get_name )
-#    elsif decl.get_initializer.eval_const(nil) == nil then  #eval_const は check_init で呼出されるので二重チェック
-#                                            # mikan 初期値が型に対し適切であること
+#    elsif decl.get_initializer.eval_const(nil) == nil then  #eval_const は check_init で呼出されるので二重チェック
+#                                            # mikan 初期値が型に対し適切であること
 #      cdl_error( "S1098 $1: has unsuitable initializer" , decl.get_name )
     else
@@ -4879 +4632 @@
  ###
 
-  #=== Namespace# すべてのセルの require ポートを設定
+  #=== Namespace# すべてのセルの require ポートを設定
   # STAGE: S
   def set_require_join
@@ -4885 +4638 @@
       ct.set_require_join
     }
-    # すべての namespace について require ポートをセット
+    # すべての namespace について require ポートをセット
     @namespace_list.each{ |ns|
       ns.set_require_join
@@ -4891 +4644 @@
   end
 
-  #=== Namespace# Join への definition の設定とチェック
-  # セルタイプに属するすべてのセルに対して実施
+  #=== Namespace# Join への definition の設定とチェック
+  # セルタイプに属するすべてのセルに対して実施
   def set_definition_join
-    # celltype のコードを生成
+    # celltype のコードを生成
     @cell_list.each { |c|
       dbgPrint "set_definition_join #{c.get_name}\n"
@@ -4904 +4657 @@
   end
 
-  #=== Namespace# セルの結合をチェックする
+  #=== Namespace# セルの結合をチェックする
   def check_join
     @cell_list.each { |c|
@@ -4916 +4669 @@
   end
 
-  #== Namespace# ルートか?
-  # ルートネームスペース と ルートリージョンは同じ
+  #== Namespace# ルートか?
+  # ルートネームスペース と ルートリージョンは同じ
   def is_root?
     @name == "::"
   end
 
-  #== Namespace# ルートを得る
-  # ルートリージョンとルートネームスペースは同じオブジェクト
+  #== Namespace# ルートを得る
+  # ルートリージョンとルートネームスペースは同じオブジェクト
   def self.get_root
     @@root_namespace
@@ -4945 +4698 @@
 #
 # available if definition is Port
-# @cell_name:: string : 右辺のセルの名前
-# @cell:: Cell  : 右辺のセル
-# @celltype:: Celltype : 右辺のセルタイプ
-# @port_name:: string : 右辺の受け口名
-# @port:: Port : 右辺の受け口
+# @cell_name:: string : 右辺のセルの名前
+# @cell:: Cell  : 右辺のセル
+# @celltype:: Celltype : 右辺のセルタイプ
+# @port_name:: string : 右辺の受け口名
+# @port:: Port : 右辺の受け口
 # @array_member:: rhs array : available only for first appear in the same name
 # @array_member2:: Join array : available only for first appear in the same name
-# @rhs_subscript:: nil : not array, >=0: 右辺の添数
+# @rhs_subscript:: nil : not array, >=0: 右辺の添数
 #
 
 # @through_list::  @cp_through_list + @region_through_list
-#  ä»¥ä¸‹ã®æ§‹é€ ã‚’æŒã¤ï¼ˆ@cp_through_list ã®æ§‹é€ ã¯å
-±é€šï¼‰
-# @cp_through_list::  呼び口に指定された through
+#  以下の構造を持つ（@cp_through_list の構造は共通）
+# @cp_through_list::  呼び口に指定された through
 #   [ [plugin_name, cell_name, plugin_arg], [plugin_name2, cell_name2, plugin_arg], ... ]
-# @region_through_list::  region に指定された through
+# @region_through_list::  region に指定された through
 #   [ [plugin_name, cell_name, plugin_arg, region], [plugin_name2, cell_name2, plugin_arg, region2], ... ]
 #
-# @through_generated_list:: [Plugin_class object, ...]: @through_list に対応
-# @region_through_generated_list:: [Plugin_class object, ...]: @region_through_list に対応
+# @through_generated_list:: [Plugin_class object, ...]: @through_list に対応
+# @region_through_generated_list:: [Plugin_class object, ...]: @region_through_list に対応
 #
 
   include PluginModule
 
-  #=== Join# 初期化
-  #name:: string: 名前（属性名、呼び口名）
-  #subscript:: Nil=非é
-åˆ—, -1="[]", N="[N]"
-  #rhs:: Expression: 右辺の式
+  #=== Join# 初期化
+  #name:: string: 名前（属性名、呼び口名）
+  #subscript:: Nil=非配列, -1="[]", N="[N]"
+  #rhs:: Expression: 右辺の式
   def initialize( name, subscript, rhs, locale = nil )
     # dbgPrint "Join#new: #{name}, #{subscript} #{rhs.eval_const(nil)}\n"
@@ -4985 +4736 @@
     @name = name
     if subscript.instance_of?( Expression ) then
-       #mikan é
-åˆ—添数が整数であることを未チェック
+       #mikan 配列添数が整数であることを未チェック
        @subscript = subscript.eval_const(nil)
        if @subscript == nil then
@@ -4998 +4748 @@
     @definition = nil
 
-    # é
-åˆ—è¦ç´ を設定
-    # æœ¬å½“ã¯ã€åˆå‡ºã®è¦ç´ ã®ã¿è¨­å®šã™ã‚‹ã®ãŒé©å½“
-    # new_join で add_array_member ã®ä¸­ã§åˆå‡ºè¦ç´ ã® array_member に対し設定する
+    # 配列要素を設定
+    # 本当は、初出の要素のみ設定するのが適当
+    # new_join で add_array_member の中で初出要素の array_member に対し設定する
     if @subscript == -1 then
       @array_member  = [self]
@@ -5019 +4768 @@
   end
 
-  #===  Join# 左辺に対応する celltype の定義を設定するとともにチェックする
+  #===  Join# 左辺に対応する celltype の定義を設定するとともにチェックする
   # STAGE:   S
   #
-  #     代å
-¥å¯èƒ½ã‹ãƒã‚§ãƒƒã‚¯ã™ã‚‹
-  #definition:: Decl (attribute,varの時) または Port (callの時) または nil (definition が見つからなかった時)
+  #     代入可能かチェックする
+  #definition:: Decl (attribute,varの時) または Port (callの時) または nil (definition が見つからなかった時)
 
   def set_definition( definition )
@@ -5030 +4778 @@
     dbgPrint "set_definition: #{@owner.get_name}.#{@name} = #{definition.class}\n"
 
-    # 二重チェックの防止
+    # 二重チェックの防止
     if @definition then
-      # set_definition を個別に行うケースで、二重に行われる可能性がある（異常ではない）
-      # 二重に set_definition が実行されると through が二重に適用されてしまう
+      # set_definition を個別に行うケースで、二重に行われる可能性がある（異常ではない）
+      # 二重に set_definition が実行されると through が二重に適用されてしまう
       # cdl_warning( "W9999 $1, internal error: set_definition duplicate", @name )
       return
@@ -5040 +4788 @@
     @definition = definition
 
-    # mikan 左辺値、右辺値の型チェックなど
+    # mikan 左辺値、右辺値の型チェックなど
     if @definition.instance_of?( Decl ) then
       check_var_init
     elsif @definition.instance_of?( Port ) then
       check_call_port_init
-      if @definition.get_port_type == :CALL then   # :ENTRY ならエラー。無視しない
+      if @definition.get_port_type == :CALL then   # :ENTRY ならエラー。無視しない
         check_and_gen_through
-        create_allocator_join  # through プラグイン生成した後でないと、挿å
-¥å‰ã®ã‚»ãƒ«ã®ã‚¢ãƒ­ã‚±ãƒ¼ã‚¿ã‚’結合してしまう
+        create_allocator_join  # through プラグイン生成した後でないと、挿入前のセルのアロケータを結合してしまう
       end
     elsif @definition == nil then
@@ -5057 +4804 @@
   end
 
-  #=== Join# 変数の初期化チェック
+  #=== Join# 変数の初期化チェック
   def check_var_init
-    # attribute, var ã®å ´åˆ
+    # attribute, var の場合
     if @definition.get_kind == :ATTRIBUTE then
 #        check_cell_cb_init( definition.get_type, @rhs )
-      # 右辺で初期化可能かチェック
+      # 右辺で初期化可能かチェック
       @definition.get_type.check_init( @locale, @definition.get_identifier, @rhs, :ATTRIBUTE )
     elsif @definition.get_kind == :VAR then
-      # var は初期化できない
+      # var は初期化できない
       cdl_error( "S1100 $1: cannot initialize var" , @name )
     else
@@ -5073 +4820 @@
   end
 
-  #=== Join# 呼び口の初期化チェック
+  #=== Join# 呼び口の初期化チェック
   def check_call_port_init
     ### Port
 
-    # 左辺は受け口か（受け口を初期化しようとしている）？
+    # 左辺は受け口か（受け口を初期化しようとしている）？
     if @definition.get_port_type == :ENTRY then
       cdl_error( "S1101 \'$1\' cannot initialize entry port" , @name )
@@ -5083 +4830 @@
     end
 
-#      # é
-åˆ—添数の整合性チェック
-#      # 呼び口の定義で、非é
-åˆ—なら添数なし、添数なしé
-åˆ—なら添数なし、添数ありé
-åˆ—なら添数あり
+#      # 配列添数の整合性チェック
+#      # 呼び口の定義で、非配列なら添数なし、添数なし配列なら添数なし、添数あり配列なら添数あり
     as = @definition.get_array_size
     if ( @subscript == nil && as != nil ) then
@@ -5111 +4854 @@
 #    end
 
-    # mikan Expression の get_type で型導出させる方がスマート
-    # mikan '=' の左辺がé
-åˆ—かどうか未チェック
-    #(1) '=' の右辺は "Cell.ePort" の形式か？
-    #     演算子は "."  かつ "." の左辺が :IDENTIFIER
-    #     "." の右辺はチェック不要 (synatax 的に :IDENTIFIER)
-    #(2) "Cell" は存在するか？（名前が一致するものはあるか）
-    #(3) "Cell" は cell か？
-    #(4) "Cell" の celltype は有効か？ (無効なら既にエラー）
-    #(5) "ePort" は "Cell" の celltype å†
-に存在するか？
-    #(6) "ePort" は entry port か？
-    #(7) signature は一致するか
-
-    # 右辺がない（以前の段階でエラー）
+    # mikan Expression の get_type で型導出させる方がスマート
+    # mikan '=' の左辺が配列かどうか未チェック
+    #(1) '=' の右辺は "Cell.ePort" の形式か？
+    #     演算子は "."  かつ "." の左辺が :IDENTIFIER
+    #     "." の右辺はチェック不要 (synatax 的に :IDENTIFIER)
+    #(2) "Cell" は存在するか？（名前が一致するものはあるか）
+    #(3) "Cell" は cell か？
+    #(4) "Cell" の celltype は有効か？ (無効なら既にエラー）
+    #(5) "ePort" は "Cell" の celltype 内に存在するか？
+    #(6) "ePort" は entry port か？
+    #(7) signature は一致するか
+
+    # 右辺がない（以前の段階でエラー）
     return unless @rhs
 
-    # cCall = composite.cCall; のチェック．この形式は属性用
-    # 呼び口を export するには cCall => composite.cCall; の形式を用いる
+    # cCall = composite.cCall; のチェック．この形式は属性用
+    # 呼び口を export するには cCall => composite.cCall; の形式を用いる
     if @rhs.instance_of?( Array ) == true && @rhs[0] == :COMPOSITE then
       cdl_error( "S1107 to export port, use \'cCall => composite.cCall\'"  )
@@ -5137 +4878 @@
     end
 
-    # 右辺の Expression ã®è¦ç´ ã‚’å–ã‚Šå‡ºã™
+    # 右辺の Expression の要素を取り出す
     ret = @rhs.analyze_cell_join_expression
     if ret == nil then   #1
@@ -5145 +4886 @@
 
     nsp, @rhs_subscript, @port_name = ret[0], ret[1], ret[2]
-    @cell_name = nsp.get_name     # mikan ns::cellname の形式の考æ
-®
-
-    # composite の定義の中なら object は結合å
-ˆ cell か、見つからなければ nil が返る
-    # composite の定義外なら false が返る
+    @cell_name = nsp.get_name     # mikan ns::cellname の形式の考慮
+
+    # composite の定義の中なら object は結合先 cell か、見つからなければ nil が返る
+    # composite の定義外なら false が返る
     object = CompositeCelltype.find( @cell_name )
     if object == false then
-#     mikan 左辺が namespace に対応していないため。 path にして find
+#     mikan 左辺が namespace に対応していないため。 path にして find
       # p nsp.get_path_str, nsp.get_path
       object = Namespace.find( nsp )    #1
@@ -5172 +4911 @@
       object.set_f_ref
 
-      # 右辺のセルのセルタイプ
+      # 右辺のセルのセルタイプ
       celltype = object.get_celltype
 
@@ -5185 +4924 @@
           cdl_error( "S1113 \'$1\' signature mismatch" , @port_name )
         elsif object2.get_array_size then
-          # 受け口é
-åˆ—
+          # 受け口配列
 
           unless @rhs_subscript then
-            # 右辺に添数指定がなかった
+            # 右辺に添数指定がなかった
             cdl_error( "S1114 \'$1\' should be array" , @port_name )
           else
@@ -5195 +4933 @@
             as = object2.get_array_size
             if( as.kind_of?( Integer ) && as <= @rhs_subscript )then
-              # 受け口é
-åˆ—の大きさに対し、右辺の添数が同じか大きい
+              # 受け口配列の大きさに対し、右辺の添数が同じか大きい
               cdl_error( "S1115 $1[$2]: subscript out of range (< $3)" , @port_name, @rhs_subscript, as )
             else
@@ -5203 +4940 @@
               @celltype = celltype
               @port = object2
-              # 右辺のセルの受け口 object2 を参ç
-§æ¸ˆã¿ã«ã™ã‚‹
+              # 右辺のセルの受け口 object2 を参照済みにする
               # object2: Port, @definition: Port
               @cell.set_entry_port_max_subscript( @port, @rhs_subscript )
@@ -5214 +4950 @@
           end
         elsif @rhs_subscript then
-          # 受け口é
-åˆ—でないのに右辺で添数指定されている
+          # 受け口配列でないのに右辺で添数指定されている
           cdl_error( "S1116 \'$1\' entry port is not array" , @port_name )
         else
@@ -5223 +4958 @@
           @celltype = celltype
 
-          # 右辺のセル object の受け口 object2 を参ç
-§æ¸ˆã¿ã«ã™ã‚‹
+          # 右辺のセル object の受け口 object2 を参照済みにする
           # object2: Port, @definition: Port
 
           # debug
           # p "rhs:  #{@cell}  #{@cell.get_name}"
-        end  # end of port (object2) チェック
+        end  # end of port (object2) チェック
 
         #else
-        #  celltype == nil (すでにエラー)
-      end  # end of celltyep チェック
+        #  celltype == nil (すでにエラー)
+      end  # end of celltyep チェック
 
 
       check_region( object )
 
-    end  # end of cell (object) チェック
-
-  end
-
-  #=== Join# アロケータの結合を生成
+    end  # end of cell (object) チェック
+
+  end
+
+  #=== Join# アロケータの結合を生成
   # STAGE: S
-  #cell::  呼び口の結合å
-ˆã®ã‚»ãƒ«
+  #cell::  呼び口の結合先のセル
   #
-  # ここでは呼び口側に生成されるアロケータ呼び口の結合を生成
-  # 受け口側は Cell の set_specifier_list で生成
-  #  a[*] のå†
-容は Cell の set_specifier_list を参ç
-§
+  # ここでは呼び口側に生成されるアロケータ呼び口の結合を生成
+  # 受け口側は Cell の set_specifier_list で生成
+  #  a[*] の内容は Cell の set_specifier_list を参照
   def create_allocator_join
 
-    cell = get_rhs_cell2   # 右辺のセルを得る
+    cell = get_rhs_cell2   # 右辺のセルを得る
     port = get_rhs_port2
 
-    if( cell && cell.get_allocator_list ) then      # cell == nil なら既にエラー
+    if( cell && cell.get_allocator_list ) then      # cell == nil なら既にエラー
 
       dbgPrint "create_allocator_join: #{@owner.get_name}.#{@name}=>#{cell ? cell.get_name : "nil"}\n"
@@ -5264 +4995 @@
 
         if( a[0+1] == port && a[1+1] == @rhs_subscript )then
-          # 名前の一致するものの結合を生成する
-          # 過不足は、別途チェックされる
+          # 名前の一致するものの結合を生成する
+          # 過不足は、別途チェックされる
           cp_name = :"#{@name}_#{a[2+1]}_#{a[3+1]}"
           # p "creating allocator join #{cp_name} #{@subscript} #{a[1+1]}"
@@ -5280 +5011 @@
   end
 
-  #=== Join# リージョン間の結合をチェック
-  # リージョン間の through による @region_through_list の作成
-  # 実際の生成は check_and_gen_through で行う
-  # mikan Cell#distance とRegion へたどり着くまでための処理にå
-±é€šéƒ¨åˆ†ãŒå¤šã„
+  #=== Join# リージョン間の結合をチェック
+  # リージョン間の through による @region_through_list の作成
+  # 実際の生成は check_and_gen_through で行う
+  # mikan Cell#distance とRegion へたどり着くまでための処理に共通部分が多い
   def check_region( object )
 
@@ -5291 +5021 @@
     # print "DOMAIN: check_region #{@owner.get_name}.#{@name} => #{object.get_name}\n"
 
-    # プラグインで生成されたなかでは生成しない
-    # さもないとプラグイン生成されたものとの間で、無限に生成される
+    # プラグインで生成されたなかでは生成しない
+    # さもないとプラグイン生成されたものとの間で、無限に生成される
 ##    if Generator.get_nest >= 1 then
-##    if Generator.get_plugin then     # mikan これはå¿
-要？ (意味解析段階での実行になるので不適切)
+##    if Generator.get_plugin then     # mikan これは必要？ (意味解析段階での実行になるので不適切)
     if @owner.get_plugin.kind_of?( ThroughPlugin ) then
-      # ãƒ—ãƒ©ã‚°ã‚¤ãƒ³ç”Ÿæˆã•ã‚ŒãŸã‚»ãƒ«ã®å ´åˆã€çµåˆãƒã‚§ãƒƒã‚¯ã®ã¿
+      # プラグイン生成されたセルの場合、結合チェックのみ
       return
     end
 
-    # region のチェック
-    r1 = @owner.get_region      # 呼び口セルの region
-    r2 = object.get_region      # 受け口セルの region
-
-    if ! r1.equal? r2 then      # 同一 region なら呼出し可能
+    # region のチェック
+    r1 = @owner.get_region      # 呼び口セルの region
+    r2 = object.get_region      # 受け口セルの region
+
+    if ! r1.equal? r2 then      # 同一 region なら呼出し可能
 
       f1 = r1.get_family_line
@@ -5312 +5041 @@
       len2 = f2.length
 
-      # 不一致になるところ（å
-„弟）を探す
-      i = 1  # i = 0 は :RootRegion なのでå¿
-ず一致
+      # 不一致になるところ（兄弟）を探す
+      i = 1  # i = 0 は :RootRegion なので必ず一致
       while( i < len1 && i < len2 )
         if( f1[i] != f2[i] )then
@@ -5323 +5050 @@
       end
 
-      sibling_level = i     # å
-„弟となるレベル、もしくはどちらか一方が終わったレベル
+      sibling_level = i     # 兄弟となるレベル、もしくはどちらか一方が終わったレベル
 
       dbgPrint "sibling_level: #{i}\n"
@@ -5337 +5063 @@
 
 
-      # 呼び側について呼びå
-ƒã®ãƒ¬ãƒ™ãƒ«ã‹ã‚‰å
-„弟レベルまで（out_through をチェックおよび挿å
-¥ï¼‰
+      # 呼び側について呼び元のレベルから兄弟レベルまで（out_through をチェックおよび挿入）
       i = len1 -1
       if b_to_through then
@@ -5364 +5087 @@
 
         out_through_list.each { |ol|
-          if ol[0] then    # plugin_name が指定されていなければ登録しない
+          if ol[0] then    # plugin_name が指定されていなければ登録しない
             plugin_arg = CDLString.remove_dquote ol[1]
             through = [ ol[0], :"Join_out_through_", plugin_arg, f1[i], f1[i-1], :OUT_THROUGH, region_count]
@@ -5377 +5100 @@
       end
 
-      # å
-„弟レベルにおいて（to_through をチェックおよび挿å
-¥ï¼‰
+      # 兄弟レベルにおいて（to_through をチェックおよび挿入）
       if f1[sibling_level] && f2[sibling_level] then
         dbgPrint "going from #{f1[sibling_level].get_name} to #{f2[sibling_level].get_name}\n"
         found = 0
-        region_count = f1[i].next_to_through_count( f2[sibling_level].get_name )   # to_through の region カウント
+        region_count = f1[i].next_to_through_count( f2[sibling_level].get_name )   # to_through の region カウント
         f1[sibling_level].get_to_through_list.each { |t|
-          if t[0][0] == f2[sibling_level].get_name then   # region 名が一致するか ?
-            if t[1] then    # plugin_name が指定されていなければ登録しない
+          if t[0][0] == f2[sibling_level].get_name then   # region 名が一致するか ?
+            if t[1] then    # plugin_name が指定されていなければ登録しない
               plugin_arg = CDLString.remove_dquote t[2]
               through = [ t[1], :"Join_to_through__", plugin_arg, f1[sibling_level], f2[sibling_level], :TO_THROUGH, region_count ]
@@ -5409 +5130 @@
       end
 
-      # 受け側についてå
-„弟レベルから受け側のレベルまで（in_through をチェックおよび挿å
-¥ï¼‰
+      # 受け側について兄弟レベルから受け側のレベルまで（in_through をチェックおよび挿入）
       if b_to_through then
-        i = sibling_level + 1      # to_through ã‚’çµŒãŸå ´åˆã€æœ€åˆã® in_through は適用しない
+        i = sibling_level + 1      # to_through を経た場合、最初の in_through は適用しない
       else
         i = sibling_level
@@ -5436 +5155 @@
         end
         in_through_list.each { |il|
-          if il[0] then    # plugin_name が指定されていなければ登録しない
+          if il[0] then    # plugin_name が指定されていなければ登録しない
             plugin_arg = CDLString.remove_dquote il[1]
             through = [ il[0], :"Join_in_through_", plugin_arg, f2[i-1], f2[i],:IN_THROUGH, region_count ]
@@ -5449 +5168 @@
 
 
-  #=== Join# 生成しないリージョンへの結合かチェック
-  # 右辺のセルが、生成されないリージョンにあればエラー
-  # 右辺は、プラグイン生成されたセルがあれば、それを対象とする
+  #=== Join# 生成しないリージョンへの結合かチェック
+  # 右辺のセルが、生成されないリージョンにあればエラー
+  # 右辺は、プラグイン生成されたセルがあれば、それを対象とする
   def check_region2
     lhs_cell = @owner
 
-    # 生成しないリージョンのセルへの結合か？
+    # 生成しないリージョンのセルへの結合か？
     # if join.get_cell && ! join.get_cell.is_generate? then
-    # if get_rhs_cell && ! get_rhs_cell.is_generate? then # composite ã‚»ãƒ«ãŒãƒ—ãƒ­ã‚¿ã‚¤ãƒ—å®£è¨€ã®å ´åˆä¾‹å¤–
+    # if get_rhs_cell && ! get_rhs_cell.is_generate? then # composite セルがプロタイプ宣言の場合例外
     # print "Link root: (caller #{@owner.get_name}) '#{@owner.get_region.get_link_root.get_name}'"
     # print " #{@owner.get_region.get_link_root == get_rhs_region.get_link_root ? "==" : "!="} "
@@ -5470 +5189 @@
       end
     else
-      # rhs のセルが存在しなかった (既にエラー)
+      # rhs のセルが存在しなかった (既にエラー)
     end
   end
@@ -5478 +5197 @@
   end
 
-  #=== Join# specifier を設定
+  #=== Join# specifier を設定
   # STAGE: B
-  # set_specifier_list は、join の解析の最後で呼び出される
-  # through 指定子を設定
-  #  check_and_gen_through を呼出して、through 生成
+  # set_specifier_list は、join の解析の最後で呼び出される
+  # through 指定子を設定
+  #  check_and_gen_through を呼出して、through 生成
   def set_specifier_list( specifier_list )
 
@@ -5490 +5209 @@
         # set plugin_name
         plugin_name = s[1].to_s
-        plugin_name[0] = "#{plugin_name[/^./].upcase}"     # å
-ˆé ­æ–‡å­—を大文字に : ruby のクラス名の制約
+        plugin_name[0] = "#{plugin_name[/^./].upcase}"     # 先頭文字を大文字に : ruby のクラス名の制約
 
         # set cell_name
@@ -5498 +5216 @@
         # set plugin_arg
         plugin_arg = CDLString.remove_dquote s[2].to_s
-        # plugin_arg = s[2].to_s.gsub( /\A"(.*)/, '\1' )   # 前後の "" を取り除く
+        # plugin_arg = s[2].to_s.gsub( /\A"(.*)/, '\1' )   # 前後の "" を取り除く
         # plugin_arg.sub!( /(.*)"\z/, '\1' )
 
@@ -5507 +5225 @@
   end
 
-  #=== Join# through のチェックと生成
-  # new_join の中の check_region で region 間の through が @region_through に設定される
-  # set_specifier で呼び口の結合で指定された through が @cp_through 設定される
-  # その後、このメソッドが呼ばれる
+  #=== Join# through のチェックと生成
+  # new_join の中の check_region で region 間の through が @region_through に設定される
+  # set_specifier で呼び口の結合で指定された through が @cp_through 設定される
+  # その後、このメソッドが呼ばれる
   def check_and_gen_through
 
@@ -5531 +5249 @@
 
     @through_list = @cp_through_list + @region_through_list
-      # 後から @cp_through_list と @region_through_list に分けたため、このような実è£
-になった
+      # 後から @cp_through_list と @region_through_list に分けたため、このような実装になった
 
     if @through_list then           # nil when the join is not Port
-      len = @through_list.length    # through が連接している数
+      len = @through_list.length    # through が連接している数
     else
       len = 0
@@ -5546 +5263 @@
     end
 
-    # 連続した through ã«ã¤ã„ã¦ã€å—ã‘å£å´ã‹ã‚‰é †ã«ã‚»ãƒ«ã‚’ç”Ÿæˆã—è§£é‡ˆã™ã‚‹
+    # 連続した through について、受け口側から順にセルを生成し解釈する
     i = len - 1
     while i >= 0
@@ -5575 +5292 @@
 
       else
-        # æœ€å¾Œã®ã‚»ãƒ«ã®å ´åˆã€æ¬¡ã®ã‚»ãƒ«ã®åå‰ã€ãƒãƒ¼ãƒˆå
+        # 最後のセルの場合、次のセルの名前、ポート名
         next_cell      = @cell
         next_port_name = @port_name
 
         if next_cell == nil then
-          # 結合å
-ˆãŒãªã„
+          # 結合先がない
           return
         end
@@ -5587 +5303 @@
 
       if i >= cp_len then
-        # region_through_list 部分
-        # region から @cell_name.@port_name への through がないか探す
+        # region_through_list 部分
+        # region から @cell_name.@port_name への through がないか探す
         # rp = @through_list[i][3].find_cell_port_through_plugin( @cell_name, @port_name ) #762
         rp = @through_list[i][3].find_cell_port_through_plugin( @cell.get_global_name, @port_name )
-           # @through_list[i] と @region_through_list[i-cp_len] は同じ
-        # å
-±ç”¨ã—ないようにするには、見つからなかったことにすればよい
+           # @through_list[i] と @region_through_list[i-cp_len] は同じ
+        # 共用しないようにするには、見つからなかったことにすればよい
         # rp = nil
       else
-        # region 以外のものはå
-±æœ‰ã—ない
-        # 呼び口側に指定されているし、plugin_arg が異なるかもしれない
+        # region 以外のものは共有しない
+        # 呼び口側に指定されているし、plugin_arg が異なるかもしれない
         rp = nil
       end
@@ -5607 +5321 @@
         end
       else
-        # 見つかったものをå
-±ç”¨ã™ã‚‹
+        # 見つかったものを共用する
         @through_generated_list[ i ] = rp
       end
 
       if i >= cp_len then
-        # @through_generated_list のうち @region_through_listに対応する部分
+        # @through_generated_list のうち @region_through_listに対応する部分
         @region_through_generated_list[ i - cp_len ] = @through_generated_list[ i ]
         if rp == nil then
-          # 生成したものを region(@through_list[i][3]) ã®ãƒªã‚¹ãƒˆã«è¿½åŠ 
+          # 生成したものを region(@through_list[i][3]) のリストに追加
           # @through_list[i][3].add_cell_port_through_plugin( @cell_name, @port_name, @through_generated_list[i] ) #762
           @through_list[i][3].add_cell_port_through_plugin( @cell.get_global_name, @port_name, @through_generated_list[i] )
@@ -5623 +5336 @@
 
       if i == 0 then
-        # 最も呼び口側のセルは、CDL 上の結合がないため、参ç
-§ã•ã‚ŒãŸã“とにならない
-        # mikan namespace 対応
+        # 最も呼び口側のセルは、CDL 上の結合がないため、参照されたことにならない
+        # mikan namespace 対応
         # cell = Namespace.find( [ @through_generated_list[0].get_cell_name] )    #1
         if @through_generated_list[0] == nil then
-          return  # plugin_object の生成に失敗している
+          return  # plugin_object の生成に失敗している
         end
         cell = Namespace.find( @through_generated_list[0].get_cell_namespace_path )    #1
@@ -5652 +5364 @@
   end
 
-  #=== Join# through プラグインを呼び出して CDL 生成させるとともに、import する
+  #=== Join# through プラグインを呼び出して CDL 生成させるとともに、import する
   def gen_through_cell_code_and_parse( plugin_name, i, next_cell, next_port_name )
 
@@ -5660 +5372 @@
     plugin_arg            = through[ 2 ]
     if through[ 3 ] then
-      # region 間の through ã®å ´åˆ
+      # region 間の through の場合
       @@start_region      = through[ 3 ]
       if next_cell.get_region.equal? @@start_region then
@@ -5670 +5382 @@
       @@region_count      = through[ 6 ]
     else
-      # 呼び口の through ã®å ´åˆ
-      @@start_region      = @owner.get_region    # 呼び口側セルの region
-      @@end_region        = next_cell.get_region # 次のセルの region
-      @@through_type      = :THROUGH             # 呼び口の through 指定
+      # 呼び口の through の場合
+      @@start_region      = @owner.get_region    # 呼び口側セルの region
+      @@end_region        = next_cell.get_region # 次のセルの region
+      @@through_type      = :THROUGH             # 呼び口の through 指定
       @@region_count      = 0
     end
@@ -5687 +5399 @@
 
     begin
-      eval( eval_str )     # plugin を生成
+      eval( eval_str )     # plugin を生成
       plugin_object.set_locale @locale
     rescue Exception => evar
@@ -5702 +5414 @@
     @through_generated_list[ i ] = plugin_object
 
-    # Region に関するæƒ
-å ±ã‚’è¨­å®š
-    # å¾Œã‹ã‚‰è¿½åŠ ã—ãŸã®ã§ã€new の引数外で設定
+    # Region に関する情報を設定
+    # 後から追加したので、new の引数外で設定
     # plugin_object.set_through_info( start_region, end_region, through_type )
 
@@ -5710 +5421 @@
   end
 
-  #プラグインへの引数で渡さないものを、一時的に記憶しておく
-  # プラグインの initialize の中でコールバックして設定する
+  #プラグインへの引数で渡さないものを、一時的に記憶しておく
+  # プラグインの initialize の中でコールバックして設定する
   @@plugin_creating_join = nil
   @@start_region = nil
@@ -5718 +5429 @@
   @@region_count = nil
 
-  #=== Join# ThroughPlugin ã®è¿½åŠ æƒ
-å ±ã‚’è¨­å®šã™ã‚‹
-  # このメソッドは ThroughPlugin#initialize から呼び出される
-  # plugin_object を生成する際の引数では不足するæƒ
-å ±ã‚’è¿½åŠ ã™ã‚‹
+  #=== Join# ThroughPlugin の追加情報を設定する
+  # このメソッドは ThroughPlugin#initialize から呼び出される
+  # plugin_object を生成する際の引数では不足する情報を追加する
   def self.set_through_info plugin_object
     plugin_object.set_through_info( @@start_region, @@end_region, @@through_type,
@@ -5734 +5443 @@
   end
 
-  #=== Join#é
-åˆ—添数を得る
-  # @subscript の説明を参ç
-§ã®ã“と
+  #=== Join#配列添数を得る
+  # @subscript の説明を参照のこと
   def get_subscript
     @subscript
   end
 
-  def get_cell_name         # 受け口セル名
+  def get_cell_name         # 受け口セル名
     @cell_name
   end
@@ -5754 +5461 @@
   end
 
-  #=== Join# 右辺の実セルを得る
-  #    実セルとは through で挿å
-¥ã•ã‚ŒãŸã‚‚の、composite のå†
-部など実際に結合されるå
-ˆ
-  #    このメソッドは　get_rhs_port と対になっている
-  #    このメソッドは、意味解析段階では呼び出してはならない (対象セルの意味解析が済む前には正しい結果を返さない)
+  #=== Join# 右辺の実セルを得る
+  #    実セルとは through で挿入されたもの、composite の内部など実際に結合される先
+  #    このメソッドは　get_rhs_port と対になっている
+  #    このメソッドは、意味解析段階では呼び出してはならない (対象セルの意味解析が済む前には正しい結果を返さない)
   def get_rhs_cell
-    # through 指定あり？
+    # through 指定あり？
     if @through_list[0] then
-      # mikan through で生成したものが root namespace 限定
+      # mikan through で生成したものが root namespace 限定
       if @through_generated_list[0] then
         # cell = Namespace.find( [ "::", @through_generated_list[0].get_cell_name.to_sym ] )    #1
         cell = Namespace.find( @through_generated_list[0].get_cell_namespace_path )    #1
-        # cell が nil になるのはプラグインの get_cell_namespace_path が正しくないか、
-        # プラグイン生成コードがエラーになっている。
-        # できの悪いプラグインが多ければ、cell == nil をはじいた方がよい。
+        # cell が nil になるのはプラグインの get_cell_namespace_path が正しくないか、
+        # プラグイン生成コードがエラーになっている。
+        # できの悪いプラグインが多ければ、cell == nil をはじいた方がよい。
         return cell.get_real_cell( @through_generated_list[0].get_through_entry_port_name )
       else
-        return nil            # generate に失敗している
+        return nil            # generate に失敗している
       end
     elsif @cell then
       return @cell.get_real_cell( @port_name )
     else
-      # å³è¾ºãŒæœªå®šç¾©ã®å ´åˆ @cell は nil (既にエラー)
+      # 右辺が未定義の場合 @cell は nil (既にエラー)
       return nil
     end
   end
 
-  #=== Join# 右辺のセルを得る
-  # 右辺のセルを得る。ただし、composite 展開されていない
-  # composite 展開されたものを得るには get_rhs_cell を使う
-  # ãƒ—ãƒ­ãƒˆã‚¿ã‚¤ãƒ—å®£è¨€ã—ã‹ã•ã‚Œã¦ã„ãªã„å ´åˆã«ã¯ã€ã“ã¡ã‚‰ã—ã‹ä½¿ãˆãªã„
-  # このメソッドは get_rhs_port2 と対になっている
+  #=== Join# 右辺のセルを得る
+  # 右辺のセルを得る。ただし、composite 展開されていない
+  # composite 展開されたものを得るには get_rhs_cell を使う
+  # プロトタイプ宣言しかされていない場合には、こちらしか使えない
+  # このメソッドは get_rhs_port2 と対になっている
   def get_rhs_cell2
-    # through 指定あり？
+    # through 指定あり？
     if @through_list[0] then
-      # mikan through で生成したものが root namespace 限定
+      # mikan through で生成したものが root namespace 限定
       # cell = Namespace.find( [ "::", @through_generated_list[0].get_cell_name ] )
       if @through_generated_list[0] then
@@ -5797 +5501 @@
         cell = Namespace.find( @through_generated_list[0].get_cell_namespace_path )    #1
       else
-        cell = @cell            # generate に失敗している
+        cell = @cell            # generate に失敗している
       end
     else
@@ -5806 +5510 @@
   end
 
-  #=== Join# 右辺のセルを得る
-  # through は適用しないが、composite は展開した後のセル
-  # (意味解析が終わっていないと、composite 展開が終わっていない)
-  # このメソッドは get_rhs_port3 と対になっている
+  #=== Join# 右辺のセルを得る
+  # through は適用しないが、composite は展開した後のセル
+  # (意味解析が終わっていないと、composite 展開が終わっていない)
+  # このメソッドは get_rhs_port3 と対になっている
   def get_rhs_cell3
     if @cell then
@@ -5816 +5520 @@
   end
 
-  #=== Join# 右辺のセルのリージョンを得る
-  # å³è¾ºãŒæœªå®šç¾©ã®å ´åˆã€nil を返す
-  # composite ã®å ´åˆã€å®Ÿã‚»ãƒ«ã§ã¯ãªã composite cell の region を返す(composite はすべて同じ region に属する)
-  # composite の cell がプロトタイプ宣言されているとき get_rhs_cell/get_real_cell は ruby の例外となる
+  #=== Join# 右辺のセルのリージョンを得る
+  # 右辺が未定義の場合、nil を返す
+  # composite の場合、実セルではなく composite cell の region を返す(composite はすべて同じ region に属する)
+  # composite の cell がプロトタイプ宣言されているとき get_rhs_cell/get_real_cell は ruby の例外となる
   def get_rhs_region
-    # through 指定あり？
+    # through 指定あり？
     if @through_list[0] then
       if @through_generated_list[0] then
-        # mikan through で生成したものが root namespace 限定
+        # mikan through で生成したものが root namespace 限定
         # cell = Namespace.find( [ "::", @through_generated_list[0].get_cell_name.to_sym ] )    #1
         cell = Namespace.find( @through_generated_list[0].get_cell_namespace_path )    #1
@@ -5831 +5535 @@
         end
       else
-        return nil       # generate に失敗している
+        return nil       # generate に失敗している
       end
     elsif @cell then
       return @cell.get_region
     end
-    # å³è¾ºãŒæœªå®šç¾©ã®å ´åˆ @cell は nil (既にエラー)
+    # 右辺が未定義の場合 @cell は nil (既にエラー)
     return nil
   end
 
-  def get_cell_global_name  # 受け口セル名（コンポジットなら展開したå†
-側のセル）
+  def get_cell_global_name  # 受け口セル名（コンポジットなら展開した内側のセル）
 
     # debug
@@ -5855 +5558 @@
   end
 
-  #===  Join# 結合の右辺の受け口の名前
-  #     namespace 名 + '_' + セル名 + '_' + 受け口名   （このセルが composite ならば展開後のセル名、受け口名）
-  #subscript:: Integer  呼び口é
-åˆ—の時添数 または nil 呼び口é
-åˆ—でない時
-  def get_port_global_name( subscript = nil )  # 受け口名（コンポジットなら展開したå†
-側のセル）
+  #===  Join# 結合の右辺の受け口の名前
+  #     namespace 名 + '_' + セル名 + '_' + 受け口名   （このセルが composite ならば展開後のセル名、受け口名）
+  #subscript:: Integer  呼び口配列の時添数 または nil 呼び口配列でない時
+  def get_port_global_name( subscript = nil )  # 受け口名（コンポジットなら展開した内側のセル）
 
     # debug
     dbgPrint "Cell get_port_global_name:  #{@cell_name}\n"
 
-    # through 指定あり？
+    # through 指定あり？
     if @through_list[0] then
 
-      # mikan through で生成したものが root namespace 限定
+      # mikan through で生成したものが root namespace 限定
       # cell = Namespace.find( [ "::", @through_generated_list[0].get_cell_name.to_sym ] )    #1
       cell = Namespace.find( @through_generated_list[0].get_cell_namespace_path )    #1
 
-      # through で挿å
-¥ã•ã‚ŒãŸã‚»ãƒ«ã§ã€å®Ÿéš›ã«æŽ¥ç¶šã•ã‚Œã‚‹ã‚»ãƒ«ï¼ˆcompositeã®å ´åˆå†
-部の)の受け口の C 言語名前
+      # through で挿入されたセルで、実際に接続されるセル（compositeの場合内部の)の受け口の C 言語名前
       return cell.get_real_global_port_name( @through_generated_list[0].get_through_entry_port_name )
     else
 
-      # 実際に接続されるセルの受け口の C 言語名前
+      # 実際に接続されるセルの受け口の C 言語名前
       if @cell then
         return @cell.get_real_global_port_name( @port_name )
@@ -5902 +5600 @@
   end
 
-  #=== Join# 右辺のポートを得る
-  #    右辺が composite ã®å ´åˆã¯ã€å†
-部の繋がるセルのポート, through ã®å ´åˆã¯æŒ¿å
-¥ã•ã‚ŒãŸã‚»ãƒ«ã®ãƒãƒ¼ãƒˆ
-  #    このメソッドは get_rhs_cell と対になっている
+  #=== Join# 右辺のポートを得る
+  #    右辺が composite の場合は、内部の繋がるセルのポート, through の場合は挿入されたセルのポート
+  #    このメソッドは get_rhs_cell と対になっている
   def get_rhs_port
-    # through 指定あり？
+    # through 指定あり？
     if @through_list[0] then
-      # mikan through で生成したものが root namespace 限定
-      # through で生成されたセルを探す
+      # mikan through で生成したものが root namespace 限定
+      # through で生成されたセルを探す
 #      cell = Namespace.find( [ "::", @through_generated_list[0].get_cell_name.to_sym ] )    #1
       cell = Namespace.find( @through_generated_list[0].get_cell_namespace_path )    #1
-      # cell のプラグインで生成されたポート名のポートを探す (composite ならå†
-部の繋がるポート)
+      # cell のプラグインで生成されたポート名のポートを探す (composite なら内部の繋がるポート)
       return cell.get_real_port( @through_generated_list[0].get_through_entry_port_name )
     else
-      # ポートを返す(composite ならå†
-部の繋がるポートを返す)
+      # ポートを返す(composite なら内部の繋がるポートを返す)
       return @cell.get_real_port( @port_name )
     end
   end
 
-  #=== Join# 右辺のポートを得る
-  # 右辺のポートを得る。
-  # ã“ã‚Œã¯ãƒ—ãƒ­ãƒˆã‚¿ã‚¤ãƒ—å®£è¨€ã—ã‹ã•ã‚Œã¦ã„ãªã„å ´åˆã«ã¯ã€ã“ã¡ã‚‰ã—ã‹ä½¿ãˆãªã„
+  #=== Join# 右辺のポートを得る
+  # 右辺のポートを得る。
+  # これはプロトタイプ宣言しかされていない場合には、こちらしか使えない
   def get_rhs_port2
-    # through 指定あり？
+    # through 指定あり？
     if @through_list[0] then
       if @through_generated_list[0] then
         port = @through_generated_list[0].get_through_entry_port_name.to_sym
       else
-        port = @port_name    # generate に失敗している
+        port = @port_name    # generate に失敗している
       end
     else
@@ -5942 +5636 @@
   end
 
-  #=== Join# 右辺のポートを得る
-  # through は適用しないが、composite は展開した後のセルの対応するポート
+  #=== Join# 右辺のポートを得る
+  # through は適用しないが、composite は展開した後のセルの対応するポート
   def get_rhs_port3
     if @cell then
@@ -5950 +5644 @@
   end
 
-  #=== Join# 呼び口é
-åˆ—の2ç•ªç›®ä»¥é™ã®è¦ç´ ã‚’è¿½åŠ ã™ã‚‹
-  #     一番最初に定義されたé
-åˆ—è¦ç´ がå
-¨è¦ç´ の初期値のé
-åˆ—を持つ
-  #     このメソッドは非é
-åˆ—ã®å ´åˆã‚‚å‘¼å‡ºã•ã‚Œã‚‹ï¼ˆjoin é‡è¤‡ã‚¨ãƒ©ãƒ¼ã®å ´åˆï¼‰
-  #join2:: Join  呼び口é
-åˆ—è¦ç´ の Join
+  #=== Join# 呼び口配列の2番目以降の要素を追加する
+  #     一番最初に定義された配列要素が全要素の初期値の配列を持つ
+  #     このメソッドは非配列の場合も呼出される（join 重複エラーの場合）
+  #join2:: Join  呼び口配列要素の Join
   def add_array_member join2
 
-    # subscript2: join2 の左辺添数
+    # subscript2: join2 の左辺添数
     subscript2 = join2.get_subscript
 
     if @subscript == nil then           # not array : initialize duplicate
-      # 非é
-åˆ—ã®å ´åˆã€join が重複している
+      # 非配列の場合、join が重複している
       cdl_error( "S1127 \'$1\' duplicate", @name )
       # print "add_array_member2: #{@owner.get_name}\n"
 
     elsif @subscript >= 0 then
-      # æ·»æ•°æŒ‡å®šã‚ã‚Šã®å ´åˆ
+      # 添数指定ありの場合
       if( subscript2 == nil || subscript2 < 0 ) then
-        # join2 左辺は非é
-åˆ—または添数なし
-        # é
-åˆ—が不一致
+        # join2 左辺は非配列または添数なし
+        # 配列が不一致
         cdl_error( "S1128 \'$1\' inconsistent array definition", @name )
       elsif @array_member[subscript2] != nil then
-        # 同じ添数が既に定義済み
+        # 同じ添数が既に定義済み
         cdl_error( "S1129 \'$1\' redefinition of subscript $2" ,@name, subscript2 )
       else
-        # æ·»æ•°ã®ä½ç½®ã«è¦ç´ ã‚’è¿½åŠ 
+        # 添数の位置に要素を追加
         @array_member[subscript2] = join2.get_rhs
         @array_member2[subscript2] = join2
@@ -5990 +5675 @@
 
     else
-      # æ·»æ•°æŒ‡å®šãªã—ã®å ´åˆ
+      # 添数指定なしの場合
       if( subscript2 == nil || subscript2 >= 0 ) then
-        # join2 左辺は非é
-åˆ—または添数有
-        # é
-åˆ—が不一致
+        # join2 左辺は非配列または添数有
+        # 配列が不一致
         cdl_error( "S1130 \'R1\' inconsistent array definition", @name )
       end
 
-      # 添数なしé
-åˆ—ã®å ´åˆã€é
-åˆ—è¦ç´ ã‚’è¿½åŠ 
+      # 添数なし配列の場合、配列要素を追加
       @array_member  << join2.get_rhs
       @array_member2 << join2
@@ -6025 +5706 @@
       while i < @array_member2.length
         if @array_member2[i] != self && @array_member[i] != nil then
-          # @array_member2[i] が nil になるのは optional の時と、
-          # Join の initialize で無駄に @array_member2 ãŒè¨­å®šã•ã‚Œã¦ã„ã‚‹å ´åˆ
-          # 無駄に設定されているものについては、再帰的に呼び出すå¿
-要はない（clone_for_composite では対策している）
+          # @array_member2[i] が nil になるのは optional の時と、
+          # Join の initialize で無駄に @array_member2 が設定されている場合
+          # 無駄に設定されているものについては、再帰的に呼び出す必要はない（clone_for_composite では対策している）
           @array_member2[i].change_name( name )
         end
@@ -6036 +5716 @@
   end
 
-  # composite cell を展開したセルの結合を clone したセルの名前に変更
+  # composite cell を展開したセルの結合を clone したセルの名前に変更
   def change_rhs_port( clone_cell_list, celltype )
 
@@ -6054 +5734 @@
     dbgPrint "  cell_name:   #{@cell_name} => #{c.get_global_name}, #{c.get_name}\n"
 
-    # @rhs のå†
-容を調整しておく（このå†
-容は、subscript を除いて、後から使われていない）
+    # @rhs の内容を調整しておく（この内容は、subscript を除いて、後から使われていない）
     elements = @rhs.get_elements
-    if elements[0] == :OP_SUBSC then  # 右辺：受け口é
-åˆ—？
+    if elements[0] == :OP_SUBSC then  # 右辺：受け口配列？
       elements  = elements[1]
     end
 
-    # 右辺が　cell.ePort の形式でない
+    # 右辺が　cell.ePort の形式でない
     if elements[0] != :OP_DOT || elements[1][0] != :IDENTIFIER then   #1
       return
     else
-      # セル名を composite å†
-部の名前から、外部の名前にå
-¥ã‚Œæ›¿ãˆã‚‹
+      # セル名を composite 内部の名前から、外部の名前に入れ替える
       # elements[1][1] = Token.new( c.get_name, nil, nil, nil )
       elements[1][1] = NamespacePath.new( c.get_name, false, c.get_namespace )
@@ -6076 +5751 @@
     @cell_name = c.get_name
     @cell = c
-    # @definition = nil          # @definition が有効： チェック済み（とは、しない）
+    # @definition = nil          # @definition が有効： チェック済み（とは、しない）
 
     if @array_member2 then
@@ -6085 +5760 @@
       i = 0
       while i < @array_member2.length
-        # @array_member2[i] が nil になるのは optional の時と、
-        # Join の initialize で無駄に @array_member2 ãŒè¨­å®šã•ã‚Œã¦ã„ã‚‹å ´åˆ
-        # 無駄に設定されているものについては、再帰的に呼び出すå¿
-要はない（clone_for_composite では対策している）
+        # @array_member2[i] が nil になるのは optional の時と、
+        # Join の initialize で無駄に @array_member2 が設定されている場合
+        # 無駄に設定されているものについては、再帰的に呼び出す必要はない（clone_for_composite では対策している）
         if @array_member2[i] != self && @array_member[i] != nil then
           @array_member2[i].change_rhs_port( clone_cell_list, celltype )
@@ -6098 +5772 @@
   end
 
-  #=== Join# composite セル用にクローン
-  #cell_global_name:: string : 親セルのグローバル名
-  # 右辺の C_EXP に含まれる $id$, $cell$, $ct$ を置換
-  # ここで置換するのは composite の attribute の C_EXP を composite セルタイプおよびセル名に置換するため
-  # （å†
-部セルの C_EXP もここで置換される）
-  # @through_list などもコピーされるので、これが呼び出される前に確定するå¿
-要がある
+  #=== Join# composite セル用にクローン
+  #cell_global_name:: string : 親セルのグローバル名
+  # 右辺の C_EXP に含まれる $id$, $cell$, $ct$ を置換
+  # ここで置換するのは composite の attribute の C_EXP を composite セルタイプおよびセル名に置換するため
+  # （内部セルの C_EXP もここで置換される）
+  # @through_list などもコピーされるので、これが呼び出される前に確定する必要がある
   def clone_for_composite( ct_name, cell_name, locale, b_need_recursive = true )
 
@@ -6125 +5797 @@
 
   def clone_array_member( array_member, array_member2, ct_name, cell_name, prev, locale )
-    # é
-åˆ—のコピーを作る
+    # 配列のコピーを作る
     am  = array_member.clone
     am2 = array_member2.clone
 
-    # é
-åˆ—è¦ç´ のコピーを作る
+    # 配列要素のコピーを作る
     i = 0
     while i < am2.length
       if array_member2[i] == prev then
-        # 自分自身である（ので、呼出すと無限再帰呼出しとなる）
+        # 自分自身である（ので、呼出すと無限再帰呼出しとなる）
         am2[i] = self
       elsif array_member2[i] then
         am2[i] = array_member2[i].clone_for_composite( ct_name, cell_name, locale, false )
       else
-        # 以前のエラーで array_member2[i] は nil になっている
+        # 以前のエラーで array_member2[i] は nil になっている
       end
 
@@ -6149 +5819 @@
     end
 
-    # i = 0 は、ここで自分自身を設定
+    # i = 0 は、ここで自分自身を設定
     # am2[0] = self
 
@@ -6157 +5827 @@
   end
 
-  #=== Join# rhs をå
-¥ã‚Œæ›ãˆã‚‹
+  #=== Join# rhs を入れ換える
   #rhs:: Expression | initializer
-  # 右辺をå
-¥ã‚Œæ›ãˆã‚‹ï¼Ž
-  # このメソッドは、composite で cell の属性の初期値を attribute の値で置き換えるのに使われる
-  # このメソッドは composite å†
-の cell ã®å±žæ€§ã®åˆæœŸå€¤ãŒå®šæ•°ã§ã¯ãªãå¼ã«ãªã£ãŸå ´åˆã€ä¸è¦ã«ãªã‚‹
+  # 右辺を入れ換える．
+  # このメソッドは、composite で cell の属性の初期値を attribute の値で置き換えるのに使われる
+  # このメソッドは composite 内の cell の属性の初期値が定数ではなく式になった場合、不要になる
   def change_rhs rhs
     @rhs = rhs
   end
 
-  #=== Join# clone された join の owner を変更
+  #=== Join# clone された join の owner を変更
   def set_cloned( owner )
     dbgPrint "Join#set_cloned: #{@name}  prev owner: #{@owner.get_name} new owner: #{owner.get_name}\n"
@@ -6255 +5922 @@
 end
 
-#== 逆結合
+#== 逆結合
 class ReverseJoin < BDNode
 #@ep_name:: Symbol
@@ -6280 +5947 @@
 end
 
-# CLASS: CompositeCelltype 用の Join
-# REM:   CompositeCelltype が export するもの
+# CLASS: CompositeCelltype 用の Join
+# REM:   CompositeCelltype が export するもの
 class CompositeCelltypeJoin < BDNode
-# @export_name:: string     :  CompositeCelltype が export する名前（呼び口、受け口、属性）
-# @internal_cell_name:: string : CompositeCelltype å†
-部のセルの名前
-# @internal_cell_elem_name:: string : CompositeCelltype å†
-部のセルの呼び口、受け口、属性の名前
-# @cell : Cell : Cell::  internal cell  : CompositeCelltyep å†
-部のセル（in_compositeセル）
+# @export_name:: string     :  CompositeCelltype が export する名前（呼び口、受け口、属性）
+# @internal_cell_name:: string : CompositeCelltype 内部のセルの名前
+# @internal_cell_elem_name:: string : CompositeCelltype 内部のセルの呼び口、受け口、属性の名前
+# @cell : Cell : Cell::  internal cell  : CompositeCelltyep 内部のセル（in_compositeセル）
 # @port_decl:: Port | Decl
 # @b_pseudo: bool : 
@@ -6304 +5968 @@
   end
 
-  #=== CompositeCelltypeJoin# CompositeCelltypeJoin の対象セルか？
-  #cell::  Cell 対象かどうかチェックするセル
+  #=== CompositeCelltypeJoin# CompositeCelltypeJoin の対象セルか？
+  #cell::  Cell 対象かどうかチェックするセル
   #
-  #     CompositeCelltypeJoin と cell の名前が一致するかチェックする
-  #     port_decl ãŒæŒ‡å®šã•ã‚ŒãŸå ´åˆã¯ã€ç¾çŠ¶ä½¿ã‚ã‚Œã¦ã„ãªã„
+  #     CompositeCelltypeJoin と cell の名前が一致するかチェックする
+  #     port_decl が指定された場合は、現状使われていない
   def match?( cell, port_decl = nil )
 
@@ -6324 +5988 @@
 
 #    if @cell.equal?( cell ) && ( port_decl == nil || @port_decl.equal?( port_decl ) ) then
-    # なぜ port_decl が一致しなければならなかったか忘れた。
-    # recursive_composite で名前の一致に変更   060917
+    # なぜ port_decl が一致しなければならなかったか忘れた。
+    # recursive_composite で名前の一致に変更   060917
     if((@cell.get_name == cell.get_name) && (port_decl == nil || @port_decl.get_name == port_decl.get_name))then
       true
@@ -6357 +6021 @@
   end
 
-  # @port_decl が Port ã®å ´åˆã®ã¿å‘¼ã³å‡ºã—ã¦ã‚ˆã„
+  # @port_decl が Port の場合のみ呼び出してよい
   def get_port_type
     if @port_decl then
@@ -6379 +6043 @@
   end
 
-  # @port_decl が Port ã®å ´åˆã®ã¿å‘¼ã³å‡ºã—ã¦ã‚ˆã„
+  # @port_decl が Port の場合のみ呼び出してよい
   def is_require?
     if @port_decl then
@@ -6386 +6050 @@
   end
 
-  # @port_decl が Port ã®å ´åˆã®ã¿å‘¼ã³å‡ºã—ã¦ã‚ˆã„
+  # @port_decl が Port の場合のみ呼び出してよい
   def is_allocator_port?
     if @port_decl then
@@ -6393 +6057 @@
   end
 
-  # @port_decl が Port ã®å ´åˆã®ã¿å‘¼ã³å‡ºã—ã¦ã‚ˆã„
+  # @port_decl が Port の場合のみ呼び出してよい
   def is_optional?
     if @port_decl then
@@ -6400 +6064 @@
   end
 
-  #=== CompositeCelltypeJoin# 右辺が Decl ならば初期化子（式）を返す
-  # このメソッドは Cell の check_join から初期値チェックのために呼び出される
+  #=== CompositeCelltypeJoin# 右辺が Decl ならば初期化子（式）を返す
+  # このメソッドは Cell の check_join から初期値チェックのために呼び出される
   def get_initializer
     if @port_decl.instance_of? Decl then
@@ -6414 +6078 @@
   end
 
-  #=== CompositeCelltypeJoin# é
-åˆ—サイズを得る
-  #RETURN:: nil: not array, "[]": 大きさ指定なし, Integer: 大きさ指定あり
+  #=== CompositeCelltypeJoin# 配列サイズを得る
+  #RETURN:: nil: not array, "[]": 大きさ指定なし, Integer: 大きさ指定あり
   def get_array_size
     @port_decl.get_array_size
   end
 
-  #=== CompositeCelltypeJoin# signature を得る
-  # @port_decl が Port の時のみ呼び出してもよい
+  #=== CompositeCelltypeJoin# signature を得る
+  # @port_decl が Port の時のみ呼び出してもよい
   def get_signature
     @port_decl.get_signature
@@ -6465 +6128 @@
 # @file_name:: string
 # @format:: string
-# @arg_list:: Expression の elements と同じ形式 [ [:IDENTIFIER, String], ... ]
+# @arg_list:: Expression の elements と同じ形式 [ [:IDENTIFIER, String], ... ]
 # @f_celltype:: bool : true: celltype factory, false: cell factory
 
@@ -6476 +6139 @@
     case name
     when :write
-      # write 関数
+      # write 関数
       @name = name
 
-      # write 関数の第一引数：出力å
-ˆãƒ•ã‚¡ã‚¤ãƒ«å
-        # 式を評価する（通常単一の文字列であるから、単一の文字列が返される）
+      # write 関数の第一引数：出力先ファイル名
+        # 式を評価する（通常単一の文字列であるから、単一の文字列が返される）
       @file_name = file_name.eval_const(nil).val  # file_name : Expression
       if ! @file_name.instance_of?( String ) then
-        # 文字列定数ではなかった
+        # 文字列定数ではなかった
         cdl_error( "S1132 $1: 1st parameter is not string(file name)" , @name )
         @file_name = nil
       end
 
-      # write 関数の第二引数：フォーマット文字列
+      # write 関数の第二引数：フォーマット文字列
       @format    = format.eval_const(nil).val     # format : Expression
-        # 式を評価する（通常単一の文字列であるから、単一の文字列が返される）
+        # 式を評価する（通常単一の文字列であるから、単一の文字列が返される）
       if ! @format.instance_of?( String ) then
-        # 文字列定数ではなかった
+        # 文字列定数ではなかった
         cdl_error( "S1133 $1: 2nd parameter is not string(fromat)" , @name )
         @format = nil
       end
 
-      # 第三引数以降を引数リストとする mikan 引数のチェック
+      # 第三引数以降を引数リストとする mikan 引数のチェック
       @arg_list = arg_list
 
@@ -6575 +6237 @@
 #== Domain
 #
-# region の domain を記憶するクラス
+# region の domain を記憶するクラス
 class DomainType < Node
-#@name::Symbol : ドメインタイプの名前 ex) HRP2
+#@name::Symbol : ドメインタイプの名前 ex) HRP2
 #@region::Region
 #@plugin_name::Symbol : ex) HRP2Plugin
 #@option::String : ex) "trusted", "nontrusted"
-#@plugin::DomainPlugin の子クラス
+#@plugin::DomainPlugin の子クラス
 
   include PluginModule
 
-  # ドメインに属する region の Hash
-  # domain æŒ‡å®šãŒä¸€åº¦ã‚‚è¡Œã‚ã‚Œãªã„å ´åˆã€ã“ã®ãƒªã‚¹ãƒˆã¯ç©ºã§ã‚ã‚‹
-  # ルートリージョンは option = "OutOfDomain" で登録される (domain 指定が無ければ登録されない)
+  # ドメインに属する region の Hash
+  # domain 指定が一度も行われない場合、このリストは空である
+  # ルートリージョンは option = "OutOfDomain" で登録される (domain 指定が無ければ登録されない)
   @@domain_regions = { }  # { :domain_type => [ region, ... ] }
 
@@ -6628 +6290 @@
   end
 
-  #== Domain リージョンの Hash を得る
-  # @@domain_regions の説明参ç
-§
+  #== Domain リージョンの Hash を得る
+  # @@domain_regions の説明参照
   def self.get_domain_regions
     return @@domain_regions
@@ -6649 +6310 @@
 end
 
-#== Region クラス
+#== Region クラス
 # 
-# Region は Namespace を継承している
-# root region は特殊で、root namespace と同じである
+# Region は Namespace を継承している
+# root region は特殊で、root namespace と同じである
 #
-# cell は region に属する
-# region に属する cell のリストは Namespace クラスのインスタンス変数として記憶される
+# cell は region に属する
+# region に属する cell のリストは Namespace クラスのインスタンス変数として記憶される
 #
 class Region < Namespace
 # @name:: string
-# @in_through_list:: [ [ plugin_name, plugin_arg ], ... ] : plungin_name = nil の時 in 禁止
-# @out_through_list:: [ [ plugin_name, plugin_arg ], ... ] : plungin_name = nil の時 out 禁止
+# @in_through_list:: [ [ plugin_name, plugin_arg ], ... ] : plungin_name = nil の時 in 禁止
+# @out_through_list:: [ [ plugin_name, plugin_arg ], ... ] : plungin_name = nil の時 out 禁止
 # @to_through_list:: [ [ dst_region, plugin_name, plugin_arg ], ... ]
-# @cell_port_throug_plugin_list:: { "#{cell_name}.#{port_name}" => through_generated_list ã®è¦ç´  }
-#    この region から cell_name.port_name への through プラグインで生成されたオブジェクト
+# @cell_port_throug_plugin_list:: { "#{cell_name}.#{port_name}" => through_generated_list の要素 }
+#    この region から cell_name.port_name への through プラグインで生成されたオブジェクト
 # @region_type::Symbol : :NODE, :LINKUNIT, :DOMAIN, :CLASS
-# @region_type_param::Symbol : domain, class の名前. node, linkunit では nil
-# @link_root:: Region : linkUnit ã®æ ¹ã£ã“ã¨ãªã‚‹ region (node, linkunit が指定された region)
-# @family_line:: [ @region_root, ...,@region_me ]  家系
-# @in_through_count:: Integer :  n 番目の in_through 結合 (n>=0)
-# @out_through_count:: Integer : n 番目の out_through 結合 (n>=0)
-# @to_through_count:: { :RegionName => Integer }: RegionName への n 番目の to_through 結合 (n>=0)
-# @domain_type::DomainType : domain æŒ‡å®šã•ã‚Œã¦ã„ãªã„å ´åˆã€nil
-# @domain_root::Region : domain 指定されていなる Region (root ã®å ´åˆ nil)
+# @region_type_param::Symbol : domain, class の名前. node, linkunit では nil
+# @link_root:: Region : linkUnit の根っことなる region (node, linkunit が指定された region)
+# @family_line:: [ @region_root, ...,@region_me ]  家系
+# @in_through_count:: Integer :  n 番目の in_through 結合 (n>=0)
+# @out_through_count:: Integer : n 番目の out_through 結合 (n>=0)
+# @to_through_count:: { :RegionName => Integer }: RegionName への n 番目の to_through 結合 (n>=0)
+# @domain_type::DomainType : domain 指定されていない場合、nil
+# @domain_root::Region : domain 指定されていなる Region (root の場合 nil)
 
   @@in_through_list  = []
@@ -6680 +6341 @@
   @@region_type_param = nil
   @@domain_name = nil
-  @@domain_option = nil    # Token がå
-¥ã‚‹
+  @@domain_option = nil    # Token が入る
 
   @@link_roots = []
 
   def initialize( name )
-    # mikan name の Namespace 修飾
-    # object = Namespace.find( [ name ] )   # 親まで捜しにいく
+    # mikan name の Namespace 修飾
+    # object = Namespace.find( [ name ] )   # 親まで捜しにいく
     if name != "::" then
       object = Namespace.get_current.find( name )    #1
     else
-      # root リージョン
+      # root リージョン
       object = nil
       @@region_type = :NODE
@@ -6727 +6387 @@
         dbgPrint "Region.new: re-appear #{@name}\n"
 
-        # # Region path が前回出現と一致するか？
+        # # Region path が前回出現と一致するか？
         # if @@region_stack[ @@region_stack_sp - 1 ] then
         #   my_path = @@region_stack[ @@region_stack_sp - 1 ].get_path_string.to_s + "." + @name.to_s
@@ -6737 +6397 @@
         # end
 
-        # 再出現
+        # 再出現
         # @@region_stack[@@region_stack_sp] = object
 
-        # 再出現時に specifier が指定されているか？
+        # 再出現時に specifier が指定されているか？
         if( @in_through_list.length != 0 || @out_through_list.length != 0 || @to_through_list.length != 0 || @region_type != nil )then
           cdl_error( "S1140 $1: region specifier must place at first appearence" , name )
@@ -6747 +6407 @@
 
       else
-        # エラー用ダミー定義
-
-        # 異なる同名のオブジェクトが定義済み
+        # エラー用ダミー定義
+
+        # 異なる同名のオブジェクトが定義済み
         cdl_error( "S1141 $1 duplication, previous one : $2" , name, object.class )
-        # @@region_stack[@@region_stack_sp] = self    # エラー時暫定 region
-      end
-    else
-      # 初出現
+        # @@region_stack[@@region_stack_sp] = self    # エラー時暫定 region
+      end
+    else
+      # 初出現
       dbgPrint "Region.new: #{@name}\n"
       set_region_family_line
@@ -6807 +6467 @@
   end
 
-  #== Region ルートリージョンを得る
-  # ルートリージョンは、ルートネームスペースと同じである
+  #== Region ルートリージョンを得る
+  # ルートリージョンは、ルートネームスペースと同じである
   def self.get_root
     Namespace.get_root
@@ -6816 +6476 @@
 
     dbgPrint  "set_region_family_line: Region: #{@name}  \n"
-    # root namespace (root region) の region type は :NODE
+    # root namespace (root region) の region type は :NODE
     if @name == "::" then
       @region_type = :NODE
@@ -6834 +6494 @@
 
     if @domain_type then
-      # ルートリージョンが最初から @domain_type 設定されることはないの
-      # で @owner == nil を調べるå¿
-要はない
+      # ルートリージョンが最初から @domain_type 設定されることはないの
+      # で @owner == nil を調べる必要はない
       @owner.set_domain_type @domain_type
     end
@@ -6850 +6509 @@
     @link_root = nil
 
-    # @family_line を作成する
-    # @link_root もみつける
-    # (上位にたどっていって Region で node または linkunit のいずれかå
-ˆã«è¦‹ã¤ã‹ã£ãŸã‚‚のが @link_root となる)
-    # root namespace は Region かつ node なのでå¿
-ず @link_root は見つかる
-    # mikan: self が node, linkUnit ã®å ´åˆã€ã“ã“ã§æœŸå¾
-したとおりに設定されないため、Region#initialize で再設定
+    # @family_line を作成する
+    # @link_root もみつける
+    # (上位にたどっていって Region で node または linkunit のいずれか先に見つかったものが @link_root となる)
+    # root namespace は Region かつ node なので必ず @link_root は見つかる
+    # mikan: self が node, linkUnit の場合、ここで期待したとおりに設定されないため、Region#initialize で再設定
     obj = self
     while 1
@@ -6868 +6524 @@
         end
       else
-        # さもなければ Namespace
-        # namespace の下に region ãŒã‚ã‚‹å ´åˆ
-      end
-
-      # root namespace にたどり着けば終り
+        # さもなければ Namespace
+        # namespace の下に region がある場合
+      end
+
+      # root namespace にたどり着けば終り
       break if obj.get_name == "::"
 
@@ -6883 +6539 @@
   end
 
-  #== Region#ドメインを設定する
+  #== Region#ドメインを設定する
   def set_domain_type domain_type
     if @region_type == :NODE then
@@ -6927 +6583 @@
   end
 
-  #== Region# domain ã®æ ¹ã£ã“ã¨ãªã‚‹ region を得る
-  # Region のインスタンスを返す
-  # domain 指定子があれば、そのリージョンがドメインルートである
-  # なければ、親リージョンのドメインルートとする
+  #== Region# domain の根っことなる region を得る
+  # Region のインスタンスを返す
+  # domain 指定子があれば、そのリージョンがドメインルートである
+  # なければ、親リージョンのドメインルートとする
   def get_domain_root
     @domain_root
@@ -6970 +6626 @@
   end
 
-  #=== Region# 構文解析中の region を得る
-  # 構文解析中 Namespace (あるいは子クラスの Region) の上位をたどって Region を見つける
-  # cell が namespace 下におくことができなければ、ループをまわすå¿
-要はない
+  #=== Region# 構文解析中の region を得る
+  # 構文解析中 Namespace (あるいは子クラスの Region) の上位をたどって Region を見つける
+  # cell が namespace 下におくことができなければ、ループをまわす必要はない
   def self.get_current
     # @@region_stack[@@region_stack_sp]
@@ -6986 +6641 @@
   end
 
-  #=== Region# through プラグインで、この region から cell_name.port_name へのプラグインオブジェクトを登録
-  # mikan namesppace 対応 (cell_name)
+  #=== Region# through プラグインで、この region から cell_name.port_name へのプラグインオブジェクトを登録
+  # mikan namesppace 対応 (cell_name)
   def add_cell_port_through_plugin( cell_name, port_name, through_plugin_object )
     @cell_port_throug_plugin_list[ "#{cell_name}.#{port_name}" ] = through_plugin_object
@@ -7002 +6657 @@
   end
 
-  #=== Region# to_region への距離（unreachable ãªå ´åˆ nil)
-  # mikan Cell#check_region とRegion へたどり着くまでための処理にå
-±é€šæ€§ãŒé«˜ã„
-  # region#distance は require で用いられる
+  #=== Region# to_region への距離（unreachable な場合 nil)
+  # mikan Cell#check_region とRegion へたどり着くまでための処理に共通性が高い
+  # region#distance は require で用いられる
   def distance( to_region )
 
-    r1 = self                   # 出発 region
-    r2 = to_region              # 目的 region
+    r1 = self                   # 出発 region
+    r2 = to_region              # 目的 region
     dist = 0
 
-    if ! r1.equal? r2 then      # 同一 region なら呼出し可能
-
-      # mikan namespace 対応
+    if ! r1.equal? r2 then      # 同一 region なら呼出し可能
+
+      # mikan namespace 対応
       f1 = r1.get_family_line
       len1 = f1.length
@@ -7020 +6674 @@
       len2 = f2.length
 
-      # 不一致になるところ（å
-„弟）を探す
-      i = 1  # i = 0 は :RootRegion なのでå¿
-ず一致
+      # 不一致になるところ（兄弟）を探す
+      i = 1  # i = 0 は :RootRegion なので必ず一致
       while( i < len1 && i < len2 )
         if( f1[i] != f2[i] )then
@@ -7031 +6683 @@
       end
 
-      sibling_level = i     # å
-„弟となるレベル、もしくはどちらか一方が終わったレベル
+      sibling_level = i     # 兄弟となるレベル、もしくはどちらか一方が終わったレベル
 
       # p "sibling_level: #{i}"
@@ -7038 +6689 @@
       # p "to: #{f2[i].get_name}" if f2[i]
 
-      # 呼び側について呼びå
-ƒã®ãƒ¬ãƒ™ãƒ«ã‹ã‚‰å
-„弟レベルまで（out_through をチェックおよび挿å
-¥ï¼‰
+      # 呼び側について呼び元のレベルから兄弟レベルまで（out_through をチェックおよび挿入）
       i = len1 -1
       while i >= sibling_level
@@ -7064 +6712 @@
       end
 
-      # å
-„弟レベルにおいて（to_through をチェックおよび挿å
-¥ï¼‰
+      # 兄弟レベルにおいて（to_through をチェックおよび挿入）
       if f1[sibling_level] && f2[sibling_level] then
         dbgPrint "going from #{f1[sibling_level].get_name} to #{f2[sibling_level].get_name}\n"
@@ -7081 +6727 @@
           found = 0
           f1[sibling_level].get_to_through_list.each { |t|
-            if t[0][0] == f2[sibling_level].get_name then   # region 名が一致するか ?
+            if t[0][0] == f2[sibling_level].get_name then   # region 名が一致するか ?
               found = 1
             end
@@ -7092 +6738 @@
       end
 
-      # 受け側についてå
-„弟レベルから受け側のレベルまで（in_through をチェックおよび挿å
-¥ï¼‰
+      # 受け側について兄弟レベルから受け側のレベルまで（in_through をチェックおよび挿入）
       i = sibling_level
       while i < len2
@@ -7137 +6781 @@
 class Import_C < Node
 
-  # ヘッダの名前文字列のリスト
+  # ヘッダの名前文字列のリスト
   @@header_list = {}
   @@header_list2 = []
   @@define_list = {}
 
-  #=== Import_C# import_C の生成（ヘッダファイルを取込む）
-  #header:: Token : import_C の第一引数文字列リテラルトークン
-  #define:: Token : import_C の第二引数文字列リテラルトークン
+  #=== Import_C# import_C の生成（ヘッダファイルを取込む）
+  #header:: Token : import_C の第一引数文字列リテラルトークン
+  #define:: Token : import_C の第二引数文字列リテラルトークン
   def initialize( header, define = nil )
     super()
-    # ヘッダファイル名文字列から前後の "" を取り除く
+    # ヘッダファイル名文字列から前後の "" を取り除く
     # header = header.to_s.gsub( /\A"(.*)"\z/, '\1' )
     header = CDLString.remove_dquote header.to_s
 
     if define then
-      # 前後の "" を取り除く
+      # 前後の "" を取り除く
       # def_opt = define.to_s.gsub( /\A"(.*)/, '\1' )
       # def_opt.sub!( /(.*)"\z/, '\1' )
       def_opt = CDLString.remove_dquote define.to_s
 
-      # "," を -D に置き換え
+      # "," を -D に置き換え
       def_opt = def_opt.gsub( /,/, " -D " )
 
-      # å
-ˆé ­ã« -D を挿å
-¥ # mikan 不適切な define å
-¥åŠ›ãŒã‚ã£ãŸå ´åˆã€CPP 時にエラー
+      # 先頭に -D を挿入 # mikan 不適切な define 入力があった場合、CPP 時にエラー
       def_opt = def_opt.gsub( /^/, "-D " )
 
     end
 
-    # コマンドライン指定された DEFINE 
+    # コマンドライン指定された DEFINE 
     $define.each{ |define|
       if $IN_EXERB then
@@ -7189 +6830 @@
       if found == false then
         begin
-          # ファイルの stat を取ってみる(なければ例外発生)
+          # ファイルの stat を取ってみる(なければ例外発生)
           File.stat( "#{path}/#{header}" )
 
-          # cdl を見つかったファイルパスに再設定
+          # cdl を見つかったファイルパスに再設定
           header_path = "#{path}/#{header}"
           found = true
@@ -7207 +6848 @@
     end
 
-    # 読込み済み？
+    # 読込み済み？
     if( @@header_list[ header ] ) then
-      # 第二引数 define が以前と異なる
+      # 第二引数 define が以前と異なる
       if @@define_list[ header ].to_s != define.to_s then
         cdl_error( "S1143 import_C: arg2: mismatch with previous one"  )
       end
-      # いずれにせよ読み込まない
+      # いずれにせよ読み込まない
       return
     end
 
-    # ヘッダのリストを記録
+    # ヘッダのリストを記録
     @@header_list[ header ] = header_path
     @@header_list2 << header
@@ -7241 +6882 @@
     end
 
-    # CPP 出力用 tmp ファイル名
+    # CPP 出力用 tmp ファイル名
     tmp_header = header.gsub( /\//, "_" )
     tmp_header = "#{$gen}/tmp_#{tmp_header}"
 
-    # CPP コマンドラインを作成
+    # CPP コマンドラインを作成
     cmd = "#{$cpp} #{def_opt} #{include_opt} #{tmp_C}"
 
@@ -7253 +6894 @@
       end
 
-      # プリプロセッサコマンドを pipe として開く
-          # cmd は cygwin/Linux では bash(sh) 経由で実行される
-          # Exerb 版では cmd.exe 経由で実行される
-          # この差は引き数の (), $, % などシェルの特別な文字の評価に現れるので注意
+      # プリプロセッサコマンドを pipe として開く
+          # cmd は cygwin/Linux では bash(sh) 経由で実行される
+          # Exerb 版では cmd.exe 経由で実行される
+          # この差は引き数の (), $, % などシェルの特別な文字の評価に現れるので注意
           cpp = IO.popen( cmd, "r:ASCII-8BIT" )
       begin
@@ -7269 +6910 @@
         print_exception( evar )
       ensure
-        tmp_file.close if tmp_file    # mikan File.open に失敗した時 tmp_file == nil は保証されている ?
+        tmp_file.close if tmp_file    # mikan File.open に失敗した時 tmp_file == nil は保証されている ?
         cpp.close
       end
@@ -7277 +6918 @@
     end
 
-    # C 言語のパーサインスタンスを生成
+    # C 言語のパーサインスタンスを生成
     c_parser = C_parser.new
 
-    # tmp_header をパース
+    # tmp_header をパース
     c_parser.parse( [tmp_header] )
 
-    # 終期化　パーサスタックを戻す
+    # 終期化　パーサスタックを戻す
     c_parser.finalize
 
@@ -7337 +6978 @@
 
 class Import < Node
-# @b_reuse::bool:       再利用．セルタイプの template 生成不要
-# @b_reuse_real::bool:  実際に再利用
-# @cdl::      string:   import する CDL
-# @cdl_path:: string:   CDL のパス
-# @b_imported:: bool:   import された(コマンドライン指定されていない)
-
-  # ヘッダの名前文字列のリスト  添字：expand したパス、値：Import
+# @b_reuse::bool:       再利用．セルタイプの template 生成不要
+# @b_reuse_real::bool:  実際に再利用
+# @cdl::      string:   import する CDL
+# @cdl_path:: string:   CDL のパス
+# @b_imported:: bool:   import された(コマンドライン指定されていない)
+
+  # ヘッダの名前文字列のリスト  添字：expand したパス、値：Import
   @@import_list = {}
 
@@ -7364 +7005 @@
   end
 
-  #=== Import# import を行う
-  #cdl::      string   cdl へのパス．"" で囲まれていることを仮定
-  #b_reuse::  bool     true: template を生成しない
+  #=== Import# import を行う
+  #cdl::      string   cdl へのパス．"" で囲まれていることを仮定
+  #b_reuse::  bool     true: template を生成しない
   def initialize( cdl, b_reuse = false, b_imported = true )
     Import.push self
@@ -7372 +7013 @@
     super()
     @@current_import = self
-    # ヘッダファイル名文字列から前後の "", <> を取り除くn
+    # ヘッダファイル名文字列から前後の "", <> を取り除くn
     @cdl = cdl.to_s.gsub( /\A["<](.*)[">]\z/, '\1' )
 
-    # サーチパスから探す
+    # サーチパスから探す
     found = false
     @cdl_path = ""
@@ -7383 +7024 @@
 
     if Generator.get_plugin then
-      # plugin から import ã•ã‚Œã¦ã„ã‚‹å ´åˆ gen をサーチパスのå
-ˆé ­ã«åŠ える
+      # plugin から import されている場合 gen をサーチパスの先頭に加える
       search_path = [ $gen ] + $import_path
     else
@@ -7399 +7039 @@
         end
 
-        # ファイルの stat を取ってみる(なければ例外発生)
+        # ファイルの stat を取ってみる(なければ例外発生)
         File.stat( cdl_path )
 
-        # cdl を見つかったファイルパスに再設定
+        # cdl を見つかったファイルパスに再設定
         @cdl_path = cdl_path
         found = true
@@ -7419 +7059 @@
     end
 
-    # 読込み済みなら、読込まない
+    # 読込み済みなら、読込まない
     prev = @@import_list[ File.expand_path( @cdl_path ) ]
     if( prev ) then
@@ -7428 +7068 @@
     end
 
-    # import リストを記録
+    # import リストを記録
     @@import_list[ File.expand_path( @cdl_path ) ] = self
 
-    # plugin から import ã•ã‚Œã¦ã„ã‚‹å ´åˆ
+    # plugin から import されている場合
     plugin = Generator.get_plugin
 
-    # パーサインスタンスを生成(別パーサで読み込む)
+    # パーサインスタンスを生成(別パーサで読み込む)
     parser = Generator.new
 
-    # plugin から import ã•ã‚Œã¦ã„ã‚‹å ´åˆã® plugin 設定
+    # plugin から import されている場合の plugin 設定
     parser.set_plugin plugin
 
-    # reuse フラグを設定
+    # reuse フラグを設定
     parser.set_reuse @b_reuse_real
 
-    # cdl をパース
+    # cdl をパース
     parser.parse( [@cdl_path] )
 
-    # 終期化　パーサスタックを戻す
+    # 終期化　パーサスタックを戻す
     parser.finalize
     Import.pop
@@ -7471 +7111 @@
   end
 
-  #=== cdl の名前を返す
-  # 引数で指定されている cdl 名。一部パスを含む可能性がある
+  #=== cdl の名前を返す
+  # 引数で指定されている cdl 名。一部パスを含む可能性がある
   def get_cdl_name
     @cdl
@@ -7478 +7118 @@
 end
 
-#== generate: signature プラグインのロードと実行
+#== generate: signature プラグインのロードと実行
 class Generate < Node
 #@plugin_name:: Symbol
 #@signature_nsp:: NamespacePath
-#@option::         String '"', '"' で囲まれている
+#@option::         String '"', '"' で囲まれている
 
   include PluginModule
@@ -7490 +7130 @@
     @plugin_name = plugin_name
     @signature_nsp = signature_nsp
-    option = option.to_s    # option は Token
+    option = option.to_s    # option は Token
     @option = option
 
@@ -7511 +7151 @@
 
     begin
-      eval( eval_str )     # plugin を生成
+      eval( eval_str )     # plugin を生成
       plugin_object.set_locale @locale
     rescue Exception => evar
@@ -7523 +7163 @@
 end
 
-#== 名前空間パス
+#== 名前空間パス
 class NamespacePath < Node
 #@b_absolute::Bool
 #@path::[ Symbol,... ]
-#@namespace::Namespace:  @b_absolute == false のとき、基点となる namespace
+#@namespace::Namespace:  @b_absolute == false のとき、基点となる namespace
 
   #=== NamespacePath# initialize
-  #ident::Symbol           最初の名前, ただし "::" ã®ã¿ã®å ´åˆã¯ String
-  #b_absolute:Bool         "::" ã§å§‹ã¾ã£ã¦ã„ã‚‹å ´åˆ true
-  #namespace::Namespace    b_absolute = false ã‹ã¤ã€æ§‹æ–‡è§£é‡ˆæ®µéšŽä»¥å¤–ã§å‘¼ã³å‡ºã™å ´åˆã¯ã€å¿
-ず指定すること 
+  #ident::Symbol           最初の名前, ただし "::" のみの場合は String
+  #b_absolute:Bool         "::" で始まっている場合 true
+  #namespace::Namespace    b_absolute = false かつ、構文解釈段階以外で呼び出す場合は、必ず指定すること 
   def initialize( ident, b_absolute, namespace = nil )
     super()
@@ -7559 +7198 @@
   end
 
-  #=== NamespacePath# append する
+  #=== NamespacePath# append する
   #RETURN self
-  # このメソッドは、å
-ƒã® NamespacePath オブジェクトを変形して返す
+  # このメソッドは、元の NamespacePath オブジェクトを変形して返す
   def append!( ident )
     @path << ident
     return self
   end
-  #=== NamespacePath# append する
-  # このメソッドは、å
-ƒã® NamespacePath オブジェクトを変形しない
-  #RETURN:: 複製した NamespacePath
+  #=== NamespacePath# append する
+  # このメソッドは、元の NamespacePath オブジェクトを変形しない
+  #RETURN:: 複製した NamespacePath
   def append( ident )
     cl = self.clone
@@ -7586 +7223 @@
   end
 
-  #=== NamespacePath#クローンを作成して名前を変更する
+  #=== NamespacePath#クローンを作成して名前を変更する
   def change_name name
     cl = self.clone
@@ -7595 +7232 @@
   alias :change_name_clone :change_name
 
-  #=== NamespacePath#名前を変更する
-  # このインスタンスを参ç
-§ã™ã‚‹ã™ã¹ã¦ã«å½±éŸ¿ã‚’与えることに注意
+  #=== NamespacePath#名前を変更する
+  # このインスタンスを参照するすべてに影響を与えることに注意
   def change_name_no_clone name
     @path[ @path.length - 1 ] = name
@@ -7603 +7239 @@
   end
 
-  #=== NamespacePath:: path 文字列を得る
-  # CDL 用の path 文字列を生成
+  #=== NamespacePath:: path 文字列を得る
+  # CDL 用の path 文字列を生成
   def to_s
     get_path_str
@@ -7633 +7269 @@
   end
 
-  #=== NamespacePath:: パスのé
-åˆ—を返す
-  # is_absolute? true ã®å ´åˆã€ãƒ«ãƒ¼ãƒˆã‹ã‚‰ã®ãƒ‘ã‚¹
-  #              false ã®å ´åˆã€base_namespace からの相対
-  # ルート namespace ã®å ´åˆã€é•·ã•ï¼ã®é
-åˆ—を返す
+  #=== NamespacePath:: パスの配列を返す
+  # is_absolute? true の場合、ルートからのパス
+  #              false の場合、base_namespace からの相対
+  # ルート namespace の場合、長さ０の配列を返す
   #
   def get_path
@@ -7644 +7278 @@
   end
 
-  #=== NamespacePath#フルパスのé
-åˆ—を返す
-  # 返されたé
-åˆ—を書き換えてはならない
+  #=== NamespacePath#フルパスの配列を返す
+  # 返された配列を書き換えてはならない
   def get_full_path
     if @b_absolute then
@@ -7656 +7288 @@
   end
 
-  #=== NamespacePath:: 相対パスのベースとなる namespace
-  # is_absolute? == false の時のみ有効な値を返す (true なら nil)
+  #=== NamespacePath:: 相対パスのベースとなる namespace
+  # is_absolute? == false の時のみ有効な値を返す (true なら nil)
   def get_base_namespace
     @namespace
   end
 
-  #=== NamespacePath:: C 言語グローバル名を得る
+  #=== NamespacePath:: C 言語グローバル名を得る
   def get_global_name
     if @b_absolute then
@@ -7680 +7312 @@
   end
 
-  #=== NamespacePath:: 分解して NamespacePath インスタンスを生成する
-  #path_str:: String       : namespace または region のパス ex) "::path::A" , "::", "ident"
-  #b_force_absolute:: Bool : "::" ã§å§‹ã¾ã£ã¦ã„ãªã„å ´åˆã§ã‚‚çµ¶å¯¾ãƒ‘ã‚¹ã«æ‰±ã†
+  #=== NamespacePath:: 分解して NamespacePath インスタンスを生成する
+  #path_str:: String       : namespace または region のパス ex) "::path::A" , "::", "ident"
+  #b_force_absolute:: Bool : "::" で始まっていない場合でも絶対パスに扱う
   #
-  # NamespacePath は通常構文解析されて作成される
-  # このメソッドは、オプションなどで指定される文字列を分解して NamespacePath を生成するのに用いる
-  # チェックはゆるい。不適切なパス指定は、不適切な NamespacePath が生成される
+  # NamespacePath は通常構文解析されて作成される
+  # このメソッドは、オプションなどで指定される文字列を分解して NamespacePath を生成するのに用いる
+  # チェックはゆるい。不適切なパス指定は、不適切な NamespacePath が生成される
   def self.analyze( path_str, b_force_absolute = false )
 
@@ -7725 +7357 @@
 end
 
-# 以下単体テストコード
+# 以下単体テストコード
 if $unit_test then
   root_namespace = Namespace.new("::")