asp/cfg/toppers/itronx/factory.cpp

   1 /*
   2  *  TOPPERS Software
   3  *      Toyohashi Open Platform for Embedded Real-Time Systems
   4  *
   5  *  Copyright (C) 2007-2011 by TAKAGI Nobuhisa
   6  *
   7  *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
   8  *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
   9  *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
  10  *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
  11  *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
  12  *      スコード中に含まれていること．
  13  *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
  14  *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
  15  *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
  16  *      の無保証規定を掲載すること．
  17  *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
  18  *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
  19  *      と．
  20  *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
  21  *        作権表示，この利用条件および下記の無保証規定を掲載すること．
  22  *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
  23  *        報告すること．
  24  *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
  25  *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
  26  *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
  27  *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
  28  *      免責すること．
  29  *
  30  *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
  31  *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
  32  *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
  33  *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
  34  *  の責任を負わない．
  35  *
  36  */
  37 #include <cstring>
  38 #include <cstdlib>
  39 #include <fstream>
  40 #include <boost/lexical_cast.hpp>
  41 #include "toppers/misc.hpp"
  42 #include "toppers/global.hpp"
  43 #include "toppers/csv.hpp"
  44 #include "toppers/nm_symbol.hpp"
  45 #include "toppers/s_record.hpp"
  46 #include "toppers/diagnostics.hpp"
  47 #include "toppers/macro_processor.hpp"
  48 #include "toppers/io.hpp"
  49 #include "toppers/cpp.hpp"
  50 #include "toppers/itronx/factory.hpp"
  51 #include "toppers/itronx/cfg1_out.hpp"
  52
  53 namespace toppers
  54 {
  55   namespace itronx
  56   {
  57     namespace
  58     {
  59
  60       // カーネルオブジェクト生成・定義用静的APIの各パラメータをマクロプロセッサの変数として設定する。
  61       void set_object_vars( cfg1_out::static_api_map const& api_map, macro_processor& mproc )
  62       {
  63         typedef macro_processor::element element;
  64         typedef macro_processor::var_t var_t;
  65         std::map< std::string, var_t > order_list_map;
  66         std::map< std::string, long > id_map;
  67
  68         for ( cfg1_out::static_api_map::const_iterator m_iter( api_map.begin() ), m_last( api_map.end() );
  69               m_iter != m_last;
  70               ++m_iter )
  71         {
  72           int order = 1;
  73
  74           for ( std::vector< static_api >::const_iterator v_iter( m_iter->second.begin() ), v_last( m_iter->second.end() );
  75                 v_iter != v_last;
  76                 ++v_iter )
  77           {
  78             static_api::info const* info = v_iter->get_info();
  79
  80             long id = -1;
  81             if ( !info->slave )
  82             {
  83               // 出現順 $OBJ.ORDER$
  84               if ( v_iter->id().value )
  85               {
  86                 id = static_cast< long >( v_iter->id().value.get() );
  87               }
  88               else
  89               {
  90                 id = order;
  91               }
  92               id_map[ v_iter->id().text ] = id;
  93               element e;
  94               e.i = order;
  95               mproc.set_var( toppers::toupper( ( boost::format( "%s.order" ) % info->type ).str() ), id, var_t( 1, e ) );
  96
  97               e.i = id;
  98               e.s = v_iter->id().text;
  99               order_list_map[ info->type ].push_back( e );
 100               ++order;
 101             }
 102             else
 103             {
 104               std::map< std::string, long >::iterator iter( id_map.find( v_iter->id().text ) );
 105               if ( iter == id_map.end() )
 106               {
 107                 error( v_iter->line(), _( "E_NOEXS: `%1%\' is undefined" ), v_iter->id().text );
 108               }
 109               else
 110               {
 111                 id = iter->second;
 112               }
 113             }
 114
 115             // 各パラメータ
 116             for ( static_api::const_iterator api_iter( v_iter->begin() ), api_last( v_iter->end() );
 117                   api_iter != api_last;
 118                   ++api_iter )
 119             {
 120               std::string name( toppers::toupper( ( boost::format( "%s.%s" ) % info->type % ( api_iter->symbol.c_str() + 1 ) ).str() ) );
 121               // 末尾の ? を除去
 122               if ( *name.rbegin() == '\?' )
 123               {
 124                 name.resize( name.size() - 1 );
 125               }
 126
 127               element e;
 128               e.s = api_iter->text; // ソースの字面
 129               if ( api_iter->symbol[0] != '&' )   // 一般定数式パラメータは値が特定できない
 130               {
 131                 if ( api_iter->symbol[0] == '$' )  // 文字列定数式パラメータ
 132                 {
 133                   e.v = api_iter->string; // 展開後の文字列
 134                 }
 135                 else
 136                 {
 137                   e.i = api_iter->value;
 138                 }
 139                 if ( api_iter->symbol[0] == '%' )
 140                 {
 141                   continue;
 142                 }
 143               }
 144               mproc.set_var( name, id, var_t( 1, e ) );
 145             }
 146
 147             // 静的APIが出現した行番号
 148             {
 149               element e;
 150               e.s = v_iter->line().file;
 151               e.i = v_iter->line().line;
 152               std::string type( toppers::toupper( info->type ) );
 153
 154               if ( info->slave )
 155               {
 156                 type = info->api_name;
 157               }
 158               mproc.set_var( type + ".TEXT_LINE", id, var_t( 1, e ) );
 159             }
 160           }
 161         }
 162
 163         std::map< std::string, var_t > id_list_map;
 164
 165         for ( std::map< std::string, var_t >::const_iterator iter( order_list_map.begin() ), last( order_list_map.end() );
 166               iter != last;
 167               ++iter )
 168         {
 169           // 出現順リスト $OBJ.ORDER_LIST$ -- ID番号の並び
 170           mproc.set_var( toppers::toupper( iter->first + ".order_list" ), iter->second );
 171           var_t rorder_list( iter->second );
 172
 173           // 逆順リスト $OBJ.RORDER_LIST$ -- ID番号の並び
 174           std::reverse( rorder_list.begin(), rorder_list.end() );
 175           mproc.set_var( toppers::toupper( iter->first + ".rorder_list" ), rorder_list );
 176
 177           // ID番号リスト $OBJ.ID_LIST$ -- ID番号の並び
 178           var_t id_list( iter->second );
 179           std::sort( id_list.begin(), id_list.end() );
 180           mproc.set_var( toppers::toupper( iter->first + ".id_list" ), id_list );
 181         }
 182
 183         element external_id;
 184         external_id.i = get_global< bool >( "external-id" );
 185         mproc.set_var( "USE_EXTERNAL_ID", var_t( 1, external_id ) );
 186       }
 187
 188       // カーネルオブジェクト生成・定義用静的APIの各パラメータをマクロプロセッサの変数として設定する。
 189       void set_object_vars( std::vector< static_api > const& api_array, macro_processor& mproc )
 190       {
 191         typedef macro_processor::element element;
 192         typedef macro_processor::var_t var_t;
 193         long order = 1;
 194         var_t order_list;
 195
 196         for ( std::vector< static_api >::const_iterator v_iter( api_array.begin() ), v_last( api_array.end() );
 197               v_iter != v_last;
 198               ++v_iter )
 199         {
 200           static_api::info const* info = v_iter->get_info();
 201           var_t params;
 202           var_t args;
 203
 204           // 静的APIが出現した行番号
 205           element e;
 206           e.s = v_iter->line().file;
 207           e.i = v_iter->line().line;
 208           mproc.set_var( "API.TEXT_LINE", order, var_t( 1, e ) );
 209
 210           // 静的API名
 211           e.s = info->api_name;
 212           e.i = boost::none;
 213           mproc.set_var( "API.NAME", order, var_t( 1, e ) );
 214
 215           // オブジェクトタイプ（"TSK", "SEM", ...）
 216           e.s = toppers::toupper( info->type );
 217           mproc.set_var( "API.TYPE", order, var_t( 1 , e ) );
 218
 219           // 各パラメータ
 220           for ( static_api::const_iterator api_iter( v_iter->begin() ), api_last( v_iter->end() );
 221                 api_iter != api_last;
 222                 ++api_iter )
 223           {
 224             std::string name( toppers::toupper( ( boost::format( "%s.%s" ) % info->type % ( api_iter->symbol.c_str() + 1 ) ).str() ) );
 225             // 末尾の ? を除去
 226             if ( *name.rbegin() == '\?' )
 227             {
 228               name.resize( name.size() - 1 );
 229             }
 230
 231             element e;
 232             e.s = api_iter->text; // ソースの字面
 233             if ( api_iter->symbol[0] != '&' )   // 一般定数式パラメータは値が特定できない
 234             {
 235               if ( api_iter->symbol[0] == '$' )  // 文字列定数式パラメータ
 236               {
 237                 e.v = api_iter->string; // 展開後の文字列
 238               }
 239               else
 240               {
 241                 e.i = api_iter->value;
 242               }
 243             }
 244             args.push_back( e );
 245
 246             e.s = name;
 247             e.i = boost::none;
 248             params.push_back( e );
 249
 250             if ( api_iter->symbol[0] == '%' )
 251             {
 252               continue;
 253             }
 254           }
 255           mproc.set_var( "API.ARGS", order, args );
 256           mproc.set_var( "API.PARAMS", order, params );
 257           e.s.clear();
 258           e.i = order;
 259           order_list.push_back( e );
 260           ++order;
 261         }
 262         mproc.set_var( "API.ORDER_LIST", order_list );
 263
 264         element external_id;
 265         external_id.i = get_global< bool >( "external-id" );
 266         mproc.set_var( "USE_EXTERNAL_ID", var_t( 1, external_id ) );
 267       }
 268
 269       // クラスIDリストをマクロプロセッサの変数として設定する。
 270       void set_clsid_vars( std::vector< std::pair< std::string, long > > const& table, cfg1_out const& cfg1out, macro_processor& mproc )
 271       {
 272         typedef macro_processor::element element;
 273         macro_processor::var_t var;
 274
 275         bool little_endian = cfg1out.is_little_endian();
 276         nm_symbol::entry nm_entry = cfg1out.get_syms()->find( "TOPPERS_cfg_sizeof_signed_t" );
 277         std::size_t sizeof_signed_t = static_cast< std::size_t >( cfg1out.get_srec()->get_value( nm_entry.address, 4, little_endian ) );
 278
 279         for ( std::vector< std::pair< std::string, long > >::const_iterator iter( table.begin() ), last( table.end() );
 280               iter != last;
 281               ++iter )
 282         {
 283           if ( !iter->first.empty() )
 284           {
 285             element e;
 286             e.s = iter->first;
 287
 288             std::string symbol = "TOPPERS_cfg_valueof_" + iter->first;
 289             nm_symbol::entry nm_entry = cfg1out.get_syms()->find( symbol );
 290             if ( nm_entry.type == -1 )
 291             {
 292               continue;
 293             }
 294             const std::size_t size = sizeof_signed_t;
 295             std::tr1::intmax_t value = cfg1out.get_srec()->get_value( nm_entry.address, size, little_endian );
 296
 297             e.i = value;
 298
 299             var.push_back( e );
 300           }
 301         }
 302         // クラスIDの値でソートしていない
 303         mproc.set_var( "CLS.ID_LIST", var );
 304       }
 305
 306       // ドメインIDリストをマクロプロセッサの変数として設定する。
 307       void set_domid_vars( std::vector< std::pair< std::string, long > > const& table, macro_processor& mproc )
 308       {
 309         typedef macro_processor::element element;
 310         macro_processor::var_t var;
 311
 312         for ( std::vector< std::pair< std::string, long > >::const_iterator iter( table.begin() ), last( table.end() );
 313               iter != last;
 314               ++iter )
 315         {
 316           if ( !iter->first.empty() )
 317           {
 318             element e;
 319             e.s = iter->first;
 320             e.i = iter->second;
 321             var.push_back( e );
 322           }
 323         }
 324         mproc.set_var( "DOM.ID_LIST", var );
 325       }
 326
 327       // プラットフォーム・コンパイラ依存の値をマクロプロセッサの変数として設定する。
 328       void set_platform_vars( cfg1_out const& cfg1out, macro_processor& mproc )
 329       {
 330         typedef macro_processor::element element;
 331         typedef macro_processor::var_t var_t;
 332
 333         cfg1_out::cfg1_def_table const* def_table = cfg1out.get_def_table();
 334         std::size_t sizeof_signed_t;
 335         std::size_t sizeof_pointer;
 336
 337         static cfg1_out::cfg1_def_t const limit_defs[] =
 338         {
 339           { false, "TOPPERS_cfg_CHAR_BIT",  "CHAR_BIT" },
 340           { false, "TOPPERS_cfg_CHAR_MAX",  "CHAR_MAX" },
 341           { true, "TOPPERS_cfg_CHAR_MIN",  "CHAR_MIN" },
 342           { false, "TOPPERS_cfg_SCHAR_MAX", "SCHAR_MAX" },  // 本来は符号付きだが、負になることはない
 343           { false, "TOPPERS_cfg_SHRT_MAX",  "SHRT_MAX" },   // 本来は符号付きだが、負になることはない
 344           { false, "TOPPERS_cfg_INT_MAX",   "INT_MAX" },    // 本来は符号付きだが、負になることはない
 345           { false, "TOPPERS_cfg_LONG_MAX",  "LONG_MAX" },   // 本来は符号付きだが、負になることはない
 346         };
 347
 348         nm_symbol::entry nm_entry = cfg1out.get_syms()->find( "TOPPERS_cfg_sizeof_signed_t" );
 349         sizeof_signed_t = static_cast< std::size_t >( cfg1out.get_srec()->get_value( nm_entry.address, 4, cfg1out.is_little_endian() ) );
 350
 351         nm_entry = cfg1out.get_syms()->find( "TOPPERS_cfg_sizeof_pointer" );
 352         sizeof_pointer = static_cast< std::size_t >( cfg1out.get_srec()->get_value( nm_entry.address, 4, cfg1out.is_little_endian() ) );
 353
 354         for ( std::size_t i = 0; i < sizeof limit_defs / sizeof limit_defs[ 0 ]; ++i )
 355         {
 356           element e;
 357           e.s = limit_defs[ i ].expression;
 358           nm_entry = cfg1out.get_syms()->find( limit_defs[ i ].name );
 359           std::tr1::int64_t value = cfg1out.get_srec()->get_value( nm_entry.address, sizeof_signed_t, cfg1out.is_little_endian() );
 360           if ( sizeof_signed_t < 8 && limit_defs[ i ].is_signed )
 361           {
 362             value = cfg1_out::make_signed( static_cast< std::tr1::uint32_t >( value ) );
 363           }
 364           mproc.set_var( e.s, var_t( 1, e ) );
 365         }
 366
 367         for ( cfg1_out::cfg1_def_table::const_iterator iter( def_table->begin() ), last( def_table->end() );
 368               iter != last;
 369               ++iter )
 370         {
 371           element e;
 372           std::tr1::int64_t value;
 373
 374           nm_entry = cfg1out.get_syms()->find( "TOPPERS_cfg_" + iter->name );
 375           if ( nm_entry.type >= 0 )
 376           {
 377             if ( !iter->expression.empty() && iter->expression[ 0 ] == '@' )  // 式が'@'で始まる場合はアドレス定数式
 378             {
 379               value = cfg1out.get_srec()->get_value( nm_entry.address, sizeof_pointer, cfg1out.is_little_endian() );
 380               if ( sizeof_signed_t < 8 && iter->is_signed )
 381               {
 382                 value = cfg1_out::make_signed( static_cast< std::tr1::uint32_t >( value ) );
 383               }
 384
 385               // 先ほど取り出したアドレスを使って間接参照
 386               value = cfg1out.get_srec()->get_value( value, 8, cfg1out.is_little_endian() );  // 取り出す値は型に関係なく常に8バイト
 387               if ( sizeof_signed_t < 8 && iter->is_signed )
 388               {
 389                 value = cfg1_out::make_signed( static_cast< std::tr1::uint32_t >( value ) );
 390               }
 391               e.s = iter->expression.c_str() + 1; // 先頭の'@'を除去
 392             }
 393             else  // アドレスではない通常の整数定数式
 394             {
 395               value = cfg1out.get_srec()->get_value( nm_entry.address, sizeof_signed_t, cfg1out.is_little_endian() );
 396               if ( sizeof_signed_t < 8 && iter->is_signed )
 397               {
 398                 value = cfg1_out::make_signed( static_cast< std::tr1::uint32_t >( value ) );
 399               }
 400               e.s = iter->expression;
 401             }
 402             e.i = value;
 403             mproc.set_var( iter->name, var_t( 1, e ) );
 404           }
 405         }
 406
 407         // バイトオーダー
 408         {
 409           bool little_endian = cfg1out.is_little_endian();
 410           element e;
 411           e.i = little_endian;
 412           mproc.set_var( "LITTLE_ENDIAN", var_t( 1, e ) );
 413
 414           e.i = !little_endian;
 415           mproc.set_var( "BIG_ENDIAN", var_t( 1, e ) );
 416         }
 417       }
 418
 419     }
 420
 421     //! コンストラクタ
 422     factory::factory( std::string const& kernel )
 423       : kernel_( tolower( kernel ) )
 424     {
 425     }
 426
 427     //! デストラクタ
 428     factory::~factory()
 429     {
 430     }
 431
 432     //! サポートしている静的API情報の取得
 433     std::map< std::string, static_api::info > const* factory::get_static_api_info_map() const
 434     {
 435       // CSVから静的API情報を読み取り、登録するためのローカルクラス
 436       struct init_t
 437       {
 438         init_t()
 439         {
 440           boost::any t = global( "api-table" );
 441           if ( !t.empty() )
 442           {
 443             std::vector< std::string > api_tables( boost::any_cast< std::vector< std::string >& >( t ) );
 444             for ( std::vector< std::string >::const_iterator iter( api_tables.begin() ), last( api_tables.end() );
 445                   iter != last;
 446                   ++iter )
 447             {
 448               std::string buf;
 449               std::string api_table_filename = *iter;
 450               read( api_table_filename.c_str(), buf );
 451               csv data( buf.begin(), buf.end() );
 452               for ( csv::const_iterator d_iter( data.begin() ), d_last( data.end() );
 453                     d_iter != d_last;
 454                     ++d_iter )
 455               {
 456                 csv::size_type len = d_iter->size();
 457                 if ( len < 3 )  // type, api_name, params は必須要素
 458                 {
 459                   toppers::fatal( _( "too little fields in `%1%\'" ), *iter );
 460                 }
 461                 static_api::info api_info = { 0 };
 462                 try
 463                 {
 464                     char* s;
 465                     s = new char[ ( *d_iter )[ 0 ].size() + 1 ];
 466                     std::strcpy( s, ( *d_iter )[ 0 ].c_str() );
 467                     api_info.type = s;
 468
 469                     s = new char[ ( *d_iter )[ 1 ].size() + 1 ];
 470                     std::strcpy( s, ( *d_iter )[ 1 ].c_str() );
 471                     api_info.api_name = s;
 472
 473                     s = new char[ ( *d_iter )[ 2 ].size() + 1 ];
 474                     std::strcpy( s, ( *d_iter )[ 2 ].c_str() );
 475                     api_info.params = s;
 476                     if ( len >= 4 && !( *d_iter )[ 3 ].empty() )
 477                     {
 478                       api_info.id_pos = std::strtol( ( *d_iter )[ 3 ].c_str(), 0, 0 );
 479                     }
 480                     if ( len >= 5 && !( *d_iter )[ 4 ].empty() )
 481                     {
 482                       api_info.slave = !!std::strtol( ( *d_iter )[ 4 ].c_str(), 0, 0 );
 483                     }
 484                     static_api_table_[ api_info.api_name ] = api_info;
 485                 }
 486                 catch ( ... )
 487                 {
 488                   delete[] api_info.type;
 489                   delete[] api_info.api_name;
 490                   delete[] api_info.params;
 491                   throw;
 492                 }
 493               }
 494             }
 495           }
 496         }
 497
 498         ~init_t()
 499         {
 500           for ( std::map< std::string, static_api::info >::const_iterator iter( static_api_table_.begin() ), last( static_api_table_.end() );
 501                 iter != last;
 502                 ++iter )
 503           {
 504             delete[] iter->second.type;
 505             delete[] iter->second.api_name;
 506             delete[] iter->second.params;
 507           }
 508         }
 509
 510         std::map< std::string, static_api::info > static_api_table_;
 511       };
 512       static init_t init;
 513       std::map< std::string, static_api::info > const* result = &init.static_api_table_;
 514       return result;
 515     }
 516
 517     /*!
 518      * \brief   cfg1_out.c への出力情報テーブルの生成
 519      * \return  生成した cfg1_out::cfg1_def_table オブジェクトへのポインタ
 520      * \note    この関数が返すポインタは delete してはならない
 521      *
 522      * --cfg1-def-table オプションで指定したファイルから、cfg1_out.c へ出力する情報を読み取り、
 523      * cfg1_out::cfg1_def_table オブジェクトを生成する。
 524      *
 525      * CSV の形式は以下の通り
 526      *
 527      *    シンボル名,式[,s|signed]
 528      *
 529      * 末尾の s または signed は省略可能。省略時は符号無し整数とみなす。s または signed 指定時は
 530      * 符号付き整数とみなす。\n
 531      * 「式」の最初に # があれば前処理式とみなす。
 532      */
 533     cfg1_out::cfg1_def_table const* factory::get_cfg1_def_table() const
 534     {
 535       struct init_t
 536       {
 537         init_t()
 538         {
 539           boost::any t = global( "cfg1-def-table" );
 540           if ( !t.empty() )
 541           {
 542             std::vector< std::string > cfg1_def_table = boost::any_cast< std::vector< std::string >& >( t );
 543             for ( std::vector< std::string >::const_iterator iter( cfg1_def_table.begin() ), last( cfg1_def_table.end() );
 544                   iter != last;
 545                   ++iter )
 546             {
 547               std::string buf;
 548               read( iter->c_str(), buf );
 549               csv data( buf.begin(), buf.end() );
 550               for ( csv::const_iterator d_iter( data.begin() ), d_last( data.end() );
 551                     d_iter != d_last;
 552                     ++d_iter )
 553               {
 554                 csv::size_type len = d_iter->size();
 555                 if ( len < 2 )
 556                 {
 557                   toppers::fatal( _( "too little fields in `%1%\'" ), *iter );
 558                 }
 559                 cfg1_out::cfg1_def_t def = { 0 };
 560                 def.name = ( *d_iter )[ 0 ];
 561                 def.expression = ( *d_iter )[ 1 ];
 562                 if ( len >= 3 )
 563                 {
 564                   std::string is_signed( ( *d_iter )[ 2 ] );
 565                   def.is_signed = ( is_signed == "s" || is_signed == "signed" );
 566                 }
 567                 if ( len >= 4)
 568                 {
 569                   def.value1 = ( *d_iter )[ 3 ];
 570                 }
 571                 if ( len >= 5)
 572                 {
 573                   def.value2 = ( *d_iter )[ 4 ];
 574                 }
 575                 cfg1_def_table_.push_back( def );
 576               }
 577             }
 578           }
 579         }
 580         cfg1_out::cfg1_def_table cfg1_def_table_;
 581       };
 582       static init_t init;
 583       cfg1_out::cfg1_def_table const* result = &init.cfg1_def_table_;
 584       return result;
 585     }
 586
 587     //! オブジェクトの交換
 588     void factory::do_swap( factory& other )
 589     {
 590       kernel_.swap( other.kernel_ );
 591     }
 592
 593     /*!
 594      *  \brief  マクロプロセッサの生成
 595      *  \param[in]  cfg1out cfg1_out オブジェクト
 596      *  \param[in]  api_map .cfg ファイルに記述された静的API情報
 597      *  \return     マクロプロセッサへのポインタ
 598      *  \note   このメンバ関数は従来仕様（ソフトウェア部品非対応版）の温存のためにそのまま残す。
 599      */
 600     std::auto_ptr< macro_processor > factory::do_create_macro_processor( cfg1_out const& cfg1out, cfg1_out::static_api_map const& api_map ) const
 601     {
 602       typedef macro_processor::element element;
 603       typedef macro_processor::var_t var_t;
 604       std::auto_ptr< macro_processor > mproc( new macro_processor );
 605       element e;
 606
 607       e.s = " ";    mproc->set_var( "SPC", var_t( 1, e ) );  // $SPC$
 608       e.s = "\t";   mproc->set_var( "TAB", var_t( 1, e ) );  // $TAB$
 609       e.s = "\n";   mproc->set_var( "NL",  var_t( 1, e ) );  // $NL$
 610
 611       // バージョン情報
 612       e.s = toppers::get_global< std::string >( "version" );
 613       e.i = toppers::get_global< std::tr1::int64_t >( "timestamp" );
 614       mproc->set_var( "CFG_VERSION", var_t( 1, e ) );   // $CFG_VERSION$
 615
 616       // その他の組み込み変数の設定
 617       set_object_vars( api_map, *mproc );
 618       set_object_vars( cfg1out.get_static_api_array(), *mproc );
 619       set_clsid_vars( cfg1out.get_clsid_table(), cfg1out, *mproc );
 620       set_domid_vars( cfg1out.get_domid_table(), *mproc );
 621       set_platform_vars( cfg1out, *mproc );
 622       e.s = cfg1out.get_includes();
 623       mproc->set_var( "INCLUDES", var_t( 1, e ) );
 624       return mproc;
 625     }
 626
 627     /*!
 628      *  \brief  マクロプロセッサの生成
 629      *  \param[in]  cfg1out cfg1_out オブジェクト
 630      *  \param[in]  api_array .cfg ファイルに記述された静的API情報
 631      *  \return     マクロプロセッサへのポインタ
 632      */
 633     std::auto_ptr< macro_processor > factory::do_create_macro_processor( cfg1_out const& cfg1out, std::vector< static_api > const& api_array ) const
 634     {
 635       typedef macro_processor::element element;
 636       typedef macro_processor::var_t var_t;
 637       std::auto_ptr< macro_processor > mproc( new macro_processor );
 638       element e;
 639
 640       e.s = " ";    mproc->set_var( "SPC", var_t( 1, e ) );  // $SPC$
 641       e.s = "\t";   mproc->set_var( "TAB", var_t( 1, e ) );  // $TAB$
 642       e.s = "\n";   mproc->set_var( "NL",  var_t( 1, e ) );  // $NL$
 643
 644       // バージョン情報
 645       e.s = toppers::get_global< std::string >( "version" );
 646       e.i = toppers::get_global< std::tr1::int64_t >( "timestamp" );
 647       mproc->set_var( "CFG_VERSION", var_t( 1, e ) );   // $CFG_VERSION$
 648
 649       // その他の組み込み変数の設定
 650       set_object_vars( api_array, *mproc );
 651       set_clsid_vars( cfg1out.get_clsid_table(), cfg1out, *mproc );
 652       set_domid_vars( cfg1out.get_domid_table(), *mproc );
 653       set_platform_vars( cfg1out, *mproc );
 654       e.s = cfg1out.get_includes();
 655       mproc->set_var( "INCLUDES", var_t( 1, e ) );
 656       return mproc;
 657     }
 658
 659     std::auto_ptr< cfg1_out > factory::do_create_cfg1_out( std::string const& filename ) const
 660     {
 661       return std::auto_ptr< itronx::cfg1_out >( new cfg1_out( filename, get_cfg1_def_table() ) );
 662     }
 663
 664     std::auto_ptr< checker > factory::do_create_checker() const
 665     {
 666       return std::auto_ptr< itronx::checker >( new checker );
 667     }
 668
 669   }
 670 }