Index: /cfg_itronx+oil_gcc/Makefile
===================================================================
--- /cfg_itronx+oil_gcc/Makefile	(revision 54)
+++ /cfg_itronx+oil_gcc/Makefile	(revision 54)
@@ -0,0 +1,53 @@
+-include Makefile.config
+
+ifndef BOOST_DIR
+	ifndef BOOST_VERSION
+		BOOST_VERSION = 1_42_0
+	endif
+	ifeq ($(OSTYPE), msys)
+		BOOST_DIR = /mingw/include/boost-$(BOOST_VERSION)
+	else
+		ifeq ($(shell echo $$OSTYPE), cygwin)
+			BOOST_DIR = /usr/include/boost-$(BOOST_VERSION)
+		else
+			BOOST_DIR = /usr/local/include/boost-$(BOOST_VERSION)
+		endif
+	endif
+endif
+
+# 非力なマシンなどでコンパイルに非常に長い時間がかかる、もしくはコンパイル時に
+# ハングアップする場合には、-O0に変更してみてください。
+OPTIMIZE = -O2 -m32
+
+SUBDIRS  = toppers \
+	toppers/itronx \
+	toppers/oil \
+	cfg
+
+all: $(SUBDIRS)
+
+$(SUBDIRS)::
+	make BOOST_DIR="$(BOOST_DIR)" LIBBOOST_SUFFIX="$(LIBBOOST_SUFFIX)" CXXFLAGS="$(OPTIMIZE) $(OPTIONS)" -C $@
+
+depend:
+	for subdir in $(SUBDIRS) ; do \
+		if test -d $$subdir ; then \
+			make BOOST_DIR="$(BOOST_DIR)" LIBBOOST_SUFFIX="$(LIBBOOST_SUFFIX)" depend -C $$subdir; \
+		fi ; \
+	done \
+
+clean:
+	for subdir in $(SUBDIRS) ; do \
+		if test -d $$subdir ; then \
+			make clean -C $$subdir ; \
+		fi ; \
+	done \
+
+realclean: clean
+	for subdir in $(SUBDIRS) ; do \
+		if test -d $$subdir ; then \
+			rm -f $$subdir/Makefile.depend ; \
+		fi ; \
+	done
+	rm -f Makefile.config
+
Index: /cfg_itronx+oil_gcc/cfg/Makefile
===================================================================
--- /cfg_itronx+oil_gcc/cfg/Makefile	(revision 54)
+++ /cfg_itronx+oil_gcc/cfg/Makefile	(revision 54)
@@ -0,0 +1,43 @@
+-include ../Makefile.config
+
+PROJDIR = ..
+WORKDIR = $(PROJDIR)/cfg
+
+CPPFLAGS := $(CPPFLAGS) -I$(BOOST_DIR) -I$(PROJDIR)
+CXXFLAGS := $(CXXFLAGS) -O2 -g
+
+CXXFILES = \
+	cfg.cpp \
+	cfg0.cpp \
+	cfg1.cpp \
+	cfg2.cpp \
+	cfg_init.cpp \
+	cfg3.cpp \
+	cfg4.cpp \
+	cfg_version.cpp
+
+OBJFILES := $(CXXFILES:%.cpp=%.o)
+
+ifeq ($(OSTYPE),msys)
+BOOST_LIBFILES = /mingw/lib/libboost_system-mgw-mt-s.lib /mingw/lib/libboost_filesystem-mgw-mt-s.lib /mingw/lib/libboost_program_options-mgw-mt-s.lib
+else
+# modified by takuya 110823
+# BOOST_LIBFILES := $(BOOST_LIBFILES) -lboost_system$(LIBBOOST_SUFFIX) -lboost_filesystem$(LIBBOOST_SUFFIX) -lboost_program_options$(LIBBOOST_SUFFIX)
+BOOST_LIBFILES := $(BOOST_LIBFILES) -lboost_system$(LIBBOOST_SUFFIX) -lboost_filesystem$(LIBBOOST_SUFFIX) -lboost_program_options$(LIBBOOST_SUFFIX) -lboost_regex$(LIBBOOST_SUFFIX)
+endif
+
+LIBFILES = $(PROJDIR)/toppers/oil/liboil.a $(PROJDIR)/toppers/itronx/libitronx.a \
+	$(PROJDIR)/toppers/libtoppers.a \
+
+all: cfg
+
+cfg: $(OBJFILES) $(LIBFILES)
+	$(CXX) $(CXXFLAGS) -o cfg $(OBJFILES) -L$(LIBBOOST_DIR) $(LIBFILES) $(BOOST_LIBFILES)
+
+depend:
+	$(CXX) $(CPPFLAGS) -M $(CXXFILES) > Makefile.depend
+
+clean:
+	-rm -f *.o cfg *.exe
+
+-include Makefile.depend
Index: /cfg_itronx+oil_gcc/cfg/cfg.cpp
===================================================================
--- /cfg_itronx+oil_gcc/cfg/cfg.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/cfg/cfg.cpp	(revision 54)
@@ -0,0 +1,360 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2009 by TAKAGI Nobuhisa
+ *  Copyright (C) 2010 by Meika Sugimoto
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+// Boost.Filesystem v3内でstd::locale("")が使用されているが、GCCの不具合で
+// 例外が発生する。
+// これを回避するための暫定対応
+#ifdef  __GNUC__
+#include <stdlib.h>
+namespace Ticket_83_fix
+{
+  char s_[] = "LANG=C";
+  int _ = putenv(s_);
+}
+#endif
+
+#include "cfg.hpp"
+#include <boost/program_options.hpp>
+#include <boost/spirit/include/classic.hpp>
+
+namespace
+{
+
+  //! 連続したスラッシュ / を単一のスラッシュに置換する
+  std::string slashes_to_single_slash( std::string const& str )
+  {
+    std::string result( str );
+    std::string::size_type pos = 0; 
+    while ( ( pos = result.find( "//", pos ) ) != std::string::npos )
+    {
+      result.erase( pos, 1 );
+    }
+    return result;
+  }
+
+  //! 起動オプションの解析
+  int parse_program_options( int argc, char* argv[] )
+  {
+    namespace po = boost::program_options;
+    int pass = 0;
+
+    // 一般オプション
+    po::options_description generic( _( "Generic options" ) );
+    generic.add_options()
+      ( "help", _( "display this information" ) )    
+      ( "version,v", _( "display cfg version number" ) )
+      ;
+
+    // 設定オプション
+    po::options_description config( _( "Configuration" ) );
+    config.add_options()
+      ( "kernel,k", po::value< std::string >()->default_value( std::string( "asp" ) ), _( "kernel type (default: asp)" ) )
+      ( "pass,p", po::value< int >( &pass )->default_value( 0 ), _( "run for pass #`arg\'" ) )
+      ( "include-path,I", po::value< std::vector< std::string > >(), _( "include path" ) )
+      ( "template-file,T", po::value< std::string >(), _( "template file" ) )
+      ( "input-charset", po::value< std::string >()->default_value( std::string( "ascii" ) ), _( "character set of input file (default: ascii)" ) )
+      ( "api-table", po::value< std::vector< std::string > >(), _( "specify static API table" ) )
+      ( "cfg1-def-table", po::value< std::vector< std::string > >(), _( "specify cfg1 definition table" ) )
+      ( "cfg1_out", po::value< std::string >()->default_value( std::string( "cfg1_out" ) ), _( "specify file name instead of `cfg1_out.srec\' (default: cfg1_out)" ) )
+      ( "rom-image,r", po::value< std::string >(), _( "ROM image (S-record)" ) )
+      ( "symbol-table,s", po::value< std::string >(), _( "Symbol table (`nm' style)" ) )
+      ( "cfg-directory,d", po::value< std::string >(), _( "cfg directory" ) )
+      ( "msgcat-directory,m", po::value< std::vector< std::string > >(), _( "msgcat(*.po) directory" ) )
+      ( "destination-directory,n", po::value< std::string >()->default_value( "." ), _( "destination directory" ) )
+      ( "id-output-file", po::value< std::string >()->default_value( std::string() ), _( "output file for id assignment" ) )
+      ( "id-input-file", po::value< std::string >()->default_value( std::string() ), _( "input file for id assignment" ) )
+      ( "alignof-fp", po::value< std::size_t >()->default_value( 1 ), _( "alignment of pointer to function" ) )
+      ( "external-id", _( "output ID numbers as external `const\' object" ) )
+      ( "print-dependencies,M", po::value< std::string >(), _( "output dependencies of source file (for `make\')" ) )
+      ( "with-software-components", _( "with software components" ) )
+      ;
+
+    // 非表示オプション
+    po::options_description hidden( _( "Hidden options" ) );
+    hidden.add_options()
+      ( "input-file,s", po::value< std::string >(), _( "input file" ) )
+      ;
+    
+    po::options_description cmdline_options;
+    cmdline_options.add( generic ).add( config ).add( hidden );
+
+    po::options_description visible( _( "Allowed options" ) );
+    visible.add( generic ).add( config );
+    
+    po::positional_options_description p;
+    p.add( "input-file", -1 );
+    
+    po::variables_map vm;
+    try
+    {
+      store( po::command_line_parser( argc, argv ).
+            options( cmdline_options ).positional( p ).run(), vm );
+      notify( vm );
+    }
+    catch ( boost::program_options::error& )
+    {
+      toppers::fatal( _( "illegal options" ) );
+    }
+
+    // グローバル変数の設定
+    if ( vm.count( "print-dependencies" ) )
+    {
+      toppers::global( "print-dependencies" ) = vm[ "print-dependencies" ].as< std::string >();
+      pass = 1; // 依存関係の出力が必要な場合、強制的にパス1に変更
+    }
+
+    toppers::global( "pass" ) = pass;
+    if ( vm.count( "kernel" ) )
+    {
+      std::string kernel = toppers::tolower( vm[ "kernel" ].as< std::string >() );
+      toppers::global( "kernel" ) = kernel;
+      bool has_class = false;
+      bool has_domain = false;
+
+      if ( kernel == "fmp" || kernel == "fmp+hrp2" || kernel == "hrp2+fmp" )
+      {
+        has_class = true;
+      }
+      if ( kernel == "hrp2" || kernel == "fmp+hrp2" || kernel == "hrp2+fmp" )
+      {
+        has_domain = true;
+      }
+
+      toppers::global( "max-pass" ) = ( has_domain ? 4 : 3 );
+      toppers::global( "has-class" ) = has_class;
+      toppers::global( "has-domain" ) = has_domain;
+    }
+    if ( vm.count( "include-path" ) )
+    {
+      std::vector< std::string > v( vm[ "include-path" ].as< std::vector< std::string > >() );
+      std::transform( v.begin(), v.end(), v.begin(), &slashes_to_single_slash );
+      toppers::global( "include-path" ) = v;
+    }
+    if ( vm.count( "template-file" ) )
+    {
+      toppers::global( "template-file" )
+        = slashes_to_single_slash( vm[ "template-file" ].as< std::string >() );
+    }
+    if ( vm.count( "input-file" ) )
+    {
+      toppers::global( "input-file" )
+        = slashes_to_single_slash( vm[ "input-file" ].as< std::string >() );
+    }
+    if ( vm.count( "input-charset" ) )
+    {
+      std::string input_charset( toppers::tolower( vm[ "input-charset" ].as< std::string >() ) );
+      toppers::global( "input-charset" ) = input_charset;
+
+      toppers::codeset_t codeset = toppers::ascii;
+      if ( ( input_charset == "cp932" )
+        || ( input_charset == "shift_jis" )
+        || ( input_charset == "sjis" ) )
+      {
+        codeset = toppers::shift_jis;
+      }
+      else if ( ( input_charset == "eucjp" )
+        || ( input_charset == "euc-jp" )
+        || ( input_charset == "euc" ) )
+      {
+        codeset = toppers::euc_jp;
+      }
+      else if ( ( input_charset == "utf-8" )
+        || ( input_charset == "utf8" ) )
+      {
+        codeset = toppers::utf8;
+      }
+      toppers::global( "codeset" ) = codeset;
+    }
+    if ( vm.count( "api-table" ) )
+    {
+      std::vector< std::string > v( vm[ "api-table" ].as< std::vector< std::string > >() );
+      std::transform( v.begin(), v.end(), v.begin(), &slashes_to_single_slash );
+      toppers::global( "api-table" ) = v;
+    }
+    if ( vm.count( "cfg1-def-table" ) )
+    {
+      std::vector< std::string > v( vm[ "cfg1-def-table" ].as< std::vector< std::string > >() );
+      std::transform( v.begin(), v.end(), v.begin(), &slashes_to_single_slash );
+      toppers::global( "cfg1-def-table" ) = v;
+    }
+    if ( vm.count( "cfg1_out" ) )
+    {
+      toppers::global( "cfg1_out" ) = vm[ "cfg1_out" ].as< std::string >();
+    }
+    else
+    {
+      toppers::global( "cfg1_out" ) = std::string( "cfg1_out" );
+    }
+    if ( vm.count( "cfg-directory" ) )
+    {
+      std::string cfg_directory( vm[ "cfg-directory" ].as< std::string >() );
+      toppers::global( "cfg-directory" ) = slashes_to_single_slash( cfg_directory );
+      toppers::load_msgcat( cfg_directory );
+    }
+    if ( vm.count( "msgcat-directory" ) )
+    {
+      std::vector< std::string > msgcat_dirs( vm[ "msgcat-directory" ].as< std::vector< std::string > >() );
+      std::transform( msgcat_dirs.begin(), msgcat_dirs.end(), msgcat_dirs.begin(), &slashes_to_single_slash );
+      std::for_each( msgcat_dirs.begin(), msgcat_dirs.end(), &toppers::load_msgcat );
+    }
+    if ( true ) // include-path を空にしてはならない
+    {
+      std::vector< std::string > include_path;
+      boost::any t( toppers::global( "include-path" ) );
+      if ( !t.empty() )
+      {
+        include_path = boost::any_cast< std::vector< std::string > >( t );
+      }
+      include_path.push_back( toppers::get_global< std::string >( "cfg-directory" ) );
+      toppers::global( "include-path" ) = include_path;
+    }
+    if ( vm.count( "output-directory" ) )
+    {
+      toppers::global( "output-directory" ) = slashes_to_single_slash( vm[ "output-directory" ].as< std::string >() );
+    }
+    if ( vm.count( "rom-image" ) )
+    {
+      toppers::global( "rom-image" ) = slashes_to_single_slash( vm[ "rom-image" ].as< std::string >() );
+    }
+    if ( vm.count( "symbol-table" ) )
+    {
+      toppers::global( "symbol-table" ) = slashes_to_single_slash( vm[ "symbol-table" ].as< std::string >() );
+    }
+    else
+    {
+      toppers::global( "symbol-table" ) = toppers::get_global< std::string >( "kernel" ) + ".syms";
+    }
+    if ( vm.count( "id-output-file" ) )
+    {
+      toppers::global( "id-output-file" ) = slashes_to_single_slash( vm[ "id-output-file" ].as< std::string >() );
+    }
+    if ( vm.count( "id-input-file" ) )
+    {
+      toppers::global( "id-input-file" ) = slashes_to_single_slash( vm[ "id-input-file" ].as< std::string >() );
+    }
+    if ( vm.count( "alignof-fp" ) )
+    {
+      toppers::global( "alignof-fp" ) = vm[ "alignof-fp" ].as< std::size_t >();
+    }
+    toppers::global( "external-id" ) = vm.count( "external-id" ) ? true : false;
+    toppers::global( "with-software-components" ) = vm.count( "with-software-components" ) ? true : false;
+
+    toppers::global( "version" ) = std::string( CFG_VERSION );
+
+    if ( vm.count( "version" ) )
+    {
+      std::cout << "TOPPERS Kernel Configurator version " << CFG_VERSION << std::endl;
+      toppers::global( "pass0" ) = true;
+    }
+    if ( vm.count( "help" ) )
+    {
+      toppers::global( "help" ) = boost::lexical_cast< std::string >( visible );
+      std::cout << visible << std::endl;
+      toppers::global( "pass0" ) = true;
+    }
+    return pass;
+  }
+
+}
+
+//! コンフィギュレータのメイン処理
+int cfg_main( int argc, char* argv[] )
+{
+  using namespace toppers;
+
+  std::string const cfg_path( argv[0] );
+  std::string const cfg_name( "cfg" );
+  std::string::const_iterator iter = std::find_end( cfg_path.begin(), cfg_path.end(), cfg_name.begin(), cfg_name.end() );
+  // 環境変数のサーチまでは行わない
+  std::string cfg_dir( cfg_path.begin(), iter );
+  if ( *cfg_dir.rbegin() == '/' || *cfg_dir.rbegin() == '\\' )
+  {
+    cfg_dir.resize( cfg_dir.size() - 1 );
+  }
+  toppers::global( "cfg-directory" ) = cfg_dir;
+  toppers::global( "argv0" ) = std::string( argv[ 0 ] );  // プログラム名
+  toppers::global( "timestamp" ) = cfg_timestamp();       // タイムスタンプ
+
+  int pass = parse_program_options( argc, argv );
+  bool ( * pfn_cfg[] )() = { &cfg0_main, &cfg1_main, &cfg2_main, &cfg3_main, &cfg4_main };
+  int max_pass = toppers::get_global< int >( "max-pass" );
+
+  if ( pass < 0 || max_pass < pass )
+  {
+    fatal( _( "illegal cfg pass #%d" ), pass );
+  }
+
+  if ( !( *pfn_cfg[ pass ] )() )
+  {
+    return EXIT_FAILURE;
+  }
+  return EXIT_SUCCESS;
+}
+
+int main( int arg, char* argv[] )
+{
+  int status;
+  try
+  {
+    toppers::set_program_name( "cfg" );
+    status = cfg_main( arg, argv );
+    if ( status != EXIT_SUCCESS && toppers::get_error_count() == 0 )
+    {
+      std::fprintf( stderr, "cfg: %s\n", _( "unknown error" ) );
+    }
+    if ( toppers::get_error_count() > 0 )
+    {
+      status = EXIT_FAILURE;
+    }
+  }
+  catch ( toppers::normal_exit& )
+  {
+    status = EXIT_SUCCESS;
+  }
+  catch ( std::exception& e )
+  {
+    std::fprintf( stderr, "cfg: %s\n", e.what() );
+    status = EXIT_FAILURE;
+  }
+  catch ( ... )
+  {
+    std::fprintf( stderr, "cfg: %s\n", _( "internal error" ) );
+    status = EXIT_FAILURE;
+  }
+  return status;
+}
Index: /cfg_itronx+oil_gcc/cfg/cfg.hpp
===================================================================
--- /cfg_itronx+oil_gcc/cfg/cfg.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/cfg/cfg.hpp	(revision 54)
@@ -0,0 +1,89 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2009 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#ifndef CFG_HPP_
+#define CFG_HPP_
+
+#include <cctype>
+#include <cstdio>
+#include <cstdlib>
+#include <string>
+#include <vector>
+#include <sstream>
+#include <iostream>
+#include <algorithm>
+#include <map>
+#include "toppers/workaround.hpp"
+#include "toppers/codeset.hpp"
+#include "toppers/global.hpp"
+#include "toppers/diagnostics.hpp"
+#include "toppers/text.hpp"
+#include "toppers/misc.hpp"
+#include "toppers/itronx/preprocess.hpp"
+#include "toppers/itronx/static_api.hpp"
+#include "toppers/itronx/factory.hpp"
+#include "toppers/itronx/cfg1_out.hpp"
+#include "toppers/oil/preprocess.hpp"
+#include "toppers/oil/factory.hpp"
+#include "toppers/oil/cfg1_out.hpp"
+#include <boost/utility.hpp>
+#include <boost/format.hpp>
+
+#define CFG_VERSION cfg_version
+
+bool cfg0_main();
+bool cfg1_main();
+bool cfg2_main();
+bool cfg3_main();
+bool cfg4_main();
+void cfg_init();
+
+extern char const cfg_version[];
+
+std::tr1::int64_t cfg_timestamp();
+
+bool read_cfg_file( std::map< std::string, toppers::itronx::static_api::info > const info_map,
+                    std::string& cfg1_list, std::string& includes,
+                    std::vector< toppers::itronx::static_api >& static_api_array );
+
+namespace toppers{ namespace itronx{
+    void assign_id( toppers::itronx::cfg1_out::static_api_map& api_map );
+}}
+namespace toppers{ namespace oil{
+    void assign_id( toppers::oil::cfg1_out::cfg_obj_map& cfg_obj_map );
+}}
+
+#endif  // ! CFG_HPP_
Index: /cfg_itronx+oil_gcc/cfg/cfg0.cpp
===================================================================
--- /cfg_itronx+oil_gcc/cfg/cfg0.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/cfg/cfg0.cpp	(revision 54)
@@ -0,0 +1,60 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2010 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include "toppers/global.hpp"
+#include "toppers/diagnostics.hpp"
+
+bool cfg0_main()
+{
+  using namespace toppers;
+
+  try
+  {
+    if ( global( "pass0" ).empty() && !get_global< bool >( "pass0" ) )
+    {
+      goto failure;
+    }
+  }
+  catch ( boost::bad_any_cast& )
+  {
+    goto failure;
+  }
+  return true;
+
+failure:
+  fatal( _( "pass # is not specified" ) );
+  return false;
+}
Index: /cfg_itronx+oil_gcc/cfg/cfg1.cpp
===================================================================
--- /cfg_itronx+oil_gcc/cfg/cfg1.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/cfg/cfg1.cpp	(revision 54)
@@ -0,0 +1,91 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2009 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <fstream>
+#include "toppers/output_file.hpp"
+#include "cfg.hpp"
+
+using namespace toppers;
+using namespace toppers::itronx;
+using namespace toppers::oil;
+
+template < class T, class U, class V > 
+static inline bool cfg1_main_body( U factory, V pass1_info )
+{
+  std::string input_file;
+  try
+  {
+    input_file = get_global< std::string >( "input-file" );
+  }
+  catch ( boost::bad_any_cast& )
+  {
+    fatal( _( "no input files" ) );
+  }
+  codeset_t codeset = get_global< codeset_t >( "codeset" );
+
+  std::string cfg1_out_name( get_global< std::string >( "cfg1_out" ) );
+  std::auto_ptr< T > cfg1_out( factory.create_cfg1_out( cfg1_out_name + ".c" ) );
+
+  cfg1_out->load_cfg( input_file, codeset, pass1_info );
+  cfg1_out->generate();
+
+  if ( get_error_count() > 0 )
+  {
+    return false;
+  }
+  output_file::save();
+  return true;
+}
+
+/*!
+ *  \brief  パス１処理
+ *  \retval true  成功
+ *  \retval false 失敗
+ */
+bool cfg1_main()
+{
+  std::string kernel( get_global< std::string >( "kernel" ) );
+  if ( kernel == "atk1" )
+  {
+      oil::factory factory( kernel );
+      return cfg1_main_body< toppers::oil::cfg1_out >( factory, factory.get_object_definition_info() );
+  }
+  else
+  {
+      itronx::factory factory( kernel );
+      return cfg1_main_body< toppers::itronx::cfg1_out >( factory, *factory.get_static_api_info_map() );
+  }
+}
Index: /cfg_itronx+oil_gcc/cfg/cfg2.cpp
===================================================================
--- /cfg_itronx+oil_gcc/cfg/cfg2.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/cfg/cfg2.cpp	(revision 54)
@@ -0,0 +1,325 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2011 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <fstream>
+#include <sstream>
+#include "toppers/diagnostics.hpp"
+#include "toppers/s_record.hpp"
+#include "toppers/macro_processor.hpp"
+#include "toppers/itronx/component.hpp"
+#include "cfg.hpp"
+#include <boost/spirit/include/classic.hpp>
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+
+/*!
+ *  \brief  オブジェクトID番号の割付け
+ *  \param[in]  api_map   ソースに記述された静的APIを登録したコンテナ
+ */
+namespace toppers{ namespace itronx{
+void assign_id( toppers::itronx::cfg1_out::static_api_map& api_map )
+{
+  using namespace toppers;
+  using namespace toppers::itronx;
+
+  std::string id_input_file( get_global< std::string >( "id-input-file" ) );
+  if ( id_input_file.empty() )  // --id-input-file オプションが指定されていない場合...
+  {
+    for ( cfg1_out::static_api_map::iterator iter( api_map.begin() ), last( api_map.end() );
+          iter != last;
+          ++iter )
+    {
+      static_api::assign_id( iter->second.begin(), iter->second.end() );
+    }
+  }
+  else  // --id-input-file オプションが指定されている場合...
+  {
+    typedef std::map< std::string, std::pair< long, bool > > id_map_t;
+    id_map_t id_map;
+    std::ifstream ifs( id_input_file.c_str() );
+    while ( ifs )
+    {
+      std::string linebuf;
+      std::getline( ifs, linebuf );
+      if ( ifs.bad() )
+      {
+        fatal( _( "I/O error" ) );
+      }
+      if ( linebuf.empty() || linebuf == "\r" )
+      {
+        break;
+      }
+
+      std::istringstream iss( linebuf );
+      std::string name;
+      iss >> name;
+      if ( iss.fail() )
+      {
+        fatal( _( "id file `%1%\' is invalid" ), id_input_file );
+      }
+
+      long value;
+      iss >> value;
+      if ( iss.fail() )
+      {
+        fatal( _( "id file `%1%\' is invalid" ), id_input_file );
+      }
+
+      if ( id_map.find( name ) != id_map.end() )
+      {
+        fatal( _( "E_OBJ: `%1%\' is duplicated" ), name );
+      }
+      else
+      {
+        id_map[ name ] = std::make_pair( value, false );
+      }
+    }
+
+    for ( cfg1_out::static_api_map::iterator iter( api_map.begin() ), last( api_map.end() );
+          iter != last;
+          ++iter )
+    {
+      for ( std::vector< static_api >::iterator iter2( iter->second.begin() ), last2( iter->second.end() );
+            iter2 != last2;
+            ++iter2 )
+      {
+        static_api::info const* info = iter2->get_info();
+        if ( info->id_pos >= 0 )
+        {
+          std::string name( iter2->at( info->id_pos ).text );
+          std::string symbol( iter2->at( info->id_pos ).symbol );
+          if ( !info->slave && symbol[0] == '#' )
+          {
+            id_map_t::iterator hit( id_map.find( name ) );
+            if ( hit != id_map.end() )
+            {
+              long id_value = hit->second.first;
+              if ( id_value > 0 )
+              {
+                iter2->at( info->id_pos ).value = id_value;
+                hit->second.second = true;
+              }
+            }
+          }
+        }
+      }
+      static_api::assign_id( iter->second.begin(), iter->second.end() );
+    }
+
+    for ( id_map_t::const_iterator iter( id_map.begin() ), last( id_map.end() ); iter != last; ++iter )  // 残り物があれば...
+    {
+      if ( !iter->second.second )
+      {
+        warning( _( "object identifier `%1%\' is not used" ), iter->first );
+      }
+    }
+  }
+
+  // --id-output-file オプションが指定されている場合
+  std::string id_output_file( get_global< std::string >( "id-output-file" ) );
+  if ( !id_output_file.empty() )
+  {
+    std::ofstream ofs( id_output_file.c_str() );
+    for ( cfg1_out::static_api_map::iterator iter( api_map.begin() ), last( api_map.end() );
+      iter != last;
+      ++iter )
+    {
+      for ( std::vector< static_api >::const_iterator iter2( iter->second.begin() ), last2( iter->second.end() );
+            iter2 != last2;
+            ++iter2 )
+      {
+        static_api::info const* info = iter2->get_info();
+        if ( info->id_pos >= 0 )
+        {
+          std::string name( iter2->at( info->id_pos ).text );
+          std::string symbol( iter2->at( info->id_pos ).symbol );
+          if ( !info->slave && symbol[0] == '#' )
+          {
+            ofs << name << '\t' << iter2->at( info->id_pos ).value.get() << std::endl;
+          }
+        }
+      }
+    }
+  }
+}
+}}
+namespace toppers{ namespace oil{
+void assign_id( toppers::oil::cfg1_out::cfg_obj_map& cfg_obj_map )
+{
+}
+}}
+
+using namespace toppers;
+using namespace toppers::itronx;
+using namespace toppers::oil;
+
+static inline bool cfg2_main_tf( std::auto_ptr< macro_processor > mproc )
+{
+  // テンプレート処理
+  boost::any template_file( global( "template-file" ) );
+  namespace fs = boost::filesystem;
+  fs::path cfg_dir( get_global< std::string >( "cfg-directory" ) );  // filesystem3対応
+  std::vector< std::string > include_paths = get_global< std::vector< std::string > >( "include-path" );
+  include_paths.push_back( cfg_dir.empty() ? "." : cfg_dir.string() );  // filesystem3対応
+  if ( !template_file.empty() )
+  {
+    toppers::text in_text;
+    toppers::text pp_text;
+    std::string file_name( boost::any_cast< std::string& >( template_file ) );
+
+    in_text.set_line( file_name, 1 );
+    std::ifstream ifs( file_name.c_str() );
+    if ( !ifs.is_open() )
+    {
+      fatal( _( "`%1%` can not be found." ), file_name );
+    }
+    in_text.append( ifs );
+    macro_processor::preprocess( in_text, pp_text );
+    mproc->evaluate( pp_text );
+  }
+  else  // テンプレートファイルが指定されていないので、共通部分（kernel.tf）のみを処理
+  {
+    fs::path kernel_cfg_template_file( cfg_dir/fs::path( "../../kernel/kernel.tf" ) );
+    if ( !fs::exists( kernel_cfg_template_file ) )
+    {
+      error( _( "cannot open file `%1%\'" ), kernel_cfg_template_file.string() );  // filesystem3対応
+    }
+    else
+    {
+      toppers::text in_text;
+      toppers::text pp_text;
+
+      in_text.set_line( kernel_cfg_template_file.string(), 1 );  // filesystem3対応
+      std::ifstream ifs( kernel_cfg_template_file.string().c_str() );  // filesystem3対応
+      in_text.append( ifs );
+      macro_processor::preprocess( in_text, pp_text );
+      mproc->evaluate( pp_text );
+    }
+  }
+
+  if ( get_error_count() > 0 )
+  {
+    return false;
+  }
+  output_file::save();
+  return true;
+}
+
+namespace toppers{ namespace itronx{
+    bool cfg2_main_mproc( itronx::factory factory, std::auto_ptr< itronx::cfg1_out > cfg1_out )
+    {
+        std::auto_ptr< macro_processor > mproc;
+        std::auto_ptr< component > component_ptr;
+
+        if ( get_global< bool >( "with-software-components" ) )
+        {
+            mproc = factory.create_macro_processor( *cfg1_out, cfg1_out->get_static_api_array() );
+            component_ptr.reset( new component( mproc.get() ) );
+        }
+        else  // 従来仕様（ソフトウェア部品非対応）
+        {
+            cfg1_out::static_api_map api_map( cfg1_out->merge() );
+            itronx::assign_id( api_map ); // ID番号の割付け
+            mproc = factory.create_macro_processor( *cfg1_out, api_map );
+        }
+        return cfg2_main_tf( mproc );
+    }
+}}
+
+namespace toppers{ namespace oil{
+    bool cfg2_main_mproc( oil::factory factory, std::auto_ptr< oil::cfg1_out > cfg1_out )
+    {
+        std::auto_ptr< macro_processor > mproc;
+        //std::auto_ptr< component > component_ptr;
+
+        if ( get_global< bool >( "with-software-components" ) )
+        {
+            error( _( "with-software-components is not supported." ) );
+        }
+        else  // 従来仕様（ソフトウェア部品非対応）
+        {
+            cfg1_out::cfg_obj_map cfg_obj_map( cfg1_out->merge() );
+            oil::assign_id(cfg_obj_map); // ID番号の割付け
+            mproc = factory.create_macro_processor( *cfg1_out, cfg_obj_map );
+        }
+        return cfg2_main_tf( mproc );
+    }
+}}
+
+template < class T, class U, class V, class W >
+static inline bool cfg2_main_init( U factory, V cfg2_info, W* p_func_mproc )
+{
+  global( "factory" ) = &factory;
+
+  // *.cfgとcfg1_out.srecの読み込み
+  std::string input_file;
+  try
+  {
+    input_file = get_global< std::string >( "input-file" );
+  }
+  catch ( boost::bad_any_cast& )
+  {
+    fatal( _( "no input files" ) );
+  }
+  std::string cfg1_out_name( get_global< std::string >( "cfg1_out" ) );
+  std::auto_ptr< T > cfg1_out( factory.create_cfg1_out( cfg1_out_name ) );
+
+  codeset_t codeset = get_global< codeset_t >( "codeset" );
+  cfg1_out->load_cfg( input_file, codeset, cfg2_info );
+  cfg1_out->load_srec();
+
+  return p_func_mproc( factory, cfg1_out );
+}
+
+/*!
+ *  \brief  パス２処理
+ *  \retval true  成功
+ *  \retval false 失敗
+ */
+bool cfg2_main()
+{
+  std::string kernel( get_global< std::string >( "kernel" ) );
+  if ( kernel == "atk1" )
+  {
+      oil::factory factory( kernel );
+      return cfg2_main_init< oil::cfg1_out >( factory, factory.get_object_definition_info(), &oil::cfg2_main_mproc );
+  }
+  else
+  {
+      itronx::factory factory( kernel );
+      return cfg2_main_init< itronx::cfg1_out >( factory, *factory.get_static_api_info_map(), &itronx::cfg2_main_mproc );
+  }
+}
Index: /cfg_itronx+oil_gcc/cfg/cfg3.cpp
===================================================================
--- /cfg_itronx+oil_gcc/cfg/cfg3.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/cfg/cfg3.cpp	(revision 54)
@@ -0,0 +1,382 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2011 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <fstream>
+#include <sstream>
+#include "toppers/diagnostics.hpp"
+#include "toppers/s_record.hpp"
+#include "toppers/macro_processor.hpp"
+#include "toppers/itronx/component.hpp"
+#include "toppers/itronx/component.hpp"
+#include "cfg.hpp"
+#include <boost/spirit/include/classic.hpp>
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+
+namespace
+{
+  using toppers::text_line;
+  typedef toppers::macro_processor::element element;
+  typedef toppers::macro_processor::var_t var_t;
+  typedef toppers::macro_processor::context context;
+
+  /*!
+   *  \brief  シンボルに対応するアドレスの取得
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   */
+  template < class checker >
+  var_t bf_symbol( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    using namespace toppers;
+    using namespace toppers::itronx;
+
+    if ( macro_processor::check_arity( line, arg_list.size(), 1, "SYMBOL" ) )
+    {
+      std::string symbol( macro_processor::to_string( arg_list[0], p_ctx ) );
+      std::tr1::shared_ptr< checker > chk = get_global< std::tr1::shared_ptr< checker > >( "checker" );
+      nm_symbol::entry entry = chk->find( symbol );
+      if ( entry.type >= 0 )
+      {
+        element e;
+        e.i = entry.address;
+        return var_t( 1, e );
+      }
+    }
+    return var_t();
+  }
+
+  // VMA アドレス解決用テーブル
+  std::vector< std::pair< std::tr1::int64_t, std::vector< unsigned char > > > vma_table;
+
+  /*!
+   *  \brief  指定したアドレスに格納されている値の取得
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *
+   *  第1引数にアドレスを、第2引数に読み込むバイト数を指定します。
+   */
+  template < class checker >
+  var_t bf_peek( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    using namespace toppers;
+    using namespace toppers::itronx;
+
+    if ( macro_processor::check_arity( line, arg_list.size(), 2, "PEEK" ) )
+    {
+      std::size_t address = static_cast< std::size_t >( macro_processor::to_integer( arg_list[0], p_ctx ) );
+      std::size_t size = static_cast< std::size_t >( macro_processor::to_integer( arg_list[1], p_ctx ) );
+      std::tr1::shared_ptr< checker > chk = get_global< std::tr1::shared_ptr< checker > >( "checker" );
+
+      std::map< std::string, var_t >::const_iterator le_iter( p_ctx->var_map.find( "LITTLE_ENDIAN" ) );
+      if ( le_iter != p_ctx->var_map.end() )
+      {
+        bool little_endian = !!( *le_iter->second.front().i );
+        long pos = -1;
+        long base = 0;
+        element e;
+
+        for ( std::size_t i = 0, n = vma_table.size(); i < n; i++ )
+        {
+          if ( vma_table[i].first <= address && address < vma_table[i].first + vma_table[i].second.size() )
+          {
+            pos = i;
+            base = static_cast< long >( address - vma_table[i].first );
+          }
+        }
+        if ( pos >= 0 )  // VMA から読み取る
+        {
+          std::tr1::uint64_t value = 0;
+          if ( little_endian )
+          {
+            for ( long j = static_cast< long >( size-1 ); j >= 0; j-- )
+            {
+              int t = vma_table[ pos ].second[ base + j ];
+              if ( t < 0 )
+              {
+                return var_t();
+              }
+              value = ( value << 8 ) | ( t & 0xff );
+            }
+          }
+          else
+          {
+            for ( std::size_t j = 0; j < size; j++ )
+            {
+              int t = vma_table[ pos ].second[ base + j ];
+              if ( t < 0 )
+              {
+                return var_t();
+              }
+              value = ( value << 8 ) | ( t & 0xff );
+            }
+          }
+          e.i = value;
+        }
+        else  // VMA ではないので、Sレコードから読み取る
+        {
+          e.i = chk->get( address, size, !!little_endian );
+        }
+        return var_t( 1, e );
+      }
+    }
+    return var_t();
+  }
+
+  /*!
+   *  \brief  メモリブロックの転送
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *
+   *  第1引数に転送元アドレス、第2引数に転送先アドレス、第3引数に転送するバイト数を指定します。
+   *  指定したコピー元アドレスからコピー先アドレスへ、指定バイト数のメモリブロックを転送します。
+   *  この関数は、LMAからVMAへのアドレス変換を目的として使用することを想定しています。
+   *
+   *  \attention  この組み込み関数は、LMAからVMAへのアドレス変換を想定しているため、頻繁に転送を
+   *              繰り返すような状況には対応していません（メモリ不足が発生します）。
+   */
+  template < class checker >
+  var_t bf_bcopy( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    using namespace toppers;
+    using namespace toppers::itronx;
+
+    if ( macro_processor::check_arity( line, arg_list.size(), 3, "BCOPY" ) )
+    {
+      std::size_t src = static_cast< std::size_t >( macro_processor::to_integer( arg_list[0], p_ctx ) );
+      std::size_t dst = static_cast< std::size_t >( macro_processor::to_integer( arg_list[1], p_ctx ) );
+      std::size_t size = static_cast< std::size_t >( macro_processor::to_integer( arg_list[2], p_ctx ) );
+      std::tr1::shared_ptr< checker > chk = get_global< std::tr1::shared_ptr< checker > >( "checker" );
+
+      std::pair< std::tr1::int64_t, std::vector< unsigned char > > block;
+      block.first = dst;
+      block.second.reserve( size );
+      for ( std::tr1::int64_t i = 0; i < size; i++ )
+      {
+        block.second.push_back( static_cast< unsigned char >( chk->get( static_cast< std::size_t >( src + i ), 1, true ) ) );
+      }
+      vma_table.push_back( block );
+    }
+    return var_t();
+  }
+
+}
+
+using namespace toppers;
+template < class checker >
+static inline bool cfg3_main_tf( std::auto_ptr< macro_processor > mproc, boost::any template_file )
+{
+  namespace fs = boost::filesystem;
+
+  // ↓ 追加組み込み関数の登録
+  toppers::macro_processor::func_t func_info = {};
+  func_info.name = "SYMBOL";
+  func_info.f = &bf_symbol< checker >;
+  mproc->add_builtin_function( func_info );
+
+  func_info.name = "PEEK";
+  func_info.f = &bf_peek< checker >;
+  mproc->add_builtin_function( func_info );
+
+  func_info.name = "BCOPY";
+  func_info.f = &bf_bcopy< checker >;
+  mproc->add_builtin_function( func_info );
+  // ↑ 追加組み込み関数の登録
+
+  fs::path cfg_dir( get_global< std::string >( "cfg-directory" ) );  // filesystem3対応
+  std::vector< std::string > include_paths = get_global< std::vector< std::string > >( "include-path" );
+  include_paths.push_back( cfg_dir.empty() ? "." : cfg_dir.string() );  // filesystem3対応
+
+  toppers::text in_text;
+  toppers::text pp_text;
+  std::string file_name( boost::any_cast< std::string& >( template_file ) );
+
+  in_text.set_line( file_name, 1 );
+  std::ifstream ifs( file_name.c_str() );
+  if ( !ifs.is_open() )
+  {
+      fatal( _( "`%1%` can not be found." ), file_name );
+  }
+
+  in_text.append( ifs );
+  macro_processor::preprocess( in_text, pp_text );
+  mproc->evaluate( pp_text );
+
+  if ( get_error_count() > 0 )
+  {
+      return false;
+  }
+  // 出力ファイルがあるかどうか分からないが、一応セーブする。
+  output_file::save();
+
+  return true;
+}
+
+namespace toppers{ namespace itronx{
+    bool cfg3_main_mproc( itronx::factory factory, std::auto_ptr< itronx::cfg1_out > cfg1_out, boost::any template_file )
+    {
+        using namespace toppers::itronx;
+
+        // テンプレート処理
+        std::auto_ptr< macro_processor > mproc;
+        std::auto_ptr< component > component_ptr;
+
+        if ( get_global< bool >( "with-software-components" ) )
+        {
+            mproc = factory.create_macro_processor( *cfg1_out, cfg1_out->get_static_api_array() );
+            component_ptr.reset( new component( mproc.get() ) );
+        }
+        else
+        {
+            cfg1_out::static_api_map api_map( cfg1_out->merge() );
+            toppers::itronx::assign_id( api_map ); // ID番号の割付け
+            mproc = factory.create_macro_processor( *cfg1_out, api_map );
+        }
+        return cfg3_main_tf< checker >( mproc, template_file );
+    }
+}}
+
+namespace toppers{ namespace oil{
+    bool cfg3_main_mproc( oil::factory factory, std::auto_ptr< oil::cfg1_out > cfg1_out, boost::any template_file )
+    {
+        using namespace toppers::oil;
+
+        // テンプレート処理
+        std::auto_ptr< macro_processor > mproc;
+        //std::auto_ptr< component > component_ptr;
+
+        if ( get_global< bool >( "with-software-components" ) )
+        {
+            error( _( "with-software-components is not supported." ) );
+        }
+        else  // 従来仕様（ソフトウェア部品非対応）
+        {
+            cfg1_out::cfg_obj_map cfg_obj_map( cfg1_out->merge() );
+            toppers::oil::assign_id(cfg_obj_map); // ID番号の割付け
+            mproc = factory.create_macro_processor( *cfg1_out, cfg_obj_map );
+        }
+        return cfg3_main_tf< checker >( mproc, template_file );
+    }
+}}
+
+
+
+template < class T, class checker, class U, class V, class W >
+static inline bool cfg3_main_init( U factory, V cfg3_info, W* p_func_mproc )
+{
+  using namespace toppers::itronx;
+  using namespace toppers::oil;
+
+  global( "factory" ) = &factory;
+
+  // *.cfgとcfg1_out.srecの読み込み
+  std::string input_file;
+  try
+  {
+    input_file = get_global< std::string >( "input-file" );
+  }
+  catch ( boost::bad_any_cast& )
+  {
+    fatal( _( "no input files" ) );
+  }
+  std::string cfg1_out_name( get_global< std::string >( "cfg1_out" ) );
+  std::auto_ptr< T > cfg1_out( factory.create_cfg1_out( cfg1_out_name ) );
+
+  codeset_t codeset = get_global< codeset_t >( "codeset" );
+  cfg1_out->load_cfg( input_file, codeset, cfg3_info );
+  cfg1_out->load_srec();
+
+  std::auto_ptr< checker > p_checker( factory.create_checker() );
+  std::tr1::shared_ptr< checker > chk( p_checker );
+  global( "checker" ) = chk;
+  std::string rom_image( get_global< std::string >( "rom-image" ) );
+  std::string symbol_table( get_global< std::string >( "symbol-table" ) );
+  chk->load_rom_image( rom_image, symbol_table );
+
+  // テンプレートファイル
+  boost::any template_file( global( "template-file" ) );
+  if ( template_file.empty() )
+  {
+    // テンプレートファイルが指定されていなければ最低限のチェックのみ（後方互換性のため）
+    // パラメータチェック
+    if ( !chk->check( *cfg1_out ) )
+    {
+      return false;
+    }
+  }
+  else
+  {
+      if( !p_func_mproc( factory, cfg1_out, template_file ) )
+      {
+          return false;
+      }
+  }
+
+  // パス4以降からも流用されるため、現在処理中のパスを調べる。
+  int pass = get_global< int >( "pass" );
+  int max_pass = get_global< int >( "max-pass" );
+  if ( max_pass == pass ) // 最終段階のパスが成功したときに"check complete"メッセージを出す。
+  {
+    std::cerr << _( "check complete" ) << std::endl;
+  }
+
+  return true;
+}
+
+bool cfg3_main()
+{
+  std::string kernel( get_global< std::string >( "kernel" ) );
+
+  if ( kernel == "atk1" )
+  {
+      using namespace toppers::oil;
+      factory factory( kernel );
+      return cfg3_main_init< cfg1_out, checker >( factory, factory.get_object_definition_info(), &cfg3_main_mproc );
+  }
+  else
+  {
+      using namespace toppers::itronx;
+      factory factory( kernel );
+      return cfg3_main_init< cfg1_out, checker >( factory, *factory.get_static_api_info_map(), &cfg3_main_mproc );
+  }
+
+}
Index: /cfg_itronx+oil_gcc/cfg/cfg4.cpp
===================================================================
--- /cfg_itronx+oil_gcc/cfg/cfg4.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/cfg/cfg4.cpp	(revision 54)
@@ -0,0 +1,42 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2009 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include "cfg.hpp"
+
+bool cfg4_main()
+{
+  return cfg3_main();
+}
Index: /cfg_itronx+oil_gcc/cfg/cfg_init.cpp
===================================================================
--- /cfg_itronx+oil_gcc/cfg/cfg_init.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/cfg/cfg_init.cpp	(revision 54)
@@ -0,0 +1,40 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+void cfg_init()
+{
+}
Index: /cfg_itronx+oil_gcc/cfg/cfg_version.cpp
===================================================================
--- /cfg_itronx+oil_gcc/cfg/cfg_version.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/cfg/cfg_version.cpp	(revision 54)
@@ -0,0 +1,78 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2011 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#define __STDC_CONSTANT_MACROS  1
+#include "cfg.hpp"
+#include <ctime>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+//! cfgのバージョン情報
+extern char const cfg_version[] = "1.8.0";
+
+/*!
+ *  \brief  プログラムファイル(cfg or cfg.exe)のタイムスタンプを取得する。
+ *  \return タイムスタンプを64ビット整数値として返す。
+ *
+ *  返却値の形式は
+ *
+ *  YYYYMMDDhhmmss
+ *
+ *  となる。YYYYは年、MMは月、DDは日、hhは時、mmは分、ssは秒
+ *
+ *  \note   ファイル名は main の引数 argv[0] を使っている。PATH は検索しないので注意!
+ *  \note   この関数は stat 関数に依存しているため移植性に問題がある。
+ */
+std::tr1::int64_t cfg_timestamp()
+{
+  std::tr1::int64_t result;
+
+  try
+  {
+    std::string program_name = toppers::get_global< std::string >( "argv0" );
+
+    struct stat sb;
+    stat( program_name.c_str(), &sb );
+    struct tm t = *localtime( &sb.st_mtime );
+    result = ( t.tm_year + 1900 ) * INT64_C( 10000000000 ) + ( t.tm_mon + 1 ) * INT64_C( 100000000 ) + t.tm_mday * 1000000
+      + t.tm_hour * 10000 + t.tm_min * 100 + t.tm_sec;
+  }
+  catch ( ... )
+  {
+    result = -1;
+  }
+  return result;
+}
Index: /cfg_itronx+oil_gcc/cfg/require_modules.hpp
===================================================================
--- /cfg_itronx+oil_gcc/cfg/require_modules.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/cfg/require_modules.hpp	(revision 54)
@@ -0,0 +1,56 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   require_module.hpp
+ *  \brief  サポート対象カーネルのためのモジュール要求
+ *
+ *  \todo   ASP以外のカーネルをサポートするときは、このヘッダファイルを存在するディレクトリを元に
+ *          自動生成させること。（OSEK SGと類似の方法？）
+ */
+#define REQUIRE_MODULE( name ) \
+  namespace name { bool init(); bool call_init = init(); }
+
+namespace toppers { namespace oil {
+
+  REQUIRE_MODULE( atk1 )
+
+} }
+namespace toppers { namespace itronx {
+
+  REQUIRE_MODULE( asp )
+
+} }
Index: /cfg_itronx+oil_gcc/configure
===================================================================
--- /cfg_itronx+oil_gcc/configure	(revision 54)
+++ /cfg_itronx+oil_gcc/configure	(revision 54)
@@ -0,0 +1,84 @@
+#!/bin/sh
+
+makefile_config="Makefile.config"
+
+# コマンドライン引数の処理
+for arg in "$@"
+do
+	name=`echo $arg | cut -d "=" -f 1`
+	value=`echo $arg | cut -d "=" -f 2`
+
+	case $name in
+		--with-headers)		include_path=$value ;;
+		--with-libraries)	library_path=$value ;;
+		--help)				echo "configure options:"
+							echo "--help"
+							echo "	display this information"
+							echo "--with-headers=<dir>"
+							echo "	specify the directory of Boost headers"
+							echo "--with-libraries=<dir>"
+							echo "	specify the directory of Boost libraries"
+							exit
+							;;
+	esac
+done
+
+# Boost C++ Librariesのヘッダファイルがあるディレクトリをサーチ
+for dir in $include_path "/usr/local/include" "/opt/local/include" "/opt/include" "/usr/include" "/mingw/include"
+do
+	ls $dir/boost* 2> /dev/null > /dev/null
+	if test $? -eq 0
+	then
+		boost_dir=`ls -d $dir/boost* | sort -r | head -1`
+		if test $boost_dir = $dir/boost
+		then
+			include_path=$dir
+		else
+			include_path=$boost_dir
+		fi
+		break
+	fi
+done
+
+# Boost C++ Librariesのライブラリファイルがあるディレクトリをサーチ
+for dir in $library_path "/usr/local/lib" "/opt/local/lib" "/opt/lib" "/usr/lib" "/lib" "/mingw/lib"
+do
+	ls $dir/libboost* 2> /dev/null > /dev/null
+	if test $? -eq 0
+	then
+		library_path=$dir
+		break
+	fi
+done
+
+##### 以下、Makefile.configを生成する #####
+
+rm Makefile.config 2> /dev/null
+
+# Boost C++ Librariesのバージョンを調べる
+boost_version=`echo "#include <boost/version.hpp>
+echo BOOST_VERSION" | g++ -E -I$include_path -L$library_path - | sh`
+
+boost_lib_version=`echo "#include <boost/version.hpp>
+echo BOOST_LIB_VERSION" | g++ -E -I$include_path -L$library_path - | sh`
+
+# ライブラリファイルの添字を調べる
+# 環境によって、-gcc-mt-s, -mt-s, -gcc42-mt-sなど、添字が異なるため
+libboost_regex_filename=`ls $library_path/libboost_regex*-s.* 2> /dev/null | head -1`
+if test -z $libboost_regex_filename
+then
+	libboost_regex_filename=`ls $library_path/libboost_regex*.* | head -1`
+fi
+libboost_suffix=`echo $libboost_regex_filename | sed -e s/.*libboost_regex//g -e s/\.[a-z]*$//g`
+echo "LIBBOOST_SUFFIX=$libboost_suffix" >> $makefile_config
+
+# 各種変数を出力
+echo BOOST_VERSION=$boost_lib_version >> $makefile_config
+echo BOOST_DIR=$include_path >> $makefile_config
+echo LIBBOOST_DIR=$library_path >> $makefile_config
+echo OPTIONS=$options >> $makefile_config
+
+# 生成結果を表示
+cat Makefile.config
+
+# 終わり
Index: /cfg_itronx+oil_gcc/system_generator.sln
===================================================================
--- /cfg_itronx+oil_gcc/system_generator.sln	(revision 54)
+++ /cfg_itronx+oil_gcc/system_generator.sln	(revision 54)
@@ -0,0 +1,20 @@
+﻿
+Microsoft Visual Studio Solution File, Format Version 10.00
+# Visual C++ Express 2008
+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "cfg", "cfg\cfg.vcproj", "{0C8E059D-E1E3-4753-8BD5-1A7098316F6E}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Win32 = Debug|Win32
+		Release|Win32 = Release|Win32
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{0C8E059D-E1E3-4753-8BD5-1A7098316F6E}.Debug|Win32.ActiveCfg = Debug|Win32
+		{0C8E059D-E1E3-4753-8BD5-1A7098316F6E}.Debug|Win32.Build.0 = Debug|Win32
+		{0C8E059D-E1E3-4753-8BD5-1A7098316F6E}.Release|Win32.ActiveCfg = Release|Win32
+		{0C8E059D-E1E3-4753-8BD5-1A7098316F6E}.Release|Win32.Build.0 = Release|Win32
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal
Index: /cfg_itronx+oil_gcc/toppers/Makefile
===================================================================
--- /cfg_itronx+oil_gcc/toppers/Makefile	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/Makefile	(revision 54)
@@ -0,0 +1,43 @@
+-include ../Makefile.config
+
+PROJDIR = ..
+WORKDIR = $(PROJDIR)/toppers
+
+CPPFLAGS := $(CPPFLAGS) -I$(BOOST_DIR) -I$(PROJDIR)
+CXXFLAGS := $(CXXFLAGS) -O2 -g
+
+CXXFILES = \
+	builtin_function.cpp \
+	c_chlit_parser.cpp \
+	c_ident_parser.cpp \
+	c_int_parser.cpp \
+	c_keywords.cpp \
+	c_plus_plus_keywords.cpp \
+	c_strlit_parser.cpp \
+	cpp.cpp \
+	diagnostics.cpp \
+	gettext.cpp \
+	global.cpp \
+	io.cpp \
+	macro_processor.cpp \
+	mbchar_parser.cpp \
+	nm_symbol.cpp \
+	output_file.cpp \
+	s_record.cpp \
+	ucn_parser.cpp \
+
+OBJFILES := $(CXXFILES:%.cpp=%.o)
+
+all: libtoppers.a
+
+libtoppers.a: $(OBJFILES)
+	$(AR) rcs libtoppers.a $(OBJFILES)
+
+depend:
+	$(CXX) $(CPPFLAGS) -M $(CXXFILES) > Makefile.depend
+
+clean:
+	-rm -f *.o *.a
+
+-include Makefile.depend
+
Index: /cfg_itronx+oil_gcc/toppers/builtin_function.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/builtin_function.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/builtin_function.cpp	(revision 54)
@@ -0,0 +1,916 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2011 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <cstdio>
+#include <cstdlib>
+#include <cerrno>
+#include <string>
+#include <vector>
+#include <utility>
+#include <algorithm>
+#include <iostream>
+#include "toppers/macro_processor.hpp"
+#include "toppers/diagnostics.hpp"
+#include "toppers/gettext.hpp"
+#include "toppers/cpp.hpp"
+#include <boost/format.hpp>
+#include <boost/utility.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/xpressive/xpressive.hpp>
+
+namespace toppers
+{
+  namespace
+  {
+    typedef macro_processor::element element;
+    typedef macro_processor::var_t var_t;
+    typedef macro_processor::context context;
+
+    inline std::tr1::int64_t get_i( var_t const& var, context const* p_ctx )
+    {
+      return macro_processor::to_integer( var, p_ctx );
+    }
+    inline std::string get_s( var_t const& var, context const* p_ctx )
+    {
+      return macro_processor::to_string( var, p_ctx );
+    }
+
+  }
+
+  /*!
+    *  \brief  引数の個数チェック
+    *  \param[in]  line    行番号情報
+    *  \param[in]  arity   引数の個数
+    *  \param[in]  valid   期待している引数の個数
+    *  \param[in]  function_name 組み込み関数名
+    */
+  bool macro_processor::check_arity( text_line const& line, std::size_t arity, std::size_t valid, char const* function_name )
+  {
+    bool result = false;
+    if ( arity < valid )
+    {
+      error( line, _( "too few arguments for `%1%\'" ), function_name );
+    }
+    else if ( arity > valid )
+    {
+      error( line, _( "too many arguments for `%1%\'" ), function_name );
+    }
+    else
+    {
+      result = true;
+    }
+    return result;
+  }
+
+  /*!
+   *  \brief  変数ダンプのための<<演算子
+   *  \param[in,out]  ostr  出力ストリーム
+   *  \param[in]      arg   変数を参照するためのペア
+   *  \return         ostrを返す
+   *  \note 現在の実装では、arg.second は使用していない。
+   */
+  std::ostream& operator<<( std::ostream& ostr, std::pair< var_t const*, context const* > const& arg )
+  {
+    for ( var_t::const_iterator iter( arg.first->begin() ), last( arg.first->end() ); iter != last; ++iter )
+    {
+      if ( !iter->s.empty() )
+      {
+        ostr << iter->s;
+      }
+      else if ( iter->i )
+      {
+        ostr << iter->i.get();
+      }
+      if ( boost::next( iter ) != last )
+      {
+        ostr << ",";
+      }
+    }
+    return ostr;
+  }
+
+  /*!
+   *  \brief  順序リストの長さ
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  第1マクロ実引数として指定した順序付きリストの要素数を返す。
+   *  第1マクロ実引数が順序付きリストでない場合は1を返す。また、第1マクロ実引数が無効な変数の場合は0を返す。
+   */
+  var_t bf_length( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    if ( macro_processor::check_arity( line, arg_list.size(), 1, "LENGTH" ) )
+    {
+      std::tr1::int64_t size = arg_list.front().size();
+      e.i = size;
+    }
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  文字列の一致判定
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  第1マクロ実引数と第2マクロ実引数を文字列として比較し、一致する場合は真を、そうでなければ偽を返す。
+   */
+  var_t bf_eq( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    if ( macro_processor::check_arity( line, arg_list.size(), 2, "EQ" ) )
+    {
+      e.i = get_s( arg_list[ 0 ], p_ctx ) == get_s( arg_list[ 1 ], p_ctx );
+    }
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  代替値
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  第1マクロ実引数が無効な変数の場合は第2実引数を返す。その他は第1実引数を返す。
+   */
+  var_t bf_alt( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    if ( macro_processor::check_arity( line, arg_list.size(), 2, "ALT" ) )
+    {
+      if ( !arg_list[0].empty() )
+      {
+        return arg_list[ 0 ];
+      }
+      else
+      {
+        return arg_list[ 1 ];                
+      }
+    }
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  順序リストの整列
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  第1マクロ実引数として与えた順序付きリストの各要素を、第2マクロ実引数の添え字とした場合の変数を評価し、
+   *  その評価結果に基づき昇順に整列する。
+   *
+   *  \example
+   *  $FOO[1] = 20$
+   *  $FOO[2] = 10$
+   *  $FOO[3] = 30$
+   *  $SORT({ 1,2,3 }, "FOO")$
+   *  → { 2,1,3 }
+   *  \endexample
+   */
+  var_t bf_sort( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    var_t result;
+    if ( macro_processor::check_arity( line, arg_list.size(), 2, "SORT" ) )
+    {
+      var_t list( arg_list[ 0 ] );
+      std::string field( get_s( arg_list[ 1 ], p_ctx ) );
+      std::vector< std::pair< element, std::tr1::int64_t > > temp;
+
+      for ( var_t::const_iterator iter( list.begin() ), last( list.end() ); iter != last; ++iter )
+      {
+        std::tr1::int64_t order = iter->i.get();
+        std::string name( ( boost::format( "%s[%d]" ) % field % order ).str() );
+        std::map< std::string, var_t >::const_iterator m_iter( p_ctx->var_map.find( name ) );
+        if ( m_iter == p_ctx->var_map.end() )
+        {
+          return var_t();
+        }
+        if ( !m_iter->second.empty() )
+        {
+          temp.push_back( std::make_pair( m_iter->second.front(), order ) );
+        }
+      }
+
+      std::stable_sort( temp.begin(), temp.end() );
+
+      for ( std::vector< std::pair< element, std::tr1::int64_t > >::const_iterator iter( temp.begin() ), last( temp.end() );
+            iter != last;
+            ++iter )
+      {
+        element e;
+        e.i = iter->second;
+        result.push_back( e );
+      }
+    }
+    return result;
+  }
+
+  /*!
+   *  \brief  環境変数の取得
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  第1マクロ実引数で指定した環境変数の値を返す。
+   */
+  var_t bf_environ( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    if ( macro_processor::check_arity( line, arg_list.size(), 1, "ENVIRON" ) )
+    {
+      std::string name = get_s( arg_list[ 0 ], p_ctx );
+      char const* env = std::getenv( name.c_str() );
+      if ( env == 0 )
+      {
+        return var_t();
+      }
+      e.s = env;
+      errno = 0;
+      char* endptr;
+      if ( std::tr1::int64_t value = std::strtol( env, &endptr, 0 ) )
+      {
+        if ( *endptr == '\0' && errno == 0 )
+        {
+          e.i = value;
+        }
+      }
+    }
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  値の生成
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  第1マクロ実引数をテキスト、第2マクロ実引数を数値として、値を生成する。
+   */
+  var_t bf_value( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    if ( macro_processor::check_arity( line, arg_list.size(), 2, "VALUE" ) )
+    {
+      if ( !arg_list[0].empty() )
+      {
+        e.s = get_s( arg_list[ 0 ], p_ctx );
+      }
+      if ( !arg_list[1].empty() )
+      {
+        e.i = get_i( arg_list[ 1 ], p_ctx );
+      }
+    }
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  文字列の連結
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  第1マクロ実引数と第2マクロ実引数を連結して新しい文字列を生成する。
+   */
+  var_t bf_concat( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    if ( macro_processor::check_arity( line, arg_list.size(), 2, "CONCAT" ) )
+    {
+      e.s = get_s( arg_list[ 0 ], p_ctx ) + get_s( arg_list[ 1 ], p_ctx );
+    }
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  順序リストの終端に要素を追加
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  第1マクロ実引数と第2マクロ実引数以降を連結して新しい順序付きリストを生成する。
+   */
+  var_t bf_append( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    var_t result;
+    var_t::size_type const n = arg_list.size();
+    if ( n < 2 )
+    {
+      error( line, _( "too few arguments for `%1%\'" ), "APPEND" );
+		}
+		else
+		{
+		  result = arg_list[ 0 ];
+      for ( var_t::size_type i = 1; i < n; i++)
+			{
+			  result.insert( result.end(), arg_list[ i ].begin(), arg_list[ i ].end() );
+			}
+		}
+    return result;
+  }
+
+  /*!
+   *  \brief  順序リストの指定要素の参照
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  第1マクロ実引数で指定した順序リストの、第2マクロ実引数で指定した要素を返す。
+   */
+  var_t bf_at( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    if ( macro_processor::check_arity( line, arg_list.size(), 2, "AT" ) )
+    {
+      try
+      {
+        e = arg_list[ 0 ].at( static_cast< std::vector< var_t >::size_type >( get_i( arg_list[1], p_ctx ) ) );
+      }
+      catch ( std::out_of_range& )
+      {
+        // 添え字が不正
+        // 特に何もしない → この時点で e が空値であることを期待
+      }
+    }
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  テキストの翻訳
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  第1マクロ実引数で指定した文字列を翻訳する。
+   */
+  var_t bf_gettext( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    if ( macro_processor::check_arity( line, arg_list.size(), 1, "GETTEXT" ) )
+    {
+      std::string message = get_s( arg_list[ 0 ], p_ctx );
+      e.s = gettext( message );
+    }
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  マクロ実引数の書式化
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  第1マクロ実引数で指定した初期化文字列によって、第2マクロ実引数以降を書式化する。
+   *  書式化文字列は、%nが使えないことを除き、printf関数のスーパーセットである。
+   *  正確な仕様は、boost::formatを参照のこと。
+   */
+  var_t bf_format( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    std::size_t arity = arg_list.size();
+    if ( arity < 1 )
+    {
+      error( line, _( "too few arguments for `%1%\'" ), "FORMAT" );
+    }
+    std::string format_str = get_s( arg_list[ 0 ], p_ctx );
+#if 0
+    std::string debug_str = format_str;
+    if ( debug_str == "0x%08x" )
+      toppers::trace("%s", debug_str.c_str() );
+#endif
+    boost::format fmt( format_str );
+    for ( std::size_t i = 1; i < arity; i++ )
+    {
+      std::pair< var_t const*, context const* > arg( &arg_list[i], p_ctx );
+      fmt % arg;
+    }
+  	e.s = fmt.str();
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  順序付きリスト内の探索
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  第1マクロ実引数で指定した順序付きリストに含まれる第2マクロ実引数で指定した値に等しい要素を、
+   *  先頭から順に探索する。
+   *  等しい要素が見つかればその要素へのインデックスを、そうでなければ空値を返す。
+   */
+  var_t bf_find( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    if ( macro_processor::check_arity( line, arg_list.size(), 2, "FIND" ) )
+    {
+      var_t list( arg_list[ 0 ] );
+
+	  if ( !arg_list[ 1 ].empty() )
+	  {
+        element key( arg_list[ 1 ].front() );
+
+        if ( !key.i )	// 整数値が設定されていなければ...
+        {
+          std::string value( key.s );
+
+          for ( var_t::const_iterator iter( list.begin() ), last( list.end() ); iter != last; ++iter )
+          {
+            if ( iter->s == value ) // 発見！
+            {
+              e.i = iter - list.begin();  // iter は RandomAccessIterator
+              return var_t( 1, e );
+            }
+          }
+        }
+		else
+		{
+          std::tr1::int64_t value( key.i.get() );
+
+          for ( var_t::const_iterator iter( list.begin() ), last( list.end() ); iter != last; ++iter )
+          {
+            if ( iter->i && iter->i.get() == value ) // 発見！
+            {
+              e.i = iter - list.begin();  // iter は RandomAccessIterator
+              return var_t( 1, e );
+            }
+          }
+        }
+	  }
+    }
+    return var_t();
+  }
+
+  /*!
+   *  \brief  範囲指定による順序付きリスト
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  第1マクロ実引数で最初の値を、第2マクロ実引数で最後の値を指定する。
+   *  { 最初の値, 最初の値 + 1, ... 最後の値 }
+   *  となる順序付きリストを生成する。
+   *  引数が正しくない場合は空値を返す。
+   */
+  var_t bf_range( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    var_t result;
+    if ( macro_processor::check_arity( line, arg_list.size(), 2, "RANGE" ) )
+    {
+      std::tr1::int64_t arg1( get_i( arg_list[ 0 ], p_ctx ) );
+      std::tr1::int64_t arg2( get_i( arg_list[ 1 ], p_ctx ) );
+
+      for ( ; arg1 <= arg2; ++arg1 )
+      {
+        element e;
+        e.i = arg1;
+        result.push_back( e );
+      }
+    }
+    return result;
+  }
+
+  /*!
+   *  \brief  全変数のダンプ
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  マクロ実引数を指定した場合、その文字列属性で指定したファイルにダンプした文字列を追記する。
+   *  ファイル名として、"stdout"を指定した場合は標準出力、"stderr"を指定した場合は標準エラーに出力する。
+   *  ファイル名を省略した場合は"stderr"を指定したものとして振舞う。
+   */
+  var_t bf_dump( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    std::size_t arity = arg_list.size();
+
+    if ( arity > 1 )
+    {
+      error( line, _( "too many arguments for `%1%\'" ), "DUMP" );
+    }
+
+    std::string dump_str;
+
+    // 全変数をなめる
+    for ( std::map< std::string, var_t >::const_iterator iter( p_ctx->var_map.begin() ), last( p_ctx->var_map.end() );
+          iter != last;
+          ++iter )
+    {
+      dump_str += "$" + iter->first + "$ = { ";
+      if ( !iter->second.empty() )
+      {
+        // 各変数の全要素
+        for ( var_t::const_iterator iter2( iter->second.begin() ), last2( iter->second.end() );
+              iter2 != last2;
+              ++iter2 )
+        {
+          dump_str += "\"" + iter2->s + "\"(";
+          if ( iter2->i ) // 値属性があれば...
+          {
+            dump_str += boost::lexical_cast< std::string >( *iter2->i );
+          }
+          dump_str += "), ";
+        }
+      }
+      dump_str += " }\n";
+    }
+
+    std::string filename( "stderr" );
+    if ( arity == 1 )
+    {
+      filename = get_s( arg_list[ 0 ], p_ctx );
+    }
+    if ( filename == "stdout" )
+    {
+      std::fputs( dump_str.c_str(), stdout );
+      std::fflush( stdout );
+    }
+    else if ( filename == "stderr" )
+    {
+      std::fputs( dump_str.c_str(), stderr );
+      std::fflush( stderr );
+    }
+    else
+    {
+      std::FILE* stream = std::fopen( filename.c_str(), "a" );
+      if ( stream != 0 )
+      {
+        std::fputs( dump_str.c_str(), stream );
+        std::fclose( stream );
+      }
+    }
+    element e;
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  変数のトレース
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  第1マクロ実引数で指定した変数の内容をトレースする。
+   *  第2マクロ実引数を指定した場合、その文字列属性で指定したファイルにトレース内容を追記する。
+   *  ファイル名として、"stdout"を指定した場合は標準出力、"stderr"を指定した場合は標準エラーに出力する。
+   *  ファイル名を省略した場合は"stderr"を指定したものとして振舞う。
+   */
+  var_t bf_trace( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    std::size_t arity = arg_list.size();
+
+    if ( arity < 1 )
+    {
+      error( line, _( "too few arguments for `%1%\'" ), "TRACE" );
+    }
+    else if ( arity > 2 )
+    {
+      error( line, _( "too many arguments for `%1%\'" ), "TRACE" );
+    }
+
+    var_t value( arg_list[ 0 ] );
+
+    std::string trace_str = "{ ";
+    for ( var_t::const_iterator iter( value.begin() ), last( value.end() );
+          iter != last;
+          ++iter )
+    {
+      trace_str += "\"" + iter->s + "\"(";
+      if ( iter->i ) // 値属性があれば...
+      {
+        trace_str += boost::lexical_cast< std::string >( *iter->i ) + " as integer";
+      }
+      else if ( !iter->v.empty() )
+      {
+        trace_str += "\"" + boost::lexical_cast< std::string >( iter->v ) + "\" as string";
+      }
+      trace_str += "), ";
+    }
+    trace_str += " }\n";
+
+    std::string filename( "stderr" );
+    if ( arity == 2 )
+    {
+      filename = get_s( arg_list[ 1 ], p_ctx );
+    }
+    if ( filename == "stdout" )
+    {
+      std::fputs( trace_str.c_str(), stdout );
+      std::fflush( stdout );
+    }
+    else if ( filename == "stderr" )
+    {
+      std::fputs( trace_str.c_str(), stderr );
+      std::fflush( stderr );
+    }
+    else
+    {
+      std::FILE* stream = std::fopen( filename.c_str(), "a" );
+      if ( stream != 0 )
+      {
+        std::fputs( trace_str.c_str(), stream );
+        std::fclose( stream );
+      }
+    }
+
+    element e;
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  文字列のエスケープ
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   */
+  var_t bf_escstr( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    if ( macro_processor::check_arity( line, arg_list.size(), 1, "ESCSTR" ) )
+    {
+      std::string str( get_s( arg_list[ 0 ], p_ctx ) );
+      e.s = quote_string( str );
+    }
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  文字列のエスケープ解除
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   */
+  var_t bf_unescstr( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    if ( macro_processor::check_arity( line, arg_list.size(), 1, "UNESCSTR" ) )
+    {
+      std::string str( get_s( arg_list[ 0 ], p_ctx ) );
+      if ( !str.empty() )
+      {
+        e.s = expand_quote( str );
+      }
+    }
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  関数の呼び出し
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   */
+  var_t bf_call( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    return macro_processor::call_user_function( line, arg_list, p_ctx );
+  }
+
+  namespace
+  {
+    struct bf_functor : std::binary_function< element const&, element const&, bool >
+    {
+    public:
+      bf_functor( text_line const& line, std::string const& func_name, context* p_ctx )
+        : line_( line ), func_name_( func_name ), p_ctx_( p_ctx )
+      {
+      }
+      bool operator()( element const& lhs, element const& rhs )
+      {
+        std::vector< var_t > arg_list;
+        arg_list.reserve( 3 );
+
+        element e;
+        e.s = func_name_;
+        arg_list.push_back( var_t( 1, e ) );
+        arg_list.push_back( var_t( 1, lhs ) );
+        arg_list.push_back( var_t( 1, rhs ) );
+        int arg1 = static_cast< int >( *lhs.i );
+        int arg2 = static_cast< int >( *rhs.i );
+
+        var_t r = bf_call( line_, arg_list, p_ctx_ );
+        bool result = 0;
+        if ( !r.empty() )
+        {
+          int retval = static_cast< int >( *r.front().i );
+          result = ( *r.front().i < 0 );
+        }
+        return result;
+      }
+    private:
+      std::string func_name_;
+      context* p_ctx_;
+      text_line line_;
+    };
+  }
+
+  /*!
+   *  \brief  ソート
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   */
+  var_t bf_lsort( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    if ( macro_processor::check_arity( line, arg_list.size(), 2, "LSORT" ) )
+    {
+      var_t temp( arg_list[ 0 ] );
+      std::string compare( arg_list[ 1 ].front().s );
+      std::stable_sort( temp.begin(), temp.end(), bf_functor( line, compare, p_ctx ) );
+      return temp;
+    }
+    element e;
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  関数かどうかの判別
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   */
+  var_t bf_isfunction( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    if ( macro_processor::check_arity( line, arg_list.size(), 1, "ISFUNCTION" ) )
+    {
+      std::string func_name( get_s( arg_list[ 0 ], p_ctx ) );
+      if ( p_ctx->func_map.find( func_name ) != p_ctx->func_map.end() )
+      {
+        e.i = 1;
+      }
+      else
+      {
+        e.i = 0;
+      }
+    }
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  順序付きリストの並びを逆にする
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   */
+  var_t bf_reverse( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    var_t result;
+    if ( macro_processor::check_arity( line, arg_list.size(), 1, "REVERSE" ) )
+    {
+      result = arg_list[ 0 ];
+      std::reverse(result.begin(), result.end());
+    }
+    return result;
+  }
+
+  /*! 
+   *  \brief  正規表現を用いた置換 
+   *  \param[in]  line      行番号 
+   *  \param[in]  arg_list  マクロ実引数リスト 
+   *  \param[in]  p_ctx     マクロコンテキスト 
+   *  \retval     マクロ返却値 
+   *  第1マクロ実引数で指定した文字列のうち、第2マクロ実引数で指定した正規表現にマッチする箇所を第3マクロ実引数の内容で置換する。
+   *  正規表現はECMAScript互換とする。
+   */ 
+   var_t bf_regex_replace( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx ) 
+   { 
+     element e; 
+     if ( macro_processor::check_arity( line, arg_list.size(), 3, "REGEX_REPLACE" ) ) 
+     {
+       e.s = boost::xpressive::regex_replace( get_s( arg_list[ 0 ], p_ctx ), 
+                                              boost::xpressive::sregex::compile( get_s( arg_list[ 1 ], p_ctx ) ), 
+                                              get_s( arg_list[ 2 ], p_ctx ) ); 
+     } 
+     return var_t( 1, e ); 
+   }
+
+  /*!
+   *  \brief  配列の全削除
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+	 *  第1マクロ実引数で指定した名前の配列を全削除する。
+   */
+  var_t bf_clean( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    if ( macro_processor::check_arity( line, arg_list.size(), 1, "CLEAN" ) ) 
+    {
+      std::string name = get_s( arg_list[ 0 ], p_ctx ) + "[";
+      for ( std::map< std::string, var_t >::iterator it = p_ctx->var_map.lower_bound( name );
+            it != p_ctx->var_map.end();
+            ++it )
+      {
+        if ( std::strncmp( it->first.c_str(), name.c_str(), name.size() ) != 0 )
+          break;
+        it->second = var_t();
+      }
+    }
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  マクロプロセッサの終了
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  マクロプロセッサを終了する。
+   */
+  var_t bf_die( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    if ( macro_processor::check_arity( line, arg_list.size(), 0, "DIE" ) ) 
+    {
+      throw macro_processor::die_terminate();
+    }
+    return var_t( 1, e );
+  }
+
+  /*!
+   *  \brief  何もしない組み込み関数
+   *  \param[in]  line      行番号
+   *  \param[in]  arg_list  マクロ実引数リスト
+   *  \param[in]  p_ctx     マクロコンテキスト
+   *  \retval     マクロ返却値
+   *  この組み込み関数は何も行わない。また、マクロ実引数のチェックも行わない。
+   *  NOOP関数は常に "" を返す。
+   *  \note       空値を返さないのは、$NOOP()$のような使い方をしたときでも不正な参照が起こらないようにするため。
+   */
+  var_t bf_noop( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    element e;
+    return var_t( 1, e );
+  }
+
+  macro_processor::func_t const macro_processor::builtin_function_table[] =
+  {
+    { "LENGTH", bf_length },
+    { "EQ", bf_eq },
+    { "ALT", bf_alt },
+    { "SORT", bf_sort },
+    { "ENVIRON", bf_environ },
+    { "VALUE", bf_value },
+    { "CONCAT", bf_concat },
+    { "APPEND", bf_append },
+    { "AT", bf_at },
+    { "GETTEXT", bf_gettext },
+    { "_", bf_gettext },  // GETTEXTのシノニム
+    { "FORMAT", bf_format },
+    { "FIND", bf_find },
+    { "RANGE", bf_range },
+    { "DUMP", bf_dump },
+    { "TRACE", bf_trace },
+    { "ESCSTR", bf_escstr },
+    { "UNESCSTR", bf_unescstr },
+    { "CALL", bf_call },
+    { "LSORT", bf_lsort },
+    { "ISFUNCTION", bf_isfunction },
+    { "REVERSE", bf_reverse },
+    { "REGEX_REPLACE", bf_regex_replace }, 
+    { "CLEAN", bf_clean },
+    { "DIE", bf_die },
+    { "NOOP", bf_noop },
+    { "", 0 },
+  };
+
+}
Index: /cfg_itronx+oil_gcc/toppers/c_chlit_parser.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/c_chlit_parser.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/c_chlit_parser.cpp	(revision 54)
@@ -0,0 +1,58 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2010 by TAKAGI Nobuhisa  
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*
+ *  toppers/c_chlit_parser.cpp
+ */
+#include "toppers/c_parser.hpp"
+
+namespace toppers
+{
+
+  //! C言語形式の文字定数パーサー（ASCII）
+  boost::spirit::classic::functor_parser< detail::c_chlit_parse_functor< ascii > > const ascii_ch_p;
+
+  //! C言語形式の文字定数パーサー（Shift JIS）
+  boost::spirit::classic::functor_parser< detail::c_chlit_parse_functor< shift_jis > > const shift_jis_ch_p;
+
+  //! C言語形式の文字定数パーサー（EUC-JP）
+  boost::spirit::classic::functor_parser< detail::c_chlit_parse_functor< euc_jp > > const euc_jp_ch_p;
+
+  //! C言語形式の文字定数パーサー（UTF-8）
+  boost::spirit::classic::functor_parser< detail::c_chlit_parse_functor< utf8 > > const utf8_ch_p;
+
+}
Index: /cfg_itronx+oil_gcc/toppers/c_expr.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/c_expr.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/c_expr.hpp	(revision 54)
@@ -0,0 +1,430 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2011 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*!
+ *  \file   toppers/c_expr.hpp
+ *  \brief  C言語の式の構文解析に関する宣言定義
+ *
+ *  このファイルで定義されるクラス
+ *  \code
+ *  struct c_expr_parser_base< Derived >;
+ *  struct c_expr_parser;
+ *  struct c_const_expr_parser;
+ *  \endcode
+ */
+#ifndef TOPPERS_C_EXPR_HPP_
+#define TOPPERS_C_EXPR_HPP_
+
+#include "toppers/c_parser.hpp"
+#include <boost/cstdint.hpp>
+
+namespace toppers
+{
+
+  /*!
+   *  \struct c_expr_parser_base c_expr.hpp "toppers/c_expr.hpp"
+   *  \brief  C言語の式を構文解析するための基底クラス
+   *
+   *  実際に使用する際は、 c_expr_parser_base および c_expr_parser_base::definition
+   *  クラスを派生する必要があります。 c_expr_parser_base::definition の派生クラスでは、
+   *  start メンバ関数を定義して、構文中の必要なルールを取り出すようにしてください。
+   *  こうすることで、定数式の文法、一次式の文法といったように、C言語の文法のサブ
+   *  セットを容易に作り出すことができます。
+   *
+   *  \code
+   *  // 一次式を取り出す例
+   *  struct c_primary_expression : c_expr_parser_base< c_primary_expression >
+   *  {
+   *    template < class Scanner >
+   *    struct definition : c_expr_parser_base< c_primary_expression >::definition
+   *    {
+   *      rule_t const& start() const { return primary_expression; }
+   *    };
+   *  };
+   *  \endcode
+   */
+  template < class Derived >
+    struct c_expr_parser_base : boost::spirit::classic::grammar< Derived >
+  {
+  public:
+    /*!
+     *  \struct definition c_expr.hpp "toppers/c_expr.hpp"
+     *  \brief  文法定義
+     */
+    template < class Scanner >
+      struct definition
+    {
+      typedef boost::spirit::classic::rule< Scanner > rule_t;
+      rule_t  primary_expression,   
+              expression,
+              constant_expression,
+              conditional_expression,
+              assignment_expression,
+              assignment_operator,
+              postfix_expression,
+              unary_expression,
+              unary_operator,
+              cast_expression,
+              multiplicative_expression,
+              additive_expression,
+              shift_expression,
+              relational_expression,
+              equality_expression,
+              AND_expression,
+              exclusive_OR_expression,
+              inclusive_OR_expression,
+              logical_AND_expression,
+              logical_OR_expression,
+              string_literal,
+              constant,
+              floating_constant,
+              decimal_floating_constant,
+              hexadecimal_floating_constant,
+              integer_constant,
+              character_constant,
+              declaration_specifiers,
+              type_name,
+              specifier_qualifier_list,
+              storage_class_specifier,
+              type_specifier,
+              type_qualifier,
+              declarator,
+              direct_declarator,
+              struct_or_union_specifier,
+              struct_declaration,
+              struct_declarator,
+              enum_specifier,
+              enumerator,
+              abstract_declarator,
+              pointer,
+              parameter_type_list,
+              parameter_list,
+              parameter_declaration,
+              direct_abstract_declarator;
+
+      c_ident_parser_t identifier;
+      c_strlit_parser_t c_strlit_p;
+      c_chlit_parser_t c_chlit_p;
+
+      /*!
+       *  \brief  コンストラクタ
+       *  \param  self  文法クラス（ c_expr_parser_base< Derived > クラスからの継承）への参照
+       */
+      definition( Derived const& self )
+        : identifier( c_ident_parser( self.ucn_, self.c_plus_plus_ ) ),
+          c_strlit_p( c_strlit_parser( self.codeset_ ) ),
+          c_chlit_p( c_chlit_parser( self.codeset_ ) )
+      {
+        using namespace boost::spirit::classic;
+        static functor_parser< detail::c_integer_constant_parse_functor< boost::uintmax_t > > const c_int_const_p;
+        static functor_parser< detail::c_integer_suffix_parse_functor > const c_int_suffix_p;
+
+        primary_expression =  // 複合リテラル未対応
+            identifier
+          | constant
+          | string_literal
+          | ( '(' >> expression >> ')' );
+        expression =
+            assignment_expression % ',';
+        constant_expression = 
+            conditional_expression;
+        conditional_expression =
+            logical_OR_expression >> *( '\?' >> expression >> ':' >> logical_OR_expression );
+        assignment_expression =
+           *( unary_expression >> assignment_operator ) >> conditional_expression;
+        assignment_operator =
+            ch_p( '=' ) | "*=" | "/=" | "%=" | "+=" | "?=" | "<<=" | ">>=" | "&=" | "^=" | "|=";
+        postfix_expression =
+            primary_expression >>
+          *(
+                ( '[' >> expression >> ']' )
+              | ( '(' >> list_p( assignment_expression, ',' ) >> ')' )
+              | ( '.' >> identifier )
+              | ( "->" >> identifier )
+              | "++"
+              | "--"
+            );
+        unary_expression =
+           *( str_p( "++" ) || "--" ) >>
+            (
+                ( "sizeof" >> unary_expression )
+              | ( str_p( "sizeof" ) >> '(' >> type_name >> ')' )
+              | postfix_expression
+              | ( unary_operator >> cast_expression )
+            );
+        unary_operator =
+            //chset<>( "&*~!+-" );
+		    ch_p( '&' ) | '*' | '~' | '!' | '+' | '-';
+        cast_expression =
+            *( '(' >> type_name >> ')' ) >> unary_expression
+          | +( '(' >> ( type_name | identifier ) >> ')' );  // 構文解析に失敗する不具合対策
+        multiplicative_expression =
+            cast_expression >>
+           *(
+                ( '*' >> cast_expression )
+              | ( '/' >> cast_expression )
+              | ( '%' >> cast_expression )
+            );
+        additive_expression =
+            multiplicative_expression >>
+           *(
+                ( '+' >> multiplicative_expression )
+              | ( '-' >> multiplicative_expression )
+            );
+        shift_expression =
+            additive_expression >>
+           *(
+                ( "<<" >> additive_expression )
+              | ( ">>" >> additive_expression )
+            );
+        relational_expression =
+            shift_expression >>
+           *(
+                ( '<' >> shift_expression )
+              | ( '>' >> shift_expression )
+              | ( "<=" >> shift_expression )
+              | ( ">=" >> shift_expression )
+            );
+        equality_expression =
+            relational_expression >>
+           *(
+                ( "==" >> relational_expression )
+              | ( "!=" >> relational_expression )
+            );
+        AND_expression =
+            equality_expression >> *( '&' >> equality_expression );
+        exclusive_OR_expression =
+            AND_expression >> *( '^' >> AND_expression );
+        inclusive_OR_expression =
+            exclusive_OR_expression >> *( '|' >> exclusive_OR_expression );
+        logical_AND_expression =
+            inclusive_OR_expression >> *( "&&" >> inclusive_OR_expression );
+        logical_OR_expression =
+            logical_AND_expression >> *( "||" >> logical_AND_expression );
+        string_literal =
+            c_strlit_p
+          | lexeme_d[ 'L' >> c_strlit_p ];
+        constant =
+            floating_constant
+          | integer_constant
+          | identifier  // 列挙定数
+          | character_constant;
+        floating_constant =
+            decimal_floating_constant
+          | hexadecimal_floating_constant;
+        decimal_floating_constant =
+            lexeme_d
+            [
+              as_lower_d
+              [
+                ( ( *digit_p >> '.' >> +digit_p ) | ( +digit_p >> '.' ) ) >>
+//                'e' >> !chset<>( "+-" ) >> +digit_p >>
+				'e' >> !( ch_p( '+' ) | '-' ) >> +digit_p >>
+//                !chset<>( "fl" )
+			    ( ch_p( 'f' ) | 'l' )
+              ]
+            ];
+        hexadecimal_floating_constant =
+            lexeme_d
+            [
+              as_lower_d
+              [
+                "0x" >>
+                ( ( *xdigit_p >> '.' >> +xdigit_p ) | ( +xdigit_p >> '.' ) ) >>
+//                'p' >> !chset<>( "+-" ) >> +digit_p >>
+				'p' >> !( ch_p( '+' ) | '-' ) >> +digit_p >>
+//                !chset<>( "fl" )
+			    ( ch_p( 'f' ) | 'l' )
+              ]
+            ];
+        integer_constant =
+            lexeme_d[ c_int_const_p >> !c_int_suffix_p ];
+        character_constant =
+            c_chlit_p
+          | lexeme_d[ 'L' >> c_chlit_p ];
+        declaration_specifiers =
+           +( storage_class_specifier | type_specifier | type_qualifier );
+        type_name =
+            specifier_qualifier_list >> !abstract_declarator;
+        specifier_qualifier_list =
+           +( type_specifier | type_qualifier );
+        storage_class_specifier =
+            str_p( "auto" )
+          | "register"
+          | "static"
+          | "extern"
+          | "typedef";
+        type_specifier =
+            str_p( "void" ) | "char" | "short" | "int" | "long" | "float" | "double"
+          | "signed" | "unsigned"
+          | identifier
+          | struct_or_union_specifier
+          | enum_specifier;
+        type_qualifier =
+            str_p( "const" ) | "volatile" | "restrict";
+        declarator =
+            !pointer >> direct_declarator;
+        direct_declarator = 
+            ( identifier | ( '(' >> declarator >> ')' ) )
+            >>
+          *(
+                ( '[' >> !constant_expression >> ']' )
+              | ( '(' >> parameter_type_list >> ')' )
+              | ( '(' >> !( identifier % ',' ) >> ')' )
+            );
+        struct_or_union_specifier =
+            lexeme_d[ ( str_p( "struct" ) | "union" ) >> +space_p >> identifier ]
+          | ( lexeme_d[ ( str_p( "struct" ) | "union" ) >> +space_p >> !identifier ] >> '{' >> +struct_declaration >> '}' );
+        struct_declaration =
+            specifier_qualifier_list >> !list_p( struct_declarator, ',' ) >> ';';
+            // lisp_p( struct_declarator, ',' )を省略可能としているのは、
+            // struct_declarator の identifier を specifier_qualifier_list が
+            // typedef 名と間違うことを回避するため
+        struct_declarator =
+            ( !declarator >> ':' >> constant_expression ) // ビットフィールド
+          | declarator;
+        enum_specifier =
+            ( lexeme_d[ "enum" >> +space_p >> !identifier ] >> '{' >> list_p( enumerator, ',', ',' ) >> '}' )   // C99では末尾のカンマがあってもよい
+          | lexeme_d[ "enum" >> +space_p >> identifier ];
+        enumerator =
+            identifier >> !( '=' >> constant_expression );
+        abstract_declarator =
+            ( !pointer >> direct_abstract_declarator )
+          | pointer;
+        pointer =
+           +( '*' >> *type_qualifier );
+        parameter_type_list =
+            parameter_list >> !( ch_p( ',' ) >> "..." );  // 可変個引数
+        parameter_list =
+            parameter_declaration % ',';
+        parameter_declaration = 
+            ( declaration_specifiers >> declarator )
+          | ( declaration_specifiers >> !abstract_declarator );
+        direct_abstract_declarator =
+            (
+             !( '(' >> abstract_declarator >> ')' ) >>
+             +(
+                  ( '[' >> !constant_expression >> ']' )
+                | ( '(' >> !parameter_type_list >> ')' ) 
+              )
+            )
+          | ( '(' >> abstract_declarator >> ')' );
+      }
+    };
+    bool ucn_;
+    codeset_t codeset_;
+    bool c_plus_plus_;
+
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  ucn         国際文字名に対応する場合は true を指定する
+     *  \param  codeset     文字コード
+     *  \param  c_plus_plus C++ に対応する場合は true を指定する
+     */
+    explicit c_expr_parser_base( bool ucn = false, codeset_t codeset = ascii, bool c_plus_plus = false )
+      : ucn_( ucn ), codeset_( codeset ), c_plus_plus_( c_plus_plus )
+    {
+    }
+  };
+
+  /*!
+   *  \class  c_expr_parser c_expr.hpp "toppers/c_expr.hpp" 
+   *  \brief  C言語の式の構文解析クラス
+   */
+  struct c_expr_parser : c_expr_parser_base< c_expr_parser >
+  {
+    typedef c_expr_parser_base< c_expr_parser > base_t;
+
+    /*!
+     *  \struct definition c_expr.hpp "toppers/c_expr.hpp"
+     *  \brief  文法定義
+     */
+    template < class Scanner >
+    struct definition : base_t::definition< Scanner >
+    {
+      typedef typename base_t::definition< Scanner >::rule_t rule_t;
+
+      definition( c_expr_parser const& self ) : base_t::definition< Scanner >( self ) {}
+      rule_t const& start() const { return base_t::definition< Scanner >::expression; };
+    };
+
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  ucn     国際文字名に対応する場合は true を指定する
+     *  \param  codeset 文字コード
+     */
+    explicit c_expr_parser( bool ucn = false, codeset_t codeset = ascii )
+      : c_expr_parser_base< c_expr_parser >( ucn, codeset )
+    {
+    }
+  };
+
+  /*!
+   *  \class  c_const_expr_parser c_expr.hpp "toppers/c_expr.hpp"
+   *  \brief  C言語の定数式の構文解析クラス
+   */
+  struct c_const_expr_parser : c_expr_parser_base< c_const_expr_parser >
+  {
+    typedef c_expr_parser_base< c_const_expr_parser > base_t;
+
+    /*!
+     *  \struct definition c_expr.hpp "toppers/c_expr.hpp"
+     *  \brief  文法定義
+     */
+    template < class Scanner >
+    struct definition : base_t::definition< Scanner >
+    {
+      typedef typename base_t::definition< Scanner >::rule_t rule_t;
+
+      definition( c_const_expr_parser const& self ) : base_t::definition< Scanner >( self ) {}
+      rule_t const& start() const { return base_t::definition< Scanner >::constant_expression; };
+    };
+
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  ucn     国際文字名に対応する場合は true を指定する
+     *  \param  codeset 文字コード
+     */
+    explicit c_const_expr_parser( bool ucn = false, codeset_t codeset = ascii )
+      : c_expr_parser_base< c_const_expr_parser >( ucn, codeset )
+    {
+    }
+  };
+
+}
+
+#endif  // ! TOPPERS_C_EXPR_HPP_
Index: /cfg_itronx+oil_gcc/toppers/c_ident_parser.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/c_ident_parser.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/c_ident_parser.cpp	(revision 54)
@@ -0,0 +1,55 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2010 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*
+ *  toppers/c_ident_parser.cpp
+ */
+#include "toppers/c_parser.hpp"
+
+namespace toppers
+{
+
+  //! C90形式の識別子パーサー
+  boost::spirit::classic::functor_parser< detail::c_identifier_parse_functor > const c_ident_p;
+
+  //! C99形式の識別子パーサー
+  boost::spirit::classic::functor_parser< detail::c_identifier_parse_functor > const c99_ident_p( detail::c_identifier_parse_functor( true ) );
+
+  //! C++形式の識別子パーサー
+  boost::spirit::classic::functor_parser< detail::c_identifier_parse_functor > const c_plus_plus_ident_p( detail::c_identifier_parse_functor( true, true ) );
+
+}
Index: /cfg_itronx+oil_gcc/toppers/c_int_parser.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/c_int_parser.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/c_int_parser.cpp	(revision 54)
@@ -0,0 +1,52 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2010 by TAKAGI Nobuhisa  
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*
+ *  toppers/c_int_parser.cpp
+ */
+#include "toppers/c_parser.hpp"
+
+namespace toppers
+{
+
+  //! C言語形式のint型定数パーサ
+  boost::spirit::classic::functor_parser< detail::c_integer_parse_functor< int > > const c_int_p;
+
+  //! C言語形式のunsigned int型定数パーサ
+  boost::spirit::classic::functor_parser< detail::c_integer_parse_functor< unsigned int > > const c_uint_p;
+
+}
Index: /cfg_itronx+oil_gcc/toppers/c_keywords.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/c_keywords.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/c_keywords.cpp	(revision 54)
@@ -0,0 +1,63 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2010 by TAKAGI Nobuhisa  
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*
+ *  toppers/c_keyword.cpp
+ */
+
+namespace toppers
+{
+
+  namespace detail
+  {
+
+    extern char const* const c_keywords[];
+
+    char const* const c_keywords[] =
+    {
+      "_Bool", "_Complex", "_Imaginary", "auto", "break", "case", "char", "const",
+      "continue", "default", "do", "double", "else", "enum", "extern", "float",
+      "for", "goto", "if", "inline", "int", "long" "register", "restrict", "return",
+      "short", "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned",
+      "void", "volatile", "while",
+      "_Decimal", "_Fract", "_Accum", "_Sat",
+      0,
+    };
+
+  }
+  
+}
Index: /cfg_itronx+oil_gcc/toppers/c_parser.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/c_parser.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/c_parser.hpp	(revision 54)
@@ -0,0 +1,555 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2010 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*!
+ *  \file   toppers/c_parser.hpp
+ *  \brief  一般的なパーサーの宣言定義
+ */
+#ifndef TOPPERS_PARSER_HPP_
+#define TOPPERS_PARSER_HPP_
+
+#include "toppers/codeset.hpp"
+#include <boost/spirit/include/classic_core.hpp>
+#include <boost/spirit/include/classic_actor.hpp>
+#include <boost/spirit/include/classic_utility.hpp>
+#include <boost/spirit/include/classic_dynamic.hpp>
+
+namespace toppers
+{
+
+  namespace detail
+  {
+
+    struct c_integer_suffix_parse_functor
+    {
+      typedef boost::spirit::classic::nil_t result_t;
+      template < class Scanner >
+      int operator()( Scanner scan, result_t& ) const
+      {
+        using namespace boost::spirit::classic;
+        int length =
+                  as_lower_d
+                  [
+                      ch_p( 'u' ) >> !( str_p( "ll" ) | 'l' | "i8" | "i16" | "i32" | "i64" )
+                    | ( str_p( "ll" ) | 'l' | "i8" | "i16" | "i32" | "i64" ) >> !ch_p( 'u' )
+                  ].parse( scan ).length();
+        return length;
+      }
+    };
+
+    template < typename T >
+    struct c_integer_constant_parse_functor
+    {
+      typedef T result_t;
+      template < class Scanner >
+      int operator()( Scanner scan, result_t& result ) const
+      {
+        using namespace boost::spirit::classic;
+        result_t x = T( 0 );
+        int length =
+                  (
+                    if_p( '0' ) // 16進または8進
+                    [
+                      !(
+                          ( ch_p( 'x' ) | 'X' ) >> uint_parser< T, 16 >()[ assign_a( x ) ]
+                        | uint_parser< T, 8 >()[ assign_a( x ) ]
+                      )
+                    ]
+                    .else_p // 10進
+                    [
+                      uint_parser< T, 10 >()[ assign_a( x ) ]
+                    ]
+                  ).parse( scan ).length();
+        result = x;
+        return length;
+      }
+    };
+
+    template < typename T >
+    struct c_integer_parse_functor
+    {
+      typedef T result_t;
+      template < class Scanner >
+      int operator()( Scanner scan, result_t& result ) const
+      {
+        using namespace boost::spirit::classic;
+        static functor_parser< c_integer_constant_parse_functor< T > > const c_int_const_p;
+        static functor_parser< c_integer_suffix_parse_functor > const c_int_suffix_p;
+        bool negative = false;
+        result_t x;
+        int length =
+                  (
+                    !sign_p[ assign_a( negative ) ] >> lexeme_d[ c_int_const_p[ assign_a( x ) ] >> !c_int_suffix_p ]
+                  ).parse( scan ).length();
+        result = ( negative ? -x : x );
+        return length;
+      }
+    };
+
+    template < int CodeSet = -1 > struct mbchar_parse_functor;
+
+    template <>
+    struct mbchar_parse_functor< ascii >
+    {
+      typedef boost::spirit::classic::nil_t result_t;
+      template < class Scanner >
+      int operator()( Scanner scan, result_t& ) const
+      {
+        return boost::spirit::classic::range_p( '\x01', '\x7f' ).parse( scan ).length();
+      }
+    };
+
+    template <>
+    struct mbchar_parse_functor< shift_jis >
+    {
+      typedef boost::spirit::classic::nil_t result_t;
+      template < class Scanner >
+      int operator()( Scanner scan, result_t& ) const
+      {
+        using namespace boost::spirit::classic;
+        int length =
+                (
+                    range_p( '\x01', '\x7f' ) // 半角英数字記号
+                  | range_p( '\xa1', '\xdf' ) // 半角カタカナ
+                  | ( chset<>( "\x81-\x9f\xe0-\xef" ) >> chset<>( "\x40-\x7e\x80-\xfc" ) )  // 全角
+                ).parse( scan ).length();
+        return length;
+      }
+    };
+
+    template <>
+    struct mbchar_parse_functor< euc_jp >
+    {
+      typedef boost::spirit::classic::nil_t result_t;
+      template < class Scanner >
+      int operator()( Scanner scan, result_t& ) const
+      {
+        using namespace boost::spirit::classic;
+        int length =
+                (
+                    range_p( '\x01', '\x7f' ) // 半角英数字記号
+                  | ( ch_p( '\x8e' ) >> range_p( '\xa1', '\xdf' ) )   // 半角カタカナ
+                  | ( !ch_p( '\x8f' ) >> range_p( '\xa1', '\xf0' ) >> range_p( '\xa1', '\xf0' ) ) // 全角
+                ).parse( scan ).length();
+        return length;
+      }
+    };
+
+    template <>
+    struct mbchar_parse_functor< utf8 >
+    {
+      typedef boost::spirit::classic::nil_t result_t;
+      template < class Scanner >
+      int operator()( Scanner scan, result_t& ) const
+      {
+        using namespace boost::spirit::classic;
+        int length =
+                (
+                    range_p( '\x01', '\x7f' ) // 1バイト
+                  | ( range_p( '\xc0', '\xdf' ) >> range_p( '\x80', '\xbf' ) )  // 2バイト
+                  | ( range_p( '\xe0', '\xef' ) >> repeat_p( 2 )[ range_p( '\x80', '\xbf' ) ] ) // 3バイト
+                  | ( range_p( '\xf0', '\xf7' ) >> repeat_p( 3 )[ range_p( '\x80', '\xbf' ) ] ) // 4バイト
+                  | ( range_p( '\xf8', '\xfb' ) >> repeat_p( 4 )[ range_p( '\x80', '\xbf' ) ] ) // 5バイト
+                  | ( range_p( '\xfc', '\xfd' ) >> repeat_p( 5 )[ range_p( '\x80', '\xbf' ) ] ) // 6バイト
+                ).parse( scan ).length();
+        return length;
+      }
+    };
+
+    template <>
+    struct mbchar_parse_functor< -1 >
+    {
+      typedef boost::spirit::classic::nil_t result_t;
+      explicit mbchar_parse_functor( codeset_t codeset = ascii ) : codeset_( codeset ) {}
+      template < class Scanner >
+      int operator()( Scanner scan, result_t& result ) const
+      {
+        int length;
+        switch ( codeset_ )
+        {
+        case ascii:
+          {
+            static mbchar_parse_functor< ascii > f;
+            length = f( scan, result );
+          }
+          break;
+        case shift_jis:
+          {
+            static mbchar_parse_functor< shift_jis > f;
+            length = f( scan, result );
+          }
+          break;
+        case euc_jp:
+          {
+            static mbchar_parse_functor< euc_jp > f;
+            length = f( scan, result );
+          }
+          break;
+        case utf8:
+          {
+            static mbchar_parse_functor< utf8 > f;
+            length = f( scan, result );
+          }
+          break;
+        default:
+          length = -1;
+          break;
+        }
+        return length;
+      }
+      codeset_t codeset_;
+    };
+
+    struct ucn_parse_functor
+    {
+      typedef long result_t;
+      template < class Scanner >
+      int operator()( Scanner scan, result_t& result ) const
+      {
+        using namespace boost::spirit::classic;
+        result_t x;
+        int length =
+                (
+                  lexeme_d
+                  [
+                      ch_p( '\\' ) >>
+                      (
+                          ( 'U' >> int_parser< long, 16, 8, 8 >()[ assign_a( x ) ] )  // \Uhhhhhhhh形式
+                        | ( 'u' >> int_parser< long, 16, 4, 4 >()[ assign_a( x ) ] )  // \uhhhh形式
+                      )
+                  ]
+                ).parse( scan ).length();
+        if ( ( x < 0xa0 && !( x == 0x24 || x == 0x40 || x == 0x60 ) )
+          || ( 0xd800 <= x && x <= 0xdfff ) 
+          || 0x10ffff < x ) // 国際文字名に使えない値（JIS X3010:2003 6.4.3）
+        {
+          x = -1;
+        }
+        result = x;
+        return length;
+      }
+    };
+
+    template < int CodeSet = -1 > struct c_strlit_parse_functor;
+
+    template < int CodeSet >
+    struct c_strlit_parse_functor
+    {
+      typedef boost::spirit::classic::nil_t result_t;
+      template < class Scanner >
+      int operator()( Scanner scan, result_t& result ) const
+      {
+        using namespace boost::spirit::classic;
+        static functor_parser< detail::mbchar_parse_functor< CodeSet > > const mbchar_p;
+        static functor_parser< detail::ucn_parse_functor > const ucn_p;
+        int length =
+                (
+                  confix_p( '\"', *( "\\\"" | mbchar_p - '\\' | ucn_p | c_escape_ch_p ), '\"' )
+                ).parse( scan ).length();
+        return length;
+      }
+    };
+
+    template <>
+    struct c_strlit_parse_functor< -1 >
+    {
+      typedef boost::spirit::classic::nil_t result_t;
+      explicit c_strlit_parse_functor( codeset_t codeset = ascii ) : codeset_( codeset ) {}
+      template < class Scanner >
+      int operator()( Scanner scan, result_t& result ) const
+      {
+        using namespace boost::spirit::classic;
+        mbchar_parse_functor<> const functor( codeset_ );
+        functor_parser< detail::mbchar_parse_functor<> > const mbchar_p( functor );
+        static functor_parser< detail::ucn_parse_functor > const ucn_p;
+        int length =
+                (
+                  confix_p( '\"', *( "\\\"" | ( mbchar_p - ch_p( '\\' ) ) | ucn_p | c_escape_ch_p ), '\"' )
+                ).parse( scan ).length();
+        return length;
+      }
+      codeset_t codeset_;
+    };
+
+    template < int CodeSet = -1 > struct c_chlit_parse_functor;
+
+    template < int CodeSet >
+    struct c_chlit_parse_functor
+    {
+      typedef boost::spirit::classic::nil_t result_t;
+      template < class Scanner >
+      int operator()( Scanner scan, result_t& result ) const
+      {
+        using namespace boost::spirit::classic;
+        static functor_parser< detail::mbchar_parse_functor< CodeSet > > const mbchar_p;
+        static functor_parser< detail::ucn_parse_functor > const ucn_p;
+        int length =
+                (
+                  confix_p( '\'', +( "\\\'" | mbchar_p - '\\' | ucn_p | c_escape_ch_p ), '\'' )
+                ).parse( scan ).length();
+        return length;
+      }
+    };
+
+    template <>
+    struct c_chlit_parse_functor< -1 >
+    {
+      typedef boost::spirit::classic::nil_t result_t;
+      explicit c_chlit_parse_functor( codeset_t codeset = ascii ) : codeset_( codeset ) {}
+      template < class Scanner >
+      int operator()( Scanner scan, result_t& result ) const
+      {
+        using namespace boost::spirit::classic;
+        mbchar_parse_functor<> const functor( codeset_ );
+        functor_parser< detail::mbchar_parse_functor<> > const mbchar_p( functor );
+        static functor_parser< detail::ucn_parse_functor > const ucn_p;
+        int length =
+                (
+                  confix_p( '\'', +( "\\\'" | mbchar_p - '\\' | ucn_p | c_escape_ch_p ), '\'' )
+                ).parse( scan ).length();
+        return length;
+      }
+      codeset_t codeset_;
+    };
+
+    extern char const* const c_keywords[];
+    extern char const* const c_plus_plus_keywords[];
+
+    struct c_identifier_parse_functor
+    {
+      typedef boost::spirit::classic::nil_t result_t;
+      template < class Scanner >
+      int operator()( Scanner scan, result_t& result ) const
+      {
+        using namespace boost::spirit::classic;
+        static functor_parser< detail::ucn_parse_functor > const ucn_p;
+        int length;
+        typename Scanner::iterator_t const first( scan.first );
+
+        if ( ucn_ )
+        {
+          length =
+                (
+                  lexeme_d
+                  [
+                    ( alpha_p | '_' | ucn_p ) >>
+                   *( alnum_p | '_' | ucn_p )
+                  ]
+                ).parse( scan ).length();
+        }
+        else
+        {
+          length =
+                (
+                  lexeme_d
+                  [
+                     ( alpha_p | '_' ) >>
+                    *( alnum_p | '_' )
+                  ]
+                ).parse( scan ).length();
+        }
+        std::string token( first, scan.first );
+
+        for ( int i = 0; c_keywords[i] != 0; i++ )
+        {
+          if ( token == c_keywords[i] )
+          {
+            length = -1;
+            break;
+          }
+        }
+        if ( c_plus_plus_ )
+        {
+          for ( int i = 0; c_plus_plus_keywords[i] != 0; i++ )
+          {
+            if ( token == c_plus_plus_keywords[i] )
+            {
+              length = -1;
+              break;
+            }
+          }
+        }
+        return length;
+      }
+      explicit c_identifier_parse_functor( bool ucn = false, bool c_plus_plus = false )
+        : ucn_( ucn ), c_plus_plus_( c_plus_plus )
+      {
+      }
+
+      bool ucn_;
+      bool c_plus_plus_;
+    };
+
+  }
+
+  /*!
+   *  \brief  C言語形式の整数定数パーサー
+   *
+   *  boost::spirit::int_parserとの違いは、接頭辞に応じて8進数や16進数として解釈
+   *  する点です。また型を特定するための接尾辞も受け入れます。
+   */
+  template < typename T >
+  inline boost::spirit::classic::functor_parser< detail::c_integer_parse_functor< T > > const c_int_parser()
+  {
+    return boost::spirit::classic::functor_parser< detail::c_integer_parse_functor< T > >();
+  }
+
+  extern boost::spirit::classic::functor_parser< detail::c_integer_parse_functor< int > > const c_int_p;
+  extern boost::spirit::classic::functor_parser< detail::c_integer_parse_functor< unsigned int > > const c_uint_p;
+
+  /*!
+   *  \brief  マルチバイト文字パーサー
+   *
+   *  テンプレート引数 CodeSet で指定した文字コードを解析します。
+   *  ascii 以外を指定した場合でも、ASCIIの範囲（0x7f以下）にも合致します。
+   *  0x00 は文字列の終端と区別できないため、合致対象にはなりません。
+   */
+  template < int CodeSet >
+  inline boost::spirit::classic::functor_parser< detail::mbchar_parse_functor< CodeSet > > const mbchar_parser()
+  {
+    return boost::spirit::classic::functor_parser< detail::mbchar_parse_functor< CodeSet > >();
+  }
+  inline boost::spirit::classic::functor_parser< detail::mbchar_parse_functor<> > const mbchar_parser( codeset_t codeset )
+  {
+    return boost::spirit::classic::functor_parser< detail::mbchar_parse_functor<> >( detail::mbchar_parse_functor<>( codeset ) );
+  }
+
+  extern boost::spirit::classic::functor_parser< detail::mbchar_parse_functor< ascii > > const ascii_p;
+  extern boost::spirit::classic::functor_parser< detail::mbchar_parse_functor< shift_jis > > const shift_jis_p;
+  extern boost::spirit::classic::functor_parser< detail::mbchar_parse_functor< euc_jp > > const euc_jp_p;
+  extern boost::spirit::classic::functor_parser< detail::mbchar_parse_functor< utf8 > > const utf8_p;
+
+  /*!
+   *  \brief  国際文字名パーサー
+   *
+   *  \\uまたは\\Uで始まる国際文字名（Universal Character Name）を解析します。
+   *  \\uhhhhまたは\\Uhhhhhhhh（hは16進数字）に合致します。なお、これらの形式に
+   *  合致している場合でも、一部の値は国際文字名として使用できません。
+   */
+  inline boost::spirit::classic::functor_parser< detail::ucn_parse_functor > const ucn_parser()
+  {
+    return boost::spirit::classic::functor_parser< detail::ucn_parse_functor >();
+  }
+
+  extern boost::spirit::classic::functor_parser< detail::ucn_parse_functor > const ucn_p;
+
+  /*!
+   *  \brief  C言語形式の文字列定数パーサー
+   *
+   *  二重引用符で囲まれたC言語形式の文字列を解析します。
+   *  文字列の文字コードは CodeSet で指定したものになります。
+   */
+  template < int CodeSet >
+  inline boost::spirit::classic::functor_parser< detail::c_strlit_parse_functor< CodeSet > > const c_strlit_parser()
+  {
+    return boost::spirit::classic::functor_parser< detail::c_strlit_parse_functor< CodeSet > >();
+  }
+
+  typedef boost::spirit::classic::functor_parser< detail::c_strlit_parse_functor<> > c_strlit_parser_t;
+
+  /*!
+   *  \brief  C言語形式の文字列定数パーサー
+   *  \param  codeset 文字列に使用されている文字コード
+   *
+   *  二重引用符で囲まれたC言語形式の文字列を解析します。
+   */
+  inline boost::spirit::classic::functor_parser< detail::c_strlit_parse_functor<> > const c_strlit_parser( codeset_t codeset )
+  {
+    return boost::spirit::classic::functor_parser< detail::c_strlit_parse_functor<> >( detail::c_strlit_parse_functor<>( codeset ) );
+  }
+
+  extern boost::spirit::classic::functor_parser< detail::c_strlit_parse_functor< ascii > > const ascii_str_p;
+  extern boost::spirit::classic::functor_parser< detail::c_strlit_parse_functor< shift_jis > > const shift_jis_str_p;
+  extern boost::spirit::classic::functor_parser< detail::c_strlit_parse_functor< euc_jp > > const euc_jp_str_p;
+  extern boost::spirit::classic::functor_parser< detail::c_strlit_parse_functor< utf8 > > const utf8_str_p;
+
+  /*!
+   *  \brief  C言語形式の文字定数パーサー
+   *
+   *  単引用符で囲まれたC言語形式の文字定数を解析します。
+   *  文字コードは CodeSet で指定したものになります。
+   */
+  template < int CodeSet >
+  inline boost::spirit::classic::functor_parser< detail::c_chlit_parse_functor< CodeSet > > const c_chlit_parser()
+  {
+    return boost::spirit::classic::functor_parser< detail::c_chlit_parse_functor< CodeSet > >();
+  }
+
+  typedef boost::spirit::classic::functor_parser< detail::c_chlit_parse_functor<> > c_chlit_parser_t;
+
+  /*!
+   *  \brief  C言語形式の文字定数パーサー
+   *  \param  codeset 文字コード
+   *
+   *  単引用符で囲まれたC言語形式の文字定数を解析します。
+   */
+  inline boost::spirit::classic::functor_parser< detail::c_chlit_parse_functor<> > const c_chlit_parser( codeset_t codeset )
+  {
+    return boost::spirit::classic::functor_parser< detail::c_chlit_parse_functor<> >( detail::c_chlit_parse_functor<>( codeset ) );
+  }
+
+  extern boost::spirit::classic::functor_parser< detail::c_chlit_parse_functor< ascii > > const ascii_ch_p;
+  extern boost::spirit::classic::functor_parser< detail::c_chlit_parse_functor< shift_jis > > const shift_jis_ch_p;
+  extern boost::spirit::classic::functor_parser< detail::c_chlit_parse_functor< euc_jp > > const euc_jp_ch_p;
+  extern boost::spirit::classic::functor_parser< detail::c_chlit_parse_functor< utf8 > > const utf8_ch_p;
+
+  typedef boost::spirit::classic::functor_parser< detail::c_identifier_parse_functor > c_ident_parser_t;
+
+  /*!
+   *  \brief  C言語形式の識別子パーサー
+   *  \param  ucn         国際文字を許容する場合は true を指定
+   *  \param  c_plus_plus C++の予約語を禁止する場合は true を指定
+   *
+   *  C言語の識別子として使用できる文字列の解析を行います。
+   *  識別子は下線または英文字で始まり、下線または英数字が続くのが原則ですが、
+   *  C99以降では国際文字名も使用できるため、引数 ucn に true を指定することで、
+   *  国際文字名対応が可能になります。
+   *
+   *  \note 翻訳限界および予約識別子の判別は行っていません。
+   */
+  inline boost::spirit::classic::functor_parser< detail::c_identifier_parse_functor > const c_ident_parser( bool ucn = false, bool c_plus_plus = false )
+  {
+    return boost::spirit::classic::functor_parser< detail::c_identifier_parse_functor >( detail::c_identifier_parse_functor( ucn, c_plus_plus ) );
+  }
+
+  extern boost::spirit::classic::functor_parser< detail::c_identifier_parse_functor > const c_ident_p;
+  extern boost::spirit::classic::functor_parser< detail::c_identifier_parse_functor > const c99_ident_p;
+  extern boost::spirit::classic::functor_parser< detail::c_identifier_parse_functor > const c_plus_plus_ident_p;
+
+}
+
+#endif  // ! TOPPERS_PARSER_HPP_
Index: /cfg_itronx+oil_gcc/toppers/c_plus_plus_keywords.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/c_plus_plus_keywords.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/c_plus_plus_keywords.cpp	(revision 54)
@@ -0,0 +1,62 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2010 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*
+ *  toppers/c_plus_plus_keywords.cpp
+ */
+
+namespace toppers
+{
+  namespace detail
+  {
+
+    extern char const* const c_plus_plus_keywords[];
+
+    char const* const c_plus_plus_keywords[] =
+    {
+      "and", "and_eq", "asm", "bitand", "bitor", "bool", "catch", "class", "compl",
+      "const_cast", "delete", "dynamic_cast", "explicit", "false", "friend", "namespace",
+      "new", "not", "not_eq", "operator", "or", "or_eq", "private", "protected",
+      "public", "reinterpret_cast", "static_cast", "this", "throw", "true", "try",
+      "typeid", "using", "virtual", "wchar_t", "xor", "xor_eq",
+      "alignof", "axiom", "char16_t", "char32_t", "constexpr", "decltype", "late_check",
+      "nullptr", "requires", "static_assert", "thread_local",
+      0
+    };
+
+  }
+}
Index: /cfg_itronx+oil_gcc/toppers/c_pp_line.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/c_pp_line.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/c_pp_line.hpp	(revision 54)
@@ -0,0 +1,189 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2010 by TAKAGI Nobuhisa  
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*!
+ *  \file   toppers/c_pp_line.hpp
+ *  \brief  \#line指令に関する宣言定義
+ */
+#ifndef TOPPERS_C_PP_LINE_HPP_
+#define TOPPERS_C_PP_LINE_HPP_
+
+#include "toppers/text_line.hpp"
+#include "toppers/c_parser.hpp"
+#include "toppers/workaround.hpp"
+#include <vector>
+#include <functional>
+
+namespace toppers
+{
+
+  namespace detail
+  {
+
+    //! \#line 指令の構文解析
+    struct c_pp_line_parser : boost::spirit::grammar< c_pp_line_parser >
+    {
+      template < class Scanner >
+      struct definition
+      {
+        typedef boost::spirit::rule< Scanner > rule_t;
+        rule_t r;
+        definition( c_pp_line_parser const& self )
+        {
+          using namespace boost::spirit;
+          r = (
+                '#' >> lexeme_d[ str_p( "line" ) >> space_p >> uint_p[ assign_a( self.line_ ) ] ] >>
+                c_strlit_parser( self.codeset_ )[ assign_a( self.file_ ) ]
+              )
+            | (
+                '#' >>
+                uint_p[ assign_a( self.line_ ) ] >>
+                c_strlit_parser( self.codeset_ )[ assign_a( self.file_ ) ] >>
+                *anychar_p
+              );
+        }
+        rule_t const& start() const { return r; }
+      };
+
+      c_pp_line_parser( long& line, std::string& file, codeset_t codeset = ascii )
+        : line_( line ), file_( file ), codeset_( codeset )
+      {
+      }
+
+      long& line_;
+      std::string& file_;
+      codeset_t codeset_;
+    };
+
+    //! \#pragma 指令の構文解析
+    struct c_pp_pragma_parser : boost::spirit::grammar< c_pp_pragma_parser >
+    {
+      template < class Scanner >
+      struct definition
+      {
+        typedef boost::spirit::rule< Scanner > rule_t;
+        rule_t r;
+        definition( c_pp_pragma_parser const& self )
+        {
+          using namespace boost::spirit;
+          r = '#' >> lexeme_d[ str_p( "pragma" ) >> space_p >> ( +anychar_p )[ assign_a( self.parameter_ ) ] ];
+        }
+        rule_t const& start() const { return r; }
+      };
+
+      c_pp_pragma_parser( std::string& parameter ) : parameter_( parameter )
+      {
+      }
+      std::string& parameter_;
+    };
+
+  }
+
+  /*!
+   *  \class  c_pp_line c_pp_line.hpp "toppers/c_pp_line.hpp"
+   *  \brief  \#line指令を処理させるためのファンクタクラス
+   *
+   *  このクラスは basic_text クラスと組み合わせて使用します。
+   */
+  template < class Container >
+  class c_pp_line : public std::binary_function< Container, line_buf, void >
+  {
+  public:
+    typedef Container conatiner;
+
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  codeset 文字コード指定
+     */
+    explicit c_pp_line( codeset_t codeset = ascii )
+      : codeset_( codeset ), pragmas_( new std::vector< line_buf > )
+    {
+    }
+    /*!
+     *  \brief  括弧演算子
+     *  \param  cont  line_buf を要素とするコンテナ
+     *  \param  buf   1行バッファ
+     */
+    void operator()( conatiner& cont, line_buf& buf )
+    {
+      using namespace boost::spirit;
+      long line;
+      std::string file;
+      detail::c_pp_line_parser c_pp_line_p( line, file, codeset_ );
+
+      if ( parse( buf.buf.begin(), buf.buf.end(), c_pp_line_p, space_p ).full ) // #line指令の処理
+      {
+        buf.line.line = line;
+        assert( file.size() >= 2 );
+        buf.line.file = file.substr( 1, file.size()-2 );
+      }
+      else
+      {
+        std::string param;
+        detail::c_pp_pragma_parser c_pp_pragma_p( param );
+
+        if ( parse( buf.buf.begin(), buf.buf.end(), c_pp_pragma_p, space_p ).full ) // #pragma指令の処理
+        {
+          line_buf t( buf );
+          t.buf = param;
+          pragmas_->push_back( t );
+        }
+        else
+        {
+          std::string::size_type pos = buf.buf.find_first_not_of( " \t" );
+          if ( pos == std::string::npos || buf.buf[pos] != '#' )
+          {
+            cont.push_back( buf );
+          }
+          ++buf.line.line;
+        }
+      }
+      buf.buf.clear();
+    }
+    /*!
+     *  \brief  \#pragma指令リストの取得
+     *  \return \#pragma指令リストを返す
+     */
+    std::vector< line_buf > const& pragmas() const { return *pragmas_; }
+  private:
+    codeset_t codeset_;
+    std::tr1::shared_ptr< std::vector< line_buf > > pragmas_;
+  };
+
+}
+
+#endif  // ! TOPPERS_C_PP_LINE_HPP_
Index: /cfg_itronx+oil_gcc/toppers/c_strlit_parser.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/c_strlit_parser.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/c_strlit_parser.cpp	(revision 54)
@@ -0,0 +1,58 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2010 by TAKAGI Nobuhisa  
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*
+ *  toppers/c_strlit_parser.cpp
+ */
+#include "toppers/c_parser.hpp"
+
+namespace toppers
+{
+
+  //! C言語形式の文字列定数パーサー（ASCII）
+  boost::spirit::classic::functor_parser< detail::c_strlit_parse_functor< ascii > > const ascii_str_p;
+
+  //! C言語形式の文字列定数パーサー（ShiftJIS）
+  boost::spirit::classic::functor_parser< detail::c_strlit_parse_functor< shift_jis > > const shift_jis_str_p;
+
+  //! C言語形式の文字列定数パーサー（EUC-JP）
+  boost::spirit::classic::functor_parser< detail::c_strlit_parse_functor< euc_jp > > const euc_jp_str_p;
+
+  //! C言語形式の文字列定数パーサー（UTF-8）
+  boost::spirit::classic::functor_parser< detail::c_strlit_parse_functor< utf8 > > const utf8_str_p;
+
+}
Index: /cfg_itronx+oil_gcc/toppers/codeset.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/codeset.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/codeset.hpp	(revision 54)
@@ -0,0 +1,85 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*!
+ *  \file   toppers/codeset.hpp
+ *  \brief  文字コード種別に関する宣言定義
+ */
+#ifndef TOPPERS_CODESET_HPP_
+#define TOPPERS_CODESET_HPP_
+
+#include "toppers/config.hpp"
+
+namespace toppers
+{
+
+  /*!
+   *  \enum   codeset_t
+   *  \brief  文字コード種別
+   *
+   *  現状では日本語のみを考慮しています。
+   */
+  enum codeset_t
+  {
+    ascii,
+    shift_jis,
+    euc_jp,
+    utf8
+  };
+
+  template < codeset_t Codeset >
+    inline bool is_lead( char c )
+  {
+    return static_cast< unsigned char >( c ) & 0x80;
+  }
+
+  template <>
+    inline bool is_lead< shift_jis >( char c )
+  {
+    int ch = static_cast< unsigned char >( c );
+    return ( 0x81 <= ch && ch <= 0x9f ) || ( 0xe0 <= ch && ch <= 0xef );
+  }
+
+  template <>
+    inline bool is_lead< utf8 >( char c )
+  {
+    return ( static_cast< unsigned char >( c ) & 0xc0 ) != 0;
+  }
+
+}
+
+#endif  // ! TOPPERS_CODESET_HPP_
Index: /cfg_itronx+oil_gcc/toppers/config.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/config.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/config.hpp	(revision 54)
@@ -0,0 +1,90 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2004 by Witz Corporation, JAPAN    
+ *  Copyright (C) 2005-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*!
+ *  \file   toppers/config.hpp
+ *  \brief  処理系に依存する設定
+ */
+#ifndef	TOPPERS_CONFIG_HPP_
+#define	TOPPERS_CONFIG_HPP_
+
+#ifdef _MSC_VER
+
+# define for			if(0);else for
+
+# pragma warning( disable: 4127 )
+# pragma warning( disable: 4239 )
+# pragma warning( disable: 4505 )
+# pragma warning( disable: 4511 )
+# pragma warning( disable: 4512 )
+# pragma warning( disable: 4630 )
+# pragma warning( disable: 4701 )
+# pragma warning( disable: 4786 )
+# pragma warning( disable: 4819 )
+# pragma warning( disable: 4996 )
+
+#define _SCL_SECURE_NO_WARNINGS   1
+
+#endif	// _MSC_VER
+
+#ifdef __BORLANDC__
+
+#pragma warn -8026
+#pragma warn -8027
+
+#endif  // __BORLANDC__
+
+#ifdef __GNUC__
+
+# if __GNUC__ > 4 || ( __GNUC__ == 4 && __GNUC_MINOR__ >= 1 )
+#   if __GNUC__ == 4 && __GNUC_MINOR__ < 3
+//#     define TOPPERS_HAS_TR1_LIBRARY	1
+#   endif
+# endif
+
+# define TOPPERS_HAS_ICONV	1
+
+#endif	// __GNUC__
+
+#if defined(unix) || defined(__unix) || defined(__unix__)
+
+# define TOPPERS_HAS_ICONV	1
+
+#endif	// UNIX
+
+#endif	// ! TOPPERS_CONFIG_HPP_
Index: /cfg_itronx+oil_gcc/toppers/cpp.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/cpp.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/cpp.cpp	(revision 54)
@@ -0,0 +1,198 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2011 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <cctype>
+#include <cstring>
+#include <cstdio>
+#include <stdexcept>
+#include <iostream>
+#include "toppers/cpp.hpp"
+
+namespace toppers
+{
+
+  /*!
+   *  \brief  二重引用符で囲まれた文字列を展開する。
+   */
+  std::string expand_quote( std::string const& str )
+  {
+    // boost-1.35.x以上対策
+    std::string::size_type n = str.find_first_not_of( " \t\r\n" );
+    std::string quoted( str, n );
+
+    if ( quoted.size() < 2 || quoted[0] != '"' || quoted[quoted.size() - 1] != '"' )
+    {
+      throw std::invalid_argument( "argument is not quoted" );
+    }
+    std::string result;
+    for ( std::string::const_iterator iter( quoted.begin() + 1 ), last( quoted.end() - 1 );
+          iter != last;
+          ++iter )
+    {
+      if ( *iter == '\\' )
+      {
+        if ( ++iter == last )
+        {
+          throw std::invalid_argument( "argument is not quoted" );
+        }
+        char c = *iter;
+        switch ( c )
+        {
+        case 'a':
+          c = '\a';
+          break;
+        case 'b':
+          c = '\b';
+          break;
+        case 'f':
+          c = '\f';
+          break;
+        case 'n':
+          c = '\n';
+          break;
+        case 'r':
+          c = '\r';
+          break;
+        case 't':
+          c = '\t';
+          break;
+        case 'v':
+          c = '\v';
+          break;
+        case 'x':
+          if ( std::isxdigit( static_cast< unsigned char >( *iter ) ) )
+          {
+            c = 0;
+            for ( std::string::const_iterator bound( iter + 2 );
+                  iter != bound && std::isxdigit( static_cast< unsigned char >( *iter ) );
+                  ++iter )
+            {
+              c <<= 4;
+              int t = std::tolower( static_cast< unsigned char >( *iter ) );
+              static char const xdigits[] = "0123456789abcdef";
+              c += std::strchr( xdigits, t ) - xdigits;
+            }
+          }
+          break;
+        default:
+          if ( '0' <= c && c <= '7' ) // '\ooo'
+          {
+            c = 0;
+            for ( std::string::const_iterator bound( iter + 3 );
+                  iter != bound && ( '0' <= *iter && *iter <= '7' );
+                  ++iter )
+            {
+              c = ( c << 3 ) + *iter - '0';
+            }
+          }
+          // 国際文字名（\uhhhh, \Uhhhhhhhh）未対応
+          // 二文字表記（<:等）未対応
+          // 三文字表記（??/等）未対応
+          break;
+        }
+        result.push_back( c );
+      }
+      else
+      {
+        result.push_back( *iter );
+      }
+    }
+    return result;
+  }
+
+  /*!
+   *  \brief  文字列で二重引用符で囲む
+   */
+  std::string quote_string( std::string const& str )
+  {
+    std::string result;
+    result.reserve( str.size() + 2 );
+
+    result.push_back( '"' );  // open
+
+    for ( std::string::const_iterator iter( str.begin() ), last( str.end() );
+          iter != last;
+          ++iter )
+    {
+      switch ( char c = *iter )
+      {
+      case '\'':
+        result += "\\\'";
+        break;
+      case '\"':
+        result += "\\\"";
+        break;
+      case '\0':
+        result += "\\0";
+        break;
+      case '\a':
+        result += "\\a";
+        break;
+      case '\b':
+        result += "\\b";
+        break;
+      case '\f':
+        result += "\\f";
+        break;
+      case '\n':
+        result += "\\n";
+        break;
+      case '\r':
+        result += "\\r";
+        break;
+      case '\t':
+        result += "\\t";
+        break;
+      case '\v':
+        result += "\\v";
+        break;
+      case '\\':
+        // SJIS未対応
+        result.push_back( c );
+        result.push_back( c );
+        break;
+      default:
+        result.push_back( c );
+        break;
+      }
+    }
+
+    result.push_back( '"' );  // close
+
+    return result;
+  }
+
+}
Index: /cfg_itronx+oil_gcc/toppers/cpp.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/cpp.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/cpp.hpp	(revision 54)
@@ -0,0 +1,196 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2011 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/cpp.hpp
+ *  \brief  Cプリプロセッサ代替機能に関する宣言定義
+ */
+#ifndef TOPPERS_CPP_HPP_
+#define TOPPERS_CPP_HPP_
+
+#include "toppers/codeset.hpp"
+#include <boost/utility.hpp>
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+#include <boost/filesystem/exception.hpp>
+
+namespace toppers
+{
+
+  /*!
+   *  \brief  コメントの除去
+   *  \param[in]  first     入力元の先頭位置
+   *  \param[in]  last      入力元の終端位置の次
+   *  \param[out] result    結果の出力先
+   *  \param[in]  codeset   文字コード
+   *  \return     処理完了後の result の値
+   *
+   *  CスタイルのブロックコメントとC++スタイルの行コメントを取り除きます。
+   *  行コメントは、行末の \\ があっても次の行には続きません。
+   */
+  template < class ForwardIterator, class OutputIterator >
+    OutputIterator remove_comment( ForwardIterator first, ForwardIterator last, OutputIterator result, codeset_t codeset = ascii )
+  {
+    enum { none, line_comment, block_comment, single_quote, double_quote } state = none;
+    char prev = '\0';
+
+    for ( ; first != last; ++first, ++result )
+    {
+      char c = *first;
+      ForwardIterator next_iter = boost::next( first );
+      char next = ( next_iter != last ? *next_iter : '\0' );
+
+      switch ( state )
+      {
+      case line_comment:
+        if ( c == '\n' )
+        {
+          state = none;
+          *result = c;
+        }
+        break;
+      case block_comment:
+        if ( c == '*' && next == '/' )
+        {
+          state = none;
+          ++first;
+        }
+        else if ( c == '\n' )
+        {
+          *result = c;
+        }
+        break;
+      case single_quote:
+        if ( c == '\\'
+          && !( codeset == shift_jis && is_lead< shift_jis >( prev ) )
+          && next == '\'' )   // '〜\'〜 の場合
+        {
+          *result++ = *first++;
+        }
+        else if ( c == '\'' )
+        {
+          state = none;
+        }
+        *result = *first;
+        break;
+      case double_quote:
+        if ( c == '\\'
+          && !( codeset == shift_jis && is_lead< shift_jis >( prev ) )
+          && next == '\"' )   // "〜\"〜 の場合
+        {
+          *result++ = *first++;
+        }
+        else if ( c == '\"' )
+        {
+          state = none;
+        }
+        *result = *first;
+        break;
+      default:
+        switch ( c )
+        {
+        case '/':   // コメント開始の検出
+          if ( next == '*' )
+          {
+            state = block_comment;
+            ++first;
+          }
+          else if ( next == '/' )
+          {
+            state = line_comment;
+            ++first;
+          }
+          else
+          {
+            *result = *first;
+          }
+          break;
+        case '\'':
+          state = single_quote;
+          *result = c;
+          break;
+        case '\"':
+          state = double_quote;
+          *result = c;
+          break;
+        default:
+          *result = c;
+          break;
+        }
+      }
+      prev = *first;
+    }
+    return result;
+  }
+
+  /*!
+   *  \brief  インクルードパスの探索
+   *  \param[in]  first       探索対象ディレクトリ列の先頭位置
+   *  \param[in]  last        探索対象ディレクトリ列の終端位置の次
+   *  \param[in]  headername  探索対象のヘッダ名
+   *  \return     探索に成功すればヘッダへの相対またはフルパスを返す。失敗した場合は空文字列を返す。
+   */
+  template < class InputIterator >
+    std::string search_include_file( InputIterator first, InputIterator last, std::string const& headername )
+  {
+    namespace fs = boost::filesystem;
+//    fs::path filename( headername, fs::native );
+    fs::path filename( headername );  // filesystem3対応
+
+    if ( fs::exists( filename ) && !fs::is_directory( filename ) )
+    {
+      return headername;
+    }
+    while ( first != last )
+    {
+//      fs::path pathname = fs::path( *first, fs::native )/filename;
+      fs::path pathname = fs::path( *first )/filename;  // filesystem3対応
+      if ( fs::exists( pathname ) && !fs::is_directory( pathname ) )
+      {
+//        return pathname.native_file_string();
+        return pathname.string();  // filesysytem3対応
+      }
+      ++first;
+    }
+    return std::string();
+  }
+
+  std::string expand_quote( std::string const& str );
+  std::string quote_string( std::string const& str );
+
+}
+
+#endif  // ! TOPPERS_CPP_HPP_
Index: /cfg_itronx+oil_gcc/toppers/csv.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/csv.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/csv.hpp	(revision 54)
@@ -0,0 +1,258 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*!
+ *  \file   toppers/csv.hpp
+ *  \brief  CSVファイル入出力に関する宣言定義
+ */
+#ifndef TOPPERS_CSV_HPP_
+#define TOPPERS_CSV_HPP_
+
+#include <stdexcept>
+#include <ostream>
+#include <iterator>
+#include <string>
+#include <vector>
+#include <algorithm>
+#include <boost/utility.hpp>
+#include "toppers/misc.hpp"
+
+namespace toppers
+{
+
+  class csv_error : public std::runtime_error
+  {
+  public:
+    explicit csv_error( long line )
+      : std::runtime_error( "CSV parse error" ), line_( line )
+    {
+    }
+    long line() const
+    {
+      return line_;
+    }
+  private:
+    long line_;
+  };
+
+  /*!
+   *  \class  basic_csv csv.hpp "toppers/csv.hpp"
+   *  \brief  CSV ファイルの解析クラス
+   */
+  template < typename CharT, class Traits = std::char_traits< CharT > >
+    class basic_csv
+  {
+  public:
+    typedef std::basic_string< CharT, Traits > string_type;
+    typedef typename std::vector< std::vector< string_type > >::const_iterator const_iterator;
+    typedef typename std::vector< std::vector< string_type > >::const_reference const_reference;
+    typedef typename std::vector< std::vector< string_type > >::value_type value_type;
+    typedef typename std::vector< std::vector< string_type > >::size_type size_type;
+
+    basic_csv();
+    template < class InputIterator >
+      basic_csv( InputIterator first, InputIterator last )
+    {
+      read( first, last );
+    }
+
+    template < class InputIterator >
+      void read( InputIterator first, InputIterator last )
+    {
+      const CharT dquo = widen< CharT >( '\"' );
+      const CharT comma = widen< CharT >( ',' );
+      const CharT lf = widen< CharT >( '\n' );
+      enum
+      {
+        none,
+        non_escaped,
+        escape_opened,
+        escape_closed
+      } state = none;
+      std::vector< std::vector< string_type > > records;
+      std::vector< string_type > record;
+      string_type field;
+      long line = 1;
+
+      record.reserve( 16 );
+      field.reserve( 255 );
+
+      while ( first != last )
+      {
+        CharT ch = *first;
+        if ( ch == dquo )
+        {
+          switch ( state )
+          {
+          case none:
+            state = escape_opened;
+            break;
+          case escape_opened:
+            ++first;
+            ch = *first;
+            if ( ch == dquo ) // "" だったので、" を追加
+            {
+              field.push_back( dquo );
+            }
+            else  // 閉じ "
+            {
+              state = escape_closed;
+            }
+            continue;   // ++first をこれ以上実行させない
+          default:
+            throw csv_error( line );
+            break;
+          }
+        }
+        else  // ch != dquo
+        {
+          if ( state == escape_opened )
+          {
+            field.push_back( ch );
+          }
+          else
+          {
+            if ( ch == comma || ch == lf )
+            {
+              record.push_back( field );
+              field.clear();
+              state = none;
+              if ( ch == lf ) // 改行（RFC4180 では厳密には CR-LF なければならないが、とりあえず '\n' とする）
+              {
+                records.push_back( record );
+                record.clear();
+                ++line;
+              }
+            }
+            else
+            {
+              field.push_back( ch );
+//              CharT const* debug_string = field.c_str();
+            }
+          }
+        }
+        ++first;
+      }
+      records_.swap( records );
+    }
+    template < class OutputIterator >
+      void write( OutputIterator result ) const
+    {
+      const CharT dquo = widen< CharT >( '\"' );
+      const CharT comma = widen< CharT >( ',' );
+      const CharT lf = widen< CharT >( '\n' );
+
+      for ( typename std::vector< std::vector< string_type > >::const_iterator r_iter( records_.begin() ), r_last( records_.end() );
+            r_iter != r_last;
+            ++r_iter )
+      {
+        for ( typename std::vector< string_type >::const_iterator f_iter( r_iter->begin() ), f_last( r_iter->end() );
+              f_iter != f_last;
+              ++f_iter )
+        {
+          std::string field;
+          bool need_escape = false;
+
+          for ( typename string_type::const_iterator s_iter( f_iter->begin() ), s_last( f_iter->end() );
+                s_iter != s_last;
+                ++s_iter )
+          {
+            CharT ch = *s_iter;
+            if ( ch == dquo )
+            {
+              field.push_back( dquo );
+              need_escape = true;
+            }
+            else if ( ch == comma || ch == lf )
+            {
+              need_escape = true;
+            }
+            field.push_back( ch );
+          }
+
+          if ( need_escape )
+          {
+            field = dquo + field + dquo;
+          }
+          result = std::copy( field.begin(), field.end(), result );
+          if ( boost::next( f_iter ) != f_last )
+          {
+            *result++ = comma;
+          }
+        }
+        *result++ = lf;
+      }
+    }
+
+    const_iterator begin() const
+    {
+      return records_.begin();
+    }
+    const_iterator end() const
+    {
+      return records_.end();
+    }
+    const_reference at( size_type pos ) const
+    {
+      return records_.at( pos );
+    }
+    const_reference operator[]( size_type pos ) const
+    {
+      return records_[ pos ];
+    }
+    bool empty() const
+    {
+      return records_.empty();
+    }
+    size_type size() const
+    {
+      return records_.size();
+    }
+    void swap( basic_csv& other )
+    {
+      records_.swap( other.records_ );
+    }
+  private:
+    std::vector< std::vector< string_type > > records_;
+  };
+
+  typedef basic_csv< char > csv;
+  typedef basic_csv< wchar_t > wcsv;
+
+}
+
+#endif  // TOPPERS_CSV_HPP_
Index: /cfg_itronx+oil_gcc/toppers/debug.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/debug.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/debug.hpp	(revision 54)
@@ -0,0 +1,75 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*!
+ *  \file   toppers/debug.hpp
+ *  \brief  デバッグ用ライブラリに関する宣言定義
+ */
+#ifndef TOPPERS_DEBUG_HPP_
+#define TOPPERS_DEBUG_HPP_
+
+#include "toppers/config.hpp"
+#include <iostream>
+#if defined( _WIN32 ) || defined( __WIN32__ ) || defined( WIN32 )
+#include <windows.h>
+#include <sstream>
+#endif
+
+namespace toppers
+{
+
+  template < typename T >
+  void trace( char const* str, const T& value )
+  {
+#if defined( _WIN32 ) || defined( __WIN32__ ) || defined( WIN32 )
+    std::ostringstream ostr;
+    ostr << str << value << '\n';
+    ::OutputDebugString( ostr.str().c_str() );
+#else
+    std::cerr << str << value << std::endl;
+#endif
+  }
+
+}
+
+#if defined( _DEBUG ) || defined( __DEBUG ) || defined( DEBUG )
+#define TOPPERS_TRACE( str, value )   ::toppers::trace( ( str ), ( value ) )
+#else
+#define TOPPERS_TRACE( str, value )   ( ( void )0 )
+#endif
+
+#endif  // ! TOPPERS_DEBUG_HPP_
Index: /cfg_itronx+oil_gcc/toppers/diagnostics.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/diagnostics.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/diagnostics.cpp	(revision 54)
@@ -0,0 +1,137 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <cstdio>
+#include <string>
+#include "toppers/diagnostics.hpp"
+#include "toppers/text_line.hpp"
+
+namespace toppers
+{
+  namespace
+  {
+    int error_abort_threshold = 100;
+    int error_count = 0;
+    std::string program_name( "(unknown)" );
+    std::string error_location;
+  }
+
+  int get_error_count()
+  {
+    return error_count;
+  }
+
+  int increment_error_count()
+  {
+    return ++error_count;
+  }
+
+  void set_program_name( char const* name )
+  {
+    program_name = name;
+  }
+
+  std::string const& get_program_name()
+  {
+    return program_name;
+  }
+
+  int set_error_abort_threshold( int thresh )
+  {
+    if ( thresh < 1 )
+    {
+      return -1;
+    }
+    int previous = error_abort_threshold;
+    error_abort_threshold = thresh;
+    return previous;
+  }
+
+  void warning( const char* msg )
+  {
+    if ( !error_location.empty() ) fprintf( stderr, "In function `%s`:\n", error_location.c_str() );
+    fprintf( stderr, "%s: %s: %s\n", program_name.c_str(), _( "warning" ), msg );
+    error_location.clear();
+  }
+  void warning( text_line const& line, const char* msg )
+  {
+    if ( !error_location.empty() ) fprintf( stderr, "In function `%s`:\n", error_location.c_str() );
+    fprintf( stderr, "%s:%s:%ld: %s: %s\n", program_name.c_str(), line.file.c_str(), line.line, _( "warning" ), msg );
+    error_location.clear();
+  }
+  void error( const char* msg )
+  {
+    if ( !error_location.empty() ) fprintf( stderr, "In function `%s`:\n", error_location.c_str() );
+    fprintf( stderr, "%s: %s: %s\n", program_name.c_str(), _( "error" ), msg );
+    ++error_count;
+    if ( error_abort_threshold <= error_count )
+    {
+      error_location.clear();
+      throw diagnostics_error( _( "too many errors" ) );
+    }
+  }
+  void error( text_line const& line, const char* msg )
+  {
+    if ( !error_location.empty() ) fprintf( stderr, "In function `%s`:\n", error_location.c_str() );
+    fprintf( stderr, "%s:%s:%ld: %s: %s\n", program_name.c_str(), line.file.c_str(), line.line, _( "error" ), msg );
+    ++error_count;
+    if ( error_abort_threshold <= error_count )
+    {
+      error_location.clear();
+      throw diagnostics_error( _( "too many errors" ) );
+    }
+  }
+  void fatal( const char* msg )
+  {
+    if ( !error_location.empty() ) fprintf( stderr, "In function `%s`:\n", error_location.c_str() );
+    fprintf( stderr, "%s: %s: %s\n", program_name.c_str(), _( "error" ), msg );
+    error_location.clear();
+    throw diagnostics_error( _( "fatal error" ) );
+  }
+  void fatal( text_line const& line, const char* msg )
+  {
+    if ( !error_location.empty() ) fprintf( stderr, "In function `%s`:\n", error_location.c_str() );
+    fprintf( stderr, "%s:%s:%ld: %s: %s\n", program_name.c_str(), line.file.c_str(), line.line, _( "error" ), msg );
+    error_location.clear();
+    throw diagnostics_error( _( "fatal error" ) );
+  }
+
+  void set_error_location( char const* msg )
+  {
+    error_location = msg;
+  }
+
+}
Index: /cfg_itronx+oil_gcc/toppers/diagnostics.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/diagnostics.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/diagnostics.hpp	(revision 54)
@@ -0,0 +1,237 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ *  Copyright (C) 2010 by Meika Sugimoto
+ *
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/diagnostics.hpp
+ *  \brief  診断処理に関する宣言定義
+ */
+#ifndef TOPPERS_DIAGNOSTICS_HPP_
+#define TOPPERS_DIAGNOSTICS_HPP_
+
+#include <stdexcept>
+#include "toppers/debug.hpp"
+#include "toppers/gettext.hpp"
+#include <boost/format.hpp>
+
+namespace toppers
+{
+
+  struct text_line;
+
+  class diagnostics_error : public std::runtime_error
+  {
+  public:
+    diagnostics_error( std::string const& msg ) : std::runtime_error( msg ) {}
+  };
+
+  class normal_exit {};
+
+  int get_error_count();
+  int increment_error_count();
+  void set_program_name( char const* name );
+  std::string const& get_program_name();
+  int set_error_abort_threshold( int thresh );
+  void warning( char const* msg );
+  void warning( text_line const& line, char const* msg );
+  void error( char const* msg );
+  void error( text_line const& line, char const* msg );
+  void fatal( char const* msg );
+  void fatal( text_line const& line, char const* msg );
+  void set_error_location( char const* msg );
+
+  template < typename T1 >
+    inline void warning( char const* str, T1 const& arg1 )
+  {
+    warning( ( boost::format( str ) % arg1 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2 >
+    inline void warning( char const* str, T1 const& arg1, T2 const& arg2 )
+  {
+    warning( ( boost::format( str ) % arg1 % arg2 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2, typename T3 >
+    inline void warning( char const* str, T1 const& arg1, T2 const& arg2, T3 const& arg3 )
+  {
+    warning( ( boost::format( str ) % arg1 % arg2 % arg3 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2, typename T3, typename T4 >
+    inline void warning( char const* str, T1 const& arg1, T2 const& arg2, T3 const& arg3, T4 const& arg4 )
+  {
+    warning( ( boost::format( str ) % arg1 % arg2 % arg3 % arg4 ).str().c_str() );
+  }
+
+  template < typename T1 >
+    inline void warning( text_line const& line, char const* str, T1 const& arg1 )
+  {
+    warning( line, ( boost::format( str ) % arg1 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2 >
+    inline void warning( text_line const& line, char const* str, T1 const& arg1, T2 const& arg2 )
+  {
+    warning( line, ( boost::format( str ) % arg1 % arg2 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2, typename T3 >
+    inline void warning( text_line const& line, char const* str, T1 const& arg1, T2 const& arg2, T3 const& arg3 )
+  {
+    warning( line, ( boost::format( str ) % arg1 % arg2 % arg3 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2, typename T3, typename T4 >
+    inline void warning( text_line const& line, char const* str, T1 const& arg1, T2 const& arg2, T3 const& arg3, T4 const& arg4 )
+  {
+    warning( line, ( boost::format( str ) % arg1 % arg2 % arg3 % arg4 ).str().c_str() );
+  }
+
+  template < typename T1 >
+    inline void error( char const* str, T1 const& arg1 )
+  {
+    error( ( boost::format( str ) % arg1 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2 >
+    inline void error( char const* str, T1 const& arg1, T2 const& arg2 )
+  {
+    error( ( boost::format( str ) % arg1 % arg2 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2, typename T3 >
+    inline void error( char const* str, T1 const& arg1, T2 const& arg2, T3 const& arg3 )
+  {
+    error( ( boost::format( str ) % arg1 % arg2 % arg3 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2, typename T3, typename T4 >
+    inline void error( char const* str, T1 const& arg1, T2 const& arg2, T3 const& arg3, T4 const& arg4 )
+  {
+    error( ( boost::format( str ) % arg1 % arg2 % arg3 % arg4 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2, typename T3, typename T4, typename T5 >
+    inline void error( char const* str, T1 const& arg1, T2 const& arg2, T3 const& arg3, T4 const& arg4 , T5 const& arg5 )
+  {
+    error( ( boost::format( str ) % arg1 % arg2 % arg3 % arg4 % arg5 ).str().c_str() );
+  }
+  
+  template < typename T1 >
+    inline void error( text_line const& line, char const* str, T1 const& arg1 )
+  {
+    error( line, ( boost::format( str ) % arg1 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2 >
+    inline void error( text_line const& line, char const* str, T1 const& arg1, T2 const& arg2 )
+  {
+    error( line, ( boost::format( str ) % arg1 % arg2 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2, typename T3 >
+    inline void error( text_line const& line, char const* str, T1 const& arg1, T2 const& arg2, T3 const& arg3 )
+  {
+    error( line, ( boost::format( str ) % arg1 % arg2 % arg3 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2, typename T3, typename T4 >
+    inline void error( text_line const& line, char const* str, T1 const& arg1, T2 const& arg2, T3 const& arg3, T4 const& arg4 )
+  {
+    error( line, ( boost::format( str ) % arg1 % arg2 % arg3 % arg4 ).str().c_str() );
+  }
+
+  template < typename T1 >
+    inline void fatal( char const* str, T1 const& arg1 )
+  {
+    fatal( ( boost::format( str ) % arg1 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2 >
+    inline void fatal( char const* str, T1 const& arg1, T2 const& arg2 )
+  {
+    fatal( ( boost::format( str ) % arg1 % arg2 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2, typename T3 >
+    inline void fatal( char const* str, T1 const& arg1, T2 const& arg2, T3 const& arg3 )
+  {
+    fatal( ( boost::format( str ) % arg1 % arg2 % arg3 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2, typename T3, typename T4 >
+    inline void fatal( char const* str, T1 const& arg1, T2 const& arg2, T3 const& arg3, T4 const& arg4 )
+  {
+    fatal( ( boost::format( str ) % arg1 % arg2 % arg3 % arg4 ).str().c_str() );
+  }
+
+  template < typename T1 >
+    inline void fatal( text_line const& line, char const* str, T1 const& arg1 )
+  {
+    fatal( line, ( boost::format( str ) % arg1 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2 >
+    inline void fatal( text_line const& line, char const* str, T1 const& arg1, T2 const& arg2 )
+  {
+    fatal( line, ( boost::format( str ) % arg1 % arg2 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2, typename T3 >
+    inline void fatal( text_line const& line, char const* str, T1 const& arg1, T2 const& arg2, T3 const& arg3 )
+  {
+    fatal( line, ( boost::format( str ) % arg1 % arg2 % arg3 ).str().c_str() );
+  }
+
+  template < typename T1, typename T2, typename T3, typename T4 >
+    inline void fatal( text_line const& line, char const* str, T1 const& arg1, T2 const& arg2, T3 const& arg3, T4 const& arg4 )
+  {
+    fatal( line, ( boost::format( str ) % arg1 % arg2 % arg3 % arg4 ).str().c_str() );
+  }
+
+  inline void exit()
+  {
+    throw normal_exit();
+  }
+
+#undef  _
+#define _( str )  ::toppers::gettext( str ).c_str()
+
+}
+
+#endif  // ! TOPPERS_DIAGNOSTICS_HPP_
+
Index: /cfg_itronx+oil_gcc/toppers/gettext.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/gettext.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/gettext.cpp	(revision 54)
@@ -0,0 +1,225 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2011 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <cstdlib>
+#include <stdlib.h>	// Cygwin対策
+#include <cstring>
+#include <clocale>
+#include <string>
+#include <map>
+#include <fstream>
+#include <stdexcept>
+#include "toppers/gettext.hpp"
+#include "toppers/cpp.hpp"
+#include "toppers/global.hpp"
+#include <boost/scoped_array.hpp>
+#include <boost/any.hpp>
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+
+namespace toppers
+{
+  namespace
+  {
+
+    std::map< std::string, std::string > msgcat;
+
+    void register_msgcat( std::string const& msgid, std::string const& msgstr )
+    {
+      std::string::size_type size = msgstr.size();
+      boost::scoped_array< wchar_t > wbuf( new wchar_t[ size + 1 ] );
+      boost::scoped_array< char > buf( new char[ size + 1 ] );
+      wchar_t* wcs = wbuf.get();
+      wchar_t wc = 0;
+      for ( std::string::const_iterator iter( msgstr.begin() ), last( msgstr.end() ); iter != last; ++iter )
+      {
+        int c = static_cast< unsigned char >( *iter );
+        if ( ( ( c & 0xc0 ) == 0xc0 ) || ( c < 0x80 ) ) // 先行バイト
+        {
+          if ( wc != 0 )
+          {
+            *wcs++ = wc;
+            wc = 0;
+          }
+          if ( ( c & 0x80 ) == 0 )
+          {
+            wc = static_cast< wchar_t >( c );
+          }
+          else if ( ( c & 0xe0 ) == 0xc0 )
+          {
+            wc = static_cast< wchar_t >( c & 0x1f );
+          }
+          else if ( ( c & 0xf0 ) == 0xe0 )
+          {
+            wc = static_cast< wchar_t >( c & 0xf );
+          }
+          else
+          {
+            // サロゲートは未対応（ここで対応したとしても、文字コード変換時にしくじる可能性大）
+          }
+        }
+        else    // 後続バイト
+        {
+          wc = static_cast< wchar_t >( ( wc << 6 ) | ( c & 0x3f ) );
+        }
+      }
+      if ( wc != 0 )
+      {
+        *wcs++ = wc;
+      }
+      *wcs = L'\0';
+
+      // ↓ この間は決して例外が発生しない
+      char const* locale = std::setlocale( LC_CTYPE, "" );
+      /* std:: */wcstombs( buf.get(), wbuf.get(), size + 1 );     // Unicode から環境依存の文字コードへ変換
+      std::setlocale( LC_CTYPE, locale );
+      // ↑ この間は決して例外が発生しない
+
+      msgcat[ msgid ] = std::string( buf.get() );
+    }
+
+    bool msgcat_loaded = false;
+
+  }
+
+  /*!
+   *  \brief      メッセージカタログのロード
+   *  \param[in]  dir     *.po ファイルが存在するディレクトリ
+   *  \retval     true    成功
+   *  \retval     false   失敗
+   *
+   *  実装を簡便化するため、.poファイルの記述方法には以下の制約がある。
+   *  - msgid, msgstr は必ず行の先頭に記述する。
+   *  - msgid, msgstr の直後には、必ず空白類文字一文字とし、その直後に文字列を記述する。
+   *  - 文字列のみを記述する行は必ず " で始める。
+   *  - .poファイルはの文字コードは必ず UTF-8N とする。
+   */
+  bool load_msgcat( std::string const& dir )
+  {
+    namespace fs = boost::filesystem;
+    char const* env = std::getenv( "TOPPERS_CFG_LANG" );
+//      env = "ja";
+    if ( env == 0 )
+    {
+      return false;
+    }
+    std::string lang( env );
+
+//    fs::path cfg_dir( dir, fs::native );
+    fs::path cfg_dir( dir );  // filesystem3対応
+//    fs::path po_file( cfg_dir/fs::path( lang + ".po", fs::native ) );
+    fs::path po_file( cfg_dir/fs::path( lang + ".po" ) );  // filesystem3対応
+
+//    std::ifstream ifs( po_file.native_file_string().c_str() );
+    std::ifstream ifs( po_file.string().c_str() );  // filesystem3対応
+    std::string msgid;
+    std::string msgstr;
+
+    while ( ifs )
+    {
+      std::string str;
+      std::getline( ifs, str );
+
+      // 改行文字の違いを吸収
+      std::string::size_type pos = str.find_last_not_of( " \t\r\n" ); // ついでに行末の空白類も除去
+      if ( pos != std::string::npos && pos < str.size() - 1 )
+      {
+        char c = str[pos];
+        str.erase( pos + 1, std::string::npos );
+      }
+
+      if ( str.empty() || str[ 0 ] == '#' || str == "" )
+      {
+        ;   // 空行またはコメント行
+      }
+      else
+      {
+        try
+        {
+          if ( std::strncmp( str.c_str(), "msgid", sizeof( "msgid" )-1 ) == 0 )
+          {
+            str.erase( 0, sizeof( "msgid" )-1+1 );
+            msgid = expand_quote( str );           
+          }
+          else if ( std::strncmp( str.c_str(), "msgstr", sizeof( "msgstr" )-1 ) == 0 )
+          {
+            str.erase( 0, sizeof( "msgstr" )-1+1 );
+            msgstr = expand_quote( str );
+          }
+          else
+          {
+            msgstr += expand_quote( str );
+          }
+          if ( !msgid.empty() && !msgstr.empty() )  // 直前の msgid / msgstr を登録
+          {
+            register_msgcat( msgid, msgstr );
+            msgid.clear();
+            msgstr.clear();
+          }
+        }
+        catch ( std::invalid_argument& )
+        {
+          return false;
+        }
+      }
+    }
+    msgcat_loaded = true;
+    return true;
+  }
+
+  /*!
+   *  \brief      メッセージの翻訳
+   *  \param[in]  message   メッセージID
+   *  \return     翻訳後のメッセージ
+   */
+  std::string const& gettext( std::string const& message )
+  {
+    static bool f = load_msgcat( get_global< std::string >( "cfg-directory" ) );
+    if ( !msgcat_loaded )
+    {
+      return message;
+    }
+
+    std::map< std::string, std::string >::const_iterator iter( msgcat.find( message ) ), last( msgcat.end() );
+    if ( iter != last )
+    {
+      std::string const& result( iter->second );
+      return result;
+    }
+    return message;
+  }
+
+}
Index: /cfg_itronx+oil_gcc/toppers/gettext.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/gettext.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/gettext.hpp	(revision 54)
@@ -0,0 +1,56 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/gettext.hpp
+ *  \brief  GNU gettext の代替コード
+ *
+ *  本来であればGNU gettextを使用すべきかも知れないが、Visual C++でGNU gettextを使用するには、
+ *  インストールが面倒なこともあり、代替コードを自前で用意することにした。
+ */
+#ifndef TOPPERS_GETTEXT_HPP_
+#define TOPPERS_GETTEXT_HPP_
+
+#include <string>
+#include "toppers/config.hpp"
+
+namespace toppers
+{
+  bool load_msgcat( std::string const& dir );
+  std::string const& gettext( std::string const& message );
+}
+
+#endif  // ! TOPPERS_GETTEXT_HPP_
Index: /cfg_itronx+oil_gcc/toppers/global.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/global.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/global.cpp	(revision 54)
@@ -0,0 +1,75 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <new>
+#include <map>
+#include "toppers/global.hpp"
+
+namespace toppers
+{
+
+  /*!
+   *  \brief  グローバルオブジェクトへのアクセッサ
+   *  \param[in]  key   オブジェクト名
+   *  \return     key で指定したオブジェクトへの参照
+   *
+   *  グローバルオブジェクトへのアクセスを一元管理する。
+   *  この関数を介してグローバルアクセスを行うことにより、通常の静的オブジェクトが持つ動的初期化の
+   *  順序に関する問題が解消される。
+   *  また、内部的に管理しているオブジェクトは、プログラム終了時にデストラクタが呼ばれることはない。
+   *  （厳密にいえばメモリリークにあたるが、弊害はとくにない）
+   */
+  boost::any& global( std::string const& key )
+  {
+    static std::map< std::string, boost::any >* gvm = 0;
+    if ( gvm == 0 )
+    {
+      union max_aligner
+      {
+        long long ll;
+        double d;
+        long double ld;
+        void* pv;
+        void (*pfn)();
+      };
+      const std::size_t size = ( sizeof( std::map< std::string, boost::any > ) + sizeof( max_aligner ) - 1 ) / sizeof( max_aligner );
+      static max_aligner gvm_storage[ size ];
+      gvm = new ( gvm_storage ) std::map< std::string, boost::any >;  // デストラクタは呼ばれない
+    }
+    return ( *gvm )[key];
+  }
+
+}
Index: /cfg_itronx+oil_gcc/toppers/global.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/global.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/global.hpp	(revision 54)
@@ -0,0 +1,88 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2009 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/global.hpp
+ *  \brief  疑似グローバルオブジェクトに関する宣言定義
+ */
+#ifndef TOPPERS_GLOBAL_HPP_
+#define TOPPERS_GLOBAL_HPP_
+
+#include <cstddef>
+#include <stdexcept>
+#include <string>
+#include "toppers/config.hpp"
+#include <boost/any.hpp>
+
+namespace toppers
+{
+
+  class global_error : public std::logic_error
+  {
+  public:
+    explicit global_error( std::string const& s )
+      : std::logic_error( "there is not global object `" + s + "`" )
+    {
+    }
+  };
+
+  boost::any& global( std::string const& key );
+
+  template < typename T >
+    T const& get_global( std::string const& key )
+  {
+    try
+    {
+      return boost::any_cast< T const& >( global( key ) );
+    }
+    catch ( boost::bad_any_cast& )
+    {
+      throw global_error( key );
+    }
+    static T t;
+    return t;
+  }
+
+  template < typename T >
+    inline T const& get_global( std::string const& key, T& storage )
+  {
+    storage = get_global< T >( key );
+    return storage;
+  }
+
+}
+
+#endif  // ! TOPPERS_GLOBAL_HPP_
Index: /cfg_itronx+oil_gcc/toppers/io.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/io.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/io.cpp	(revision 54)
@@ -0,0 +1,81 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <fstream>
+#include <algorithm>
+#include <iterator>
+#include "toppers/io.hpp"
+#include "toppers/diagnostics.hpp"
+#include <boost/format.hpp>
+
+namespace toppers
+{
+
+  void read( std::string const& filename, std::string& buf, std::ios_base::openmode omode )
+  {
+    std::ifstream ifs( filename.c_str(), std::ios_base::in | omode );
+    if ( !ifs.is_open() )
+    {
+      throw io_error( str( boost::format( _( "cannot open file `%1%\'" ) ) % filename ) );
+    }
+    std::string t;
+    char c;
+    while ( ifs.get( c ) )
+    {
+      t.push_back( c );
+    }
+    if ( ifs.bad() )
+    {
+      throw io_error( _( "I/O error" ) );
+    }
+    buf.swap( t );
+  }
+
+  void write( std::string const& filename, std::string const& buf, std::ios_base::openmode omode )
+  {
+    std::ofstream ofs( filename.c_str(), std::ios_base::out | omode );
+    if ( !ofs.is_open() )
+    {
+      throw io_error( str( boost::format( _( "cannot open file `%1%\'" ) ) % filename ) );
+    }
+    std::copy( buf.begin(), buf.end(), std::ostream_iterator< char >( ofs ) );
+    if ( ofs.bad() )
+    {
+      throw io_error( _( "I/O error" ) );
+    }
+  }
+
+}
Index: /cfg_itronx+oil_gcc/toppers/io.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/io.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/io.hpp	(revision 54)
@@ -0,0 +1,68 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/io.hpp
+ *  \brief  ファイル入出力に関する宣言定義
+ */
+#ifndef TOPPERS_IO_HPP_
+#define TOPPERS_IO_HPP_
+
+#include <ios>
+#include <string>
+#include <stdexcept>
+#include "toppers/config.hpp"
+
+namespace toppers
+{
+
+  class io_error : public std::runtime_error
+  {
+  public:
+    explicit io_error( std::string const& msg ) : std::runtime_error( msg ) {}
+  };
+
+  void read( std::string const& filename, std::string& buf, std::ios_base::openmode omode = std::ios_base::openmode( 0 ) );
+  void write( std::string const& filename, std::string const& buf, std::ios_base::openmode omode = std::ios_base::openmode( 0 ) );
+
+  inline void append( std::string const& filename, std::string const buf, std::ios_base::openmode omode = std::ios_base::openmode( 0 ) )
+  {
+    write( filename, buf, omode | std::ios_base::app );
+  }
+
+}
+
+#endif  // ! TOPPERS_IO_HPP_
Index: /cfg_itronx+oil_gcc/toppers/itronx/Makefile
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/Makefile	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/Makefile	(revision 54)
@@ -0,0 +1,31 @@
+-include ../Makefile.config
+
+PROJDIR = ../..
+WORKDIR = $(PROJDIR)/toppers/itronx
+
+CPPFLAGS := $(CPPFLAGS) -I$(BOOST_DIR) -I$(PROJDIR)
+CXXFLAGS := $(CXXFLAGS) -O2 -g
+
+CXXFILES = \
+	cfg1_out.cpp \
+	checker.cpp \
+	component.cpp \
+	factory.cpp \
+	preprocess.cpp \
+	static_api.cpp
+
+OBJFILES := $(CXXFILES:%.cpp=%.o)
+
+all: libitronx.a
+
+libitronx.a: $(OBJFILES)
+	$(AR) rcs libitronx.a $(OBJFILES)
+
+depend:
+	$(CXX) $(CPPFLAGS) -M $(CXXFILES) > Makefile.depend
+
+clean:
+	-rm -f *.o *.a
+
+-include Makefile.depend
+
Index: /cfg_itronx+oil_gcc/toppers/itronx/cfg1_out.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/cfg1_out.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/cfg1_out.cpp	(revision 54)
@@ -0,0 +1,997 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2011 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <cstdlib>
+#include <cerrno>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <iterator>
+#include <algorithm>
+#include <stack>
+#include "toppers/text.hpp"
+#include "toppers/diagnostics.hpp"
+#include "toppers/c_expr.hpp"
+#include "toppers/global.hpp"
+#include "toppers/macro_processor.hpp"
+#include "toppers/s_record.hpp"
+#include "toppers/nm_symbol.hpp"
+#include "toppers/misc.hpp"
+#include "toppers/itronx/cfg1_out.hpp"
+#include "toppers/itronx/preprocess.hpp"
+#include <boost/spirit/include/classic.hpp>
+#include <boost/filesystem/path.hpp>
+#include <boost/lexical_cast.hpp>
+
+namespace toppers
+{
+  namespace itronx
+  {
+    namespace
+    {
+      struct block_t
+      {
+        std::string type;
+        std::string id;
+        text_line line;
+      };
+    }
+
+    //! cfg_out クラスの実装詳細
+    struct cfg1_out::implementation
+    {
+    protected:
+      output_file ofile_;
+      std::vector< static_api > static_api_array_;
+      std::string cfg1_out_list_;
+      std::string includes_;
+      std::string domid_defs_;
+      std::vector< block_t > block_table_;
+      std::vector< std::pair< std::string, long > > clsid_table_;
+      std::vector< std::pair< std::string, long > > domid_table_;
+
+      std::tr1::shared_ptr< s_record > srec_;
+      std::tr1::shared_ptr< nm_symbol > syms_;
+      bool little_endian_;
+      std::size_t base_;
+      cfg1_def_table const* def_table_;
+
+      implementation( std::string const& filename, std::ios_base::openmode omode, cfg1_def_table const* def_table = 0 )
+        : ofile_( filename, omode ), little_endian_( true ), base_( 1 ), def_table_( def_table )
+      {
+      }
+      virtual ~implementation()
+      {
+      }
+      virtual void do_load_cfg( std::string const& input_file, codeset_t codeset, std::map< std::string, static_api::info > const& info_map );
+      virtual void do_generate_includes() const
+      {
+      }
+      virtual void do_generate_cfg1_def() const
+      {
+        ofile_ << "const uint32_t TOPPERS_cfg_magic_number = 0x12345678;\n"
+                  "const uint32_t TOPPERS_cfg_sizeof_signed_t = sizeof(signed_t);\n"
+                  "const uint32_t TOPPERS_cfg_sizeof_pointer = sizeof(const volatile void*);\n"
+                  "const unsigned_t TOPPERS_cfg_CHAR_BIT = CHAR_BIT;\n"
+                  "const unsigned_t TOPPERS_cfg_CHAR_MAX = CHAR_MAX;\n"
+                  "const unsigned_t TOPPERS_cfg_CHAR_MIN = CHAR_MIN;\n"
+                  "const unsigned_t TOPPERS_cfg_SCHAR_MAX = SCHAR_MAX;\n"
+                  "const unsigned_t TOPPERS_cfg_SHRT_MAX = SHRT_MAX;\n"
+                  "const unsigned_t TOPPERS_cfg_INT_MAX = INT_MAX;\n"
+                  "const unsigned_t TOPPERS_cfg_LONG_MAX = LONG_MAX;\n"
+                  "\n";
+
+        if ( def_table_ != 0 )	// 「値取得シンボルテーブル」
+        {
+          for ( cfg1_def_table::const_iterator iter( def_table_->begin() ), last( def_table_->end() );
+                iter != last;
+                ++iter )
+          {
+            // 式の最初に # があれば、それはマクロ定義の判定
+            // ★注意★ #@ で始まる書式は廃止 2010/07/23
+            bool is_pp = ( iter->expression[ 0 ] == '#' );
+            if ( !iter->value1.empty() || !iter->value2.empty() ) // （CSVの）4番目または5番目の値があれば...
+            {
+              is_pp = true;
+            }
+
+            std::string type = ( iter->is_signed ? "signed_t" : "unsigned_t" );
+            std::string definition = "const " + type + " ";
+            definition += "TOPPERS_cfg_" + iter->name;
+            if ( is_pp )
+            {
+              std::string expression = iter->expression.substr( iter->expression[ 0 ] == '#' ? 1 : 0 );
+              std::string value1 = ( !iter->value1.empty() ? iter->value1 : "1" );
+              std::string value2 = ( !iter->value2.empty() ? iter->value2 : "0" );
+              definition +=
+                          " = \n"
+                          "#if " + expression + "\n"
+                          "(" + value1 + ");\n"
+                          "#else\n"
+                          "(" + value2 + ");\n"
+                          "#endif\n";
+            }
+            else if ( iter->expression[ 0 ] == '@' )  // '@'で始まればアドレス
+            {
+              definition = "const volatile void* const TOPPERS_cfg_" + iter->name + " = (" + ( iter->expression.c_str() + 1 ) + ");\n";
+            }
+            else
+            {
+              definition +=
+                          " = ( " + type + " )" + iter->expression + ";\n";
+            }
+            ofile_ << definition;
+          }
+        }
+      }
+      virtual void do_assign_params();
+      virtual implementation* do_clone() const
+      {
+        return new implementation( *this );
+      }
+
+      void preprocess( std::string const& input_file, codeset_t codeset, text& txt );
+
+      friend class cfg1_out;
+    };
+
+
+    /*!
+     *  \brief  コンストラクタ
+     *  \param[in]  filename    cfg1_out.c または cfg1_out.srec 若しくはそれらの代替名
+     *  \param[in]  def_table   cfg1_out.c 生成用の定義テーブル
+     */
+    cfg1_out::cfg1_out( std::string const& filename, cfg1_def_table const* def_table )
+      : pimpl_( new implementation( filename, std::ios_base::out, def_table ) )
+    {
+    }
+
+    /*!
+     *  \brief  コピーコンストラクタ
+     *  \param[in]  other   コピー元
+     */
+    cfg1_out::cfg1_out( cfg1_out const& other )
+      : pimpl_( other.pimpl_->do_clone() )
+    {
+    }
+
+    //! デストラクタ
+    cfg1_out::~cfg1_out()
+    {
+      delete pimpl_;
+      pimpl_ = 0;
+    }
+
+    /*!
+     *  \brief  システムコンフィギュレーションファイルのロード
+     *  \param[in]  input_file  入力ファイル名
+     *  \param[in]  codeset     文字コード
+     *  \param[in]  info_map    静的API情報の連想配列
+     */
+    void cfg1_out::load_cfg( std::string const& input_file, codeset_t codeset, std::map< std::string, static_api::info > const& info_map )
+    {
+      return pimpl_->do_load_cfg( input_file, codeset, info_map );
+    }
+
+    //! 前処理
+    void cfg1_out::implementation::preprocess( std::string const& input_file, codeset_t codeset, text& txt )
+    {
+      boost::any print_depend = global( "print-dependencies" );
+      if ( !print_depend.empty() )
+      {
+        std::set< std::string > depend, onces;
+        itronx::preprocess( input_file, txt, codeset, &depend, &onces );
+
+        // 依存関係の出力（GNU makeに適した形式）
+        std::string target_file = boost::any_cast< std::string& >( print_depend );
+        std::cout << target_file << ": " << input_file << ' ';
+        std::copy( depend.begin(), depend.end(), std::ostream_iterator< std::string >( std::cout, " " ) );
+        std::cout << std::endl;
+        exit();
+      }
+      else
+      {
+        std::set< std::string > onces;
+        itronx::preprocess( input_file, txt, codeset, 0, &onces );
+      }
+    }
+
+    /*!
+     *  \brief  システムコンフィギュレーションファイルのロード処理の実体
+     *  \param[in]  input_file  入力ファイル名
+     *  \param[in]  codeset     文字コード
+     *  \param[in]  info_map    静的API情報の連想配列
+     */
+    void cfg1_out::implementation::do_load_cfg( std::string const& input_file, codeset_t codeset, std::map< std::string, static_api::info > const& info_map )
+    {
+      text txt;
+      preprocess( input_file, codeset, txt );
+
+      // システムコンフィギュレーションファイルの解析
+      std::ostringstream oss, includes_oss;
+      std::vector< static_api > api_array;
+      long serial = 0;
+      std::stack< block_t > block_stack;
+      std::vector< block_t > block_table;
+      std::string current_class, current_domain;
+      long domain_serial = 1;
+      std::map< std::string, std::pair< long, bool > > id_map;
+      std::vector< std::pair< std::string, long > > clsid_table;
+      std::vector< std::pair< std::string, long > > domid_table;
+
+      for ( text::const_iterator iter( txt.begin() ), last( txt.end() ); iter != last; ++iter )
+      {
+        using namespace boost::spirit::classic;
+        parse_info< text::const_iterator > info;
+
+        info = parse( iter, last, ( ch_p( '#' ) >> *( anychar_p - eol_p ) >> eol_p ) ); // 前処理指令の検出
+        if ( info.hit ) // 前処理指令ならば...
+        {
+          if ( std::size_t col = info.stop.get_col() )
+          {
+            if ( info.stop.get_row()->buf.find_first_not_of( " \t" ) < col )
+            {
+              error( _( "illegal character `%1%\' is found" ), '#' );
+            }
+          }
+          text::const_iterator stop = info.stop;
+          std::string directive;
+          info = parse( iter, last, ( ch_p( '#' ) >> ( +alnum_p )[ assign_a( directive ) ] >> *( anychar_p - eol_p ) >> eol_p ) );
+          if ( info.hit )
+          {
+            if ( directive == "include" )
+            {
+              std::string directive_line_str( iter, info.stop );
+              if ( *directive_line_str.rbegin() == '\n' )
+              {
+                directive_line_str.erase( directive_line_str.size() - 1 );
+              }
+              includes_oss << directive_line_str << '\n';
+              oss << "/* " << directive_line_str << " */\n";
+            }
+            else if ( directive == "if" || directive == "ifdef" || directive == "ifndef"
+                   || directive == "else" || directive == "elif" || directive == "endif" )
+            {
+              oss << '\n' << std::string( iter, stop );
+            }
+            else if ( directive != "pragma" ) // コンフィギュレータが処理すべき#pragma指令はこの時点では除去されている
+            {
+              error( iter.line(), _( "`#%1%\' is not supported" ), directive );
+            }
+          }
+          else
+          {
+            oss << std::string( iter, stop );
+          }
+          iter = boost::prior( stop );
+        }
+        else // 前処理指令ではなく...
+          if ( !std::isspace( static_cast< unsigned char >( *iter ) ) )
+        {
+          while ( iter != last )
+          {
+            int ch = static_cast< unsigned char >( *iter );
+            if ( !std::isspace( ch ) )
+            {
+              break;
+            }
+          }
+
+          std::string block_type;
+          std::string id;
+          std::string idexp;
+          c_const_expr_parser const c_const_expr_p;
+          info = parse( iter, last,
+                        (
+                          str_p( "DOMAIN" )[ assign_a( block_type ) ]
+                          >> '(' >> c_ident_p[ assign_a( id ) ] >> ')' >> '{'
+                        )
+                      | (
+                          str_p( "CLASS" )[ assign_a( block_type ) ]
+                          >> '(' >> c_const_expr_p[ assign_a( id ) ] >> ')' >> '{'
+                        )
+                      | (
+                          str_p( "KERNEL_DOMAIN" )[ assign_a( block_type ) ] >> '{'
+                        ),
+                        space_p );
+          if ( info.hit )               // CLASS or DOMAINブロック開始ならば...
+          {
+            block_t b;
+            b.type = block_type;
+            b.id = id;
+            b.line = iter.line();
+            idexp = id; // 字面としてのIDを保存
+
+            if ( block_type == "CLASS" )
+            {
+              if ( !get_global< bool >( "has-class" ) )
+              {
+                error( "cannot use `%1%'", "CLASS" );
+              }
+            }
+            if ( block_type == "DOMAIN" || block_type == "KERNEL_DOMAIN"  )
+            {
+              if ( !get_global< bool >( "has-domain" ) )
+              {
+                error( "cannot use `%1%'", block_type );
+              }
+            }
+            // カーネルドメインを通常のドメインと同じように扱えるように変形
+            if ( block_type == "KERNEL_DOMAIN" )
+            {
+              block_type = "DOMAIN";
+              id = "TDOM_KERNEL";
+              b.type = block_type;
+              b.id = id;
+            }
+            else if ( block_type == "DOMAIN" ) // ドメインIDの仮登録
+            {
+              bool hit = false;
+              for ( std::vector< std::pair< std::string, long > >::const_iterator iter( domid_table.begin() ), last( domid_table.end() );
+                    iter != last;
+                    ++iter )
+              {
+                if ( iter->first == id )
+                {
+                  hit = true;
+                  break;
+                }
+              }
+              if ( !hit )
+              {
+                domid_table.push_back( std::make_pair( id, 0L ) );
+              }
+            }
+            else if ( block_type == "CLASS" ) // クラスIDの登録
+            {
+              // クラスIDに式を使えるようにしたため、識別子に使える形式に変換する必要がある
+              std::tr1::uint64_t hash = 0;
+              for ( const char* s = id.c_str(); *s != '\0'; ++s )
+              {
+                hash = ( ( hash << 1 ) | ( hash >> 63 ) ) ^ static_cast< unsigned char >( *s );
+              }
+              id = boost::str( boost::format( "%02x_%016x_%u" ) % *id.c_str() % hash % id.size() );
+              b.id = id;
+
+              bool hit = false;
+              for ( std::vector< std::pair< std::string, long > >::const_iterator iter( clsid_table.begin() ), last( clsid_table.end() );
+                    iter != last;
+                    ++iter )
+              {
+                if ( iter->first == id )
+                {
+                  hit = true;
+                  break;
+                }
+              }
+              if ( !hit )
+              {
+                clsid_table.push_back( std::make_pair( id, 0L ) );
+              }
+            }
+
+            // 入れ子判定
+            if ( block_type == "CLASS" && !current_class.empty()
+              || block_type == "DOMAIN" && !current_domain.empty() )
+            {
+              fatal( iter.line(), _( "`%1%\' is nested" ), block_type );
+            }
+
+            block_stack.push( b );
+            block_table.push_back( b );
+
+            if ( block_type == "CLASS" )
+            {
+              oss << "\n#ifndef TOPPERS_cfg_valueof_" << id << "_DEFINED\n"
+                    "#define TOPPERS_cfg_valueof_" << id << "_DEFINED 1\n";
+              oss << boost::format( "\n#line %1% \"%2%\"\n" ) % ( iter.line().line ) % dir_delimiter_to_slash( iter.line().file );
+
+              current_class = idexp;
+              oss << "const unsigned_t TOPPERS_cfg_valueof_" << id << " = " << idexp << ";\n";
+            }
+            if ( block_type == "DOMAIN" )
+            {
+              oss << "\n#ifndef TOPPERS_cfg_valueof_" << id << "_DEFINED\n"
+                    "#define TOPPERS_cfg_valueof_" << id << "_DEFINED 1\n";
+              oss << boost::format( "\n#line %1% \"%2%\"\n" ) % ( iter.line().line ) % dir_delimiter_to_slash( iter.line().file );
+
+              current_domain = id;
+              oss << "const unsigned_t TOPPERS_cfg_valueof_" << id << " = ";
+              if ( id == "TDOM_KERNEL" )
+              {
+                oss << "-1" << ";\n";
+              }
+              else
+              {
+                oss << id << ";\n";
+              }
+            }
+            oss << "\n#endif\n";
+
+            oss << "#define TOPPERS_cfg_inside_of_" << id << "\n";
+
+            iter = boost::prior( info.stop );
+          }
+          else if ( *info.stop == '}' ) // ブロック末尾ならば...
+          {
+            if ( block_stack.empty() )
+            {
+              fatal( iter.line(), _( "syntax error" ) );
+            }
+            block_t b = block_stack.top();
+            block_stack.pop();
+
+            oss << "\n#ifndef TOPPERS_cfg_inside_of_" << b.id << "\n";
+            oss << boost::format( "\n#line %1% \"%2%\"\n" ) % ( iter.line().line ) % dir_delimiter_to_slash( iter.line().file );
+            oss << "#error syntax error\n"
+                    "#endif\n";
+            oss << "#undef TOPPERS_cfg_inside_of_" << b.id << "\n"
+                    "\n";
+
+            if ( b.type == "CLASS" )
+            {
+              current_class.clear();
+            }
+            if ( b.type == "DOMAIN" )
+            {
+              current_domain.clear();
+            }
+            iter = info.stop;
+          }
+          else
+          {
+            static_api api;
+            if ( api.parse( iter, last, info_map, false, codeset ) )  // 静的APIならば...
+            {
+              if ( !current_class.empty() )
+              {
+                api.set_class( current_class );
+                oss << "const unsigned_t TOPPERS_cfg_valueof_CLASS_" << serial << " = " << current_class << ";";
+              }
+              if ( !current_domain.empty() )
+              {
+                api.set_domain( current_domain );
+                oss << "const unsigned_t TOPPERS_cfg_valueof_DOMAIN_" << serial << " = " << current_domain << ";";
+              }
+
+              api_array.push_back( api );
+
+              oss << boost::format( "\n#line %1% \"%2%\"\n" ) % api.line().line % dir_delimiter_to_slash( api.line().file );
+              oss << "const unsigned_t TOPPERS_cfg_static_api_" << serial << " = " << serial << ";\n";
+
+              if ( !api.params().empty() && api.begin()->symbol[0] == '#' )   // オブジェクト識別名
+              {
+                std::string object_id( api.begin()->text );
+                bool valid_object_id = true;
+                if ( !object_id.empty() && ( std::isalpha( static_cast< unsigned char >( object_id[ 0 ] ) ) || object_id[ 0 ] == '_' ) )
+                {
+                  for ( std::string::const_iterator id_iter( object_id.begin() + 1 ), id_last( object_id.end() );
+                        id_iter != id_last;
+                        ++id_iter )
+                  {
+                    if ( !( std::isalnum( static_cast< unsigned char >( *id_iter ) ) || *id_iter == '_' ) )
+                    {
+                      valid_object_id = false;
+                    }
+                  }
+                }
+                else
+                {
+                  valid_object_id = false;
+                }
+                if ( !valid_object_id )
+                {
+                  error( _( "`%1%\' is illegal object identifier" ), object_id );
+                }
+                else
+                {
+                  oss << "#define " << object_id << "\t(<>)\n";   // でたらめな字句（基本ソース文字集合のみで構成）に定義することで、誤使用を検出する
+                  oss << boost::format( "\n#line %1% \"%2%\"\n" ) % ( api.line().line ) % dir_delimiter_to_slash( api.line().file );
+                }
+              }
+              for ( static_api::iterator api_iter( api.begin() ), api_last( api.end() );
+                    api_iter != api_last;
+                    ++api_iter )
+              {
+                if ( ( api_iter->symbol[0] == '.' ) || ( api_iter->symbol[0] == '+' ) )
+                    // 整数定数式パラメータのみ出力
+                {
+                  char const* type;
+                  if ( api_iter->symbol[0] == '.' )
+                  {
+                    type = "unsigned_t";
+                  }
+                  else
+                  {
+                    type = "signed_t";
+                  }
+                  oss << "const " << type << " ";
+
+                  // 省略可能パラメータ情報の末尾にある ? を除去
+                  std::string parameter_name( api_iter->symbol.c_str() + 1 );
+                  if ( *parameter_name.rbegin() == '\?' )
+                  {
+                    parameter_name.resize( parameter_name.size() - 1 );
+                  }
+                  // 末尾の ... を除去 & order を付加
+                  if ( parameter_name.size() > 3 && parameter_name.substr( parameter_name.size() - 3 ) == "..." )
+                  {
+                    parameter_name.resize( parameter_name.size() - 3 );
+                    parameter_name += boost::lexical_cast< std::string >( api_iter->order );
+                  }
+
+                  oss << "TOPPERS_cfg_valueof_" << parameter_name << "_" << serial << " = ( " << type << " )( " << api_iter->text << " ); ";
+
+                  // 暫定値を設定
+                  char* endptr;
+                  errno = 0;
+                  unsigned long value = std::strtoul( api_iter->text.c_str(), &endptr, 0 );
+                  if ( errno == 0 && *endptr == '\0' )
+                  {
+                    api_iter->value = value;
+                  }
+                }
+                else if ( api_iter->symbol[0] == '$' )  // 文字列定数式パラメータ
+                {
+                  // 省略可能パラメータ情報の末尾にある ? を除去
+                  std::string parameter_name( api_iter->symbol.c_str() + 1 );
+                  if ( *parameter_name.rbegin() == '\?' )
+                  {
+                    parameter_name.resize( parameter_name.size() - 1 );
+                  }
+                  // 末尾の ... を除去 & order を付加
+                  if ( parameter_name.size() > 3 && parameter_name.substr( parameter_name.size() - 3 ) == "..." )
+                  {
+                    parameter_name.resize( parameter_name.size() - 3 );
+                    parameter_name += boost::lexical_cast< std::string >( api_iter->order );
+                  }
+
+                  oss << "const char TOPPERS_cfg_valueof_" << parameter_name << "_" << serial << "[] = " << api_iter->text << "; ";
+                }
+              }
+            }
+            else
+            {
+              fatal( iter.line(), _( "syntax error" ) );
+            }
+
+            ++serial;
+            iter = boost::prior( iter );
+          }
+        }
+      }
+
+      for ( std::vector< block_t >::const_iterator iter( block_table.begin() ), last( block_table.end() );
+            iter != last;
+            ++iter )
+      {
+        oss << "\n#ifdef TOPPERS_cfg_inside_of_" << iter->id << "\n";
+        oss << "#error missing \'}\'\n"
+               "#endif\n";
+      }
+
+      // 統合仕様書1.1.0における2.14.2 TOPPERS共通データ型の規定により、ACPTNは32ビット符号無し整数型である。
+      // これにより、ドメインの最大数は32個でなければならない。
+      const std::size_t domain_max = 32;
+      if ( domid_table.size() > domain_max )
+      {
+        fatal( _( "there are too many %1% ids" ), "domain" );
+      }
+
+      std::string domid_defs_temp;
+
+      if ( get_global< bool >( "has-domain" ) )
+      {
+        load_id_input_file( id_map ); // --id-input-fileによるドメインIDの読み込み
+
+        std::string domids[ domain_max ];
+
+        // 一周目は、--id-input-fileオプションを反映
+        for ( std::vector< std::pair< std::string, long > >::iterator iter( domid_table.begin() ), last( domid_table.end() );
+              iter != last;
+              ++iter )
+        {
+          std::map< std::string, std::pair< long, bool > >::iterator hit = id_map.find( iter->first );
+          if ( hit != id_map.end() )
+          {
+            long domid = hit->second.first; // --id-input-fileオプションで指定された値
+            if ( domid > 32 )
+            {
+              fatal( _( "%1% id `%2%' is too large" ), "domain", hit->first );
+            }
+            domids[ domid - 1 ] = hit->first;
+          }
+        }
+        // 二周目は、残りのドメインIDを割り付ける
+        for ( std::vector< std::pair< std::string, long > >::iterator iter( domid_table.begin() ), last( domid_table.end() );
+              iter != last;
+              ++iter )
+        {
+          if ( id_map.find( iter->first ) == id_map.end() )
+          {
+            for ( int i = 0; i < sizeof( domids ) / sizeof( domids[ 0 ] ); i++ )
+            {
+              if ( domids[ i ].empty() )
+              {
+                domids[ i ] = iter->first;
+                break;
+              }
+            }
+          }
+        }
+        domid_table.clear();
+        for ( std::size_t i = 0; i < sizeof( domids ) / sizeof( domids[ 0 ] ); i++ )
+        {
+          domid_table.push_back( std::make_pair( domids[ i ], long( i + 1 ) ) );
+        }
+
+        // cfg1_out.c出力用のコードを生成
+        for ( std::vector< std::pair< std::string, long > >::iterator iter( domid_table.begin() ), last( domid_table.end() );
+              iter != last;
+              ++iter )
+        {
+          if ( !iter->first.empty() )
+          {
+            domid_defs_temp += ( boost::format( "#define %1%\t%2%\n" ) % iter->first % iter->second ).str();
+          }
+        }
+      }
+
+      // データメンバへの反映
+      std::string cfg1_list_temp( oss.str() );
+      std::string includes_temp( includes_oss.str() );
+
+      clsid_table_.swap( clsid_table );
+      domid_table_.swap( domid_table );
+      domid_defs_.swap( domid_defs_temp );
+      cfg1_out_list_.swap( cfg1_list_temp );
+      includes_.swap( includes_temp );
+      static_api_array_.swap( api_array );
+      block_table_.swap( block_table );
+    }
+
+    /*!
+     *  \brief  cfg1_out.c の内容生成
+     *  \param[in]  type  配列 cfg1_out[] の要素型。空ポインタの場合は uint32_t として扱われる。
+     */
+    void cfg1_out::generate( char const* type ) const
+    {
+      if ( type == 0 )
+      {
+        type = "uint32_t";
+      }
+      pimpl_->ofile_ << "/* cfg1_out.c */\n"
+                        "#define TOPPERS_CFG1_OUT  1\n" 
+                        "#include \"kernel/kernel_int.h\"\n";
+      pimpl_->do_generate_includes();
+      pimpl_->ofile_ << pimpl_->includes_ << '\n';
+
+      // int128_tは故意に無視
+      // int128_tに揃えると処理が重くなりすぎるため
+      pimpl_->ofile_ << "\n#ifdef INT64_MAX\n"
+                        "  typedef int64_t signed_t;\n"
+                        "  typedef uint64_t unsigned_t;\n"
+                        "#else\n"
+                        "  typedef int32_t signed_t;\n"
+                        "  typedef uint32_t unsigned_t;\n"
+                        "#endif\n";
+
+      pimpl_->ofile_ << "\n#include <target_cfg1_out.h>\n\n";
+
+      pimpl_->do_generate_cfg1_def();
+      pimpl_->ofile_ << '\n' << pimpl_->domid_defs_ << '\n';
+      pimpl_->ofile_ << pimpl_->cfg1_out_list_ << '\n';
+    }
+
+    /*!
+     *  \brief  静的API配列の参照
+     *  \return 内部で保持している静的API配列への参照
+     */
+    std::vector< static_api > const& cfg1_out::get_static_api_array() const
+    {
+      return pimpl_->static_api_array_;
+    }
+
+    /*!
+     *  \brief  ドメインIDテーブルの参照
+     *  \return 内部で保持しているドメインIDテーブルへの参照
+     */
+    std::vector< std::pair< std::string, long > > const& cfg1_out::get_domid_table() const
+    {
+      return pimpl_->domid_table_;
+    }
+
+    /*!
+     *  \brief  クラスIDテーブルの参照
+     *  \return 内部で保持しているクラスIDテーブルへの参照
+     */
+    std::vector< std::pair< std::string, long > > const& cfg1_out::get_clsid_table() const
+    {
+      return pimpl_->clsid_table_;
+    }
+
+    /*!
+     *  \brief  #include指令の並びを取得する
+     *  \return #include指令の並び
+     *
+     *  このメンバ関数は、
+     *  \code
+     *  #include <...>
+     *  #include "..."
+     *  \endcode
+     *  といった#include指令の並びを文字列として返す。
+     */
+    std::string const& cfg1_out::get_includes() const
+    {
+      return pimpl_->includes_;
+    }
+
+    /*!
+     *  \brief  Sレコードのロード
+     */
+    void cfg1_out::load_srec()
+    {
+      std::ifstream srec_ifs( ( pimpl_->ofile_.file_name() + ".srec" ).c_str() );
+      if ( !srec_ifs.is_open() )
+      {
+        fatal( _( "cannot open file `%1%\'" ), pimpl_->ofile_.file_name() + ".srec" );
+      }
+      pimpl_->srec_ = std::tr1::shared_ptr< s_record >( new s_record( srec_ifs ) );
+
+      std::ifstream syms_ifs( ( pimpl_->ofile_.file_name() + ".syms" ).c_str() );
+      if ( !syms_ifs.is_open() )
+      {
+        fatal( _( "cannot open file `%1%\'" ), pimpl_->ofile_.file_name() + ".syms" );
+      }
+      pimpl_->syms_ = std::tr1::shared_ptr< nm_symbol >( new nm_symbol( syms_ifs ) );
+
+      nm_symbol::entry nm_entry = pimpl_->syms_->find( "TOPPERS_cfg_magic_number" );
+      if ( nm_entry.type < 0 )
+      {
+        fatal( _( "magic number is not found in `%1%\'" ), ( pimpl_->ofile_.file_name() + ".srec/.syms" ) );
+      }
+      unsigned long magic[ 4 ];
+      magic[ 0 ] = ( *pimpl_->srec_ )[ nm_entry.address + 0 ];
+      magic[ 1 ] = ( *pimpl_->srec_ )[ nm_entry.address + 1 ];
+      magic[ 2 ] = ( *pimpl_->srec_ )[ nm_entry.address + 2 ];
+      magic[ 3 ] = ( *pimpl_->srec_ )[ nm_entry.address + 3 ];
+      unsigned long magic_number = ( magic[ 0 ] << 24 ) | ( magic[ 1 ] << 16 ) | ( magic[ 2 ] << 8 ) | magic[ 3 ];
+      if ( magic_number == 0x12345678 )
+      {
+        pimpl_->little_endian_ = false;
+      }
+      else if ( magic_number == 0x78563412 )
+      {
+        pimpl_->little_endian_ = true;
+      }
+      else
+      {
+        fatal( _( "magic number is not found in `%1%\'" ), ( pimpl_->ofile_.file_name() + ".srec/.syms" ) );
+      }
+      pimpl_->do_assign_params();
+    }
+
+    /*!
+     *  \brief  "cfg1_out.srec" から読み取った情報の参照
+     */
+    std::tr1::shared_ptr< s_record > cfg1_out::get_srec() const
+    {
+      return pimpl_->srec_;
+    }
+
+    /*!
+     *  \brief  "cfg1_out.syms" から読み取った情報の参照
+     */
+    std::tr1::shared_ptr< nm_symbol > cfg1_out::get_syms() const
+    {
+      return pimpl_->syms_;
+    }
+
+    cfg1_out::cfg1_def_table const* cfg1_out::get_def_table() const
+    {
+      return pimpl_->def_table_;
+    }
+
+    /*!
+     *  \brief  カーネルオブジェクトごとに静的API情報をまとめる
+     *  \return 静的API情報
+     *
+     *  この関数は、"tsk"や"sem"といった種別をキーとして、その種別に分類される静的API情報の連想配列を生成する。
+     */
+    cfg1_out::static_api_map cfg1_out::merge() const
+    {
+      static_api_map result;
+      for ( std::vector< static_api >::const_iterator iter( pimpl_->static_api_array_.begin() ), last( pimpl_->static_api_array_.end() );
+            iter != last;
+            ++iter )
+      {
+        static_api::info const* info = iter->get_info();
+        if ( info != 0 )
+        {
+          result[ info->type ].push_back( *iter );
+        }
+      }
+      return result;
+    }
+
+    /*!
+     *  \brief  リトルエンディアンかどうかの判定
+     *  \retval     true  リトルエンディアン
+     *  \retval     false ビッグエンディアン
+     *  \attention  load_srec 呼び出し前は正しい結果を得られない。
+     */
+    bool cfg1_out::is_little_endian() const
+    {
+      return pimpl_->little_endian_;
+    }
+
+    /*!
+     *  \brief  静的APIのパラメータにSレコードから取得した値を代入する
+     */
+    void cfg1_out::implementation::do_assign_params()
+    {
+      std::vector< toppers::itronx::static_api > temp_array;
+
+      for ( std::vector< static_api >::size_type serial = 0, n = static_api_array_.size(); serial < n; ++serial )
+      {
+        toppers::itronx::static_api api( static_api_array_.at( serial ) );
+
+        nm_symbol::entry nm_entry = syms_->find( boost::str( boost::format( "TOPPERS_cfg_static_api_%d" ) % serial ) );
+        if ( nm_entry.type == -1 )
+        {
+          continue;
+        }
+
+        // sizeof( signed_t )
+        std::size_t const sizeof_signed_t = static_cast< std::size_t >( srec_->get_value( syms_->find( "TOPPERS_cfg_sizeof_signed_t" ).address, 4, little_endian_ ) );
+
+        for ( toppers::itronx::static_api::iterator api_iter( api.begin() ),
+                                                    api_last( api.end() );
+              api_iter != api_last;
+              ++api_iter )
+        {
+          if ( ( api_iter->symbol[0] == '.' ) || ( api_iter->symbol[0] == '+' ) || ( api_iter->symbol[0] == '*' ) )
+            // 整数定数式パラメータのみ値を取得
+          {
+            std::string parameter_name( api_iter->symbol.c_str() + 1 );
+
+            // 省略可能パラメータ情報の末尾にある ? を除去
+            if ( *parameter_name.rbegin() == '\?' )
+            {
+              parameter_name.resize( parameter_name.size() - 1 );
+            }
+
+            std::string symbol = boost::str( boost::format( "TOPPERS_cfg_valueof_%s_%d" ) % parameter_name % serial );
+            nm_symbol::entry nm_entry = syms_->find( symbol );
+            if ( nm_entry.type == -1 )
+            {
+              continue;
+            }
+            const std::size_t size = sizeof_signed_t;
+            std::tr1::intmax_t value = srec_->get_value( nm_entry.address, size, little_endian_ );
+
+            if ( api_iter->symbol[0] == '+' )
+            {
+              value = make_signed( static_cast< std::tr1::uint32_t >( value ) );
+            }
+            api_iter->value = value;
+          }
+          else if ( api_iter->symbol[0] == '$' )  // 文字列定数式パラメータ
+          {
+            std::string parameter_name( api_iter->symbol.c_str() + 1 );
+
+            // 省略可能パラメータ情報の末尾にある ? を除去
+            if ( *parameter_name.rbegin() == '\?' )
+            {
+              parameter_name.resize( parameter_name.size() - 1 );
+            }
+
+            std::string symbol = boost::str( boost::format( "TOPPERS_cfg_valueof_%s_%d" ) % parameter_name % serial );
+            nm_symbol::entry nm_entry = syms_->find( symbol );
+            if ( nm_entry.type == -1 )
+            {
+              continue;
+            }
+            std::string string;
+            string.reserve( 256 );
+            char c;
+            for ( long i = 0; ( c = static_cast< char >( srec_->get_value( nm_entry.address + i, 1, little_endian_ ) ) ) != '\0'; i++ )
+            {
+              string.push_back( c );
+            }
+
+            api_iter->string = string;
+          }
+        }
+        temp_array.push_back( api );
+      }
+      static_api_array_.swap( temp_array );
+    }
+
+    /*!
+     *  \brief  --id-input-fileオプションで指定したファイルの読み込み
+     *  \id_map 読み込んだデータの格納先
+     */
+    void cfg1_out::load_id_input_file( std::map< std::string, std::pair< long, bool > >& id_map )
+    {
+      std::string id_input_file( get_global< std::string >( "id-input-file" ) );
+      if ( id_input_file.empty() )
+      {
+        return;
+      }
+
+      std::ifstream ifs( id_input_file.c_str() );
+      while ( ifs )
+      {
+        std::string linebuf;
+        std::getline( ifs, linebuf );
+        if ( ifs.bad() )
+        {
+          fatal( _( "I/O error" ) );
+        }
+        if ( linebuf.empty() || linebuf == "\r" )
+        {
+          break;
+        }
+
+        std::istringstream iss( linebuf );
+        std::string name;
+        iss >> name;
+        if ( iss.fail() )
+        {
+          fatal( _( "id file `%1%\' is invalid" ), id_input_file );
+        }
+
+        long value;
+        iss >> value;
+        if ( iss.fail() )
+        {
+          fatal( _( "id file `%1%\' is invalid" ), id_input_file );
+        }
+
+        if ( id_map.find( name ) != id_map.end() )
+        {
+          fatal( _( "`%1%\' is duplicated" ), name );
+        }
+        else
+        {
+          id_map[ name ] = std::make_pair( value, false );
+        }
+      }
+    }
+
+  }
+}
Index: /cfg_itronx+oil_gcc/toppers/itronx/cfg1_out.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/cfg1_out.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/cfg1_out.hpp	(revision 54)
@@ -0,0 +1,141 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2010 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/itronx/cfg1_out.hpp
+ *  \brief  cfg1_out.c/.srec ファイルを扱うための宣言定義
+ *
+ *  このファイルで定義されるクラス
+ *  \code
+ *  class cfg1_out;
+ *  \endcode
+ */
+#ifndef TOPPERS_ITRONX_CFG1_OUT_HPP_
+#define TOPPERS_ITRONX_CFG1_OUT_HPP_
+
+#include <string>
+#include <vector>
+#include <map>
+#include "toppers/workaround.hpp"
+#include "toppers/codeset.hpp"
+#include "toppers/itronx/static_api.hpp"
+
+namespace toppers
+{
+
+  class macro_processor;
+  class s_record;
+  class nm_symbol;
+
+  namespace itronx
+  {
+
+    /*!
+     *  \class  cfg1_out  cfg1_out.hpp  "toppers/itronx/cfg1_out.hpp"
+     *  \brief  cfg1_out.c/.srec ファイル管理クラス
+     */
+    class cfg1_out
+    {
+    public:
+      struct cfg1_def_t
+      {
+        bool is_signed;
+        std::string name;
+        std::string expression;
+        std::string value1;
+        std::string value2;
+      };
+      typedef std::map< std::string, std::vector< static_api > > static_api_map;
+      typedef std::vector< cfg1_def_t > cfg1_def_table;
+
+      explicit cfg1_out( std::string const& filename, cfg1_def_table const* def_table = 0 );
+      cfg1_out( cfg1_out const& other );
+      virtual ~cfg1_out();
+      cfg1_out& operator = ( cfg1_out const& other )
+      {
+        cfg1_out t( other );
+        swap( t );
+        return *this;
+      }
+
+      void load_cfg( std::string const& input_file, codeset_t codeset, std::map< std::string, static_api::info > const& info_map );
+      void generate( char const* type = 0 ) const;
+      std::vector< static_api > const& get_static_api_array() const;
+      std::vector< std::pair< std::string, long > > const& get_domid_table() const;
+      std::vector< std::pair< std::string, long > > const& get_clsid_table() const;
+      std::string const& get_includes() const;
+
+      void load_srec();
+      std::tr1::shared_ptr< s_record > get_srec() const;
+      std::tr1::shared_ptr< nm_symbol > get_syms() const;
+      cfg1_def_table const* get_def_table() const;
+      static_api_map merge() const;
+      bool is_little_endian() const;
+
+      void swap( cfg1_out& other )
+      {
+        implementation* t = pimpl_;
+        pimpl_ = other.pimpl_;
+        other.pimpl_ = t;
+      }
+
+      static std::tr1::int32_t make_signed( std::tr1::uint32_t value )
+      {
+        std::tr1::int32_t result;
+        if ( ( value >> 31 ) != 0 )
+        {
+          result = -static_cast< std::tr1::int32_t >( ( value ^ 0xffffffff ) + 1 ); // 2の補数表現にしか対応しない
+        }
+        else
+        {
+          result = static_cast< std::tr1::int32_t >( value );
+        }
+        return result;
+      }
+
+      static void load_id_input_file( std::map< std::string, std::pair< long, bool > >& id_map );
+
+    protected:
+      struct implementation;
+      explicit cfg1_out( implementation* pimpl ) : pimpl_( pimpl ) {}
+    private:
+      implementation* pimpl_;
+    };
+
+  }
+}
+
+#endif  // ! TOPPERS_ITRONX_CFG1_OUT_HPP_
Index: /cfg_itronx+oil_gcc/toppers/itronx/checker.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/checker.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/checker.cpp	(revision 54)
@@ -0,0 +1,172 @@
+/*
+ *  TOPPERS/ASP Kernel
+ *      Toyohashi Open Platform for Embedded Real-Time Systems/
+ *      Advanced Standard Profile Kernel
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <fstream>
+#include <map>
+#include "toppers/workaround.hpp"
+#include "toppers/s_record.hpp"
+#include "toppers/nm_symbol.hpp"
+#include "toppers/misc.hpp"
+#include "toppers/diagnostics.hpp"
+#include "toppers/itronx/checker.hpp"
+#include "toppers/itronx/cfg1_out.hpp"
+
+namespace toppers
+{
+  namespace itronx
+  {
+
+    struct checker::implementation
+    {
+    protected:
+      std::tr1::shared_ptr< s_record > srec_;
+      std::tr1::shared_ptr< nm_symbol > syms_;
+
+      virtual ~implementation() {}
+      virtual bool do_check( cfg1_out& cfg1out, std::map< std::string, std::size_t > const& count_map )
+      {
+        return true;
+      }
+      virtual implementation* do_clone() const
+      {
+        return new implementation( *this );
+      }
+
+      friend class checker;
+    };
+
+    checker::checker()
+      : pimpl_( new implementation )
+    {
+    }
+
+    /*!
+     *  \brief  コピーコンストラクタ
+     *  \param[in]  コピー元
+     */
+    checker::checker( checker const& other )
+      : pimpl_( other.pimpl_->do_clone() )
+    {
+    }
+
+    //! デストラクタ
+    checker::~checker()
+    {
+      delete pimpl_;
+      pimpl_ = 0;
+    }
+
+    /*!
+     *  \brief  ROMイメージのロード
+     *  \param[in]  srec_file   Sレコード形式のファイル名
+     *  \param[in]  nm_file     nmコマンドが出力したシンボルテーブルのファイル名
+     */
+    void checker::load_rom_image( std::string const& srec_file, std::string const& nm_file )
+    {
+      std::ifstream ifs_srec( srec_file.c_str() );
+      if ( !ifs_srec.is_open() )
+      {
+        fatal( _( "cannot open file `%1%\'" ), srec_file );
+      }
+      std::tr1::shared_ptr< s_record > srec( new s_record( ifs_srec ) );
+
+      std::ifstream ifs_nm( nm_file.c_str() );
+      if ( !ifs_nm.is_open() )
+      {
+        fatal( _( "cannot open file `%1%\'" ), nm_file );
+      }
+      std::tr1::shared_ptr< nm_symbol > syms( new nm_symbol( ifs_nm ) );
+
+      pimpl_->srec_.swap( srec );
+      pimpl_->syms_.swap( syms );
+    }
+
+    /*!
+     *  \brief  チェックの実施
+     *  \param[in]  cfg1_out情報
+     */
+    bool checker::check( cfg1_out& cfg1out ) const
+    {
+      cfg1_out::static_api_map api_map( cfg1out.merge() );
+
+      std::map< std::string, std::size_t > count_map;
+      for ( cfg1_out::static_api_map::const_iterator iter( api_map.begin() ), last( api_map.end() );
+            iter != last;
+            ++iter )
+      {
+        std::size_t count = 0;
+        for ( std::vector< static_api >::const_iterator iter2( iter->second.begin() ), last2( iter->second.end() );
+              iter2 != last2;
+              ++iter2 )
+        {
+          if ( !iter2->get_info()->slave )
+          {
+            ++count;
+          }
+        }
+        count_map[ iter->first ] = count;
+      }
+
+      return pimpl_->do_check( cfg1out, count_map );
+    }
+
+    /*!
+     *  \brief  シンボル情報の検索
+     *  \param[in]  symbol  検索するシンボル名
+     *  \return     検索結果
+     *
+     *  検索に失敗した場合には、返却値の.typeフィールドに-1が設定される。
+     */
+    nm_symbol::entry checker::find( std::string const& symbol ) const
+    {
+      return pimpl_->syms_->find( symbol );
+    }
+
+    /*!
+     *  \brief  指定アドレスの整数値を取得
+     *  \param[in]  address   アドレス
+     *  \param[in]  size      整数値を構成するバイト数
+     *  \param[in]  little_endian   バイトオーダーがリトルエンディアンならtrueを指定する
+     *  \return     取得した整数値を符号無しで返す。
+     */
+    std::tr1::uintmax_t checker::get( std::size_t address, std::size_t size, bool little_endian ) const
+    {
+      return pimpl_->srec_->get_value( address, size, little_endian );
+    }
+
+  }
+}
Index: /cfg_itronx+oil_gcc/toppers/itronx/checker.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/checker.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/checker.hpp	(revision 54)
@@ -0,0 +1,91 @@
+/*
+ *  TOPPERS/ASP Kernel
+ *      Toyohashi Open Platform for Embedded Real-Time Systems/
+ *      Advanced Standard Profile Kernel
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#ifndef TOPPERS_ITRONX_CHECKER_HPP_
+#define TOPPERS_ITRONX_CHECKER_HPP_
+
+#include <cstddef>
+#include <string>
+#include "toppers/workaround.hpp"
+#include "toppers/nm_symbol.hpp"
+
+namespace toppers
+{
+  namespace itronx
+  {
+
+    class cfg1_out;
+
+    /*!
+     *  \class  checker checker.hpp "toppers/itronx/checker.hpp"
+     *  \brief  全体リンク後のパラメータチェック処理クラス
+     */
+    class checker
+    {
+    public:
+      checker();
+      checker( checker const& other );
+      virtual ~checker();
+      checker& operator=( checker const& other )
+      {
+        checker t( other );
+        swap( t );
+        return *this;
+      }
+
+      void load_rom_image( std::string const& srec_file, std::string const& nm_file );
+      bool check( cfg1_out& cfg1out ) const;
+      nm_symbol::entry find( std::string const& symbol ) const;
+      std::tr1::uintmax_t get( std::size_t address, std::size_t size, bool little_endian ) const;
+
+      void swap( checker& other )
+      {
+        implementation* t = pimpl_;
+        pimpl_ = other.pimpl_;
+        other.pimpl_ = t;
+      }
+    protected:
+      struct implementation;
+      explicit checker( implementation* pimpl ) : pimpl_( pimpl ) {}
+    private:
+      implementation* pimpl_;
+    };
+
+  }
+}
+
+#endif  // ! TOPPERS_ITRONX_CHECKER_HPP_
Index: /cfg_itronx+oil_gcc/toppers/itronx/component.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/component.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/component.cpp	(revision 54)
@@ -0,0 +1,385 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2010 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <cstdlib>
+#include <cstring>
+#include <cerrno>
+#include <string>
+#include <vector>
+#include <utility>
+#include <algorithm>
+#include <fstream>
+#include "toppers/macro_processor.hpp"
+#include "toppers/diagnostics.hpp"
+#include "toppers/gettext.hpp"
+#include "toppers/cpp.hpp"
+#include "toppers/global.hpp"
+#include "toppers/misc.hpp"
+#include "toppers/itronx/static_api.hpp"
+#include "toppers/itronx/factory.hpp"
+#include "toppers/itronx/component.hpp"
+#include <boost/format.hpp>
+#include <boost/utility.hpp>
+#include <boost/lexical_cast.hpp>
+
+namespace toppers
+{
+  namespace
+  {
+    typedef macro_processor::element element;
+    typedef macro_processor::var_t var_t;
+    typedef macro_processor::context context;
+
+    inline std::tr1::int64_t get_i( var_t const& var, context const* p_ctx )
+    {
+      return macro_processor::to_integer( var, p_ctx );
+    }
+    inline std::string get_s( var_t const& var, context const* p_ctx )
+    {
+      return macro_processor::to_string( var, p_ctx );
+    }
+
+    inline bool less_element( const element& lhs, const element& rhs )
+    {
+      return *lhs.i < *rhs.i;
+    }
+
+    /*!
+     *  \brief  ID番号を割付ける
+     *  \param[in]  line      行番号
+     *  \param[in]  arg_list  マクロ実引数リスト
+     *  \param[in]  p_ctx     マクロコンテキスト
+     *  \retval     マクロ返却値
+     *  第一引数で指定した種別のオブジェクトに対してID番号を割付け、個々のパラメータを表す変数、
+     *  TEXT_LINE、ID_LIST、ORDER_LIST、およびRORDER_LISTを設定する。ただし、ID番号を持たない
+     *  オブジェクトの場合、ID_LISTは設定しない。
+     */
+    var_t bf_assignid( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+    {
+      if ( macro_processor::check_arity( line, arg_list.size(), 1, "ASSIGNID" ) )
+      {
+        itronx::factory* factory = get_global< itronx::factory* >( "factory" );
+        std::map< std::string, itronx::static_api::info > const* info_map = factory->get_static_api_info_map();
+
+        std::string type = get_s( arg_list[ 0 ], p_ctx );    // 出力先リストの識別名
+        std::string TYPE = toppers::toupper( type );
+        typedef std::map< std::string, long > id_map_t;
+        typedef std::map< long, std::string > id_rmap_t;
+        id_map_t id_map;
+        id_rmap_t id_rmap;
+        var_t id_list, order_list, rorder_list;
+        bool has_id = false;
+
+        std::string id_input_file( get_global< std::string >( "id-input-file" ) );
+        if ( !id_input_file.empty() )  // --id-input-file オプションが指定されている場合...
+        {
+          std::ifstream ifs( id_input_file.c_str() );
+          while ( ifs )
+          {
+            std::string linebuf;
+            std::getline( ifs, linebuf );
+            if ( ifs.bad() )
+            {
+              fatal( _( "I/O error" ) );
+            }
+            if ( linebuf.empty() || linebuf == "\r" )
+            {
+              break;
+            }
+
+            std::istringstream iss( linebuf );
+            std::string name;
+            iss >> name;
+            if ( iss.fail() )
+            {
+              fatal( _( "id file `%1%\' is invalid" ), id_input_file );
+            }
+
+            long value;
+            iss >> value;
+            if ( iss.fail() )
+            {
+              fatal( _( "id file `%1%\' is invalid" ), id_input_file );
+            }
+
+            if ( id_map.find( name ) != id_map.end() )
+            {
+              fatal( _( "E_OBJ: `%1%\' is duplicated" ), name );
+            }
+            else
+            {
+              id_map[ name ] = value;
+              id_rmap[ value ] = name;
+            }
+          }
+        }
+        long order = 1;
+        for ( int i = 1; ; i++ )
+        {
+          std::string str_i = boost::lexical_cast< std::string >( i );
+          if ( p_ctx->var_map.find( "API.TYPE[" + str_i + "]" ) == p_ctx->var_map.end() )
+          {
+            break;
+          }
+          std::string api_name = p_ctx->var_map[ "API.NAME[" + str_i + "]" ].at( 0 ).s;
+          std::map< std::string, itronx::static_api::info >::const_iterator it = info_map->find( api_name );
+          if ( it == info_map->end() )
+          {
+            break;
+          }
+          itronx::static_api::info info = it->second;
+          if ( info.type != type )
+          {
+            continue;
+          }
+
+          var_t params = p_ctx->var_map[ "API.PARAMS[" + str_i + "]" ];
+          var_t args = p_ctx->var_map[ "API.ARGS[" + str_i + "]" ];
+          long id = -1;
+
+          if ( info.id_pos >= 0 )  // ID番号のあるもの...
+          {
+            if ( !info.slave )
+            {
+              if ( std::strchr( info.params, '#' ) != 0 ) // オブジェクト識別名を持つ場合...
+              {
+                for ( id = 1; id_rmap.find( id ) != id_rmap.end(); id++ ) // 未使用のID番号を検索
+                  ;
+                args.at( info.id_pos ).i = id; // ID番号を設定
+              }
+              else
+              {
+                id = static_cast< long >( *args.at( info.id_pos ).i );
+              }
+              std::string idname = args[ info.id_pos ].s; // IDの字面
+              id_map[ idname ] = id;
+              id_rmap[ id ] = idname;
+              order_list.push_back( args[ info.id_pos ] );
+            }
+            else
+            {
+              id_map_t::iterator it = id_map.find( args.at( info.id_pos ).s );
+              if ( it == id_map.end() )
+              {
+                fatal( line, _( "`%1%\' is undefined" ), args[ info.id_pos ].s );
+              }
+              args.at( info.id_pos ).i = it->second;
+            }
+            has_id = true;
+          }
+          else  // ID番号の無いもの...
+          {
+            element e;
+            e.i = order;
+            order_list.push_back( e );
+          }
+          std::string str_id = boost::lexical_cast< std::string >( id > 0 ? id : order );
+
+          // 各パラメータの変数を設定
+          for ( var_t::size_type i = 0, n = params.size(); i < n; i++ )
+          {
+            std::string var_name = params[ i ].s + "[" + str_id + "]";
+            p_ctx->var_map[ var_name ] = var_t( 1, args.at( i ) );
+          }
+          p_ctx->var_map[ TYPE + ".TEXT_LINE[" + str_id + "]" ] = p_ctx->var_map[ "API.TEXT_LINE[" + str_i + "]" ];
+          ++order;
+        }
+
+        id_list = order_list;
+        std::sort( id_list.begin(), id_list.end(), less_element );
+        rorder_list = order_list;
+        std::reverse( rorder_list.begin(), rorder_list.end() );
+        p_ctx->var_map[ TYPE + ".ID_LIST" ] = id_list;
+        p_ctx->var_map[ TYPE + ".ORDER_LIST" ] = order_list;
+        p_ctx->var_map[ TYPE + ".RORDER_LIST" ] = rorder_list;
+      }
+      return var_t();
+    }
+
+    /*!
+     *  \brief  指定した連想配列群に静的APIを追加する
+     *  \param[in]  line      行番号
+     *  \param[in]  arg_list  マクロ実引数リスト
+     *  \param[in]  p_ctx     マクロコンテキスト
+     *  \retval     マクロ返却値
+     *  API.で始まる連想配列群を、必要に応じて適切に変換を行った上で、別のプレフィックスで始まる
+     *  連想配列群に追加する。想定する使用方法としては、特定のソフトウェア部品で理解可能な静的API
+     *  に関しては、追加を行わないか、他の静的APIに置き換えて追加を行う。理解できない静的APIに関して
+     *  はそのまま追加を行う。
+     *  この関数の第一引数にはAPI.で始まる連想配列の連番を、第二引数には追加先に連想配列群の
+     *  プレフィックスを、第三引数には対象とする静的API名を、第四引数には追加するパラメータシンボルの
+     *  並びを、第五引数にはパラメータの並びを指定する。     
+     */
+    var_t bf_addapi( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+    {
+      element e;
+      if ( macro_processor::check_arity( line, arg_list.size(), 5, "ADDAPI" ) )
+      {
+        itronx::factory* factory = get_global< itronx::factory* >( "factory" );
+        std::map< std::string, itronx::static_api::info > const* info_map = factory->get_static_api_info_map();
+
+        std::tr1::int64_t order = get_i( arg_list[ 0 ], p_ctx );  // 元の静的APIの連番
+        std::string list_name = get_s( arg_list[ 1 ], p_ctx );    // 出力先リストの識別名
+        std::string api_name = get_s( arg_list[ 2 ], p_ctx );     // 静的API名
+        var_t params = arg_list[ 3 ]; // パラメータシンボルの並び
+        var_t args = arg_list[ 4 ];   // パラメータの並び
+
+        std::map< std::string, itronx::static_api::info >::const_iterator it = info_map->find( api_name );
+        if ( it != info_map->end() )
+        {
+          itronx::static_api::info info = it->second;
+          std::string str_order = boost::lexical_cast< std::string >( order );
+          p_ctx->var_map[ list_name + ".TEXT_LINE[" + str_order + "]" ] = p_ctx->var_map[ "API.TEXT_LINE[" + str_order + "]" ]; 
+          e.s = api_name;
+          p_ctx->var_map[ list_name + ".NAME[" + str_order + "]" ] = var_t( 1, e );
+          e.s = info.type;
+          p_ctx->var_map[ list_name + ".TYPE[" + str_order + "]" ] = var_t( 1, e );
+          p_ctx->var_map[ list_name + ".PARAMS[" + str_order + "]" ] = params;
+          p_ctx->var_map[ list_name + ".ARGS[" + str_order + "]" ] = args;
+
+          e.s.clear();
+          if ( !p_ctx->var_map[ list_name + ".ORDER_LIST" ].empty() )
+          {
+            e.i = *p_ctx->var_map[ list_name + ".ORDER_LIST" ].back().i + 1;
+          }
+          else
+          {
+            e.i = 1;
+          }
+          p_ctx->var_map[ list_name + ".ORDER_LIST" ].push_back( e );
+
+          e.s.clear();
+          e.i = 1;
+        }
+      }
+      return var_t( 1, e );
+    }
+
+    /*!
+     *  \brief  変数群の交換
+     *  \param[in]  line      行番号
+     *  \param[in]  arg_list  マクロ実引数リスト
+     *  \param[in]  p_ctx     マクロコンテキスト
+     *  \retval     マクロ返却値
+     *  第一引数および第二引数で指定したプレフィックスを持つ変数群を入れ替える。
+     *  ‘ADDAPI’関数で、別のプレフィックスを持つ連想配列を組み立てたあとは、この関数を用いることで、
+     *  API.をプレフィックスに持つ連想配列と交換することができる。
+     */
+    var_t bf_swapprefix( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+    {
+      if ( macro_processor::check_arity( line, arg_list.size(), 2, "SWAPPREFIX" ) )
+      {
+        std::string list1_name = get_s( arg_list[ 0 ], p_ctx ) + ".";    // 一方のAPIリストの識別名.
+        std::string list2_name = get_s( arg_list[ 1 ], p_ctx ) + ".";    // 他方のAPIリストの識別名.
+        std::string::size_type list1_size = list1_name.size();
+        std::string::size_type list2_size = list2_name.size();
+
+        std::map< std::string, var_t > temp;
+        for ( std::map< std::string, var_t >::const_iterator iter = p_ctx->var_map.begin(), last = p_ctx->var_map.end();
+              iter != last;
+              ++iter )
+        {
+          std::pair< std::string, var_t > element = *iter;
+          if ( std::strncmp( iter->first.c_str(), list1_name.c_str(), list1_size ) == 0 )
+          {
+            element.first = list2_name + ( iter->first.c_str() + list1_size );
+          }
+          else if ( std::strncmp( iter->first.c_str(), list2_name.c_str(), list2_size ) == 0 )
+          {
+            element.first = list1_name + ( iter->first.c_str() + list2_size );
+          }
+          temp.insert( element );
+        }
+        p_ctx->var_map.swap( temp );
+      }
+      return var_t();
+    }
+
+    /*!
+     *  \brief  変数群の交換
+     *  \param[in]  line      行番号
+     *  \param[in]  arg_list  マクロ実引数リスト
+     *  \param[in]  p_ctx     マクロコンテキスト
+     *  \retval     マクロ返却値
+     *  第一引数で指定したプレフィックスで始まる変数群を削除する。’SWAPPREFIX’関数で交換したあと、
+     *  不要になった変数群はこの関数で削除しておくことが望ましい。
+     */
+    var_t bf_cleanvars( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+    {
+      if ( macro_processor::check_arity( line, arg_list.size(), 1, "CLEANVARS" ) )
+      {
+        std::string prefix = get_s( arg_list[ 0 ], p_ctx ) + ".";    // 変数の接頭辞
+        std::size_t n = prefix.size();
+        std::map< std::string, var_t > temp_map;
+
+        for ( std::map< std::string, var_t >::const_iterator iter = p_ctx->var_map.begin(), last =p_ctx->var_map.end();
+              iter != last;
+              ++iter )
+        {
+          if ( std::strncmp( iter->first.c_str(), prefix.c_str(), n ) != 0 )
+          {
+            temp_map.insert( *iter );
+          }
+        }
+        p_ctx->var_map.swap( temp_map );
+      }
+      return var_t();
+    }
+
+    macro_processor::func_t const function_table[] =
+    {
+      { "ASSIGNID",   &bf_assignid },
+      { "ADDAPI",     &bf_addapi },
+      { "SWAPPREFIX", &bf_swapprefix },
+      { "CLEANVARS",  &bf_cleanvars },
+    };
+
+  }
+
+  namespace itronx
+  {
+
+    component::component( macro_processor* mproc )
+      : mproc_( mproc )
+    {
+      for ( std::size_t i = 0; i < sizeof( function_table ) / sizeof( function_table[ 0 ] ); i++ )
+      {
+        mproc_->add_builtin_function( function_table[ i ] );
+      }
+    }
+
+  }
+}
Index: /cfg_itronx+oil_gcc/toppers/itronx/component.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/component.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/component.hpp	(revision 54)
@@ -0,0 +1,74 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2010 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/itronx/component.hpp
+ *  \brief  ソフトウェア部品用のコンフィギュレーションを扱うための宣言定義
+ *
+ *  このファイルで定義されるクラス
+ *  \code
+ *  class component;
+ *  \endcode
+ */
+#ifndef TOPPERS_ITRONX_COMPONENT_HPP_
+#define TOPPERS_ITRONX_COMPONENT_HPP_
+
+namespace toppers
+{
+
+  class macro_processor;
+
+  namespace itronx
+  {
+
+    /*!
+     *  \class  component component.hpp "toppers/itronx/component.hpp"
+     *  \brief  ソフトウェア部品用のコンフィギュレーションを扱うためのクラス
+     *  \note   現状ではコンストラクタ以外のメンバ関数を持たない。将来の拡張用にクラスにする。
+     */
+    class component
+    {
+    public:
+      explicit component( macro_processor* mproc );
+      // 現状ではメンバ無し
+    private:
+      macro_processor* mproc_;
+    };
+
+  }
+}
+
+#endif  // !TOPPERS_ITRONX_COMPONENT_HPP_
Index: /cfg_itronx+oil_gcc/toppers/itronx/factory.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/factory.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/factory.cpp	(revision 54)
@@ -0,0 +1,716 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2011 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <cstring>
+#include <cstdlib>
+#include <fstream>
+#include <boost/lexical_cast.hpp>
+#include "toppers/misc.hpp"
+#include "toppers/global.hpp"
+#include "toppers/csv.hpp"
+#include "toppers/nm_symbol.hpp"
+#include "toppers/s_record.hpp"
+#include "toppers/diagnostics.hpp"
+#include "toppers/macro_processor.hpp"
+#include "toppers/io.hpp"
+#include "toppers/cpp.hpp"
+#include "toppers/itronx/factory.hpp"
+#include "toppers/itronx/cfg1_out.hpp"
+
+namespace toppers
+{
+  namespace itronx
+  {
+    namespace
+    {
+
+      // カーネルオブジェクト生成・定義用静的APIの各パラメータをマクロプロセッサの変数として設定する。
+      void set_object_vars( cfg1_out::static_api_map const& api_map, macro_processor& mproc )
+      {
+        typedef macro_processor::element element;
+        typedef macro_processor::var_t var_t;
+        std::map< std::string, var_t > order_list_map;
+        std::map< std::string, long > id_map;
+
+        for ( cfg1_out::static_api_map::const_iterator m_iter( api_map.begin() ), m_last( api_map.end() );
+              m_iter != m_last;
+              ++m_iter )
+        {
+          int order = 1;
+
+          for ( std::vector< static_api >::const_iterator v_iter( m_iter->second.begin() ), v_last( m_iter->second.end() );
+                v_iter != v_last;
+                ++v_iter )
+          {
+            static_api::info const* info = v_iter->get_info();
+
+            long id = -1;
+            if ( !info->slave )
+            {
+              // 出現順 $OBJ.ORDER$
+              if ( v_iter->id().value )
+              {
+                id = static_cast< long >( v_iter->id().value.get() );
+              }
+              else
+              {
+                id = order;
+              }
+              id_map[ v_iter->id().text ] = id;
+              element e;
+              e.i = order;
+              mproc.set_var( toppers::toupper( ( boost::format( "%s.order" ) % info->type ).str() ), id, var_t( 1, e ) );
+
+              e.i = id;
+              e.s = v_iter->id().text;
+              order_list_map[ info->type ].push_back( e );
+              ++order;
+            }
+            else
+            {
+              std::map< std::string, long >::iterator iter( id_map.find( v_iter->id().text ) );
+              if ( iter == id_map.end() )
+              {
+                error( v_iter->line(), _( "E_NOEXS: `%1%\' is undefined" ), v_iter->id().text );
+              }
+              else
+              {
+                id = iter->second;
+              }
+            }
+
+            // 各パラメータ
+            var_t var;
+            std::string prev_name;
+            for ( static_api::const_iterator api_iter( v_iter->begin() ), api_last( v_iter->end() );
+                  api_iter != api_last;
+                  ++api_iter )
+            {
+              bool is_param_list = false;
+
+              std::string name( toppers::toupper( ( boost::format( "%s.%s" ) % info->type % ( api_iter->symbol.c_str() + 1 ) ).str() ) );
+              // 末尾の ? を除去
+              if ( *name.rbegin() == '\?' ) 
+              {
+                name.resize( name.size() - 1 );
+              }
+              // 末尾の ... を除去
+              if ( name.size() > 3 && name.substr( name.size() - 3 ) == "..." )
+              {
+                name.resize( name.size() - 3 );
+                is_param_list = true;
+              }
+
+              if (!var.empty())
+              {
+                if (prev_name != name)
+                {
+                  var.clear();
+                }
+              }
+
+              element e;
+              e.s = api_iter->text; // ソースの字面
+              if ( api_iter->symbol[0] != '&' )   // 一般定数式パラメータは値が特定できない
+              {
+                if ( api_iter->symbol[0] == '$' )  // 文字列定数式パラメータ
+                {
+                  e.v = api_iter->string; // 展開後の文字列
+                }
+                else
+                {
+                  e.i = api_iter->value;
+                }
+                if ( api_iter->symbol[0] == '%' )
+                {
+                  continue;
+                }
+              }
+              var.push_back(e);
+              mproc.set_var( name, id, var );
+
+              prev_name = name;
+
+              // 下位互換性のため、symbol + order 名の変数を登録
+              if (is_param_list)
+              {
+                name += boost::lexical_cast< std::string >( api_iter->order );
+                mproc.set_var( name, id, var_t( 1, e ) );
+              }
+            }
+
+            // 静的APIが出現した行番号
+            {
+              element e;
+              e.s = v_iter->line().file;
+              e.i = v_iter->line().line;
+              std::string type( toppers::toupper( info->type ) );
+
+              if ( info->slave )
+              {
+                type = info->api_name;
+              }
+              mproc.set_var( type + ".TEXT_LINE", id, var_t( 1, e ) );
+            }
+          }
+        }
+
+        std::map< std::string, var_t > id_list_map;
+
+        for ( std::map< std::string, var_t >::const_iterator iter( order_list_map.begin() ), last( order_list_map.end() );
+              iter != last;
+              ++iter )
+        {
+          // 出現順リスト $OBJ.ORDER_LIST$ -- ID番号の並び
+          mproc.set_var( toppers::toupper( iter->first + ".order_list" ), iter->second );
+          var_t rorder_list( iter->second );
+
+          // 逆順リスト $OBJ.RORDER_LIST$ -- ID番号の並び
+          std::reverse( rorder_list.begin(), rorder_list.end() );
+          mproc.set_var( toppers::toupper( iter->first + ".rorder_list" ), rorder_list );
+
+          // ID番号リスト $OBJ.ID_LIST$ -- ID番号の並び
+          var_t id_list( iter->second );
+          std::sort( id_list.begin(), id_list.end() );
+          mproc.set_var( toppers::toupper( iter->first + ".id_list" ), id_list );
+        }
+
+        element external_id;
+        external_id.i = get_global< bool >( "external-id" );
+        mproc.set_var( "USE_EXTERNAL_ID", var_t( 1, external_id ) );
+      }
+
+      // カーネルオブジェクト生成・定義用静的APIの各パラメータをマクロプロセッサの変数として設定する。
+      void set_object_vars( std::vector< static_api > const& api_array, macro_processor& mproc )
+      {
+        typedef macro_processor::element element;
+        typedef macro_processor::var_t var_t;
+        long order = 1;
+        var_t order_list;
+
+        for ( std::vector< static_api >::const_iterator v_iter( api_array.begin() ), v_last( api_array.end() );
+              v_iter != v_last;
+              ++v_iter )
+        {
+          static_api::info const* info = v_iter->get_info();
+          var_t params;
+          var_t args;
+
+          // 静的APIが出現した行番号
+          element e;
+          e.s = v_iter->line().file;
+          e.i = v_iter->line().line;
+          mproc.set_var( "API.TEXT_LINE", order, var_t( 1, e ) );
+
+          // 静的API名
+          e.s = info->api_name;
+          e.i = boost::none;
+          mproc.set_var( "API.NAME", order, var_t( 1, e ) );
+
+          // オブジェクトタイプ（"TSK", "SEM", ...）
+          e.s = toppers::toupper( info->type );
+          mproc.set_var( "API.TYPE", order, var_t( 1 , e ) );
+
+          // 各パラメータ
+          for ( static_api::const_iterator api_iter( v_iter->begin() ), api_last( v_iter->end() );
+                api_iter != api_last;
+                ++api_iter )
+          {
+            std::string name( toppers::toupper( ( boost::format( "%s.%s" ) % info->type % ( api_iter->symbol.c_str() + 1 ) ).str() ) );
+            // 末尾の ? を除去
+            if ( *name.rbegin() == '\?' ) 
+            {
+              name.resize( name.size() - 1 );
+            }
+            // 末尾の ... を除去 & order を付加
+            if ( name.size() > 3 && name.substr( name.size() - 3 ) == "..." )
+            {
+              name.resize( name.size() - 3 );
+              name += boost::lexical_cast< std::string >( api_iter->order );
+            }
+
+            element e;
+            e.s = api_iter->text; // ソースの字面
+            if ( api_iter->symbol[0] != '&' )   // 一般定数式パラメータは値が特定できない
+            {
+              if ( api_iter->symbol[0] == '$' )  // 文字列定数式パラメータ
+              {
+                e.v = api_iter->string; // 展開後の文字列
+              }
+              else
+              {
+                e.i = api_iter->value;
+              }
+            }
+            args.push_back( e );
+
+            e.s = name;
+            e.i = boost::none;
+            params.push_back( e );
+
+            if ( api_iter->symbol[0] == '%' )
+            {
+              continue;
+            }
+          }
+          mproc.set_var( "API.ARGS", order, args );
+          mproc.set_var( "API.PARAMS", order, params );
+          e.s.clear();
+          e.i = order;
+          order_list.push_back( e );
+          ++order;
+        }
+        mproc.set_var( "API.ORDER_LIST", order_list );
+
+        element external_id;
+        external_id.i = get_global< bool >( "external-id" );
+        mproc.set_var( "USE_EXTERNAL_ID", var_t( 1, external_id ) );
+      }
+
+      // クラスIDリストをマクロプロセッサの変数として設定する。
+      void set_clsid_vars( std::vector< std::pair< std::string, long > > const& table, cfg1_out const& cfg1out, macro_processor& mproc )
+      {
+        typedef macro_processor::element element;
+        macro_processor::var_t var;
+
+        bool little_endian = cfg1out.is_little_endian();
+        nm_symbol::entry nm_entry = cfg1out.get_syms()->find( "TOPPERS_cfg_sizeof_signed_t" );
+        std::size_t sizeof_signed_t = static_cast< std::size_t >( cfg1out.get_srec()->get_value( nm_entry.address, 4, little_endian ) );
+
+        for ( std::vector< std::pair< std::string, long > >::const_iterator iter( table.begin() ), last( table.end() );
+              iter != last;
+              ++iter )
+        {
+          if ( !iter->first.empty() )
+          {
+            element e;
+            e.s = iter->first;
+
+            std::string symbol = "TOPPERS_cfg_valueof_" + iter->first;
+            nm_symbol::entry nm_entry = cfg1out.get_syms()->find( symbol );
+            if ( nm_entry.type == -1 )
+            {
+              continue;
+            }
+            const std::size_t size = sizeof_signed_t;
+            std::tr1::intmax_t value = cfg1out.get_srec()->get_value( nm_entry.address, size, little_endian );
+
+            e.i = value;
+
+            var.push_back( e );
+          }
+        }
+        // クラスIDの値でソートしていない
+        mproc.set_var( "CLS.ID_LIST", var );
+      }
+
+      // ドメインIDリストをマクロプロセッサの変数として設定する。
+      void set_domid_vars( std::vector< std::pair< std::string, long > > const& table, macro_processor& mproc )
+      {
+        typedef macro_processor::element element;
+        macro_processor::var_t var;
+
+        for ( std::vector< std::pair< std::string, long > >::const_iterator iter( table.begin() ), last( table.end() );
+              iter != last;
+              ++iter )
+        {
+          if ( !iter->first.empty() )
+          {
+            element e;
+            e.s = iter->first;
+            e.i = iter->second;
+            var.push_back( e );
+          }
+        }
+        mproc.set_var( "DOM.ID_LIST", var );
+      }
+
+      // プラットフォーム・コンパイラ依存の値をマクロプロセッサの変数として設定する。
+      void set_platform_vars( cfg1_out const& cfg1out, macro_processor& mproc )
+      {
+        typedef macro_processor::element element;
+        typedef macro_processor::var_t var_t;
+
+        cfg1_out::cfg1_def_table const* def_table = cfg1out.get_def_table();
+        std::size_t sizeof_signed_t;
+        std::size_t sizeof_pointer;
+
+        static cfg1_out::cfg1_def_t const limit_defs[] =
+        {
+          { false, "TOPPERS_cfg_CHAR_BIT",  "CHAR_BIT" },
+          { false, "TOPPERS_cfg_CHAR_MAX",  "CHAR_MAX" },
+          { true, "TOPPERS_cfg_CHAR_MIN",  "CHAR_MIN" },
+          { false, "TOPPERS_cfg_SCHAR_MAX", "SCHAR_MAX" },  // 本来は符号付きだが、負になることはない
+          { false, "TOPPERS_cfg_SHRT_MAX",  "SHRT_MAX" },   // 本来は符号付きだが、負になることはない
+          { false, "TOPPERS_cfg_INT_MAX",   "INT_MAX" },    // 本来は符号付きだが、負になることはない
+          { false, "TOPPERS_cfg_LONG_MAX",  "LONG_MAX" },   // 本来は符号付きだが、負になることはない
+        };
+
+        nm_symbol::entry nm_entry = cfg1out.get_syms()->find( "TOPPERS_cfg_sizeof_signed_t" );
+        sizeof_signed_t = static_cast< std::size_t >( cfg1out.get_srec()->get_value( nm_entry.address, 4, cfg1out.is_little_endian() ) );
+
+        nm_entry = cfg1out.get_syms()->find( "TOPPERS_cfg_sizeof_pointer" );
+        sizeof_pointer = static_cast< std::size_t >( cfg1out.get_srec()->get_value( nm_entry.address, 4, cfg1out.is_little_endian() ) );
+
+        for ( std::size_t i = 0; i < sizeof limit_defs / sizeof limit_defs[ 0 ]; ++i )
+        {
+          element e;
+          e.s = limit_defs[ i ].expression;
+          nm_entry = cfg1out.get_syms()->find( limit_defs[ i ].name );
+          std::tr1::int64_t value = cfg1out.get_srec()->get_value( nm_entry.address, sizeof_signed_t, cfg1out.is_little_endian() );
+          if ( sizeof_signed_t < 8 && limit_defs[ i ].is_signed )
+          {
+            value = cfg1_out::make_signed( static_cast< std::tr1::uint32_t >( value ) );
+          }
+          mproc.set_var( e.s, var_t( 1, e ) );
+        }
+
+        for ( cfg1_out::cfg1_def_table::const_iterator iter( def_table->begin() ), last( def_table->end() );
+              iter != last;
+              ++iter )
+        {
+          element e;
+          std::tr1::int64_t value;
+
+          nm_entry = cfg1out.get_syms()->find( "TOPPERS_cfg_" + iter->name );
+          if ( nm_entry.type >= 0 )
+          {
+            if ( !iter->expression.empty() && iter->expression[ 0 ] == '@' )  // 式が'@'で始まる場合はアドレス定数式
+            {
+              value = cfg1out.get_srec()->get_value( nm_entry.address, sizeof_pointer, cfg1out.is_little_endian() );
+              if ( sizeof_signed_t < 8 && iter->is_signed )
+              {
+                value = cfg1_out::make_signed( static_cast< std::tr1::uint32_t >( value ) );
+              }
+
+              // 先ほど取り出したアドレスを使って間接参照
+              value = cfg1out.get_srec()->get_value( value, 8, cfg1out.is_little_endian() );  // 取り出す値は型に関係なく常に8バイト
+              if ( sizeof_signed_t < 8 && iter->is_signed )
+              {
+                value = cfg1_out::make_signed( static_cast< std::tr1::uint32_t >( value ) );
+              }
+              e.s = iter->expression.c_str() + 1; // 先頭の'@'を除去
+            }
+            else  // アドレスではない通常の整数定数式
+            {
+              value = cfg1out.get_srec()->get_value( nm_entry.address, sizeof_signed_t, cfg1out.is_little_endian() );
+              if ( sizeof_signed_t < 8 && iter->is_signed )
+              {
+                value = cfg1_out::make_signed( static_cast< std::tr1::uint32_t >( value ) );
+              }
+              e.s = iter->expression;
+            }
+            e.i = value;
+            mproc.set_var( iter->name, var_t( 1, e ) );
+          }
+        }
+
+        // バイトオーダー
+        {
+          bool little_endian = cfg1out.is_little_endian();
+          element e;
+          e.i = little_endian;
+          mproc.set_var( "LITTLE_ENDIAN", var_t( 1, e ) );
+
+          e.i = !little_endian;
+          mproc.set_var( "BIG_ENDIAN", var_t( 1, e ) );
+        }
+      }
+
+    }
+
+    //! コンストラクタ
+    factory::factory( std::string const& kernel )
+      : kernel_( tolower( kernel ) )
+    {
+    }
+
+    //! デストラクタ
+    factory::~factory()
+    {
+    }
+
+    //! サポートしている静的API情報の取得
+    std::map< std::string, static_api::info > const* factory::get_static_api_info_map() const
+    {
+      // CSVから静的API情報を読み取り、登録するためのローカルクラス
+      struct init_t
+      {
+        init_t()
+        {
+          boost::any t = global( "api-table" );
+          if ( !t.empty() )
+          {
+            std::vector< std::string > api_tables( boost::any_cast< std::vector< std::string >& >( t ) );
+            for ( std::vector< std::string >::const_iterator iter( api_tables.begin() ), last( api_tables.end() );
+                  iter != last;
+                  ++iter )
+            {
+              std::string buf;
+              std::string api_table_filename = *iter;
+              read( api_table_filename.c_str(), buf );
+              csv data( buf.begin(), buf.end() );
+              for ( csv::const_iterator d_iter( data.begin() ), d_last( data.end() );
+                    d_iter != d_last;
+                    ++d_iter )
+              {
+                csv::size_type len = d_iter->size();
+                if ( len < 3 )  // type, api_name, params は必須要素
+                {
+                  toppers::fatal( _( "too little fields in `%1%\'" ), *iter );
+                }
+                static_api::info api_info = { 0 };
+                try
+                {
+                    char* s;
+                    s = new char[ ( *d_iter )[ 0 ].size() + 1 ];
+                    std::strcpy( s, ( *d_iter )[ 0 ].c_str() );
+                    api_info.type = s;
+
+                    s = new char[ ( *d_iter )[ 1 ].size() + 1 ];
+                    std::strcpy( s, ( *d_iter )[ 1 ].c_str() );
+                    api_info.api_name = s;
+
+                    s = new char[ ( *d_iter )[ 2 ].size() + 1 ];
+                    std::strcpy( s, ( *d_iter )[ 2 ].c_str() );
+                    api_info.params = s;
+                    if ( len >= 4 && !( *d_iter )[ 3 ].empty() )
+                    {
+                      api_info.id_pos = std::strtol( ( *d_iter )[ 3 ].c_str(), 0, 0 );
+                    }
+                    if ( len >= 5 && !( *d_iter )[ 4 ].empty() )
+                    {
+                      api_info.slave = !!std::strtol( ( *d_iter )[ 4 ].c_str(), 0, 0 );
+                    }
+                    static_api_table_[ api_info.api_name ] = api_info;
+                }
+                catch ( ... )
+                {
+                  delete[] api_info.type;
+                  delete[] api_info.api_name;
+                  delete[] api_info.params;
+                  throw;
+                }
+              }
+            }
+          }
+        }
+
+        ~init_t()
+        {
+          for ( std::map< std::string, static_api::info >::const_iterator iter( static_api_table_.begin() ), last( static_api_table_.end() );
+                iter != last;
+                ++iter )
+          {
+            delete[] iter->second.type;
+            delete[] iter->second.api_name;
+            delete[] iter->second.params;
+          }
+        }
+
+        std::map< std::string, static_api::info > static_api_table_;
+      };
+      static init_t init;
+      std::map< std::string, static_api::info > const* result = &init.static_api_table_;
+      return result;
+    }
+
+    /*!
+     * \brief   cfg1_out.c への出力情報テーブルの生成
+     * \return  生成した cfg1_out::cfg1_def_table オブジェクトへのポインタ
+     * \note    この関数が返すポインタは delete してはならない
+     *
+     * --cfg1-def-table オプションで指定したファイルから、cfg1_out.c へ出力する情報を読み取り、
+     * cfg1_out::cfg1_def_table オブジェクトを生成する。
+     *
+     * CSV の形式は以下の通り
+     *
+     *    シンボル名,式[,s|signed]
+     *
+     * 末尾の s または signed は省略可能。省略時は符号無し整数とみなす。s または signed 指定時は
+     * 符号付き整数とみなす。\n
+     * 「式」の最初に # があれば前処理式とみなす。
+     */
+    cfg1_out::cfg1_def_table const* factory::get_cfg1_def_table() const
+    {
+      struct init_t
+      {
+        init_t()
+        {
+          boost::any t = global( "cfg1-def-table" );
+          if ( !t.empty() )
+          {
+            std::vector< std::string > cfg1_def_table = boost::any_cast< std::vector< std::string >& >( t );
+            for ( std::vector< std::string >::const_iterator iter( cfg1_def_table.begin() ), last( cfg1_def_table.end() );
+                  iter != last;
+                  ++iter )
+            {
+              std::string buf;
+              read( iter->c_str(), buf );
+              csv data( buf.begin(), buf.end() );
+              for ( csv::const_iterator d_iter( data.begin() ), d_last( data.end() );
+                    d_iter != d_last;
+                    ++d_iter )
+              {
+                csv::size_type len = d_iter->size();
+                if ( len < 2 )
+                {
+                  toppers::fatal( _( "too little fields in `%1%\'" ), *iter );
+                }
+                cfg1_out::cfg1_def_t def = { 0 };
+                def.name = ( *d_iter )[ 0 ];
+                def.expression = ( *d_iter )[ 1 ];
+                if ( len >= 3 )
+                {
+                  std::string is_signed( ( *d_iter )[ 2 ] );
+                  def.is_signed = ( is_signed == "s" || is_signed == "signed" );
+                }
+                if ( len >= 4)
+                {
+                  def.value1 = ( *d_iter )[ 3 ];
+                }
+                if ( len >= 5)
+                {
+                  def.value2 = ( *d_iter )[ 4 ];
+                }
+                cfg1_def_table_.push_back( def );
+              }
+            }
+          }
+        }
+        cfg1_out::cfg1_def_table cfg1_def_table_;
+      };
+      static init_t init;
+      cfg1_out::cfg1_def_table const* result = &init.cfg1_def_table_;
+      return result;
+    }
+
+    //! オブジェクトの交換
+    void factory::do_swap( factory& other )
+    {
+      kernel_.swap( other.kernel_ );
+    }
+
+    /*!
+     *  \brief  マクロプロセッサの生成
+     *  \param[in]  cfg1out cfg1_out オブジェクト
+     *  \param[in]  api_map .cfg ファイルに記述された静的API情報
+     *  \return     マクロプロセッサへのポインタ
+     *  \note   このメンバ関数は従来仕様（ソフトウェア部品非対応版）の温存のためにそのまま残す。
+     */
+    std::auto_ptr< macro_processor > factory::do_create_macro_processor( cfg1_out const& cfg1out, cfg1_out::static_api_map const& api_map ) const
+    {
+      typedef macro_processor::element element;
+      typedef macro_processor::var_t var_t;
+      std::auto_ptr< macro_processor > mproc( new macro_processor );
+      element e;
+
+      e.s = " ";    mproc->set_var( "SPC", var_t( 1, e ) );  // $SPC$
+      e.s = "\t";   mproc->set_var( "TAB", var_t( 1, e ) );  // $TAB$
+      e.s = "\n";   mproc->set_var( "NL",  var_t( 1, e ) );  // $NL$
+
+      // バージョン情報
+      e.s = toppers::get_global< std::string >( "version" );
+      e.i = toppers::get_global< std::tr1::int64_t >( "timestamp" );
+      mproc->set_var( "CFG_VERSION", var_t( 1, e ) );   // $CFG_VERSION$
+
+      // その他の組み込み変数の設定
+      set_object_vars( api_map, *mproc );
+      set_object_vars( cfg1out.get_static_api_array(), *mproc );
+      set_clsid_vars( cfg1out.get_clsid_table(), cfg1out, *mproc );
+      set_domid_vars( cfg1out.get_domid_table(), *mproc );
+      set_platform_vars( cfg1out, *mproc );
+      e.s = cfg1out.get_includes();
+      mproc->set_var( "INCLUDES", var_t( 1, e ) );
+
+      // パス情報
+      e.s = boost::lexical_cast< std::string >(toppers::get_global< int >( "pass" ));
+      e.i = toppers::get_global< int >( "pass" );
+      mproc->set_var( "CFG_PASS", var_t( 1, e ) );
+
+      return mproc;
+    }
+
+    /*!
+     *  \brief  マクロプロセッサの生成
+     *  \param[in]  cfg1out cfg1_out オブジェクト
+     *  \param[in]  api_array .cfg ファイルに記述された静的API情報
+     *  \return     マクロプロセッサへのポインタ
+     */
+    std::auto_ptr< macro_processor > factory::do_create_macro_processor( cfg1_out const& cfg1out, std::vector< static_api > const& api_array ) const
+    {
+      typedef macro_processor::element element;
+      typedef macro_processor::var_t var_t;
+      std::auto_ptr< macro_processor > mproc( new macro_processor );
+      element e;
+
+      e.s = " ";    mproc->set_var( "SPC", var_t( 1, e ) );  // $SPC$
+      e.s = "\t";   mproc->set_var( "TAB", var_t( 1, e ) );  // $TAB$
+      e.s = "\n";   mproc->set_var( "NL",  var_t( 1, e ) );  // $NL$
+
+      // バージョン情報
+      e.s = toppers::get_global< std::string >( "version" );
+      e.i = toppers::get_global< std::tr1::int64_t >( "timestamp" );
+      mproc->set_var( "CFG_VERSION", var_t( 1, e ) );   // $CFG_VERSION$
+
+      // その他の組み込み変数の設定
+      set_object_vars( api_array, *mproc );
+      set_clsid_vars( cfg1out.get_clsid_table(), cfg1out, *mproc );
+      set_domid_vars( cfg1out.get_domid_table(), *mproc );
+      set_platform_vars( cfg1out, *mproc );
+      e.s = cfg1out.get_includes();
+      mproc->set_var( "INCLUDES", var_t( 1, e ) );
+
+      // パス情報
+      e.s = boost::lexical_cast< std::string >(toppers::get_global< int >( "pass" ));
+      e.i = toppers::get_global< int >( "pass" );
+      mproc->set_var( "CFG_PASS", var_t( 1, e ) );
+
+      return mproc;
+    }
+
+    std::auto_ptr< cfg1_out > factory::do_create_cfg1_out( std::string const& filename ) const
+    {
+      return std::auto_ptr< itronx::cfg1_out >( new cfg1_out( filename, get_cfg1_def_table() ) );
+    }
+
+    std::auto_ptr< checker > factory::do_create_checker() const
+    {
+      return std::auto_ptr< itronx::checker >( new checker );
+    }
+
+  }
+}
Index: /cfg_itronx+oil_gcc/toppers/itronx/factory.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/factory.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/factory.hpp	(revision 54)
@@ -0,0 +1,105 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/itronx/factory.hpp
+ *  \brief  カーネルまたはモジュールに応じた処理オブジェクト生成に関する宣言定義
+ *
+ *  このファイルで定義されるクラス
+ *  \code
+ *  class factory;
+ *  \endcode
+ */
+#ifndef TOPPERS_ITRONX_FACTORY_HPP_
+#define TOPPERS_ITRONX_FACTORY_HPP_
+
+#include <memory>
+#include <string>
+#include <vector>
+#include "toppers/macro_processor.hpp"
+#include "toppers/itronx/static_api.hpp"
+#include "toppers/itronx/cfg1_out.hpp"
+#include "toppers/itronx/checker.hpp"
+
+namespace toppers
+{
+
+  namespace itronx
+  {
+
+    /*!
+     *  \class  factory factory.hpp "toppers/itronx/factory.hpp"
+     *  \brief  カーネルまたはモジュールに応じた処理オブジェクト生成クラス
+     */
+    class factory
+    {
+    public:
+      explicit factory( std::string const& kernel );
+      virtual ~factory();
+      std::map< std::string, static_api::info > const* get_static_api_info_map() const;
+      cfg1_out::cfg1_def_table const* get_cfg1_def_table() const;
+      std::auto_ptr< cfg1_out > create_cfg1_out( std::string const& filename ) const
+      {
+        return do_create_cfg1_out( filename );
+      }
+      std::auto_ptr< checker > create_checker() const
+      {
+        return do_create_checker();
+      }
+      std::auto_ptr< macro_processor > create_macro_processor( cfg1_out const& cfg1out, cfg1_out::static_api_map const& api_map ) const
+      {
+        return do_create_macro_processor( cfg1out, api_map );
+      }
+      std::auto_ptr< macro_processor > create_macro_processor( cfg1_out const& cfg1out, std::vector< static_api > const& api_array ) const
+      {
+        return do_create_macro_processor( cfg1out, api_array );
+      }
+      void swap( factory& other ) { do_swap( other ); }
+    protected:
+      virtual void do_swap( factory& other );
+      virtual std::auto_ptr< macro_processor > do_create_macro_processor( cfg1_out const& cfg1out, cfg1_out::static_api_map const& api_map ) const;
+      virtual std::auto_ptr< macro_processor > do_create_macro_processor( cfg1_out const& cfg1out, std::vector< static_api > const& api_array ) const;
+    private:
+      virtual std::auto_ptr< cfg1_out > do_create_cfg1_out( std::string const& filename ) const;
+      virtual std::auto_ptr< checker > do_create_checker() const;
+
+      std::string kernel_;
+    };
+
+  }
+}
+
+#endif  // ! TOPPERS_ITRONX_FACTORY_HPP_
Index: /cfg_itronx+oil_gcc/toppers/itronx/init_helper.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/init_helper.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/init_helper.hpp	(revision 54)
@@ -0,0 +1,91 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/itronx/init_helper.hpp
+ *  \brief  カーネルまたはモジュールの初期化処理ヘルパー関数の宣言・定義
+ */
+#ifndef TOPPERS_ITRONX_INIT_HELPER_HPP_
+#define TOPPERS_ITRONX_INIT_HELPER_HPP_
+
+#include <string>
+#include <map>
+#include <iostream>
+#include "toppers/global.hpp"
+#include "toppers/itronx/static_api.hpp"
+#include "toppers/itronx/asp/factory.hpp"
+
+namespace toppers
+{
+  namespace itronx
+  {
+
+    /*!
+     *  \brief      カーネルまたはモジュールの初期化処理ヘルパー関数
+     *  \param[in]  module_name   モジュール名
+     *  \param[in]  info_table    静的APIに関する情報テーブル
+     *  \param[in]  table_count   info_table の要素数
+     *  retval      true          初期化成功
+     *  retval      false         初期化失敗
+     */
+    template < class Factory >
+      bool init_helper( std::string const& module_name, static_api::info const* info_table, std::size_t table_count )
+    {
+      try
+      {
+        std::map< std::string, static_api::info > temp_map;
+        for ( std::size_t i = 0; ( i < table_count ) && ( info_table[ i ].type != 0 ); ++i )
+        {
+          temp_map[ info_table[ i ].api_name ] = info_table[ i ];
+        }
+        static std::map< std::string, static_api::info > const info_map( temp_map );
+        global( module_name + "_static_api_info_map" ) = static_cast< void const* >( &info_map );	// GCCバグ対策
+
+        static Factory factory;
+        global( module_name + "_factory" ) = static_cast< itronx::factory* >( &factory );
+      }
+      catch ( ... )
+      {
+        std::cerr << "module `" << module_name << "\' is failed to initialize" << std::endl;
+        return false;
+      }
+      return true;
+    }
+
+  }
+}
+
+#endif  // ! TOPPERS_ITRONX_INIT_HELPER_HPP_
Index: /cfg_itronx+oil_gcc/toppers/itronx/itronx.vcproj
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/itronx.vcproj	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/itronx.vcproj	(revision 54)
@@ -0,0 +1,170 @@
+<?xml version="1.0" encoding="shift_jis"?>
+<VisualStudioProject
+	ProjectType="Visual C++"
+	Version="7.10"
+	Name="itronx"
+	ProjectGUID="{994810C2-F530-4679-9DF8-AF39A3AC61C9}"
+	Keyword="Win32Proj">
+	<Platforms>
+		<Platform
+			Name="Win32"/>
+	</Platforms>
+	<Configurations>
+		<Configuration
+			Name="Debug|Win32"
+			OutputDirectory="Debug"
+			IntermediateDirectory="Debug"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="0"
+				AdditionalIncludeDirectories="../.."
+				PreprocessorDefinitions="_SCL_SECURE_NO_WARNINGS=1"
+				StringPooling="TRUE"
+				MinimalRebuild="TRUE"
+				BasicRuntimeChecks="3"
+				SmallerTypeCheck="TRUE"
+				RuntimeLibrary="1"
+				BufferSecurityCheck="TRUE"
+				EnableFunctionLevelLinking="TRUE"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="TRUE"
+				RuntimeTypeInfo="TRUE"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="4"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/itronx.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+		<Configuration
+			Name="Release|Win32"
+			OutputDirectory="Release"
+			IntermediateDirectory="Release"
+			ConfigurationType="4"
+			CharacterSet="2">
+			<Tool
+				Name="VCCLCompilerTool"
+				Optimization="1"
+				GlobalOptimizations="TRUE"
+				InlineFunctionExpansion="0"
+				EnableIntrinsicFunctions="TRUE"
+				ImproveFloatingPointConsistency="FALSE"
+				FavorSizeOrSpeed="2"
+				AdditionalIncludeDirectories="../.."
+				PreprocessorDefinitions="_SCL_SECURE_NO_WARNINGS=1"
+				StringPooling="TRUE"
+				RuntimeLibrary="0"
+				TreatWChar_tAsBuiltInType="TRUE"
+				ForceConformanceInForLoopScope="TRUE"
+				RuntimeTypeInfo="TRUE"
+				UsePrecompiledHeader="0"
+				WarningLevel="3"
+				Detect64BitPortabilityProblems="FALSE"
+				DebugInformationFormat="3"/>
+			<Tool
+				Name="VCCustomBuildTool"/>
+			<Tool
+				Name="VCLibrarianTool"
+				OutputFile="$(OutDir)/itronx.lib"/>
+			<Tool
+				Name="VCMIDLTool"/>
+			<Tool
+				Name="VCPostBuildEventTool"/>
+			<Tool
+				Name="VCPreBuildEventTool"/>
+			<Tool
+				Name="VCPreLinkEventTool"/>
+			<Tool
+				Name="VCResourceCompilerTool"/>
+			<Tool
+				Name="VCWebServiceProxyGeneratorTool"/>
+			<Tool
+				Name="VCXMLDataGeneratorTool"/>
+			<Tool
+				Name="VCManagedWrapperGeneratorTool"/>
+			<Tool
+				Name="VCAuxiliaryManagedWrapperGeneratorTool"/>
+		</Configuration>
+	</Configurations>
+	<References>
+	</References>
+	<Files>
+		<Filter
+			Name="\[X t@C"
+			Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm;asmx"
+			UniqueIdentifier="{4FC737F1-C7A5-4376-A066-2A32D752A2FF}">
+			<File
+				RelativePath=".\cfg1_out.cpp">
+			</File>
+			<File
+				RelativePath=".\checker.cpp">
+			</File>
+			<File
+				RelativePath=".\component.cpp">
+			</File>
+			<File
+				RelativePath=".\factory.cpp">
+			</File>
+			<File
+				RelativePath=".\preprocess.cpp">
+			</File>
+			<File
+				RelativePath=".\static_api.cpp">
+			</File>
+		</Filter>
+		<Filter
+			Name="wb_[ t@C"
+			Filter="h;hpp;hxx;hm;inl;inc;xsd"
+			UniqueIdentifier="{93995380-89BD-4b04-88EB-625FBE52EBFB}">
+			<File
+				RelativePath=".\cfg1_out.hpp">
+			</File>
+			<File
+				RelativePath=".\checker.hpp">
+			</File>
+			<File
+				RelativePath=".\component.hpp">
+			</File>
+			<File
+				RelativePath=".\factory.hpp">
+			</File>
+			<File
+				RelativePath=".\init_helper.hpp">
+			</File>
+			<File
+				RelativePath=".\preprocess.hpp">
+			</File>
+			<File
+				RelativePath=".\static_api.hpp">
+			</File>
+			<File
+				RelativePath=".\static_api_parser.hpp">
+			</File>
+		</Filter>
+	</Files>
+	<Globals>
+	</Globals>
+</VisualStudioProject>
Index: /cfg_itronx+oil_gcc/toppers/itronx/kernel_chk.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/kernel_chk.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/kernel_chk.hpp	(revision 54)
@@ -0,0 +1,72 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#undef  BEGIN_KERNEL_CHK
+#undef  END_KERNEL_CHK
+#undef  KERNEL_CHK_SIZEOF
+#undef  KERNEL_CHK_OFFSETOF
+#undef  KERNEL_CHK_VALUEOF
+
+#ifdef IMPLEMENT_KERNEL_CHK
+
+#define BEGIN_KERNEL_CHK            ofile_ << "\t0x12345678,\n\tTKERNEL_PRID,\n"  \
+                                              "\tCHAR_BIT,\n" \
+                                              "\tCHAR_MAX,\n" \
+                                              "\tSCHAR_MAX,\n" \
+                                              "\tSHRT_MAX,\n" \
+                                              "\tINT_MAX,\n" \
+                                              "\tLONG_MAX,\n"
+#define END_KERNEL_CHK              ;
+#define KERNEL_CHK_SIZEOF( sym )    KERNEL_CHK_SIZEOF_( sym )
+#define KERNEL_CHK_SIZEOF_( sym )   "\tsizeof(" #sym "),\n"
+#define KERNEL_CHK_OFFSETOF( type, member )  "\toffsetof(" #type ", " #member "),\n"
+#define KERNEL_CHK_VALUEOF( expr )  "\t" #expr ",\n"
+
+#else
+
+#define BEGIN_KERNEL_CHK            enum { magic_number, TKERNEL_PRID, \
+                                           valueof_CHAR_BIT, \
+                                           valueof_CHAR_MAX, \
+                                           valueof_SCHAR_MAX, \
+                                           valueof_SHRT_MAX, \
+                                           valueof_INT_MAX, \
+                                           valueof_LONG_MAX,
+#define END_KERNEL_CHK              kernel_chk_table_size };
+#define KERNEL_CHK_SIZEOF( sym )    sizeof_##sym,
+#define KERNEL_CHK_OFFSETOF( type, member )  offsetof_##type##_##member,
+#define KERNEL_CHK_VALUEOF( expr )  valueof_##expr,
+
+#endif
Index: /cfg_itronx+oil_gcc/toppers/itronx/preprocess.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/preprocess.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/preprocess.cpp	(revision 54)
@@ -0,0 +1,200 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2011 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include "toppers/io.hpp"
+#include "toppers/cpp.hpp"
+#include "toppers/global.hpp"
+#include "toppers/diagnostics.hpp"
+#include "toppers/misc.hpp"
+#include "toppers/itronx/preprocess.hpp"
+#include <boost/spirit/include/classic.hpp>
+
+namespace toppers
+{
+  namespace itronx
+  {
+
+    /*!
+     *  \brief  静的API `INCLUDE'の展開
+     *  \param[in]  in      入力ファイルの内容
+     *  \param[out] out     出力ファイルの内容
+     *  \param[in]  codeset 文字コード
+     *  \param[out] dependencies  依存関係の格納先（NULLの場合は格納しない）
+     *  \param[out] onces   #pragma onceが記述されていたファイル名の格納先（NULLの場合は格納しない）
+     *
+     *  `INCLUDE' の引数は、μITRON 仕様のものとは異なり、二重引用符で囲まずに #include 指令と
+     *  同じ形式を用いる。
+     */
+    void expand_include( text const& in, text& out, codeset_t codeset, std::set< std::string >* dependencies, std::set< std::string >* onces )
+    {
+      typedef text::container::const_iterator const_row_iterator;
+      typedef std::string::size_type size_type;
+      size_type const npos = std::string::npos;
+      const_row_iterator first( in.begin().get_row() ), last( in.end().get_row() );
+
+      out.set_line( first->line.file, first->line.line );
+      for ( const_row_iterator iter( first ); iter != last; ++iter )
+      {
+        std::string const& buf = iter->buf;
+        char state = 0;
+
+        for ( size_type i = 0, n = buf.size(); i != n; ++i )
+        {
+          char c = buf[i];
+          if ( c == '\'' || c == '\"' )
+          {
+            if ( state == 0 )
+            {
+              state = c;    // 文字（列）リテラル開始
+            }
+            else if ( buf[i - 1] != '\\' ) //  \' または \" ではない
+            {
+              state = 0;    // 文字（列）リテラル終了
+            }
+            else if ( ( codeset == shift_jis ) && ( i >= 2 ) && is_lead< shift_jis >( buf[i - 2] ) )
+            {
+              state = 0;
+            }
+            out.push_back( c );
+          }
+          else if ( state != 0 )  // 文字（列）リテラル内
+          {
+            out.push_back( c );
+          }
+          else
+          {
+            using namespace boost::spirit::classic;
+            std::string headername;
+            if ( iter == last )
+            {
+              return;
+            }
+            text::const_iterator iter2( iter, i );
+            if ( iter2 == in.end() )
+            {
+              break;
+            }
+            parse_info< text::const_iterator > info
+              = parse( iter2, in.end(),
+                        ( str_p( "INCLUDE" ) >> *space_p
+                          >> '(' >> *space_p
+                            >> '\"' >> ( +( anychar_p - '\"' ) )[ assign( headername ) ] >> '\"' >> *space_p
+                          >> ')' >> *space_p >> ';' ) );  // 行番号がずれるので、スキップパーサは使用しない
+            if ( info.hit )
+            {
+              std::vector< std::string > include_paths = get_global< std::vector< std::string > >( "include-path" );
+              std::string hname = search_include_file( include_paths.begin(), include_paths.end(), headername );
+              if ( hname.empty() )  // ヘッダ名が見つからない
+              {
+                fatal( iter->line, _( "cannot open file `%1%\'" ), headername );
+              }
+              else if ( onces == 0 || onces->find( hname ) == onces->end() )
+              {
+                if ( dependencies != 0 )
+                {
+                  dependencies->insert( dir_delimiter_to_slash( hname ) );
+                }
+                out.push_back( ' ' ); // ダミーを挿入しておかないと行番号がずれる
+                preprocess( hname, out, codeset, dependencies, onces );  // ヘッダ名で指定されたファイルに対して前処理を再帰的に行う
+                iter = info.stop.get_row();
+                i = info.stop.get_col() - 1;
+                if ( iter != last )
+                {
+                  out.set_line( iter->line.file, iter->line.line );
+                }
+              }
+            }
+            else
+            {
+              if ( iter2.get_col() == 0 )
+              {
+                info = parse( iter2, in.end(),
+                              ( *( space_p - eol_p ) >>
+                                  ch_p( '#' ) >> *( space_p - eol_p ) >> "pragma" >> *( space_p - eol_p )
+                                    >> "once"
+                                    >> *( space_p - eol_p ) >> eol_p ) );
+                if ( info.hit )
+                {
+                  if ( onces != 0 )
+                  {
+                    onces->insert( iter2.line().file );
+                  }
+                  out.push_back( '\n' );
+                  iter = info.stop.get_row();
+                  --iter;   // インクリメントされるのでいったん戻す。
+                  break;
+                }
+              }
+              if ( parse( iter2, in.end(),
+                        ( str_p( "INCLUDE" ) >> *space_p >> '(' >> +( anychar_p - ')' ) >> ')' >> *space_p >> ';' ) ).hit )
+              {
+                warning( iter->line, _( "probably, %1% argument of `%2%\' is illegal" ), _( "1st" ), "INCLUDE" );
+              }
+              out.push_back( c );
+            }
+          }
+        }
+      }
+    }
+
+    /*!
+     *  \brief  コンフィギュレーションファイルの前処理
+     *  \param[in]  file    コンフィギュレーションファイル名
+     *  \param[out] result  前処理後の内容
+     *  \param[in]  codeset 文字コード
+     *  \param[out] dependencies  依存関係の格納先（NULLの場合は格納しない）
+     *  \param[out] onces   #pragma onceが記述されていたファイル名の格納先（NULLの場合は格納しない）
+     */
+    void preprocess( std::string const& file, text& result, codeset_t codeset, std::set< std::string >* dependencies, std::set< std::string >* onces )
+    {
+      std::string buf;
+      read( file, buf );
+      if ( buf.empty() )
+      {
+        return;
+      }
+      text txt;
+      txt.set_line( file, 1 );
+      remove_comment( buf.begin(), buf.end(), std::back_inserter( txt ), codeset );
+      expand_include( txt, result, codeset, dependencies, onces );
+    }
+
+  }
+}
Index: /cfg_itronx+oil_gcc/toppers/itronx/preprocess.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/preprocess.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/preprocess.hpp	(revision 54)
@@ -0,0 +1,60 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/itronx/preprocess.hpp
+ *  \brief  システムコンフィギュレーションファイルの前処理に関する宣言定義
+ */
+#ifndef TOPPERS_ITRONX_PREPROCESSOR_HPP_
+#define TOPPERS_ITRONX_PREPROCESSOR_HPP_
+
+#include <string>
+#include <set>
+#include "toppers/text.hpp"
+#include "toppers/cpp.hpp"
+
+namespace toppers
+{
+  namespace itronx
+  {
+
+    void expand_include( text const& in, text& out, codeset_t codeset = ascii, std::set< std::string >* dependencies = 0, std::set< std::string >* onces = 0 );
+    void preprocess( std::string const& file, text& result, codeset_t codeset = ascii, std::set< std::string >* dependencies = 0, std::set< std::string >* onces = 0 );
+
+  }
+}
+
+#endif  // ! TOPPERS_ITRONX_PREPROCESSOR_HPP_
Index: /cfg_itronx+oil_gcc/toppers/itronx/static_api.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/static_api.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/static_api.cpp	(revision 54)
@@ -0,0 +1,243 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2010 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <cctype>
+#include <sstream>
+#include "toppers/diagnostics.hpp"
+#include "toppers/itronx/static_api.hpp"
+#include "toppers/itronx/static_api_parser.hpp"
+#include <boost/spirit/include/classic.hpp>
+#include <boost/lexical_cast.hpp>
+
+namespace toppers
+{
+  namespace itronx
+  {
+    namespace
+    {
+      class find_api_predicate
+      {
+      public:
+        explicit find_api_predicate( std::string const& api_name ) : api_name_( api_name ) {}
+        bool operator()( static_api::info const& info ) const
+        {
+          return info.api_name == api_name_;
+        }
+      private:
+        std::string api_name_;
+      };
+    }
+
+    /*!
+     *  \brief  静的APIの構文解析
+     *  \param[in,out]  next      テキストの読み込み位置、兼構文解析後の次の読み込み位置の格納先
+     *  \param[in]      last      テキストの終端位置
+     *  \param[in]      info_map  静的API情報マップ
+     *  \param[in]      ucn       国際文字名を有効にする場合は true を指定する。
+     *  \param[in]      codeset   文字コード
+     *  \retval         true    成功
+     *  \retval         false   失敗
+     */
+    bool static_api::parse( text::const_iterator& next, text::const_iterator last,
+                            std::map< std::string, info > const& info_map,
+                            bool ucn, codeset_t codeset )
+    {
+      boost::spirit::classic::parse_info< text::const_iterator > pi;
+      std::vector< std::string > tokens;
+      c_const_expr_parser cexpr_p( ucn, codeset );
+      static_api_parser parser( tokens, cexpr_p );
+      static_api temp;
+
+      text::const_iterator next_temp;
+      for ( next_temp = next; next_temp != last; ++next_temp )
+      {
+        if ( !std::isspace( static_cast< unsigned char >( *next_temp ) ) )
+        {
+          break;
+        }
+      }
+      if ( next_temp == last )
+      {
+        return false;
+      }
+
+      // エラーメッセージ用の行番号
+      // この行番号は、静的APIの開始位置のものであるため、エラー発生箇所そのものズバリを指すことはできない。
+      temp.line_ = next_temp.line();
+
+      pi = boost::spirit::classic::parse( next_temp, last, parser, boost::spirit::classic::space_p );
+      if ( !pi.hit )
+      {
+        return false;
+      }
+
+      // 静的APIが存在するかどうかの判定およびシグニチャの取得
+      std::string api_name( tokens.front() );
+      std::map< std::string, info >::const_iterator info_iter = info_map.find( api_name );
+      info const* pinfo = 0;
+      if ( info_iter != info_map.end() )
+      {
+        pinfo = &info_iter->second;
+        temp.pinfo_ = pinfo;
+      }
+      else
+      {
+        error( temp.line_, _( "static API `%1%\' is unknown" ), api_name );
+        return false;
+      }
+
+      // 各パラメータの解析
+      std::istringstream iss( pinfo->params );
+      int order = 0;            // パラメータリスト内の順序
+      bool param_list = false;  // パラメータリスト解析中フラグ
+      std::string symbol;
+      bool skip = false;
+
+      for ( std::vector< std::string >::const_iterator iter( tokens.begin() + 1 ), last( tokens.end() );
+            iter != last;
+            ++iter )
+      {
+        if ( !param_list )
+        {
+          iss >> symbol;
+          if ( symbol.size() > 3 && symbol.substr( symbol.size() - 3 ) == "..." )
+          {
+            param_list = true;
+            order = 0;
+            //symbol.resize( symbol.size() - 3 );
+          }
+        }
+        if ( symbol == "{" || symbol == "}" )
+        {
+          if ( symbol != *iter )
+          {
+            error( temp.line_, _( "missing token `%1%\'" ), symbol );
+            --iter;
+          }
+        }
+        else if ( *iter == "{" || *iter == "}" )
+        {
+          if ( param_list && *iter == "}" )
+          {
+            iss >> symbol;
+            if ( symbol != "}" )
+            {
+              error( temp.line_, _( "illegal token `%1%\'" ), *iter );
+            }
+            param_list = false;
+          }
+          else if ( *symbol.rbegin() == '\?' ) // 省略可能パラメータのスキップ
+          {
+            skip = true;
+            --iter;
+          }
+          else
+          {
+            error( temp.line_, _( "illegal token `%1%\'" ), *iter );
+          }
+        }
+        else
+        {
+          parameter value;
+          value.symbol = symbol;
+          if ( param_list )
+          {
+            //value.symbol += boost::lexical_cast< std::string >( order++ );
+            value.order = order++;
+          }
+          value.text = *iter;
+          value.value = 0;
+          temp.params_.push_back( value );
+        }
+      }
+      if ( !iss.eof() )
+      {
+        iss >> symbol;
+        if ( symbol != "}" )
+        {
+          error( temp.line_, _( "few parameters for static API `%s\'" ), api_name );
+        }
+        else if ( !skip )
+        {
+          error( temp.line_, _( "missing token `%1%\'" ), symbol );
+        }
+        else
+        {
+          skip = false;
+        }
+      }
+      next = pi.stop;
+      swap( temp );
+      return true;
+    }
+
+    bool static_api::set_block( char const* type, std::string const& id )
+    {
+      for ( std::vector< parameter >::const_iterator iter( params_.begin() ), last( params_.end() );
+            iter != last;
+            ++iter )
+      {
+        if ( iter->symbol == type )
+        {
+          return false;
+        }
+      }
+      parameter value;
+      value.symbol = type;
+      value.text = id;
+      value.value = 0;
+      params_.push_back( value );
+      return true;
+    }
+
+    static_api::size_type static_api::count_integer_params() const
+    {
+      size_type result = 0;
+      for ( std::vector< parameter >::const_iterator iter( params_.begin() ), last( params_.end() );
+            iter != last;
+            ++iter )
+      {
+        if ( !iter->symbol.empty()
+          && ( ( iter->symbol[0] == '.' ) || ( iter->symbol[0] == '+' ) ) )
+        {
+          ++result;
+        }
+      }
+      return result;
+    }
+
+  }
+}
Index: /cfg_itronx+oil_gcc/toppers/itronx/static_api.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/static_api.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/static_api.hpp	(revision 54)
@@ -0,0 +1,313 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2010 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/itronx/static_api.hpp
+ *  \brief  静的API情報の解析と管理に関する宣言定義
+ *
+ *  このファイルで定義されるクラス
+ *  \code
+ *  class static_api;
+ *  \endcode
+ */
+#ifndef TOPPERS_ITRONX_STATIC_API_HPP_
+#define TOPPERS_ITRONX_STATIC_API_HPP_
+
+#include <string>
+#include <map>
+#include <set>
+#include <algorithm>
+#include "toppers/workaround.hpp"
+#include "toppers/text.hpp"
+#include "toppers/codeset.hpp"
+#include "toppers/diagnostics.hpp"
+#include <boost/any.hpp>
+#include <boost/optional.hpp>
+
+namespace toppers
+{
+  namespace itronx
+  {
+
+    /*!
+     *  \class  static_api static_api.hpp "toppers/itronx/static_api.hpp"
+     *  \brief  コンフィギュレーションファイルに記述された静的APIの情報を管理するためのクラス
+     */
+    class static_api
+    {
+    public:
+      /*!
+       *  \struct info  static_api.hpp "toppers/itronx/static_api.hpp"
+       *  \brief  静的APIの仕様に関する情報
+       *
+       *  static_api::info の params メンバ内の各要素に付けられた接頭辞の意味は次のとおり
+       *
+       *  - #: オブジェクト識別子
+       *  - %: オブジェクト識別子で、かつ自動割付けの対象とならないもの
+       *  - .: 符号無し整数定数式パラメータ
+       *  - +: 符号付き整数定数式パラメータ
+       *  - $: 文字列定数式パラメータ
+       *  - &: 一般定数式パラメータ
+       *
+       *  なお、{ および } も便宜的にパラメータの一種として扱っている（構文解析に必要なため）。
+       */
+      struct info
+      {
+        char const* type;     //!< カーネルオブジェクトの種別を表す三文字（"tsk", "sem"等）
+        char const* api_name; //!< 静的API名（"CRE_TSK", "CRE_SEM"等）
+        char const* params;   //!< パラメータ並び
+        int id_pos;           //!< パラメータのうちID番号の位置（-1の場合はID番号無し）
+        bool slave;           //!< 他の静的APIに対して従属関係にある場合にtrue（"DEF_TEX"等）
+      };
+      /*!
+       *  \struct parameter static_api.hpp "toppers/itronx/static_api.hpp"
+       *  \brief  静的APIのパラメータに関する情報
+       */
+      struct parameter
+      {
+        std::string symbol;   //!< 仮引数名
+        std::string text;     //!< 実引数の字面
+        boost::optional< std::tr1::intmax_t > value;  //!< 実引数の値
+        std::string string;
+        int order;            //!< リスト形式パラメータの連番
+      };
+      typedef std::vector< parameter > parameter_container;
+      typedef parameter_container::iterator iterator;
+      typedef parameter_container::const_iterator const_iterator;
+      typedef parameter_container::reference reference;
+      typedef parameter_container::const_reference const_reference;
+      typedef parameter_container::size_type size_type;
+
+      char const* api_name() const { return pinfo_ != 0 ? pinfo_->api_name : ""; }
+      info const* get_info() const { return pinfo_; }
+
+      parameter_container const& params() const { return params_; }
+      iterator begin() { return params_.begin(); }
+      const_iterator begin() const { return params_.begin(); }
+      iterator end() { return params_.end(); }
+      const_iterator end() const { return params_.end(); }
+      reference at( size_type pos ) { return params_.at( pos ); }
+      reference at( std::string const& symbol )
+      {
+        iterator iter = std::find_if( params_.begin(), params_.end(), match_param_symbol( symbol ) );
+        if ( iter == params_.end() )
+        {
+          throw std::out_of_range( "out of range" );
+        }
+        return *iter;
+      }
+      const_reference at( size_type pos ) const { return params_.at( pos ); }
+      const_reference at( std::string const& symbol ) const
+      {
+        const_iterator iter = std::find_if( params_.begin(), params_.end(), match_param_symbol( symbol ) );
+        if ( iter == params_.end() )
+        {
+          throw std::out_of_range( "out of range" );
+        }
+        return *iter;
+      }
+      parameter id() const
+      {
+        if ( pinfo_->id_pos < 0 )
+        {
+          return parameter();
+        }
+        return at( pinfo_->id_pos );
+      }
+      
+      text_line const& line() const { return line_; }
+      void line( text_line const& value ) { line_ = value; }
+      size_type count_integer_params() const;
+        
+      //! オブジェクトの交換
+      void swap( static_api& other )
+      {
+        std::swap( pinfo_, other.pinfo_ );
+        params_.swap( other.params_ );
+        line_.swap( other.line_ );
+      }
+
+      bool parse( text::const_iterator& next, text::const_iterator last, 
+                  std::map< std::string, info > const& info_map,
+                  bool ucn = false, codeset_t codeset = ascii );
+
+      bool set_class( std::string const& id )
+      {
+        return set_block( "*CLASS", id );
+      }
+      bool set_domain( std::string const& id )
+      {
+        return set_block( "*DOMAIN", id );
+      }
+
+      /*!
+       *  \brief  ID番号の割付け
+       *  \param[in]  first   ID番号を割り付ける static_api 列の先頭位置
+       *  \param[in]  last    ID番号を割り付ける static_api 列の終端 + 1
+       */
+      template < class ForwardIterator >
+        static void assign_id( ForwardIterator first, ForwardIterator last )
+      {
+        std::map< std::string, long > id_map;
+        std::map< std::string, std::set< std::string > > slave_id_set;
+        std::vector< std::string > id_res;
+        typedef std::vector< std::string >::size_type size_type;
+
+        // 予約済みのID番号を洗い出す
+        for ( ForwardIterator iter( first ); iter != last; ++iter )
+        {
+          static_api::info const* info = iter->get_info();
+          if ( info->id_pos >= 0 )
+          {
+            if ( !info->slave )
+            {
+              if ( iter->at( info->id_pos ).symbol[0] == '#' )
+              {
+                boost::optional< std::tr1::int64_t > id_value = *iter->at( info->id_pos ).value;
+                if ( id_value )
+                {
+                  long id = static_cast< long >( *id_value );
+                  if ( id > 0 )
+                  {
+                    long n = static_cast< long >( id_res.size() );
+                    if ( n < id + 1 )
+                    {
+                      n = id + 1;
+                    }
+                    id_res.resize( n );
+                    std::string name( iter->at( info->id_pos ).text );
+                    if ( !id_res[ id ].empty() )
+                    {
+                      fatal( _( "%1% `%2%\' in %3% is duplicated" ), iter->at( info->id_pos ).symbol.c_str() + 1, id, info->api_name );
+                    }
+                    id_res[ id ] = name;
+                  }
+                }
+              }
+            }
+          }
+        }
+
+        // 予約されていないID番号を自動割付け
+        long id = 1;
+        for ( ForwardIterator iter( first ); iter != last; ++iter )
+        {
+          static_api::info const* info = iter->get_info();
+          if ( info->id_pos >= 0 )
+          {
+            std::string name( iter->at( info->id_pos ).text );
+            if ( !info->slave )
+            {
+              long id_value = -1;
+              if ( iter->at( info->id_pos ).symbol[0] == '#' )
+              {
+                std::vector< std::string >::iterator id_iter( std::find( id_res.begin(), id_res.end(), name ) );
+                if ( id_iter != id_res.end() )  // 割り付け済みの場合...
+                {
+                  id_value = id_iter - id_res.begin();
+                }
+                else  // まだ割り付けられていない場合...
+                {
+                  long n = static_cast< long >( id_res.size() );
+                  while ( id < n && !id_res[ id ].empty() )
+                  {
+                    ++id;
+                  }
+                  if ( n < id + 1 )
+                  {
+                    n = id + 1;
+                  }
+                  id_res.resize( n );
+                  id_res[ id ] = name;
+                  id_value = id;
+                  iter->at( info->id_pos ).value = id_value;
+                }
+                if ( id_map.find( name ) != id_map.end() )
+                {
+                  fatal( iter->line(), _( "E_OBJ: `%1%\' is duplicated" ), name );
+                }
+              }
+              else if ( iter->at( info->id_pos ).value )
+              {
+                id_value = static_cast< long >( iter->at( info->id_pos ).value.get() );
+              }
+              id_map[ name ] = id_value;
+            }
+            else  // slave
+            {
+              if ( id_map[ name ] < 1 )
+              {
+                fatal( iter->line(), _( "`%1%\' is undefined" ), iter->at( info->id_pos ).text );
+              }
+              std::set< std::string >& set = slave_id_set[ info->api_name ];
+              if ( set.find( name ) != set.end() )  // DEF_TEX重複定義の判定
+              {
+                fatal( iter->line(), _( "E_OBJ: `%1%\' is duplicated" ), iter->at( info->id_pos ).text );
+              }
+              set.insert( name );
+            }
+          }
+        }
+
+        if ( !id_res.empty() && std::find( id_res.begin() + 1, id_res.end(), std::string() ) != id_res.end() )
+        {
+          error( _( "`%1%\' id numbers do not continue" ), first->get_info()->type );          
+        }
+      }
+    private:
+      class match_param_symbol
+      {
+      public:
+        explicit match_param_symbol( std::string const& symbol ) : symbol_( symbol ) {}
+        bool operator()( parameter const& param ) const
+        {
+          return param.symbol == symbol_;
+        }
+      private:
+        std::string symbol_;
+      };
+
+      bool set_block( char const* type, std::string const& id );
+
+      info const* pinfo_;
+      std::vector< parameter > params_;
+      text_line line_;
+    };
+
+  }
+}
+
+#endif  // ! TOPPERS_ITRONX_STATIC_API_HPP_
Index: /cfg_itronx+oil_gcc/toppers/itronx/static_api_parser.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/itronx/static_api_parser.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/itronx/static_api_parser.hpp	(revision 54)
@@ -0,0 +1,218 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2010 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*!
+ *  \file   toppers/itronx/static_api_parser.hpp
+ *  \brief  静的APIの文法に関する宣言定義
+ *
+ *  このファイルで定義されるクラス
+ *  \code
+ *  struct static_api_parser;
+ *  struct static_api_parser::error_handler;
+ *  struct static_api_parser::definition< Scanner >;
+ *  \endcode
+ */
+#ifndef TOPPERS_ITRONX_STATIC_API_PARSER_HPP_
+#define TOPPERS_ITRONX_STATIC_API_PARSER_HPP_
+
+#include "toppers/diagnostics.hpp"
+#include "toppers/c_expr.hpp"
+#include <boost/spirit/include/classic_error_handling.hpp>
+
+namespace toppers
+{
+  namespace itronx
+  {
+
+    /*!
+     *  \struct static_api_parser static_api_parser.hpp "toppers/itronx/static_api_parser.hpp"
+     *  \brief  静的APIの構文解析クラス
+     */
+    struct static_api_parser : boost::spirit::classic::grammar< static_api_parser >
+    {
+      enum rule_id_t
+      {
+        id_top = 1, id_api_name, id_parameter_list, id_parameter, id_packet, id_cexpr
+      };
+      enum expected_t
+      {
+        open_paren_expected, close_paren_expected, open_brace_expected, close_brace_expected,
+        comma_expected, semicolon_expected
+      };
+
+      /*!
+       *  \struct error_handler static_api_parser.hpp "toppers/itronx/static_api_parser.hpp"
+       *  \brief  静的APIの構文解析におけるエラー処理ファンクタ
+       */
+      struct error_handler
+      {
+        template < class Scanner, class Error >
+          boost::spirit::classic::error_status<> operator()( Scanner const& scan, Error const& error ) const
+        {
+          typename Error::iterator_t iter( error.where );
+          std::string str;
+          text_line ln;
+          if ( iter != scan.last )
+          {
+            while ( *iter != '\0' && *iter != '\n' )
+            {
+              ++iter;
+            }
+            str = '\"' + std::string( error.where, iter ) + '\"';
+            ln = get_text_line( error.where );
+          }
+          else
+          {
+            str = "\"end of file\"";
+            ln = get_text_line( iter - 1 );
+          }
+
+          switch ( error.descriptor )
+          {
+          case open_paren_expected:
+            toppers::fatal( ln, _( "missing `%1%\' before %2%" ), '(', str );
+            break;
+          case close_paren_expected:
+            toppers::fatal( ln, _( "missing `%1%\' before %2%" ), ')', str );
+            break;
+          case close_brace_expected:
+            toppers::fatal( ln, _( "missing `%1%\' before %2%" ), '}', str );
+            break;
+          case semicolon_expected:
+            toppers::fatal( ln, _( "missing `%1%\' before %2%" ), ';', str );
+            break;
+          }
+          return  boost::spirit::classic::error_status<>( boost::spirit::classic::error_status<>::fail );
+        }
+      };
+
+      /*!
+       *  \struct definition static_api_parser.hpp "toppers/itronx/static_api_parser.hpp" 
+       *  \brief  静的APIの構文解析における文法定義
+       */
+      template < class Scanner >
+        struct definition
+      {
+        typedef boost::spirit::classic::rule< Scanner, boost::spirit::classic::dynamic_parser_tag > rule_t;
+        typedef boost::spirit::classic::guard< expected_t > guard_t;
+        typedef boost::spirit::classic::assertion< expected_t > assertion_t;
+
+        c_strlit_parser_t const c_strlit_p;
+        c_ident_parser_t const c_ident_p;
+
+        rule_t  top, api_name, parameter_list, parameter, packet, cexpr;
+        guard_t guard_api, guard_packet;
+        assertion_t expect_open_paren,
+                    expect_close_paren,
+                    expect_close_brace,
+                    expect_comma, expect_semicolon;
+
+        /*!
+         *  \brief  コンストラクタ
+         *  \param  self  構文解析クラス（文法クラス）への参照
+         */
+        definition( static_api_parser const& self )
+          : c_strlit_p( c_strlit_parser( self.cexpr_p_.codeset_ ) ),
+            c_ident_p( c_ident_parser( self.cexpr_p_.ucn_, self.cexpr_p_.c_plus_plus_ ) ),
+            expect_open_paren( open_paren_expected ),
+            expect_close_paren( close_paren_expected ),
+            expect_close_brace( close_brace_expected ),
+            expect_comma( comma_expected ),
+            expect_semicolon( semicolon_expected )
+        {
+          using namespace boost::spirit::classic;
+          set_id();
+          top =
+              guard_api
+              (
+                api_name >> 
+                  str_p( "(" ) >>
+                  !parameter_list >>
+                  expect_close_paren( str_p( ")" ) ) >>
+                  expect_semicolon( ch_p( ';' ) )
+              )
+              [
+                error_handler()
+              ];
+          api_name =
+              c_ident_p[ push_back_a( self.tokens_ ) ];
+          parameter_list =
+              !( parameter % ',' );
+          parameter =
+              packet | cexpr;
+          packet =
+              guard_packet
+              (
+                str_p( "{" )[ push_back_a( self.tokens_ ) ] >>
+                parameter_list >>
+                expect_close_brace( str_p( "}" )[ push_back_a( self.tokens_ ) ] ) 
+              )
+              [
+                error_handler()
+              ];
+          cexpr =
+              self.cexpr_p_[ push_back_a( self.tokens_ ) ];
+        }
+        void set_id()
+        {
+          top.set_id( id_top );
+          api_name.set_id( id_api_name );
+          parameter_list.set_id( id_parameter_list );
+          parameter.set_id( id_parameter );
+          packet.set_id( id_packet );
+          cexpr.set_id( id_cexpr );
+        }
+        rule_t const& start() const { return top; }
+      };
+      /*!
+       *  \brief  コンストラクタ
+       *  \param  tokens  静的APIの構成トークンの格納先
+       *  \param  cexpr_p C言語の定数式構文解析関数オブジェクト
+       */
+      explicit static_api_parser( std::vector< std::string >& tokens, c_const_expr_parser const& cexpr_p )
+        : tokens_( tokens ), cexpr_p_( cexpr_p )
+      {
+      }
+
+      std::vector< std::string >& tokens_;
+      c_const_expr_parser const& cexpr_p_;
+    };
+
+  }
+}
+
+#endif  // ! TOPPERS_ITRONX_STATIC_API_PARSER_HPP_
Index: /cfg_itronx+oil_gcc/toppers/macro_processor.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/macro_processor.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/macro_processor.cpp	(revision 54)
@@ -0,0 +1,2158 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2011 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <cstdlib>
+#include <cctype>
+#include <cerrno>
+#include <algorithm>
+#include <functional>
+#include <iterator>
+#include <sstream>
+#include <fstream>
+#include <limits>
+#include "toppers/workaround.hpp"
+#include "toppers/io.hpp"
+#include "toppers/cpp.hpp"
+#include "toppers/global.hpp"
+#include "toppers/macro_processor.hpp"
+#include "toppers/diagnostics.hpp"
+#include "toppers/misc.hpp"
+#include <boost/spirit/include/classic.hpp>
+#include <boost/spirit/include/classic_dynamic.hpp>
+#include <boost/spirit/include/classic_parse_tree.hpp>
+#include <boost/lexical_cast.hpp>
+
+// 非標準マクロの定義を除去
+#ifdef  max
+#undef  max
+#endif
+#ifdef  min
+#undef  min
+#endif
+
+#define DEBUG_TRACE   0
+
+namespace toppers
+{
+
+  namespace
+  {
+
+    struct expr_error {};
+
+     /*!
+      *  \struct parser macro_processor.cpp "toppers/macro_processor.cpp"
+      *  \brief  マクロ内に記述される式のパーサ
+      */
+    struct parser : boost::spirit::classic::grammar< parser >
+    {
+      enum rule_id_t
+      {
+        id_other = 0,
+
+        id_expression, id_assignment_expr, id_logical_or_expr, id_logical_and_expr,
+        id_or_expr, id_xor_expr, id_and_expr, id_equality_expr, id_relational_expr,
+        id_shift_expr, id_additive_expr, id_multiplicative_expr, id_unary_expr,
+        id_postfix_expr, id_primary_expr, id_lvalue_expr, id_identifier, id_constant,
+        id_string_literal, id_ordered_list, id_ordered_sequence, id_ordered_item,
+
+        id_root, id_top,
+        id_function_, id_if_, id_foreach_, id_joineach_, id_while_, id_joinwhile_,
+        id_error_, id_warning_,
+        id_file_, id_expr_, id_plain,
+
+        id_illegal = -1
+      };
+      enum expected_t
+      {
+        doller_expected, end_expected, close_paren_expected, close_brace_expected,
+        close_bracket_expected
+      };
+
+      /*!
+       *  \struct error_handler static_api_parser.hpp "toppers/itronx/static_api_parser.hpp"
+       *  \brief  静的APIの構文解析におけるエラー処理ファンクタ
+       */
+      struct error_handler
+      {
+        template < class Scanner, class Error >
+          boost::spirit::classic::error_status<> operator()( Scanner const& scan, Error const& error ) const
+        {
+          typename Error::iterator_t iter( error.where );
+          while ( iter != scan.last && *iter != '\0' && *iter != '\n' )
+          {
+            ++iter;
+          }
+          std::string str;
+          if ( error.where == iter )
+          {
+            str = _( "end of line" );
+          }
+          else
+          {
+            str = '\"' + std::string( error.where, iter ) + '\"';
+          }
+
+          text_line ln;
+          if ( error.where != scan.last )
+          {
+            ln = get_text_line( error.where );
+          }
+          else
+          {
+            // テンプレートファイルの最終行を求める
+            typename Error::iterator_t prev( scan.first );
+            for ( iter = scan.first; iter != scan.last; ++iter )
+            {
+              prev = iter;
+            }
+            ln = get_text_line( prev );
+          }
+          switch ( error.descriptor )
+          {
+          case doller_expected:
+            toppers::fatal( ln, _( "missing `%1%\' before %2%" ), '$', str );
+            break;
+          case end_expected:
+            toppers::fatal( ln, _( "missing `%1%\' before %2%" ), "$END$", str );
+            break;
+          case close_paren_expected:
+            toppers::fatal( ln, _( "missing `%1%\' before %2%" ), ")", str );
+            break;
+          case close_brace_expected:
+            toppers::fatal( ln, _( "missing `%1%\' before %2%" ), "}", str );
+            break;
+          case close_bracket_expected:
+            toppers::fatal( ln, _( "missing `%1%\' before %2%" ), "]", str );
+            break;
+          }
+          return  boost::spirit::classic::error_status<>( boost::spirit::classic::error_status<>::fail );
+        }
+      };
+
+
+      template < class Scanner >
+        struct definition
+      {
+        typedef boost::spirit::classic::rule< Scanner, boost::spirit::classic::dynamic_parser_tag > rule_t;
+        typedef boost::spirit::classic::guard< expected_t > guard_t;
+        typedef boost::spirit::classic::assertion< expected_t > assertion_t;
+
+        rule_t  expression,
+                assignment_expr,
+                logical_or_expr,
+                logical_and_expr,
+                or_expr,
+                xor_expr,
+                and_expr,
+                equality_expr,
+                relational_expr,
+                shift_expr,
+                additive_expr,
+                multiplicative_expr,
+                unary_expr,
+                postfix_expr,
+                primary_expr,
+                lvalue_expr,
+                identifier,
+                constant,
+                string_literal,
+                ordered_list,
+                ordered_sequence,
+                ordered_item;
+
+        rule_t  root,
+                top,
+                function_,
+                if_,
+                foreach_,
+                joineach_,
+                while_,
+                joinwhile_,
+                error_,
+                warning_,
+                file_,
+                expr_,
+                call,
+                plain;
+
+        guard_t guard_function_,
+                guard_if_,
+                guard_foreach_,
+                guard_joineach_,
+                guard_while_,
+                guard_joinwhile_,
+                guard_expr,
+                guard_postfix_expr,
+                guard_lvalue_expr,
+                guard_ordered_list;
+
+        assertion_t expect_doller,
+                    expect_end,
+                    expect_close_paren,
+                    expect_close_brace,
+                    expect_close_bracket;
+
+        definition( parser const& self )
+          : expect_doller( doller_expected ),
+            expect_end( end_expected ),
+            expect_close_paren( close_paren_expected ),
+            expect_close_brace( close_brace_expected ),
+            expect_close_bracket( close_bracket_expected )
+        {
+          using namespace boost::spirit::classic;
+
+          set_id();
+
+          expression =
+              logical_or_expr;
+          assignment_expr =
+              lvalue_expr >> '=' >> expression;
+          logical_or_expr =
+              logical_and_expr >> *( "||" >> logical_and_expr );
+          logical_and_expr =
+              or_expr >> *( "&&" >> or_expr );
+          or_expr =
+              xor_expr >> *( '|' >> xor_expr );
+          xor_expr =
+              and_expr >> *( '^' >> and_expr );
+          and_expr =
+              equality_expr >> *( '&' >> equality_expr );
+          equality_expr =
+              relational_expr >> *( ( str_p( "==" ) | "!=" ) >> relational_expr );
+          relational_expr =
+              shift_expr >> *( ( str_p( "<=" ) | ">=" | "<" | ">" ) >> shift_expr );
+          shift_expr =
+              additive_expr >> *( ( str_p( "<<" ) | ">>" ) >> additive_expr );
+          additive_expr =
+              multiplicative_expr >> *( chset<>( "+-" ) >> multiplicative_expr );
+          multiplicative_expr =
+              unary_expr >> *( chset<>( "*/%" ) >> unary_expr );
+          unary_expr =
+              *chset<>( "-+~!@" ) >> postfix_expr;
+          postfix_expr =
+            guard_postfix_expr
+            (
+                ( identifier >> '(' >> *( expression % ',' ) >> expect_close_paren( ch_p( ')' ) ) )
+              | primary_expr
+            )
+            [
+              error_handler()
+            ];
+          primary_expr =
+              lvalue_expr | ordered_list | constant | string_literal
+            | ( '(' >> expression >> ')' );
+          lvalue_expr =
+            guard_lvalue_expr
+            (
+                ( identifier >> '[' >> expression >> expect_close_bracket( ch_p( ']' ) ) )
+              | identifier
+            )
+            [
+              error_handler()
+            ];
+          identifier =
+              leaf_node_d[ lexeme_d[ ( alpha_p | '_' ) >> *( alnum_p | '_' | '.' ) ] ] - "ELIF";
+          constant =
+              leaf_node_d
+              [
+                lexeme_d
+                [
+                  if_p( '0' ) // 16進または8進
+                  [
+                    !(
+                        ( ( ch_p( 'x' ) | 'X' ) >> ( hex_p | +xdigit_p ) )
+                      | ( oct_p | +chset<>( "0-7" ) )
+                     )
+                  ]
+                  .else_p // 10進
+                  [
+                    ( int_p | +digit_p )
+                  ]
+                ]
+              ];
+          string_literal =
+              leaf_node_d[ lexeme_d[ '\"' >> *( c_escape_ch_p - '\"' ) >> '\"' ] ];
+          ordered_list =
+            guard_ordered_list
+            (
+              '{' >> !( ( ordered_sequence | ordered_item ) >> *( ';' >> ( ordered_sequence | ordered_item ) ) ) >> expect_close_brace( ch_p( '}' ) )
+            )
+            [
+              error_handler()
+            ];
+          ordered_sequence =
+              ( constant >> ',' >> constant >> ',' >> "..." >> ',' >> constant );
+          ordered_item =
+              expression >> *( ',' >> expression );
+
+          root =
+              top >> lexeme_d[ !space_p ];
+          top =
+              *( function_ | if_ | foreach_ | joineach_ | while_ | joinwhile_ | warning_ | error_ | file_ | expr_ | plain );
+          function_ =
+            guard_function_
+            (
+              "$FUNCTION" >> identifier >> expect_doller( ch_p( '$' ) ) >> top >> expect_end( str_p( "$END$" ) )
+            )
+            [
+              error_handler()
+            ];
+          if_ =
+            guard_if_
+            (
+                ( "$IF" >> expression >> expect_doller( ch_p( '$' ) ) >> top
+                  >> +( "$ELIF" >> expression >> expect_doller( ch_p( '$' ) ) >> top )
+                  >> ( "$ELSE$" >> top ) >> expect_end( str_p( "$END$" ) ) )
+              | ( "$IF" >> expression >> expect_doller( ch_p( '$' ) ) >> top
+                  >> +( "$ELIF" >> expression >> expect_doller( ch_p( '$' ) ) >> top ) >> expect_end( str_p( "$END$" ) ) )
+              | ( "$IF" >> expression >> expect_doller( ch_p( '$' ) ) >> top >> "$ELSE$" >> top >> expect_end( str_p( "$END$" ) ) )
+              | ( "$IF" >> expression >> expect_doller( ch_p( '$' ) ) >> top >> expect_end( str_p( "$END$" ) ) )
+            )
+            [
+              error_handler()
+            ];
+          foreach_ =
+            guard_foreach_
+            (
+              "$FOREACH" >> identifier >> expression >> expect_doller( ch_p( '$' ) ) >> top >> expect_end( str_p( "$END$" ) )
+            )
+            [
+              error_handler()
+            ];
+          joineach_ =
+            guard_joineach_
+            (
+              "$JOINEACH" >> identifier >> expression >> expression >> expect_doller( ch_p( '$' ) ) >> top >> expect_end( str_p( "$END$" ) )
+            )
+            [
+              error_handler()
+            ];
+          while_ =
+            guard_while_
+            (
+              "$WHILE" >> expression >> expect_doller( ch_p( '$' ) ) >> top >> expect_end( str_p( "$END$" ) )
+            )
+            [
+              error_handler()
+            ];
+          joinwhile_ =
+            guard_joinwhile_
+            (
+              "$JOINWHILE" >> expression >> expression >> expect_doller( ch_p( '$' ) ) >> top >> expect_end( str_p( "$END$" ) )
+            )
+            [
+              error_handler()
+            ];
+          warning_ =
+              "$WARNING$" >> top >> "$END$" >> !eol_p
+			  // Ticket #75対策
+			  // ちょっと不細工だが、他の方法ではうまくいかなかった
+            | "$WARNING " >> expression >> '$' >> top >> "$END$"
+            | "$WARNING\t" >> expression >> '$' >> top >> "$END$"
+            | "$WARNING\n" >> expression >> '$' >> top >> "$END$";
+          error_ =
+              "$ERROR$" >> top >> "$END$" >> !eol_p
+			  // Ticket #75対策
+			  // ちょっと不細工だが、他の方法ではうまくいかなかった
+            | "$ERROR " >> expression >> '$' >> top >> "$END$"
+            | "$ERROR\t" >> expression >> '$' >> top >> "$END$"
+            | "$ERROR\n" >> expression >> '$' >> top >> "$END$";
+          file_ =
+              "$FILE" >> string_literal >> '$';
+          expr_ =
+            guard_expr
+            (
+              ( ( '$' >> ( assignment_expr | expression ) >> expect_doller( ch_p( '$' ) ) ) - "$END$" - "$ELSE$" )
+            )
+            [
+              error_handler()
+            ];
+          plain =
+              leaf_node_d[ lexeme_d[ +( anychar_p - '$' ) | "$$" ] ];
+        }
+        rule_t const& start() const { return root; }
+        void set_id()
+        {
+          expression.set_id( id_expression );
+          assignment_expr.set_id( id_assignment_expr );
+          logical_or_expr.set_id( id_logical_or_expr );
+          logical_and_expr.set_id( id_logical_and_expr );
+          or_expr.set_id( id_or_expr );
+          xor_expr.set_id( id_xor_expr );
+          and_expr.set_id( id_and_expr );
+          equality_expr.set_id( id_equality_expr );
+          relational_expr.set_id( id_relational_expr );
+          shift_expr.set_id( id_shift_expr );
+          additive_expr.set_id( id_additive_expr );
+          multiplicative_expr.set_id( id_multiplicative_expr );
+          unary_expr.set_id( id_unary_expr );
+          postfix_expr.set_id( id_postfix_expr );
+          primary_expr.set_id( id_primary_expr );
+          lvalue_expr.set_id( id_lvalue_expr );
+          identifier.set_id( id_identifier );
+          constant.set_id( id_constant );
+          string_literal.set_id( id_string_literal );
+          ordered_list.set_id( id_ordered_list );
+          ordered_sequence.set_id( id_ordered_sequence );
+          ordered_item.set_id( id_ordered_item );
+
+          root.set_id( id_root );
+          top.set_id( id_top );
+          function_.set_id( id_function_ );
+          if_.set_id( id_if_ );
+          foreach_.set_id( id_foreach_ );
+          joineach_.set_id( id_joineach_ );
+          while_.set_id( id_while_ );
+          joinwhile_.set_id( id_joinwhile_ );
+          error_.set_id( id_error_ );
+          warning_.set_id( id_warning_ );
+          file_.set_id( id_file_ );
+          expr_.set_id( id_expr_ );
+          plain.set_id( id_plain );
+        }
+      };
+
+      parser()
+      {
+      }
+    };
+
+    typedef macro_processor::element element;
+    typedef macro_processor::var_t var_t;
+    typedef macro_processor::context context;
+
+    //! 変数が保持する数値の参照
+    std::tr1::int64_t get_i( var_t const& var, context const* p_ctx )
+    {
+      if ( var.empty() )
+      {
+        fatal( p_ctx->line, _( "non-value is referred" ) );
+        return 0;
+      }
+      element e = var.front();
+      if ( !e.i )
+      {
+        fatal( p_ctx->line, _( "non-value is referred" ) );
+        return 0;
+      }
+      return e.i.get();
+    }
+    //! 変数が保持する文字列の参照
+    std::string get_s( var_t const& var, context const* p_ctx )
+    {
+      if ( var.empty() )
+      {
+        return "";
+      }
+      std::string result;
+      for ( var_t::const_iterator iter( var.begin() ), last( var.end() ); iter != last; ++iter )
+      {
+        if ( !iter->s.empty() )
+        {
+          result += iter->s;
+        }
+        else if ( !iter->v.empty() )
+        {
+          result += iter->v;
+        }
+        else if ( iter->i )
+        {
+          result += boost::lexical_cast< std::string >( iter->i.get() );
+        }
+        if ( boost::next( iter ) != last )
+        {
+          result += ",";
+        }
+      }
+      return result;
+    }
+
+    typedef boost::spirit::classic::tree_node< boost::spirit::classic::node_iter_data< text::const_iterator > > tree_node_t;
+    bool eval_node( tree_node_t const& node, context* p_ctx );
+
+    //! 代入式
+    bool assignment_expr( tree_node_t const& node, context* p_ctx )
+    {
+      //   0 1   2
+      // lhs = rhs
+      if ( eval_node( node.children[ 0 ], p_ctx ) )
+      {
+        var_t lhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+        std::string name( get_s( lhs, p_ctx ) );
+        if ( eval_node( node.children[ 2 ], p_ctx ) )
+        {
+          var_t rhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+          var_t old_var( p_ctx->var_map[ name ] );
+          p_ctx->var_map[ name ] = rhs;
+          // modified by takuya 110823
+          if ( p_ctx->hook_on_assign != 0 )
+          {
+            ( *p_ctx->hook_on_assign )( node.children[0].value.begin().line(), name, old_var, rhs, p_ctx );
+          }
+        }
+      }
+      return true;
+    }
+
+    //! 論理和式
+    bool logical_or_expr( tree_node_t const& node, context* p_ctx )
+    {
+      //   0  1   2
+      // lhs || rhs ...
+      bool result = true;
+
+      if ( eval_node( node.children[ 0 ], p_ctx ) )
+      {
+        std::size_t const n = node.children.size();
+        if ( n == 1 )  // 左辺のみ
+        {
+          return true;
+        }
+        var_t lhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+        for ( std::size_t i = 2; i < n; i += 2 )
+        {
+          std::tr1::int64_t value = 0;
+          try
+          {
+            value = get_i( lhs, p_ctx );
+          }
+          catch ( expr_error& )
+          {
+            error( node.children[ 0 ].value.begin().line(), _( "`%1%\' does not have a value" ), get_s( lhs, p_ctx ) );
+            throw;
+          }
+          if ( value )
+          {
+            break;
+          }
+          result = eval_node( node.children[ i ], p_ctx );
+          var_t rhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+          element e;
+          std::tr1::int64_t value2 = 0;
+          try
+          {
+            value2 = get_i( rhs, p_ctx );
+          }
+          catch ( expr_error& )
+          {
+            error( node.children[ i ].value.begin().line(), _( "`%1%\' does not have a value" ), get_s( lhs, p_ctx ) );
+            throw;
+          }
+          e.i = ( value || value2 );
+          lhs[ 0 ] = e;
+        }
+        p_ctx->stack.push( lhs );
+      }
+      return result;
+    }
+
+    //! 論理積式
+    bool logical_and_expr( tree_node_t const& node, context* p_ctx )
+    {
+      //   0  1   2
+      // lhs && rhs ...
+      bool result = true;
+
+      if ( eval_node( node.children[ 0 ], p_ctx ) )
+      {
+        std::size_t const n = node.children.size();
+        if ( n == 1 )  // 左辺のみ
+        {
+          return true;
+        }
+        var_t lhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+        for ( std::size_t i = 2; i < n; i += 2 )
+        {
+          std::tr1::int64_t value = 0;
+          try
+          {
+            value = get_i( lhs, p_ctx );
+          }
+          catch ( expr_error& )
+          {
+            error( node.children[ 0 ].value.begin().line(), _( "`%1%\' does not have a value" ), get_s( lhs, p_ctx ) );
+            throw;
+          }
+          if ( !value )
+          {
+            break;
+          }
+          result = eval_node( node.children[ i ], p_ctx );
+          var_t rhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+          element e;
+          std::tr1::int64_t value2 = 0;
+          try
+          {
+            value2 = get_i( rhs, p_ctx );
+          }
+          catch ( expr_error& )
+          {
+            error( node.children[ i ].value.begin().line(), _( "`%1%\' does not have a value" ), get_s( lhs, p_ctx ) );
+            throw;
+          }
+          e.i = ( value && value2 );
+          lhs[ 0 ] = e;
+        }
+        p_ctx->stack.push( lhs );
+      }
+      return result;
+    }
+
+    //! ビット和式
+    bool or_expr( tree_node_t const& node, context* p_ctx )
+    {
+      //   0 1   2
+      // lhs | rhs ...
+      if ( eval_node( node.children[ 0 ], p_ctx ) )
+      {
+        std::size_t const n = node.children.size();
+        if ( n == 1 )  // 左辺のみ
+        {
+          return true;
+        }
+        var_t lhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+        for ( std::size_t i = 1; ( i < n ) && eval_node( node.children[ i+1 ], p_ctx ); i += 2 )
+        {
+          var_t rhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+          element e;
+          e.i = ( get_i( lhs, p_ctx ) | get_i( rhs, p_ctx ) );
+          lhs[ 0 ] = e;
+        }
+        p_ctx->stack.push( lhs );
+      }
+      return true;
+    }
+
+    //! 排他的論理和式
+    bool xor_expr( tree_node_t const& node, context* p_ctx )
+    {
+      //   0 1   2
+      // lhs ^ rhs ...
+      if ( eval_node( node.children[ 0 ], p_ctx ) )
+      {
+        std::size_t const n = node.children.size();
+        if ( n == 1 )  // 左辺のみ
+        {
+          return true;
+        }
+        var_t lhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+        for ( std::size_t i = 1; ( i < n ) && eval_node( node.children[ i+1 ], p_ctx ); i += 2 )
+        {
+          var_t rhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+          element e;
+          e.i = ( get_i( lhs, p_ctx ) ^ get_i( rhs, p_ctx ) );
+          lhs[ 0 ] = e;
+        }
+        p_ctx->stack.push( lhs );
+      }
+      return true;
+    }
+
+    //! ビット積式
+    bool and_expr( tree_node_t const& node, context* p_ctx )
+    {
+      //   0 1   2
+      // lhs & rhs ...
+      if ( eval_node( node.children[ 0 ], p_ctx ) )
+      {
+        std::size_t const n = node.children.size();
+        if ( n == 1 )  // 左辺のみ
+        {
+          return true;
+        }
+        var_t lhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+        for ( std::size_t i = 1; ( i < n ) && eval_node( node.children[ i+1 ], p_ctx ); i += 2 )
+        {
+          var_t rhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+          element e;
+          e.i = ( get_i( lhs, p_ctx ) & get_i( rhs, p_ctx ) );
+          lhs[ 0 ] = e;
+        }
+        p_ctx->stack.push( lhs );
+      }
+      return true;
+    }
+
+    //! 等価式（==、!=）
+    bool equality_expr( tree_node_t const& node, context* p_ctx )
+    {
+      //   0  1   2
+      // lhs op rhs ...
+      if ( eval_node( node.children[ 0 ], p_ctx ) )
+      {
+        std::size_t const n = node.children.size();
+        if ( n == 1 )  // 左辺のみ
+        {
+          return true;
+        }
+        var_t lhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+        for ( std::size_t i = 1; ( i < n ) && eval_node( node.children[ i+1 ], p_ctx ); i += 2 )
+        {
+          var_t rhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+          std::string op( node.children[ i ].value.begin(), node.children[ i ].value.end() );
+          std::tr1::int64_t value;
+          if ( op == "==" )
+          {
+            value = ( get_i( lhs, p_ctx ) == get_i( rhs, p_ctx ) );
+          }
+          else
+          {
+            value = ( get_i( lhs, p_ctx ) != get_i( rhs, p_ctx ) );
+          }
+          element e;
+          e.i = value;
+          lhs[ 0 ] = e;
+        }
+        p_ctx->stack.push( lhs );
+      }
+      return true;
+    }
+
+    //! 関係式（不等号）
+    bool relational_expr( tree_node_t const& node, context* p_ctx )
+    {
+      //   0  1   2
+      // lhs op rhs ...
+      if ( eval_node( node.children[0], p_ctx ) )
+      {
+        std::size_t const n = node.children.size();
+        if ( n == 1 )  // 左辺のみ
+        {
+          return true;
+        }
+        var_t lhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+        for ( std::size_t i = 1; ( i < n ) && eval_node( node.children[ i+1 ], p_ctx ); i += 2 )
+        {
+          var_t rhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+          std::string op( node.children[i].value.begin(), node.children[ i ].value.end() );
+          std::tr1::int64_t value;
+          if ( op == "<" )
+          {
+            value = ( get_i( lhs, p_ctx ) < get_i( rhs, p_ctx ) );
+          }
+          else if ( op == "<=" )
+          {
+            value = ( get_i( lhs, p_ctx ) <= get_i( rhs, p_ctx ) );
+          }
+          else if ( op == ">" )
+          {
+            value = ( get_i( lhs, p_ctx ) > get_i( rhs, p_ctx ) );
+          }
+          else
+          {
+            value = ( get_i( lhs, p_ctx ) >= get_i( rhs, p_ctx ) );
+          }
+          element e;
+          e.i = value;
+          lhs[ 0 ] = e;
+        }
+        p_ctx->stack.push( lhs );
+      }
+      return true;
+    }
+
+    //! シフト式
+    bool shift_expr( tree_node_t const& node, context* p_ctx )
+    {
+      //   0  1   2
+      // lhs op rhs ...
+      if ( eval_node( node.children[ 0 ], p_ctx ) )
+      {
+        std::size_t const n = node.children.size();
+        if ( n == 1 )  // 左辺のみ
+        {
+          return true;
+        }
+        var_t lhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+        for ( std::size_t i = 1; ( i < n ) && eval_node( node.children[ i+1 ], p_ctx ); i += 2 )
+        {
+          var_t rhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+          std::string op( node.children[ i ].value.begin(), node.children[ i ].value.end() );
+          std::tr1::int64_t value = get_i( lhs, p_ctx );
+          std::tr1::int64_t shift = get_i( rhs, p_ctx );
+          if ( shift < 0 )  // 負の値でシフトしようとした
+          {
+            error( node.children[ 0 ].value.begin().line(), _( "shift with nagative value `%1%\'" ), shift );
+          }
+          if ( shift > 64 )
+          {
+            error( node.children[ 0 ].value.begin().line(), _( "shift with too large value `%1%\'" ), shift );
+          }
+          if ( op == "<<" )
+          {
+            if ( value < 0 )
+            { // 負の値のシフトはできない
+              error( node.children[0].value.begin().line(), _( "negative value `%1%\' is shift" ), value );
+            }
+            else if ( shift != 0 && static_cast< std::tr1::int64_t >( static_cast< std::tr1::uint64_t >( 1 ) << ( 63 - shift ) ) <= value )
+            { // シフトの結果が負になる
+              error( node.children[0].value.begin().line(), _( "shift with too large value `%1%\'" ), shift );
+            }
+            value = value << shift;
+          }
+          else
+          {
+            if ( value < 0 )  // 強制的に算術シフトさせる
+            {
+              value = static_cast< std::tr1::int64_t >( ( static_cast< std::tr1::uint64_t >( value ) >> shift ) | ( ~static_cast< std::tr1::uint64_t >( 0 ) << shift ) );
+            }
+            else
+            {
+              value = value >> shift;
+            }
+          }
+          element e;
+          e.i = value;
+          lhs[ 0 ] = e;
+        }
+        p_ctx->stack.push( lhs );
+      }
+      return true;
+    }
+
+    //! 加減式
+    bool additive_expr( tree_node_t const& node, context* p_ctx )
+    {
+      //   0  1   2
+      // lhs op rhs ...
+      if ( eval_node( node.children[ 0 ], p_ctx ) )
+      {
+        std::size_t const n = node.children.size();
+        if ( n == 1 )  // 左辺のみ
+        {
+          return true;
+        }
+        var_t lhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+        for ( std::size_t i = 1; ( i < n ) && eval_node( node.children[ i+1 ], p_ctx ); i += 2 )
+        {
+          var_t rhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+          std::string op( node.children[ i ].value.begin(), node.children[ i ].value.end() );
+          std::tr1::int64_t x = get_i( lhs, p_ctx );
+          std::tr1::int64_t y = get_i( rhs, p_ctx );
+          element e;
+          if ( op == "+" )
+          {
+            if ( ( y > 0 && ( std::numeric_limits< std::tr1::int64_t >::max() - y ) < x )
+              || ( y < 0 && ( std::numeric_limits< std::tr1::int64_t >::min() - y ) > x ) )
+            {
+              error( node.children[ 0 ].value.begin().line(), _( "overflow at `%1%\'" ), get_s( lhs, p_ctx ) + "+" + get_s( rhs, p_ctx ) );
+              // e.i に値はセットされない
+            }
+            else
+            {
+              e.i = x + y;
+            }
+          }
+          else  // "-"
+          {
+            if ( ( y < 0 && ( std::numeric_limits< std::tr1::int64_t >::max() + y ) < x )
+              || ( y > 0 && ( std::numeric_limits< std::tr1::int64_t >::min() + y ) > x ) )
+            {
+              error( node.children[ 0 ].value.begin().line(), _( "overflow at `%1%\'" ), get_s( lhs, p_ctx ) + "-" + get_s( rhs, p_ctx ) );
+              // e.i に値はセットされない
+            }
+            else
+            {
+              e.i = x - y;
+            }
+          }
+          lhs[ 0 ] = e;
+        }
+        p_ctx->stack.push( lhs );
+      }
+      return true;
+    }
+
+    //! 乗除式
+    bool multiplicative_expr( tree_node_t const& node, context* p_ctx )
+    {
+      //   0  1   2
+      // lhs op rhs ...
+      if ( eval_node( node.children[ 0 ], p_ctx ) )
+      {
+        std::size_t const n = node.children.size();
+        if ( n == 1 )  // 左辺のみ
+        {
+          return true;
+        }
+        var_t lhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+        for ( std::size_t i = 1; ( i < n ) && eval_node( node.children[ i+1 ], p_ctx ); i += 2 )
+        {
+          var_t rhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+          std::string op( node.children[i].value.begin(), node.children[i].value.end() );
+          std::tr1::int64_t x = get_i( lhs, p_ctx );
+          std::tr1::int64_t y = get_i( rhs, p_ctx );
+          element e;
+          if ( op == "*" )
+          {
+            if ( ( x == 0 ) || ( y == 0 ) )
+            {
+              e.i = 0;
+            }
+            else if ( ( ( x < 0 ) == ( y < 0 ) ) && ( std::numeric_limits< std::tr1::int64_t >::max() / y < x )
+                 || ( ( x < 0 ) != ( y < 0 ) ) && ( std::numeric_limits< std::tr1::int64_t >::min() / y > x ) )
+            {
+              error( node.children[0].value.begin().line(), _( "overflow at `%1%\'" ), get_s( lhs, p_ctx ) + "*" + get_s( rhs, p_ctx ) );
+              // e.i に値はセットされない
+            }
+            else
+            {
+              e.i = x * y;
+            }
+          }
+          else
+          {
+            if ( y == 0 )
+            {
+              error( node.value.begin().line(), _( "devide by zero" ) );
+              // e.i には値がセットされない
+            }
+            else
+            {
+              std::tr1::int64_t value;
+              // 本当はここで一方のオペランドが負の場合の処理を行う必要がある。
+              // そんな変な処理系は実質的にないので放置
+              if ( op == "/" )
+              {
+                value = ( x / y );
+              }
+              else  // "%"
+              {
+                value = ( x % y );
+              }
+              e.i = value;
+            }
+          }
+          lhs[ 0 ] = e;
+        }
+        p_ctx->stack.push( lhs );
+      }
+      return true;
+    }
+
+    //! 単項式（後置式、単項演算子 一次式）
+    bool unary_expr( tree_node_t const& node, context* p_ctx )
+    {
+      //  0 1..n-2          n-1
+      // op ...... primary_expr
+      if ( eval_node( node.children[ node.children.size() - 1 ], p_ctx ) )
+      {
+        std::size_t const n = node.children.size();
+        if ( n == 1 )  // 一次式のみ
+        {
+          return true;
+        }
+        var_t expr( p_ctx->stack.top() ); p_ctx->stack.pop();
+        for ( long i = static_cast< long >( n ) - 2, t = 0; i >= 0 && eval_node( node.children[i+1], p_ctx ); i-- )
+        {
+          std::string op( node.children[ i ].value.begin(), node.children[ i ].value.end() );
+          element e;
+          std::tr1::int64_t value = 0;
+          if ( op != "@" )
+          {
+            try
+            {
+              value = get_i( expr, p_ctx );
+            }
+            catch ( expr_error& )
+            {
+              error( node.children[0].value.begin().line(), _( "`%1%\' is undefined" ), get_s( expr, p_ctx ) );
+              throw;
+            }
+            if ( op == "+" )
+            {
+              e.i = +value;
+            }
+            else if ( op == "-" )
+            {
+              if ( value == std::numeric_limits< std::tr1::int64_t >::min() )
+              {
+                error( node.children[0].value.begin().line(), _( "overflow at `%1%\'" ), "-" + get_s( expr, p_ctx ) );
+                // e.i に値はセットされない
+              }
+              else
+              {
+                e.i = -value;
+              }
+            }
+            else if ( op == "~" )
+            {
+              e.i = ~value;
+            }
+            else if ( op == "!" )
+            {
+              e.i = !value;
+            }
+            value = *e.i;
+          }
+          else  // op == "@" （値属性 → 文字列属性）
+          {
+            if ( expr.front().i )
+            {
+              e.s = boost::lexical_cast< std::string >( *expr.front().i );
+            }
+            else
+            {
+              e.s = expr.front().v;
+            }
+          }
+          expr[ 0 ] = e;  // 演算結果を累積する
+          if ( i == t )
+          {
+            break;
+          }
+        }
+        p_ctx->stack.push( expr );
+      }
+      return true;
+    }
+
+    //! 後置式（関数呼び出し、一次式）
+    bool postfix_expr( tree_node_t const& node, context* p_ctx )
+    {
+      //            0 1    2 3 4..2+2*n-1 2+2*n 2+2*n+1 
+      //   identifier ( arg0 , ..........  argn       )
+      // primary_expr
+      if ( eval_node( node.children[0], p_ctx ) )
+      {
+        if ( node.children.size() > 1 )   // 関数の呼び出し
+        {
+          var_t ident( p_ctx->stack.top() ); p_ctx->stack.pop();
+          std::string func_name( get_s( ident, p_ctx ) );
+          std::map< std::string, macro_processor::func_t >::const_iterator iter( p_ctx->func_map.find( func_name ) );
+          if ( iter == p_ctx->func_map.end() )  // そんな関数はない
+          {
+            error( node.children[ 0 ].value.begin().line(), _( "function `%1%\' is undefined" ), func_name );
+            p_ctx->stack.push( var_t() );
+          }
+          else  // 関数を呼び出す
+          {
+            std::vector< var_t > arg_list;
+            for ( std::size_t i = 0, n = node.children.size() - 1; 2 + 2*i < n; i++ )
+            {
+              if ( eval_node( node.children[ 2 + 2*i ], p_ctx ) )
+              {
+                var_t arg( p_ctx->stack.top() ); p_ctx->stack.pop();
+                arg_list.push_back( arg );
+              }
+            }
+            var_t result;
+            if ( iter->second.f != 0 )  // 組み込み関数
+            {
+              result = ( *iter->second.f )( node.children[0].value.begin().line(), arg_list, p_ctx );
+            }
+            else if ( iter->second.node != 0 )  // ユーザー定義関数
+            {
+              // ARGC
+              {
+                element e;
+                e.i = static_cast< std::tr1::int64_t >( arg_list.size() + 1 );
+                p_ctx->var_map[ "ARGC" ] = var_t( 1, e );
+              }
+
+              // ARGV
+              {
+                element e;
+                e.s = func_name;
+                p_ctx->var_map[ "ARGV[0]" ] = var_t( 1, e );
+
+                std::size_t n = arg_list.size() + 1;
+                for ( std::size_t i = 1; i < n; i++ )
+                {
+                  std::string argv_i = boost::str( boost::format( "ARGV[%d]" ) % i );
+                  p_ctx->var_map[ argv_i ] = arg_list[ i - 1 ];
+                }
+
+                std::string argv_n = boost::str( boost::format( "ARGV[%d]" ) % n );
+                p_ctx->var_map[ argv_n ] = var_t();
+              }
+
+              set_error_location( func_name.c_str() );
+              tree_node_t const* func_body_node = reinterpret_cast< tree_node_t const* >( iter->second.node );
+              if ( !eval_node( *func_body_node, p_ctx ) )
+              {
+                // 呼び出し失敗
+                p_ctx->stack.push( result );
+                return false;
+              }
+
+              result = p_ctx->var_map[ "RESULT" ];
+              p_ctx->var_map[ "RESULT" ] = var_t(); // 変数$RESULT$をクリア
+            }
+            p_ctx->stack.push( result );
+          }
+        }
+      }
+      return true;
+    }
+
+    //! 一次式（左辺値式、(式)）
+    bool primary_expr( tree_node_t const& node, context* p_ctx )
+    {
+      bool result = true;
+
+      if ( node.children.size() == 1 )
+      {
+        result = eval_node( node.children[0], p_ctx );
+        if ( node.children[ 0 ].value.id() == parser::id_lvalue_expr )
+        {
+          var_t ident( p_ctx->stack.top() ); p_ctx->stack.pop();
+          std::string name( get_s( ident, p_ctx ) );
+          var_t value( p_ctx->var_map[ name ] );
+          p_ctx->stack.push( value );
+        }
+      }
+      else
+      {
+        // 0          1 2
+        // ( expression )
+        result = eval_node( node.children[1], p_ctx );
+      }
+      return result;
+    }
+
+    //! 左辺値式（変数、配列変数）
+    bool lvalue_expr( tree_node_t const& node, context* p_ctx )
+    {
+      //          0 1          2 3
+      // identifier
+      // identifier [ expression ]
+      if ( eval_node( node.children[ 0 ], p_ctx ) )
+      {
+        if ( ( node.children.size() > 1 ) && eval_node( node.children[ 2 ], p_ctx ) )
+        {
+          var_t expr( p_ctx->stack.top() ); p_ctx->stack.pop();
+          var_t ident( p_ctx->stack.top() ); p_ctx->stack.pop();
+          element e;
+          std::string subscript;
+          try
+          {
+            std::tr1::int64_t i = get_i( expr, p_ctx );
+            subscript = boost::lexical_cast< std::string >( i );
+          }
+          catch ( expr_error& )
+          {
+            subscript = get_s( expr, p_ctx );
+            error( node.children[ 0 ].value.begin().line(), _( "`%1%\' does not have a value" ), subscript );
+            throw;
+          }
+          e.s = ( boost::format( "%s[%s]" ) % get_s( ident, p_ctx ) % subscript ).str();
+          p_ctx->stack.push( var_t( 1, e ) );
+        }
+      }
+      return true;
+    }
+
+    //! 識別子
+    bool identifier( tree_node_t const& node, context* p_ctx )
+    {
+      element e;
+      std::string ident( node.children[0].value.begin(), node.children[0].value.end() );
+      std::string::size_type n = ident.find_first_not_of( " \t\r\n" );
+      e.s = ident.c_str() + n;
+      p_ctx->stack.push( var_t( 1, e ) );
+      return true;
+    }
+
+    //! 整数定数
+    bool constant( tree_node_t const& node, context* p_ctx )
+    {
+      element e;
+      e.s.assign( node.children[0].value.begin(), node.children[0].value.end() );
+
+      // Boost 1.39.0?以上で、0の前の空白を含めてトークンとしてしまう不具合の対策
+      std::string::size_type pos = e.s.find_first_not_of( " \t\n" );
+      if (pos != std::string::npos )
+      {
+        e.s = e.s.substr( pos );
+      }
+
+      std::istringstream iss( e.s );
+      iss.unsetf( std::ios_base::basefield );
+      std::tr1::int64_t value;
+      iss >> value;
+      if ( iss.bad() )
+      {
+        error( node.children[0].value.begin().line(), _( "overflow at `%1%\'" ), e.s );
+      }
+      e.i = value;
+      p_ctx->stack.push( var_t( 1, e ) );
+      return true;
+    }
+
+    //! 文字列
+    bool string_literal( tree_node_t const& node, context* p_ctx )
+    {
+      // 0 1..n-2 n-1
+      // " ......   "
+      element e;
+      // ここで構文エラー例外になることはあり得ない。（構文解析後なので）
+      e.s = expand_quote( std::string( node.children[0].value.begin(), node.children[0].value.end() ) );
+      p_ctx->stack.push( var_t( 1, e ) );
+      return true;
+    }
+
+    //! 順序付きリスト
+    bool ordered_list( tree_node_t const& node, context* p_ctx )
+    {
+      // 0                1 2     n-1
+      // { ordered_sequence ; ...   }
+      // {     ordered_item ; ...   }
+      if ( node.children.size() < 3 )
+      {
+        p_ctx->stack.push( var_t() );
+      }
+      else if ( eval_node( node.children[1], p_ctx ) )
+      {
+        var_t lhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+        for ( std::size_t i = 1, n = node.children.size(); ( i+2 < n ) && eval_node( node.children[i+2], p_ctx ); i += 2 )
+        {
+          var_t rhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+          std::copy( rhs.begin(), rhs.end(), std::back_inserter( lhs ) );
+        }
+        p_ctx->stack.push( lhs );
+      }
+      return true;
+    }
+
+    //! 順序付きリスト（等差数列）
+    bool ordered_sequence( tree_node_t const& node, context* p_ctx )
+    {
+      //   0 1   2 3   4 5   6
+      // int , int , ... , int
+      if ( eval_node( node.children[0], p_ctx ) )
+      {
+        var_t first( p_ctx->stack.top() ); p_ctx->stack.pop();
+        if ( eval_node( node.children[ 2 ], p_ctx ) )
+        {
+          var_t second( p_ctx->stack.top() ); p_ctx->stack.pop();
+          if ( eval_node( node.children[ 6 ], p_ctx ) )
+          {
+            var_t last( p_ctx->stack.top() ); p_ctx->stack.pop();
+            std::tr1::int64_t a0 = get_i( first, p_ctx );
+            std::tr1::int64_t a1 = get_i( second, p_ctx );
+            std::tr1::int64_t an = get_i( last, p_ctx );
+            std::tr1::int64_t d = a1 - a0;
+            if ( ( an - a0 ) % d != 0 )
+            {
+              error( node.children[ 0 ].value.begin().line(), _( "illegal arithmetic sequence" ) );
+            }
+            else
+            {
+              for ( std::tr1::int64_t i = a1, t = an + d; i != t; i += d )
+              {
+                element e;
+                e.i = i;
+                first.push_back( e );
+              }
+              first[ 1 ].s = second[0].s;
+              first.back().s = last[ 0 ].s;
+            }
+            p_ctx->stack.push( first );
+          }
+        }
+      }
+      return true;
+    }
+
+    //! 順序付きリスト（列記）
+    bool ordered_item( tree_node_t const& node, context* p_ctx )
+    {
+      //   0 1   2
+      // int , int ...
+      if ( eval_node( node.children[ 0 ], p_ctx ) )
+      {
+        var_t lhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+        for ( std::size_t i = 1, n = node.children.size(); ( i < n ) && eval_node( node.children[ i+1 ], p_ctx ); i += 2 )
+        {
+          var_t rhs( p_ctx->stack.top() ); p_ctx->stack.pop();
+          lhs.push_back( rhs[ 0 ] );
+        }
+        p_ctx->stack.push( lhs );
+      }
+      return true;
+    }
+
+    //! トップレベル
+    bool top( tree_node_t const& node, context* p_ctx )
+    {
+      bool result = true;
+
+      for ( std::size_t i = 0, n = node.children.size(); i < n; i++ )
+      {
+        for ( text::const_iterator iter( node.children[ i ].value.begin() ), last( node.children[ i ].value.end() );
+              iter != last;
+              ++iter )
+        {
+          char c = *iter;
+          if ( !std::isspace( static_cast< unsigned char >( c ) ) )
+          {
+            break;
+          }
+          if ( c != '\n' )
+          {
+            p_ctx->target_file << c;
+          }
+        }
+        result &= eval_node( node.children[i], p_ctx );
+      }
+      return result;
+    }
+
+    //! $FUNCTION命令
+    bool function_( tree_node_t const& node, context* p_ctx )
+    {
+      bool result = true;
+
+      if ( node.children.empty() )
+      {
+        fatal( node.value.begin().line(), "no body of %1%", "'FUNCTION'" );
+      }
+
+      if ( p_ctx->in_function )
+      {
+        fatal( node.value.begin().line(), "function cannot be nested" );
+      }
+      p_ctx->in_function = true;
+
+      //         0          1 2   3    4
+      // $FUNCTION identifier $ top $END$
+      if ( eval_node( node.children[ 1 ], p_ctx ) )   // identifier
+      {
+        var_t ident( p_ctx->stack.top() ); p_ctx->stack.pop();
+        macro_processor::func_t func;
+        func.name = get_s( ident, p_ctx );
+        func.node = &node.children[ 3 ];
+        func.f = 0; // 組み込み関数ではないので
+        p_ctx->func_map[ func.name ] = func;
+      }
+      else
+      {
+        result = false;
+      }
+      p_ctx->in_function = false;
+      return result;
+    }
+
+    //! $IF命令
+    bool if_( tree_node_t const& node, context* p_ctx )
+    {
+      bool result = true;
+
+      if ( node.children.empty() )
+      {
+        fatal( node.value.begin().line(), "no body of %1%", "'IF' or 'ELSE'" );
+      }
+
+      //   0          1 2   3      4   5     6 4+4*i    4+4*i+1 4+4*i+2 4+4*i+3        n-3 n-2   n-1
+      // $IF expression $ top  $END$
+      // $IF expression $ top $ELSE$ top $END$
+      // $IF expression $ top ...              $ELIF expression       $     top ... $ELSE$ top $END$
+      if ( eval_node( node.children[ 1 ], p_ctx ) )   // expression
+      {
+        var_t expr( p_ctx->stack.top() ); p_ctx->stack.pop();
+        bool cond = false;
+        try
+        {
+          cond = !!get_i( expr, p_ctx );
+        }
+        catch ( expr_error& )
+        {
+          error( node.children[ 0 ].value.begin().line(), _( "`%1%\' does not have a value" ), get_s( expr, p_ctx ) );
+          throw;
+        }
+
+        std::size_t n = node.children.size();
+        
+        if ( cond )           // $IF expr$
+        {
+          result &= eval_node( node.children[ 3 ], p_ctx );   // top
+        }
+        else if ( n == 7 ) // $ELSE$
+        {
+          result &= eval_node( node.children[ 5 ], p_ctx );   // top
+        }
+        else if ( n > 5 )  // $ELIF...
+        {
+          for ( std::size_t i = 0; 4 + 4 * i < n - 1; i++ )
+          {
+            std::string token( node.children[ 4 + 4 * i ].value.begin(), node.children[ 4 + 4 * i ].value.end() );
+            if ( token == "$ELIF" )  // $ELIF
+            {
+              if ( eval_node( node.children[ 4 + 4 * i + 1 ], p_ctx ) )   // expression
+              {
+                var_t expr( p_ctx->stack.top() ); p_ctx->stack.pop();
+                cond = false;
+                try
+                {
+                  cond = !!get_i( expr, p_ctx );
+                }
+                catch ( expr_error& )
+                {
+                  error( node.children[ 0 ].value.begin().line(), _( "`%1%\' does not have a value" ), get_s( expr, p_ctx ) );
+                  throw;
+                }
+                if ( cond )           // $ELIF expr$
+                {
+                  result &= eval_node( node.children[ 4 + 4 * i + 3 ], p_ctx );   // top
+                  break;
+                }
+              }
+            }
+            else  // ELSE
+            {
+              result &= eval_node( node.children[ 4 + 4 * i + 1 ], p_ctx );   // top
+              break;
+            }
+          }
+        }
+      }
+      return result;
+    }
+
+    //! FOREACH命令
+    bool foreach_( tree_node_t const& node, context* p_ctx )
+    {
+      bool result = true;
+
+      if ( node.children.empty() )
+      {
+        fatal( node.value.begin().line(), "no body of %1%", "'FOREACH'" );
+      }
+
+      //        0          1          2 3   4     5
+      // $FOREACH identifier order_list $ top $END$
+      if ( eval_node( node.children[1], p_ctx ) )   // identifier
+      {
+        var_t ident( p_ctx->stack.top() ); p_ctx->stack.pop();
+        if ( eval_node( node.children[ 2 ], p_ctx ) ) // order_list
+        {
+          var_t order_list( p_ctx->stack.top() ); p_ctx->stack.pop();
+          if ( !order_list.empty() )
+          {
+            for ( var_t::const_iterator iter( order_list.begin() ), last( order_list.end() ); iter != last; ++iter )
+            {
+              p_ctx->var_map[ get_s( ident, p_ctx ) ] = var_t( 1, *iter );
+              result &= eval_node( node.children[ 4 ], p_ctx ); // top
+            }
+          }
+        }
+      }
+      return result;
+    }
+
+    //! $JOINEACH命令
+    bool joineach_( tree_node_t const& node, context* p_ctx )
+    {
+      bool result = true;
+
+      if ( node.children.empty() )
+      {
+        fatal( node.value.begin().line(), "no body of %1%", "'JOINEACH'" );
+      }
+
+      //         0          1          2         3 4   5     6
+      // $JOINEACH identifier order_list delimitor $ top $END$
+      if ( eval_node( node.children[ 1 ], p_ctx ) )       // identifier
+      {
+        var_t ident( p_ctx->stack.top() ); p_ctx->stack.pop();
+        if ( eval_node( node.children[ 2 ], p_ctx ) )     // order_list
+        {
+          var_t order_list( p_ctx->stack.top() ); p_ctx->stack.pop();
+          //if ( !order_list.empty() && order_list[0].i ) // TODO: 1.8.0と違う
+          if ( !order_list.empty() ) // TODO: 1.8.0と違う
+          {
+            if ( eval_node( node.children[ 3 ], p_ctx ) ) // delimitor
+            {
+              var_t delimitor( p_ctx->stack.top() ); p_ctx->stack.pop();
+              for ( var_t::const_iterator iter( order_list.begin() ), last( order_list.end() ); iter != last; ++iter )
+              {
+                p_ctx->var_map[ get_s( ident, p_ctx ) ] = var_t( 1, *iter );
+                result &= eval_node( node.children[ 5 ], p_ctx ); // top
+                if ( boost::next( iter ) != last )
+                {
+                  p_ctx->target_file << get_s( delimitor, p_ctx );
+                }
+              }
+            }
+          }
+        }
+      }
+      return result;
+    }
+
+    //! WHILE命令
+    bool while_( tree_node_t const& node, context* p_ctx )
+    {
+      bool result = true;
+
+      if ( node.children.empty() )
+      {
+        fatal( node.value.begin().line(), "no body of %1%", "'WHILE'" );
+      }
+
+      //      0          1 2   3     4
+      // $WHILE expression $ top $END$
+      for (;;)
+      {
+        if ( eval_node( node.children[1], p_ctx ) )   // expression
+        {
+          var_t expr( p_ctx->stack.top() ); p_ctx->stack.pop();
+          bool cond = false;
+          try
+          {
+            cond = !!get_i( expr, p_ctx );
+          }
+          catch ( expr_error& )
+          {
+            error( node.children[ 0 ].value.begin().line(), _( "`%1%\' does not have a value" ), get_s( expr, p_ctx ) );
+            throw;
+          }
+          if ( !cond )
+          {
+            break;
+          }
+          result &= eval_node( node.children[ 3 ], p_ctx ); // top
+        }
+      }
+      return result;
+    }
+
+    //! $JOINWHILE命令
+    bool joinwhile_( tree_node_t const& node, context* p_ctx )
+    {
+      bool result = true;
+
+      if ( node.children.empty() )
+      {
+        fatal( node.value.begin().line(), "no body of %1%", "'JOINWHILE'" );
+      }
+
+      //          0          1         2 3   4     5
+      // $JOINWHILE expression delimitor $ top $END$
+      for ( bool first = true; ; first = false )
+      {
+        if ( eval_node( node.children[1], p_ctx ) )   // expression
+        {
+          var_t expr( p_ctx->stack.top() ); p_ctx->stack.pop();
+          bool cond = false;
+          try
+          {
+            cond = !!get_i( expr, p_ctx );
+          }
+          catch ( expr_error& )
+          {
+            error( node.children[ 0 ].value.begin().line(), _( "`%1%\' does not have a value" ), get_s( expr, p_ctx ) );
+            throw;
+          }
+          if ( !cond )
+          {
+            break;
+          }
+          if ( !first && eval_node( node.children[ 2 ], p_ctx ) ) // delimitor
+          {
+            var_t delimitor( p_ctx->stack.top() ); p_ctx->stack.pop();
+            p_ctx->target_file << get_s( delimitor, p_ctx );
+          }
+        }
+        result &= eval_node( node.children[ 4 ], p_ctx ); // top
+      }
+      return result;
+    }
+
+    //! $ERROR命令
+    bool error_( tree_node_t const& node, context* p_ctx )
+    { 
+      //         0    1     2   3     4
+      //   $ERROR$  top $END$
+      // $WARNING$  top $END$
+      //    $ERROR expr     $ top $END$
+      //  $WARNING expr     $ top $END$
+
+      if ( node.children.empty() )
+      {
+        fatal( node.value.begin().line(), "no body of %1%", "'ERROR' or 'WARNING'" );
+      }
+
+      output_file of = p_ctx->target_file;
+      p_ctx->target_file = output_file( "stderr", std::ios_base::out ); // 出力先を一時的に標準エラー出力に切り替える。
+
+      bool is_error = ( static_cast< parser::rule_id_t >( node.value.id().to_long() ) == parser::id_error_ );
+
+      p_ctx->target_file << get_program_name() << ':';
+
+      bool has_expr = ( node.children.size() > 3 );
+
+      if ( has_expr && eval_node( node.children[1], p_ctx ) ) // expr
+      {
+        var_t expr( p_ctx->stack.top() ); p_ctx->stack.pop();
+        if ( !expr.empty() )
+        {
+          if ( !expr.front().s.empty() )
+          {
+            p_ctx->target_file << expr.front().s << ':';
+          }
+          if ( expr.front().i )
+          {
+            p_ctx->target_file << expr.front().i.get() << ':';
+          }
+        }
+      }
+
+      p_ctx->target_file << ( is_error ? " error: " : " warning: " );
+
+      bool result = eval_node( node.children[has_expr ? 3 : 1], p_ctx ); // top
+      p_ctx->target_file << '\n';
+      p_ctx->target_file = of;
+
+      if ( is_error )
+      {
+        increment_error_count();  // error関数を使わないので、明示的にエラーカウントを操作する。
+      }
+      return result;
+    }
+
+    //! $WARNING命令
+    bool warning_( tree_node_t const& node, context* p_ctx )
+    {
+      return error_( node, p_ctx );
+    }
+
+    //! $FILE命令
+    bool file_( tree_node_t const& node, context* p_ctx )
+    {
+      //     0              1 2
+      // $FILE string-literal $
+      if ( eval_node( node.children[1], p_ctx ) ) // string-literal
+      {
+        var_t filename( p_ctx->stack.top() ); p_ctx->stack.pop();
+        p_ctx->target_file << '\n';
+        p_ctx->target_file = output_file( get_s( filename, p_ctx ), std::ios_base::out );
+      }
+      return true;
+    }
+
+    //! 式
+    bool expr_( tree_node_t const& node, context* p_ctx )
+    {
+      // 0          1 2
+      // $ expression $
+      if ( eval_node( node.children[ 1 ], p_ctx ) ) // expression
+      {
+        if ( node.children[1].value.id().to_long() == parser::id_expression )
+        {
+          var_t expr( p_ctx->stack.top() ); p_ctx->stack.pop();
+          p_ctx->target_file << get_s( expr, p_ctx );
+        }
+      }
+      return true;
+    }
+
+    // マクロ命令以外
+    bool plain( tree_node_t const& node, context* p_ctx )
+    {
+      std::string buf;
+      buf.reserve( node.children[ 0 ].value.end() - node.children[ 0 ].value.begin() );
+	  std::size_t offset = 0;
+
+	  if ( std::isspace( static_cast< unsigned char >( *node.children[ 0 ].value.begin() ) ) )	// plainの先頭が空白類文字の場合、なぜか二重になる不具合の暫定対策
+	  	offset = 1;
+
+	  for ( text::const_iterator iter( node.children[ 0 ].value.begin() + offset ), last( node.children[0].value.end() ); iter != last; ++iter )
+      {
+        if ( *iter == '$' )
+        {
+          ++iter;
+        }
+        switch ( char c = *iter )
+        {
+        case '\r':
+        case '\n':
+          break;
+        default:
+          buf.push_back( c );
+          break;
+        }
+      }
+      p_ctx->target_file << buf;
+      return true;
+    }
+
+    // 構文木の各ノードの評価
+    bool eval_node( tree_node_t const& node, context* p_ctx )
+    {
+      bool result = true;
+      if ( p_ctx != 0 )
+      {
+        p_ctx->line = node.value.begin().line();
+      }
+
+#if defined( _MSC_VER ) && DEBUG_TRACE
+      ::OutputDebugString( ( boost::format( "%s:%d:%s\n" )
+                        % node.children[ 0 ].value.begin().line().file
+                        % node.children[ 0 ].value.begin().line().line
+                        % std::string( node.children[ 0 ].value.begin(), node.children[ 0 ].value.end() )
+                        ).str().c_str() );
+#elif 0
+      std::cerr << boost::format( "%s:%d:%s" )
+                        % node.children[ 0 ].value.begin().line().file
+                        % node.children[ 0 ].value.begin().line().line
+                        % std::string( node.children[ 0 ].value.begin(), node.children[ 0 ].value.end() )
+                        << std::endl;
+#endif
+
+      switch ( parser::rule_id_t id = static_cast< parser::rule_id_t >( node.value.id().to_long() ) )
+      {
+      case parser::id_expression:
+        result = eval_node( node.children[ 0 ], p_ctx );
+        break;
+      case parser::id_assignment_expr:
+        result = assignment_expr( node, p_ctx );
+        break;
+      case parser::id_logical_or_expr:
+        result = logical_or_expr( node, p_ctx );
+        break;
+      case parser::id_logical_and_expr:
+        result = logical_and_expr( node, p_ctx );
+        break;
+      case parser::id_or_expr:
+        result = or_expr( node, p_ctx );
+        break;
+      case parser::id_xor_expr:
+        result = xor_expr( node, p_ctx );
+        break;
+      case parser::id_and_expr:
+        result = and_expr( node, p_ctx );
+        break;
+      case parser::id_equality_expr:
+        result = equality_expr( node, p_ctx );
+        break;
+      case parser::id_relational_expr:
+        result = relational_expr( node, p_ctx );
+        break;
+      case parser::id_shift_expr:
+        result = shift_expr( node, p_ctx );
+        break;
+      case parser::id_additive_expr:
+        result = additive_expr( node, p_ctx );
+        break;
+      case parser::id_multiplicative_expr:
+        result = multiplicative_expr( node, p_ctx );
+        break;
+      case parser::id_unary_expr:
+        result = unary_expr( node, p_ctx );
+        break;
+      case parser::id_postfix_expr:
+        result = postfix_expr( node, p_ctx );
+        break;
+      case parser::id_primary_expr:
+        result = primary_expr( node, p_ctx );
+        break;
+      case parser::id_lvalue_expr:
+        result = lvalue_expr( node, p_ctx );
+        break;
+      case parser::id_identifier:
+        result = identifier( node, p_ctx );
+        break;
+      case parser::id_constant:
+        result = constant( node, p_ctx );
+        break;
+      case parser::id_string_literal:
+        result = string_literal( node, p_ctx );
+        break;
+      case parser::id_ordered_list:
+        result = ordered_list( node, p_ctx );
+        break;
+      case parser::id_ordered_sequence:
+        result = ordered_sequence( node, p_ctx );
+        break;
+      case parser::id_ordered_item:
+        result = ordered_item( node, p_ctx );
+        break;
+      case parser::id_root:
+        result = eval_node( node.children[0], p_ctx );
+        break;
+      case parser::id_top:
+        result = top( node, p_ctx );
+        break;
+      case parser::id_function_:
+        result = function_( node, p_ctx );
+        break;
+      case parser::id_if_:
+        result = if_( node, p_ctx );
+        break;
+      case parser::id_foreach_:
+        result = foreach_( node, p_ctx );
+        break;
+      case parser::id_joineach_:
+        result = joineach_( node, p_ctx );
+        break;
+      case parser::id_while_:
+        result = while_( node, p_ctx );
+        break;
+      case parser::id_joinwhile_:
+        result = joinwhile_( node, p_ctx );
+        break;
+      case parser::id_error_:
+        result = error_( node, p_ctx );
+        break;
+      case parser::id_warning_:
+        result = warning_( node, p_ctx );
+        break;
+      case parser::id_file_:
+        result = file_( node, p_ctx );
+        break;
+      case parser::id_expr_:
+        result = expr_( node, p_ctx );
+        break;
+      case parser::id_plain:
+        result = plain( node, p_ctx );
+        break;
+      default:
+        result = false;
+        break;
+      }
+      return result;
+    }
+
+    bool eval_text( text::const_iterator first, text::const_iterator last, context* p_ctx )
+    {
+      using namespace boost::spirit::classic;
+      typedef text::const_iterator iterator_t;
+      tree_parse_info< iterator_t, node_iter_data_factory<> > info;
+      info = pt_parse( first, last, parser(), space_p, node_iter_data_factory<>() );
+      if ( info.full && !info.trees.empty() )
+      {
+        bool result;
+        if ( info.length <= 0 )
+        {
+          result = true;
+        }
+        else
+        {
+          result = eval_node( info.trees[ 0 ], p_ctx );
+        }
+        return result;
+      }
+      else
+      {
+        fatal( info.stop.line(), _( "syntax error" ) );
+      }
+      return false;
+    }
+
+  }
+
+  std::tr1::int64_t macro_processor::to_integer( var_t const& var, context const* p_ctx )
+  {
+    return get_i( var, p_ctx );
+  }
+
+  std::string macro_processor::to_string( var_t const& var, context const* p_ctx )
+  {
+    return get_s( var, p_ctx );
+  }
+
+  macro_processor::macro_processor()
+    : p_ctx_( new context )
+  {
+  }
+
+  // modified by takuya 110823
+  macro_processor::macro_processor( hook_t hook_on_assign )
+    : p_ctx_( new context( hook_on_assign ) )
+  {
+  }
+
+  macro_processor::macro_processor( macro_processor const& other )
+    : p_ctx_( new context( *other.p_ctx_ ) )
+  {
+  }
+
+  macro_processor::macro_processor( text const& in )
+    : p_ctx_( new context )
+  {
+    evaluate( in );
+  }
+
+  // modified by takuya 110823
+  macro_processor::macro_processor( text const& in, hook_t hook_on_assign )
+    : p_ctx_( new context( hook_on_assign ) )
+  {
+    evaluate( in );
+  }
+
+  macro_processor::~macro_processor()
+  {
+    delete p_ctx_;
+    p_ctx_ = 0;
+  }
+
+  macro_processor& macro_processor::operator=( macro_processor const& other )
+  {
+    macro_processor t( *this );
+    swap( t );
+    return *this;
+  }
+
+  void macro_processor::swap( macro_processor& other )
+  {
+    std::swap( p_ctx_, other.p_ctx_ );
+  }
+
+  void macro_processor::evaluate( text const& in )
+  {
+    try
+    {
+      for ( func_t const* p_bf = builtin_function_table; !p_bf->name.empty(); p_bf++ )
+      {
+        p_ctx_->func_map[ p_bf->name ] = *p_bf;
+      }
+      if ( !eval_text( in.begin(), in.end(), p_ctx_ ) )
+      {
+        fatal( _( "macro processing error" ) );
+      }
+    }
+    catch ( die_terminate& )
+    {
+      // $DIE()$関数が呼ばれた
+    }
+    catch ( expr_error& )
+    {
+      fatal( _( "macro processing error" ) );
+    }
+  }
+
+  void macro_processor::set_var( std::string const& name, var_t const& value )
+  {
+#if defined( _MSC_VER ) && /* DEBUG_TRACE */ 1
+    std::string s( "$" + name + " = " + get_s( value, p_ctx_ ) + "$" );
+    if ( !value.empty() && value[ 0 ].i )
+    {
+      s += "(" + boost::lexical_cast< std::string >( get_i( value, p_ctx_ ) ) + ")";
+    }
+    s += "\n";
+    ::OutputDebugString( s.c_str() );
+#endif
+    p_ctx_->var_map[ name ] = value;
+  }
+
+  void macro_processor::set_var( std::string const& name, long name2, var_t const& value )
+  {
+    set_var( ( boost::format( "%s[%d]" ) % name % name2 ).str(), value );
+  }
+
+  macro_processor::var_t const& macro_processor::get_var( std::string const& name ) const
+  {
+    return p_ctx_->var_map[ name ];
+  }
+
+  macro_processor::var_t const& macro_processor::get_var( std::string const& name, long name2 ) const
+  {
+    return get_var( ( boost::format( "%s[%d]" ) % name % name2 ).str() );
+  }
+
+  /*!
+    *  \brief  コメントの除去
+    *  \param[in]  first   処理対象シーケンスの先頭位置  
+    *  \param[in]  last    処理対象シーケンスの終端位置の次
+    *  \param[out] result  処理結果の格納先
+    *  \return     処理完了後の result の値
+    *
+    *  「$ + 空白類文字」で始まり、改行で終わるコメントを除去します。
+    */
+  void macro_processor::remove_comment( text const& in, text& out )
+  {
+    text::const_iterator first( in.begin() ), last( in.end() );
+    std::back_insert_iterator< text > result( std::back_inserter( out ) );
+    out.set_line( first.line().file, first.line().line );
+
+    for ( text::const_iterator iter; ( iter = std::find( first, last, '\n' ) ) != last ; first = iter + 1 )
+    {
+      std::string buf( first, iter );
+      std::string::size_type found_pos;
+
+      if ( ( ( buf.size() >= 2 ) && ( buf[0] == '$' ) && std::isspace( static_cast< unsigned char >( buf[1] ) ) )
+        || ( buf.size() == 1 && buf[0] == '$' ) )	// 行頭に限り、'$'単独でもコメントとみなす
+      {
+        *result = '\n'; 
+      }
+      else if ( ( found_pos = buf.find( std::string( "$#" ) ) ) != std::string::npos )  // 行の途中に"$#"があれば、それ以降をコメントとみなす
+      {
+        result = std::copy( buf.begin(), buf.begin() + found_pos, result );
+      }
+	  else
+      {
+        // コメント行以外は行頭の空白類を除去する。
+        first = std::find_if( first, iter, std::not1( std::ptr_fun< char, bool >( &toppers::isspace ) ) );
+        result = std::copy( first, iter + 1, result );
+      }
+    }
+  }
+
+  void macro_processor::expand_include( text const& in, text& out )
+  {
+    typedef text::container::const_iterator const_row_iterator;
+    typedef std::string::size_type size_type;
+    size_type const npos = std::string::npos;
+std::string debug_str;
+
+    if ( in.empty() ) // 空のファイルが入力された場合の対策
+    {
+      return;
+    }
+
+    const_row_iterator first( in.begin().get_row() ), last( in.end().get_row() );
+
+    out.set_line( first->line.file, first->line.line );
+    for ( const_row_iterator iter( first ); iter != last; ++iter )
+    {
+      std::string const& buf = iter->buf;
+
+      for ( size_type i = 0, n = buf.size(); i != n; ++i )
+      {
+        using namespace boost::spirit::classic;
+        char c = buf[i];
+        std::string headername;
+        text::const_iterator iter2( iter, i );
+        if ( iter2 == in.end() )
+        {
+          break;
+        }
+        parse_info< text::const_iterator > info
+          = parse( iter2, in.end(),
+                    ( ch_p( '$' ) >> str_p( "INCLUDE" ) >> *space_p
+                        >> '\"' >> ( +( anychar_p - '\"' ) )[ assign( headername ) ] >> '\"'
+                      >> '$' ) );
+        if ( info.hit )
+        {
+          std::vector< std::string > include_paths = get_global< std::vector< std::string > >( "include-path" );
+          std::string hname = search_include_file( include_paths.begin(), include_paths.end(), headername );
+          if ( hname.empty() )
+          {
+            fatal( iter->line, _( "cannot open file `%1%\'" ), headername );
+          }
+          else
+          {
+            text t;
+            t.set_line( hname, 1 );
+            std::ifstream ifs( hname.c_str() );
+            t.append( ifs );
+
+            preprocess( t, out );
+            iter = info.stop.get_row();
+            i = info.stop.get_col() - 1;
+            out.set_line( iter->line.file, iter->line.line );
+          }
+        }
+        else
+        {
+          out.push_back( c );
+          debug_str.push_back( c );
+          if ( c == '\n' )
+          {
+//            ::OutputDebugString( ( out.get_line().file + ":" + boost::lexical_cast< std::string >( out.get_line().line ) + ":" ).c_str() );
+//            ::OutputDebugString( debug_str.c_str() );
+            debug_str.clear();
+          }
+        }
+      }
+    }
+  }
+
+  void macro_processor::preprocess( text const& in, text& out )
+  {
+    if ( in.empty() )
+    {
+      return;
+    }
+    text temp;
+    macro_processor::remove_comment( in, temp );
+    expand_include( temp, out );
+  }
+
+  void macro_processor::add_builtin_function( func_t const& f )
+  {
+    p_ctx_->func_map[ f.name ] = f;
+  }
+
+  macro_processor::var_t macro_processor::call_user_function( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx )
+  {
+    if ( arg_list.empty() )
+    {
+      return var_t();
+    }
+
+    func_t func = p_ctx->func_map[ get_s( arg_list.front(), p_ctx ) ]; 
+    if ( func.name.empty() )
+    {
+      fatal( line, "function is not defined" );
+      return var_t();
+    }
+
+    // ARGC
+    {
+      element e;
+      e.i = static_cast< std::tr1::int64_t >( arg_list.size() );
+      p_ctx->var_map[ "ARGC" ] =var_t( 1, e );
+    }
+
+    // ARGV
+    {
+      std::size_t n = arg_list.size();
+      for ( std::size_t i = 0; i < n; i++ )
+      {
+        std::string argv_i = boost::str( boost::format( "ARGV[%d]" ) % i );
+        p_ctx->var_map[ argv_i ] = arg_list[ i ];
+      }
+
+      std::string argv_n = boost::str( boost::format( "ARGV[%d]" ) % n );
+      p_ctx->var_map[ argv_n ] = var_t();
+    }
+
+    tree_node_t const* func_body_node = reinterpret_cast< tree_node_t const* >( func.node );
+    if ( !eval_node( *func_body_node, p_ctx ) )
+    {
+      return var_t();
+    }
+
+    var_t result = p_ctx->var_map[ "RESULT" ];
+    p_ctx->var_map[ "RESULT" ] = var_t(); // 変数$RESULT$をクリア
+    return result;
+  }
+
+}
Index: /cfg_itronx+oil_gcc/toppers/macro_processor.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/macro_processor.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/macro_processor.hpp	(revision 54)
@@ -0,0 +1,179 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2009 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/macro_processor.hpp
+ *  \brief  マクロ処理のための宣言定義
+ *
+ *  このファイルで定義されるクラス
+ *  \code
+ *  class macro_processor;
+ *  \endcode
+ */
+#ifndef TOPPERS_MACRO_PROCESSOR_HPP_
+#define TOPPERS_MACRO_PROCESSOR_HPP_
+
+#include <string>
+#include <vector>
+#include <stack>
+#include <map>
+#include "toppers/workaround.hpp"
+#include "toppers/output_file.hpp"
+#include "toppers/text.hpp"
+
+namespace toppers
+{
+
+  class macro_processor
+  {
+  public:
+    struct context;
+
+    /*!
+     *  \struct element macro_processor.hpp "toppers/macro_processor.hpp"
+     *  \brief  マクロ中で使用する変数の値
+     *
+     *  正確には、変数の値は常に順序付きリストとして扱われます。element は順序付きリストの 1 要素を表します。
+     */
+    struct element
+    {
+      boost::optional< std::tr1::int64_t > i;
+      std::string v;
+      std::string s;
+    };
+    /*!
+     *  \brief  マクロ中で使用する変数を表現する型
+     */
+    typedef std::vector< element > var_t;
+
+    /*!
+     *  \struct func_t macro_processor.hpp "toppers/macro_processor.hpp"
+     *  \brief  マクロ内で扱う関数を表現する型
+     *  \note   元々単純な構造体であったため、互換性のため、集成体と特性を維持させている。
+     *  \attention  node の初期化忘れに要注意
+     */
+    struct func_t
+    {
+      std::string name;   //!< 関数名
+      var_t ( * f )( text_line const& line, std::vector< var_t > const&, context* );  //!< 処理内容
+      void const* node;
+    };
+
+    // modified by takuya 110823
+    typedef void ( * hook_t )( text_line const&, std::string const&, var_t const&, var_t const&, context* );
+
+    struct context
+    {
+      std::stack< var_t > stack;
+      std::map< std::string, var_t > var_map;
+      std::map< std::string, func_t > func_map;
+      bool in_function;
+      output_file target_file;
+      hook_t hook_on_assign;
+      text_line line;
+      // modified by takuya 110823
+      // hoaは省略可能引数なので，問題はないはず
+      // ここで，下記2つのコンストラクタを定義すると，
+      // 引数なしのコンストラクタを呼んだ場合にどちらを
+      // 適用するか判断できず，コンパイルエラーとなるため，
+      // context()を削除した．
+      // context() : in_function( false ) {}
+      explicit context( hook_t hoa = 0 ) : hook_on_assign( hoa ), in_function( false ) {}
+    };
+
+    struct die_terminate {};
+
+    // modified by takuya 110823
+    // 省略可能引数を追加しただけなので，問題はないはず
+    // ここで，省略可能な引数が追加されたコンストラクタを定義すると，
+    // 引数なしのコンストラクタを呼んだ場合に追加する前後のどちらを
+    // 適用するか判断できず，コンパイルエラーとなるため，
+    // 追加する前のコンストラクタを削除した．
+    // しかし，そのようにしたところ，macro_processor.cppでの定義と
+    // 矛盾が生じたため，省略可能引数は使わないようにした．
+    macro_processor();
+    //explicit macro_processor( hook_t hook_on_assign = 0 );
+    explicit macro_processor( hook_t hook_on_assign );
+    macro_processor( macro_processor const& other );
+    explicit macro_processor( text const& in );
+    //explicit macro_processor( text const& in, hook_t hook_on_assign = 0 );
+    explicit macro_processor( text const& in, hook_t hook_on_assign );
+
+    ~macro_processor();
+    macro_processor& operator=( macro_processor const& other );
+    void swap( macro_processor& other );
+    void evaluate( text const& in );
+    void set_var( std::string const& name, var_t const& value );
+    void set_var( std::string const& name, long name2, var_t const& value );
+    var_t const& get_var( std::string const& name ) const;
+    var_t const& get_var( std::string const& name, long name2 ) const;
+    void add_builtin_function( func_t const& f );
+
+    static void remove_comment( text const& in, text& out );
+    static void expand_include( text const& in, text& out );
+    static void preprocess( text const& in, text& out );
+    static std::tr1::int64_t to_integer( var_t const& var, context const* p_ctx );
+    static std::string to_string( var_t const& var, context const* p_ctx );
+    static bool check_arity( text_line const& line, std::size_t arity, std::size_t valid, char const* function_name );
+    static var_t call_user_function( text_line const& line, std::vector< var_t > const& arg_list, context* p_ctx );
+  private:
+    context* p_ctx_;
+    static func_t const builtin_function_table[];
+  };
+
+  inline bool operator == ( macro_processor::element const& lhs, macro_processor::element const& rhs )
+  {
+    return lhs.i == rhs.i;
+  }
+
+  inline bool operator < ( macro_processor::element const& lhs, macro_processor::element const& rhs )
+  {
+    return lhs.i < rhs.i;
+  }
+
+  struct element_eq
+  {
+    explicit element_eq( std::tr1::int64_t value ) : value_( value ) {}
+    bool operator()( toppers::macro_processor::element const& e ) const
+    {
+      return e.i && ( e.i.get() == value_ );
+    }
+    std::tr1::int64_t value_;
+  };
+
+}
+
+#endif  // ! TOPPERS_MACRO_PROCESSOR_HPP_
Index: /cfg_itronx+oil_gcc/toppers/mbchar_parser.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/mbchar_parser.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/mbchar_parser.cpp	(revision 54)
@@ -0,0 +1,58 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2010 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*
+ *  toppers/mbchar_parser.cpp
+ */
+#include "toppers/c_parser.hpp"
+
+namespace toppers
+{
+
+  //! ASCII文字パーサー
+  boost::spirit::classic::functor_parser< detail::mbchar_parse_functor< ascii > > const ascii_p;
+
+  //! ShiftJIS文字パーサー
+  boost::spirit::classic::functor_parser< detail::mbchar_parse_functor< shift_jis > > const shift_jis_p;
+
+  //! EUC-JP文字パーサー
+  boost::spirit::classic::functor_parser< detail::mbchar_parse_functor< euc_jp > > const euc_jp_p;
+
+  //! UTF-8文字パーサー
+  boost::spirit::classic::functor_parser< detail::mbchar_parse_functor< utf8 > > const utf8_p;
+
+}
Index: /cfg_itronx+oil_gcc/toppers/misc.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/misc.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/misc.hpp	(revision 54)
@@ -0,0 +1,308 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*!
+ *  \file   toppers/misc.hpp
+ *  \brief  雑多なライブラリのための宣言定義
+ */
+#ifndef TOPPERS_MISC_HPP_
+#define TOPPERS_MISC_HPP_
+
+#include <stdexcept>
+#include <locale>
+#include <iosfwd>
+#include <string>
+#include <algorithm>
+#include <cctype>
+#include <cwchar>
+#include <cwctype>
+#include <cstdlib>
+#include "toppers/codeset.hpp"
+#include <boost/scoped_array.hpp>
+
+#if defined(_MSC_VER) || defined(__MINGW32__)
+#include <mbstring.h>
+#endif
+
+// workaround
+#include <ctype.h>
+#include <wctype.h>
+
+#define TOPPERS_STRINGIFY( s )  TOPPERS_STRINGIFY_( s )
+#define TOPPERS_STRINGIFY_( s ) # s
+
+namespace toppers
+{
+
+  /*!
+   *  \class  conversion_error misc.hpp "toppers/misc.hpp"
+   *  \brief  変換エラー例外クラス
+   */
+  class conversion_error : public std::runtime_error
+  {
+  public:
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  what  例外原因文字列
+     */
+    explicit conversion_error( std::string const& what ) : std::runtime_error( what ) {}
+  };
+
+  /*!
+   *  \brief  シングルバイト文字から CharT 型（多くは wchar_t 型）文字への変換
+   *  \param  ch  シングルバイト文字
+   *  \return CharT 型文字を返す
+   */
+  template < typename CharT >
+    inline CharT widen( char ch )
+  {
+    return std::use_facet< std::ctype< CharT > >( std::locale() ).widen( ch );
+  }
+
+  template <>
+    inline char widen< char >( char ch )
+  {
+    return ch;
+  }
+
+  template <>
+    inline unsigned char widen< unsigned char >( char ch )
+  {
+    return static_cast< unsigned char >( ch );
+  }
+
+  template <>
+    inline wchar_t widen< wchar_t >( char ch )
+  {
+#if defined( __MINGW32__ )
+    wchar_t wc = wchar_t( -1 );
+    if ( std::mbtowc( &wc, &ch, 1 ) < 0 )
+    {
+      return WEOF;
+    }
+    return wc;
+#elif defined( __CYGWIN__ )
+    return static_cast< wchar_t >( static_cast< unsigned char >( ch ) );
+#else
+    return static_cast< wchar_t >( std::btowc( static_cast< unsigned char >( ch ) ) );
+#endif
+  }
+
+  /*!
+   *  \brief  シングルバイト文字列から CharT 型文字列への変換
+   *  \param  str   シングルバイト文字列
+   *  \return CharT 型文字列を返す
+   */
+  template < typename CharT >
+    std::basic_string< CharT > const widen( std::string const& str );
+
+  template <>
+    inline std::basic_string< char > const widen( std::string const& str )
+  {
+    return str;
+  }
+
+  template <>
+    inline std::basic_string< wchar_t > const widen( std::string const& str )
+  {
+    boost::scoped_array< wchar_t > t( new wchar_t[str.size()+1] );
+    if ( std::mbstowcs( t.get(), str.c_str(), str.size() ) == size_t( -1 ) )
+    {
+      static conversion_error x( "in function widen" );
+      throw x;
+    }
+    return t.get();
+  }
+
+#undef  tolower
+
+  /*!
+   *  \brief  小文字への変換
+   *  \param  ch    変換対象の文字
+   *  \return ch が大文字であれば対応する小文字を、それ以外は ch を返す
+   */
+  inline char tolower( char ch )
+  {
+    return static_cast< char >( std::tolower( static_cast< unsigned char >( ch ) ) );
+  }
+
+  /*!
+   *  \brief  文字列を小文字に変換
+   *  \param  str   変換対象の文字
+   *  \return str に含まれる大文字を小文字に変換した文字列を返す
+   */
+  inline std::string const tolower( std::string str )
+  {
+    char ( *f )( char ) = &tolower;
+    std::transform( str.begin(), str.end(), str.begin(), f );
+    return str;
+  }
+
+  /*!
+   *  \brief  ワイド文字列を小文字に変換
+   *  \param  str   変換対象の文字
+   *  \return str に含まれる大文字を小文字に変換したワイド文字列を返す
+   */
+  template < class Traits, class Allocator >
+    std::basic_string< wchar_t, Traits, Allocator > const tolower( std::basic_string< wchar_t, Traits, Allocator > str )
+  {
+  	wint_t ( *f )( wint_t ) = &towlower;
+    std::transform( str.begin(), str.end(), str.begin(), f );
+    return str;
+  }
+
+#undef  toupper
+
+  /*!
+   *  \brief  大文字への変換
+   *  \param  ch    変換対象の文字
+   *  \return ch が小文字であれば対応する大文字を、それ以外は ch を返す
+   */
+  inline char toupper( char ch )
+  {
+    return static_cast< char >( std::toupper( static_cast< unsigned char >( ch ) ) );
+  }
+
+  /*!
+   *  \brief  文字列を大文字に変換
+   *  \param  str   変換対象の文字
+   *  \return str に含まれる小文字を大文字に変換した文字列を返す
+   */
+  inline std::string const toupper( std::string str )
+  {
+    char ( *f )( char ) = &toupper;
+    std::transform( str.begin(), str.end(), str.begin(), f );
+    return str;
+  }
+
+  /*!
+   *  \brief  ワイド文字列を大文字に変換
+   *  \param  str   変換対象の文字
+   *  \return str に含まれる小文字を大文字に変換したワイド文字列を返す
+   */
+  template < class Traits, class Allocator >
+    std::basic_string< wchar_t, Traits, Allocator > const toupper( std::basic_string< wchar_t, Traits, Allocator > str )
+  {
+  	wint_t ( *f )( wint_t ) = &towupper;
+    std::transform( str.begin(), str.end(), str.begin(), f );
+    return str;
+  }
+
+#undef  isspace
+
+  /*!
+   *  \brief  空白類の判別
+   *  
+   */
+  inline bool isspace( char ch )
+  {
+    return std::isspace( static_cast< unsigned char >( ch ) ) != 0;
+  }
+
+  /*!
+   *  \brief  指定文字で区切られたリスト出力
+   *  \param  first   出力する先頭要素位置
+   *  \param  last    出力する終端要素位置+1
+   *  \param  ostr    出力ストリーム
+   *  \param  pred    各要素を受け取り出力値を返す述語
+   *  \param  delim   区切文字
+   *
+   *  この関数は区間 [first, last) の各要素を pred に渡して得られる値を delim
+   *  で区切って ostr に出力します。\n
+   *  終端の要素の後には delim は出力されず、要素と要素の間にのみ delim が
+   *  出力されます。
+   */
+  template < class InputIterator, typename CharT, class Traits, class Pred >
+    void output_list( InputIterator first, InputIterator last, std::basic_ostream< CharT, Traits >& ostr, Pred pred, CharT const* delim = 0 )
+  {
+    if ( delim == 0 )
+    {
+      static CharT const null_delim[] = { 0 };
+      delim = null_delim;
+    }
+
+    for ( bool f = false; first != last; ++first )
+    {
+      if ( f )
+      {
+        ostr << delim;
+      }
+      ostr << pred( *first );
+      f = true;
+    }
+  }
+
+  template < typename CharT, class Traits, class Allocator >
+    std::basic_string< CharT, Traits, Allocator > trim( std::basic_string< CharT, Traits, Allocator > const& str, std::basic_string< CharT, Traits, Allocator > const& ws )
+  {
+    if ( str.empty() || ws.empty() )
+    {
+      return str;
+    }
+    typename std::basic_string< CharT, Traits, Allocator >::size_type first = str.find_first_not_of( ws, 0 );
+    for ( typename std::basic_string< CharT, Traits, Allocator >::size_type i = str.size() - 1; i >= 0; i-- )
+    {
+      if ( ws.find( str[ i ] ) == ws.npos )
+      {
+        return str.substr( first, i );
+      }
+    }
+    return str.substr( first );
+  }
+
+  inline std::string dir_delimiter_to_slash( std::string const& str )
+  {
+#if defined(_MSC_VER) || defined(__MINGW32__)
+    std::string result;
+    result.reserve( str.size() );
+
+    unsigned char const* s1 = reinterpret_cast< unsigned char const* >( str.c_str() );
+    while ( unsigned char const* s2 = _mbschr( s1, '\\' ) )
+    {
+      result.append( s1, s2 );
+      result.push_back( '/' );
+      s1 = s2 + 1;
+    }
+    return result + reinterpret_cast< char const* >( s1 );
+#else
+    return str;
+#endif
+  }
+
+}
+
+#endif  // ! TOPPERS_MISC_HPP_
Index: /cfg_itronx+oil_gcc/toppers/nm_symbol.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/nm_symbol.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/nm_symbol.cpp	(revision 54)
@@ -0,0 +1,104 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*
+ *  toppers/nm_symbol.cpp
+ */
+#include "toppers/nm_symbol.hpp"
+#include <istream>
+#include <sstream>
+#include <cctype>
+
+namespace toppers
+{
+
+  /*!
+   *  \brief  シンボルテーブルのロード
+   *  \param  istr  入力ストリーム
+   */
+  void nm_symbol::load( std::istream& istr )
+  {
+    while ( istr )
+    {
+      std::string buf;
+      std::getline( istr, buf );
+      std::istringstream isstr( buf );
+
+      unsigned long address = 0;
+      char type;
+      std::string symbol;
+      if ( !buf.empty() && !std::isspace( static_cast< unsigned char >( buf[0] ) ) )
+      {
+        isstr >> std::hex >> address;
+      }
+      isstr >> type >> symbol;
+
+      if ( !symbol.empty() )
+      {
+        entry e;
+        e.address = address;
+        e.type = static_cast< unsigned char >( type );
+        symbol_map_[symbol] = e;
+      }
+    }
+  }
+
+  /*!
+   *  \brief  シンボルの探索
+   *  \param  symbol  探索するシンボル文字列
+   *  \return シンボルに対応するエントリを返す
+   */
+  nm_symbol::entry const nm_symbol::find( std::string const& symbol ) const
+  {
+    std::map< std::string, entry >::const_iterator iter( symbol_map_.find( symbol ) );
+    entry e = { 0, -1 };
+    if ( iter != symbol_map_.end() )
+    {
+      e = iter->second;
+    }
+    else
+    {
+      iter = symbol_map_.find( "_" + symbol );  // 識別子に'_'が付加される場合に対応
+      if ( iter != symbol_map_.end() )
+      {
+        e = iter->second;
+      }
+    }
+    return e;
+  }
+
+}
Index: /cfg_itronx+oil_gcc/toppers/nm_symbol.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/nm_symbol.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/nm_symbol.hpp	(revision 54)
@@ -0,0 +1,100 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/nm_symbol.hpp
+ *  \brief  "nm"コマンドで得られるシンボルテーブルを扱うための宣言定義
+ *
+ *  このファイルで定義されるクラス
+ *  \code
+ *  class nm_symbol;
+ *  \endcode
+ */
+#ifndef TOPPERS_NM_SYMBOL_HPP_
+#define TOPPERS_NM_SYMBOL_HPP_
+
+#include "toppers/config.hpp"
+#include <iosfwd>
+#include <string>
+#include <map>
+
+namespace toppers
+{
+
+  /*!
+   *  \class  nm_symbol nm_symbol.hpp "toppers/nm_symbol.hpp"
+   *  \brief  `nm'コマンドで得られるシンボルテーブルを扱うためのクラス
+   *
+   *  \sa nm_symbol::entry
+   */
+  class nm_symbol
+  {
+  public:
+    /*!
+     *  \struct entry nm_symbol.hpp "toppers/nm_symbol.hpp"
+     *  \brief  アドレスとタイプ情報を格納する構造体
+     *
+     *  `nm'コマンドの出力結果が、
+     *  \code
+     *  01234567 T foo
+     *  \endcode
+     *  となった場合、0x01234567が address に、'T'が type に格納されます。
+     */
+    struct entry
+    {
+      unsigned long address;
+      int type;
+    };
+
+    /*!
+     *  \brief  デフォルトコンストラクタ
+     */
+    nm_symbol() {}
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  istr  入力ストリーム
+     */
+    explicit nm_symbol( std::istream& istr ) { load( istr ); }
+
+    void load( std::istream& istr );
+    entry const find( std::string const& symbol ) const; 
+  private:
+    std::map< std::string, entry > symbol_map_;
+  };
+
+}
+
+#endif  // ! TOPPERS_NM_SYMBOL_HPP_
Index: /cfg_itronx+oil_gcc/toppers/oil/Makefile
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/Makefile	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/Makefile	(revision 54)
@@ -0,0 +1,32 @@
+-include ../Makefile.config
+
+PROJDIR = ../..
+WORKDIR = $(PROJDIR)/toppers/oil
+
+CPPFLAGS := $(CPPFLAGS) -I$(BOOST_DIR) -I$(PROJDIR)
+CXXFLAGS := $(CXXFLAGS) -O2 -g
+
+CXXFILES = \
+	cfg1_out.cpp \
+	checker.cpp \
+	configuration_manager.cpp \
+	factory.cpp \
+	oil_object.cpp \
+	oil_parse.cpp \
+	preprocess.cpp
+
+OBJFILES := $(CXXFILES:%.cpp=%.o)
+
+all: liboil.a
+
+liboil.a: $(OBJFILES)
+	$(AR) rcs liboil.a $(OBJFILES)
+
+depend:
+	$(CXX) $(CPPFLAGS) -M $(CXXFILES) > Makefile.depend
+
+clean:
+	-rm -f *.o *.a
+
+-include Makefile.depend
+
Index: /cfg_itronx+oil_gcc/toppers/oil/cfg1_out.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/cfg1_out.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/cfg1_out.cpp	(revision 54)
@@ -0,0 +1,466 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2009 by TAKAGI Nobuhisa
+ *  Copyright (C) 2010 by Meika Sugimoto
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <cstdlib>
+#include <cerrno>
+#include <iostream>
+#include <fstream>
+#include <sstream>
+#include <iterator>
+#include <algorithm>
+#include <stack>
+#include "toppers/text.hpp"
+#include "toppers/diagnostics.hpp"
+#include "toppers/c_expr.hpp"
+#include "toppers/global.hpp"
+#include "toppers/macro_processor.hpp"
+#include "toppers/s_record.hpp"
+#include "toppers/nm_symbol.hpp"
+#include "toppers/oil/cfg1_out.hpp"
+#include "toppers/oil/preprocess.hpp"
+#include "toppers/oil/configuration_manager.hpp"
+#include <boost/spirit/include/classic_spirit.hpp>
+#include <boost/filesystem/path.hpp>
+
+using namespace toppers::oil::oil_definition;
+using namespace toppers::configuration_manager;
+
+namespace toppers
+{
+  namespace oil
+  {
+    namespace
+    {
+      struct block_t
+      {
+        std::string type;
+        std::string id;
+        text_line line;
+      };
+    }
+
+    //! cfg_out クラスの実装詳細
+    struct cfg1_out::implementation
+    {
+    protected:
+      output_file ofile_;
+      oil_def *oil_def_array;
+      std::string cfg1_out_list_;
+      std::string includes_;
+      std::vector< block_t > block_table_;
+
+      std::tr1::shared_ptr< s_record > srec_;
+      std::tr1::shared_ptr< nm_symbol > syms_;
+      bool little_endian_;
+      std::size_t base_;
+      cfg1_def_table const* def_table_;
+	  config_manage oil_configuration;
+
+      implementation( std::string const& filename, std::ios_base::openmode omode, cfg1_def_table const* def_table = 0 )
+		  : ofile_( filename, omode ), little_endian_( true ), base_( 1 ), def_table_( def_table )
+      {
+      }
+      virtual ~implementation()
+      {
+      }
+      virtual void do_load_cfg( std::string const& input_file, codeset_t codeset,  std::vector<std::string> const& obj_info );
+      virtual void do_generate_includes() const
+      {
+      }
+      virtual void do_generate_cfg1_def() const
+      {
+        ofile_ << "const uint32_t TOPPERS_cfg_magic_number = 0x12345678;\n"
+                  "const uint32_t TOPPERS_cfg_sizeof_signed_t = sizeof(signed_t);\n"
+                  "const uint32_t TOPPERS_cfg_sizeof_pointer = sizeof(const volatile void*);\n"
+                  "const unsigned_t TOPPERS_cfg_CHAR_BIT = CHAR_BIT;\n"
+                  "const unsigned_t TOPPERS_cfg_CHAR_MAX = CHAR_MAX;\n"
+                  "const unsigned_t TOPPERS_cfg_CHAR_MIN = CHAR_MIN;\n"
+                  "const unsigned_t TOPPERS_cfg_SCHAR_MAX = SCHAR_MAX;\n"
+                  "const unsigned_t TOPPERS_cfg_SHRT_MAX = SHRT_MAX;\n"
+                  "const unsigned_t TOPPERS_cfg_INT_MAX = INT_MAX;\n"
+                  "const unsigned_t TOPPERS_cfg_LONG_MAX = LONG_MAX;\n"
+                  "\n";
+
+        if ( def_table_ != 0 )	// 「値取得シンボルテーブル」
+        {
+          for ( cfg1_def_table::const_iterator iter( def_table_->begin() ), last( def_table_->end() );
+                iter != last;
+                ++iter )
+          {
+            // 式の最初に # があれば、それはマクロ定義の判定
+            // ★注意★ #@ で始まる書式は廃止 2010/07/23
+            bool is_pp = ( iter->expression[ 0 ] == '#' );
+            if ( !iter->value1.empty() || !iter->value2.empty() ) // （CSVの）4番目または5番目の値があれば...
+            {
+              is_pp = true;
+            }
+
+            std::string type = ( iter->is_signed ? "signed_t" : "unsigned_t" );
+            std::string definition = "const " + type + " ";
+            definition += "TOPPERS_cfg_" + iter->name;
+            if ( is_pp )
+            {
+              std::string expression = iter->expression.substr( iter->expression[ 0 ] == '#' ? 1 : 0 );
+              std::string value1 = ( !iter->value1.empty() ? iter->value1 : "1" );
+              std::string value2 = ( !iter->value2.empty() ? iter->value2 : "0" );
+              definition +=
+                          " = \n"
+                          "#if " + expression + "\n"
+                          "(" + value1 + ");\n"
+                          "#else\n"
+                          "(" + value2 + ");\n"
+                          "#endif\n";
+            }
+            else if ( iter->expression[ 0 ] == '@' )  // '@'で始まればアドレス
+            {
+              definition = "const volatile void* const TOPPERS_cfg_" + iter->name + " = (" + ( iter->expression.c_str() + 1 ) + ");\n";
+            }
+            else
+            {
+              definition +=
+                          " = ( " + type + " )" + iter->expression + ";\n";
+            }
+            ofile_ << definition;
+          }
+        }
+      }
+      virtual void do_assign_params();
+      virtual implementation* do_clone() const
+      {
+        return new implementation( *this );
+      }
+
+      void preprocess( std::string const& input_file, codeset_t codeset, text& txt );
+
+      friend class cfg1_out;
+    };
+
+
+    /*!
+     *  \brief  コンストラクタ
+     *  \param[in]  filename    cfg1_out.c または cfg1_out.srec 若しくはそれらの代替名
+     *  \param[in]  def_table   cfg1_out.c 生成用の定義テーブル
+     */
+    cfg1_out::cfg1_out( std::string const& filename, cfg1_def_table const* def_table )
+      : pimpl_( new implementation( filename, std::ios_base::out, def_table ) )
+    {
+    }
+
+    /*!
+     *  \brief  コピーコンストラクタ
+     *  \param[in]  other   コピー元
+     */
+    cfg1_out::cfg1_out( cfg1_out const& other )
+      : pimpl_( other.pimpl_->do_clone() )
+    {
+    }
+
+    //! デストラクタ
+    cfg1_out::~cfg1_out()
+    {
+      delete pimpl_;
+      pimpl_ = 0;
+    }
+
+    /*!
+     *  \brief  システムコンフィギュレーションファイルのロード
+     *  \param[in]  input_file  入力ファイル名
+     *  \param[in]  codeset     文字コード
+     *  \param[in]  obj_info    オブジェクト情報の連想配列
+     */
+    void cfg1_out::load_cfg( std::string const& input_file, codeset_t codeset, 
+    		std::vector<std::string> const* obj_info )
+    {
+      return pimpl_->do_load_cfg( input_file, codeset, *obj_info );
+    }
+
+    //! 前処理
+    void cfg1_out::implementation::preprocess( std::string const& input_file, codeset_t codeset, text& txt )
+    {
+      boost::any print_depend = global( "print-dependencies" );
+      if ( !print_depend.empty() )
+      {
+        std::set< std::string > depend, onces;
+        oil::preprocess( input_file, txt, codeset, &depend, &onces );
+
+        // 依存関係の出力（GNU makeに適した形式）
+        std::string target_file = boost::any_cast< std::string& >( print_depend );
+        std::cout << target_file << ": " << input_file << ' ';
+        std::copy( depend.begin(), depend.end(), std::ostream_iterator< std::string >( std::cout, " " ) );
+        std::cout << std::endl;
+        exit();
+      }
+      else
+      {
+        std::set< std::string > onces;
+        oil::preprocess( input_file, txt, codeset, 0, &onces );
+      }
+    }
+
+    /*!
+     *  \brief  システムコンフィギュレーションファイルのロード処理の実体
+     *  \param[in]  input_file  入力ファイル名
+     *  \param[in]  codeset     文字コード
+     *  \param[in]  obj_info    オブジェクト情報の連想配列
+     */
+    void cfg1_out::implementation::do_load_cfg( std::string const& input_file, 
+    			codeset_t codeset, std::vector<std::string> const& obj_info )
+    {
+	  
+	  text txt;
+      // システムコンフィギュレーションファイルの解析
+      std::ostringstream oss, includes_oss;
+
+      preprocess( input_file, codeset, txt );
+	  
+	  // OIL情報の読み出し
+	  if(oil_configuration.read_configuration(&txt , obj_info) == true)
+	  {
+		  oil_def_array = oil_configuration.get_obj_def();
+		  oil_configuration.validate_and_assign_default_configuration();
+	  }
+		
+      // データメンバへの反映
+      std::string cfg1_list_temp( oss.str() );
+      std::string includes_temp( includes_oss.str() );
+
+      cfg1_out_list_.swap( cfg1_list_temp );
+      includes_.swap( includes_temp );
+    }
+
+    /*!
+     *  \brief  cfg1_out.c の内容生成
+     *  \param[in]  type  配列 cfg1_out[] の要素型。空ポインタの場合は uint32_t として扱われる。
+     */
+    void cfg1_out::generate( char const* type ) const
+    {
+      if ( type == 0 )
+      {
+        type = "uint32_t";
+      }
+      pimpl_->ofile_ << "/* cfg1_out.c */\n"
+                        "#define TOPPERS_CFG1_OUT  1\n" 
+                        "#include \"osek_kernel.h\"\n"
+                        "#include \"target_cfg1_out.h\"\n";
+      pimpl_->do_generate_includes();
+      pimpl_->ofile_ << pimpl_->includes_ << '\n';
+
+      // int128_tは故意に無視
+      // int128_tに揃えると処理が重くなりすぎるため
+      pimpl_->ofile_ << "\n#ifdef INT64_MAX\n"
+                        "  typedef int64_t signed_t;\n"
+                        "  typedef uint64_t unsigned_t;\n"
+                        "#else\n"
+                        "  typedef int32_t signed_t;\n"
+                        "  typedef uint32_t unsigned_t;\n"
+                        "#endif\n";
+
+      pimpl_->ofile_ << "\n#include <target_cfg1_out.h>\n\n";
+
+      pimpl_->do_generate_cfg1_def();
+      pimpl_->ofile_ << pimpl_->cfg1_out_list_ << '\n';
+    }
+
+    /*!
+     *  \brief  #include指令の並びを取得する
+     *  \return #include指令の並び
+     *
+     *  このメンバ関数は、
+     *  \code
+     *  #include <...>
+     *  #include "..."
+     *  \endcode
+     *  といった#include指令の並びを文字列として返す。
+     */
+    std::string const& cfg1_out::get_includes() const
+    {
+      return pimpl_->includes_;
+    }
+
+    /*!
+     *  \brief  Sレコードのロード
+     */
+    void cfg1_out::load_srec()
+    {
+      std::ifstream srec_ifs( ( pimpl_->ofile_.file_name() + ".srec" ).c_str() );
+      if ( !srec_ifs.is_open() )
+      {
+        fatal( _( "cannot open file `%1%\'" ), pimpl_->ofile_.file_name() + ".srec" );
+      }
+      pimpl_->srec_ = std::tr1::shared_ptr< s_record >( new s_record( srec_ifs ) );
+
+      std::ifstream syms_ifs( ( pimpl_->ofile_.file_name() + ".syms" ).c_str() );
+      if ( !syms_ifs.is_open() )
+      {
+        fatal( _( "cannot open file `%1%\'" ), pimpl_->ofile_.file_name() + ".syms" );
+      }
+      pimpl_->syms_ = std::tr1::shared_ptr< nm_symbol >( new nm_symbol( syms_ifs ) );
+
+      nm_symbol::entry nm_entry = pimpl_->syms_->find( "TOPPERS_cfg_magic_number" );
+      if ( nm_entry.type < 0 )
+      {
+        fatal( _( "magic number is not found in `%1%\'" ), ( pimpl_->ofile_.file_name() + ".srec/.syms" ) );
+      }
+      unsigned long magic[ 4 ];
+      magic[ 0 ] = ( *pimpl_->srec_ )[ nm_entry.address + 0 ];
+      magic[ 1 ] = ( *pimpl_->srec_ )[ nm_entry.address + 1 ];
+      magic[ 2 ] = ( *pimpl_->srec_ )[ nm_entry.address + 2 ];
+      magic[ 3 ] = ( *pimpl_->srec_ )[ nm_entry.address + 3 ];
+      unsigned long magic_number = ( magic[ 0 ] << 24 ) | ( magic[ 1 ] << 16 ) | ( magic[ 2 ] << 8 ) | magic[ 3 ];
+      if ( magic_number == 0x12345678 )
+      {
+        pimpl_->little_endian_ = false;
+      }
+      else if ( magic_number == 0x78563412 )
+      {
+        pimpl_->little_endian_ = true;
+      }
+      else
+      {
+        fatal( _( "magic number is not found in `%1%\'" ), ( pimpl_->ofile_.file_name() + ".srec/.syms" ) );
+      }
+      pimpl_->do_assign_params();
+    }
+
+    /*!
+     *  \brief  "cfg1_out.srec" から読み取った情報の参照
+     */
+    std::tr1::shared_ptr< s_record > cfg1_out::get_srec() const
+    {
+      return pimpl_->srec_;
+    }
+
+    /*!
+     *  \brief  "cfg1_out.syms" から読み取った情報の参照
+     */
+    std::tr1::shared_ptr< nm_symbol > cfg1_out::get_syms() const
+    {
+      return pimpl_->syms_;
+    }
+
+    cfg1_out::cfg1_def_table const* cfg1_out::get_def_table() const
+    {
+      return pimpl_->def_table_;
+    }
+
+    /*!
+     *  \brief  オブジェクトごとにOILオブジェクト情報をまとめる
+     *  \return 静的API情報
+     *
+     *  この関数は、"tsk"や"sem"といった種別をキーとして、その種別に分類される静的API情報の連想配列を生成する。
+     */
+	cfg1_out::cfg_obj_map cfg1_out::merge() const
+    {
+	  cfg_obj_map result;
+	  
+	  result = oil_definition::merge(pimpl_->oil_def_array , result);
+
+	  return result;
+
+    }
+
+    /*!
+     *  \brief  リトルエンディアンかどうかの判定
+     *  \retval     true  リトルエンディアン
+     *  \retval     false ビッグエンディアン
+     *  \attention  load_srec 呼び出し前は正しい結果を得られない。
+     */
+    bool cfg1_out::is_little_endian() const
+    {
+      return pimpl_->little_endian_;
+    }
+
+    /*!
+     *  \brief  静的APIのパラメータにSレコードから取得した値を代入する
+     */
+    void cfg1_out::implementation::do_assign_params()
+    {
+    }
+
+    /*!
+     *  \brief  --id-input-fileオプションで指定したファイルの読み込み
+     *  \id_map 読み込んだデータの格納先
+     */
+    void cfg1_out::load_id_input_file( std::map< std::string, std::pair< long, bool > >& id_map )
+    {
+      std::string id_input_file( get_global< std::string >( "id-input-file" ) );
+      if ( id_input_file.empty() )
+      {
+        return;
+      }
+
+      std::ifstream ifs( id_input_file.c_str() );
+      while ( ifs )
+      {
+        std::string linebuf;
+        std::getline( ifs, linebuf );
+        if ( ifs.bad() )
+        {
+          fatal( _( "I/O error" ) );
+        }
+        if ( linebuf.empty() || linebuf == "\r" )
+        {
+          break;
+        }
+
+        std::istringstream iss( linebuf );
+        std::string name;
+        iss >> name;
+        if ( iss.fail() )
+        {
+          fatal( _( "id file `%1%\' is invalid" ), id_input_file );
+        }
+
+        long value;
+        iss >> value;
+        if ( iss.fail() )
+        {
+          fatal( _( "id file `%1%\' is invalid" ), id_input_file );
+        }
+
+        if ( id_map.find( name ) != id_map.end() )
+        {
+          fatal( _( "`%1%\' is duplicated" ), name );
+        }
+        else
+        {
+          id_map[ name ] = std::make_pair( value, false );
+        }
+      }
+    }
+  }
+}
Index: /cfg_itronx+oil_gcc/toppers/oil/cfg1_out.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/cfg1_out.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/cfg1_out.hpp	(revision 54)
@@ -0,0 +1,143 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/oil/cfg1_out.hpp
+ *  \brief  cfg1_out.c/.srec ファイルを扱うための宣言定義
+ *
+ *  このファイルで定義されるクラス
+ *  \code
+ *  class cfg1_out;
+ *  \endcode
+ */
+#ifndef TOPPERS_OIL_CFG1_OUT_HPP_
+#define TOPPERS_OIL_CFG1_OUT_HPP_
+
+#include <string>
+#include <vector>
+#include <map>
+#include "toppers/workaround.hpp"
+#include "toppers/codeset.hpp"
+#include "toppers/oil/oil_object.hpp"
+
+namespace toppers
+{
+
+  class macro_processor;
+  class s_record;
+  class nm_symbol;
+
+  namespace oil
+  {
+	  using namespace toppers::oil::oil_definition;
+
+    /*!
+     *  \class  cfg1_out  cfg1_out.hpp  "toppers/oil/cfg1_out.hpp"
+     *  \brief  cfg1_out.c/.srec ファイル管理クラス
+     */
+    class cfg1_out
+    {
+    public:
+      struct cfg1_def_t
+      {
+        bool is_signed;
+        std::string name;
+        std::string expression;
+        std::string value1;
+        std::string value2;
+      };
+	  typedef std::map< std::string, std::vector< object_definition* > > cfg_obj_map;
+     typedef std::vector< cfg1_def_t > cfg1_def_table;
+
+      explicit cfg1_out( std::string const& filename, cfg1_def_table const* def_table = 0 );
+      cfg1_out( cfg1_out const& other );
+      virtual ~cfg1_out();
+      cfg1_out& operator = ( cfg1_out const& other )
+      {
+        cfg1_out t( other );
+        swap( t );
+        return *this;
+      }
+
+	  void load_cfg( std::string const& input_file, codeset_t codeset, std::vector<std::string> const* obj_info );
+      void generate( char const* type = 0 ) const;
+      std::string const& get_includes() const;
+
+      void load_srec();
+      std::tr1::shared_ptr< s_record > get_srec() const;
+      std::tr1::shared_ptr< nm_symbol > get_syms() const;
+      cfg1_def_table const* get_def_table() const;
+      cfg_obj_map merge(void) const;
+      bool is_little_endian() const;
+
+      void swap( cfg1_out& other )
+      {
+        implementation* t = pimpl_;
+        pimpl_ = other.pimpl_;
+        other.pimpl_ = t;
+      }
+	  void swap(cfg_obj_map& other)
+	  {
+
+	  }
+
+      static std::tr1::int32_t make_signed( std::tr1::uint32_t value )
+      {
+        std::tr1::int32_t result;
+        if ( ( value >> 31 ) != 0 )
+        {
+          result = -static_cast< std::tr1::int32_t >( ( value ^ 0xffffffff ) + 1 ); // 2の補数表現にしか対応しない
+        }
+        else
+        {
+          result = static_cast< std::tr1::int32_t >( value );
+        }
+        return result;
+      }
+
+      static void load_id_input_file( std::map< std::string, std::pair< long, bool > >& id_map );
+
+    protected:
+      struct implementation;
+      explicit cfg1_out( implementation* pimpl ) : pimpl_( pimpl ) {}
+    private:
+      implementation* pimpl_;
+    };
+
+  }
+}
+
+#endif  // ! TOPPERS_OIL_CFG1_OUT_HPP_
Index: /cfg_itronx+oil_gcc/toppers/oil/checker.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/checker.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/checker.cpp	(revision 54)
@@ -0,0 +1,172 @@
+/*
+ *  TOPPERS/ASP Kernel
+ *      Toyohashi Open Platform for Embedded Real-Time Systems/
+ *      Advanced Standard Profile Kernel
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <fstream>
+#include <map>
+#include "toppers/workaround.hpp"
+#include "toppers/s_record.hpp"
+#include "toppers/nm_symbol.hpp"
+#include "toppers/misc.hpp"
+#include "toppers/diagnostics.hpp"
+#include "toppers/oil/checker.hpp"
+#include "toppers/oil/cfg1_out.hpp"
+
+namespace toppers
+{
+  namespace oil
+  {
+
+    struct checker::implementation
+    {
+    protected:
+      std::tr1::shared_ptr< s_record > srec_;
+      std::tr1::shared_ptr< nm_symbol > syms_;
+
+      virtual ~implementation() {}
+      virtual bool do_check( cfg1_out& cfg1out, std::map< std::string, std::size_t > const& count_map )
+      {
+        return true;
+      }
+      virtual implementation* do_clone() const
+      {
+        return new implementation( *this );
+      }
+
+      friend class checker;
+    };
+
+    checker::checker()
+      : pimpl_( new implementation )
+    {
+    }
+
+    /*!
+     *  \brief  コピーコンストラクタ
+     *  \param[in]  コピー元
+     */
+    checker::checker( checker const& other )
+      : pimpl_( other.pimpl_->do_clone() )
+    {
+    }
+
+    //! デストラクタ
+    checker::~checker()
+    {
+      delete pimpl_;
+      pimpl_ = 0;
+    }
+
+    /*!
+     *  \brief  ROMイメージのロード
+     *  \param[in]  srec_file   Sレコード形式のファイル名
+     *  \param[in]  nm_file     nmコマンドが出力したシンボルテーブルのファイル名
+     */
+    void checker::load_rom_image( std::string const& srec_file, std::string const& nm_file )
+    {
+      std::ifstream ifs_srec( srec_file.c_str() );
+      if ( !ifs_srec.is_open() )
+      {
+        fatal( _( "cannot open file `%1%\'" ), srec_file );
+      }
+      std::tr1::shared_ptr< s_record > srec( new s_record( ifs_srec ) );
+
+      std::ifstream ifs_nm( nm_file.c_str() );
+      if ( !ifs_nm.is_open() )
+      {
+        fatal( _( "cannot open file `%1%\'" ), nm_file );
+      }
+      std::tr1::shared_ptr< nm_symbol > syms( new nm_symbol( ifs_nm ) );
+
+      pimpl_->srec_.swap( srec );
+      pimpl_->syms_.swap( syms );
+    }
+
+    /*!
+     *  \brief  チェックの実施
+     *  \param[in]  cfg1_out情報
+     */
+    bool checker::check( cfg1_out& cfg1out ) const
+    {
+      cfg1_out::cfg_obj_map obj_map( cfg1out.merge() );
+
+      std::map< std::string, std::size_t > count_map;
+      for ( cfg1_out::cfg_obj_map::const_iterator iter( obj_map.begin() ), last( obj_map.end() );
+            iter != last;
+            ++iter )
+      {
+        std::size_t count = 0;
+        for ( std::vector< object_definition* >::const_iterator iter2( iter->second.begin() ), last2( iter->second.end() );
+              iter2 != last2;
+              ++iter2 )
+        {
+          // if ( !iter2->get_info()->slave )
+          {
+            ++count;
+          }
+        }
+        count_map[ iter->first ] = count;
+      }
+
+      return pimpl_->do_check( cfg1out, count_map );
+    }
+
+    /*!
+     *  \brief  シンボル情報の検索
+     *  \param[in]  symbol  検索するシンボル名
+     *  \return     検索結果
+     *
+     *  検索に失敗した場合には、返却値の.typeフィールドに-1が設定される。
+     */
+    nm_symbol::entry checker::find( std::string const& symbol ) const
+    {
+      return pimpl_->syms_->find( symbol );
+    }
+
+    /*!
+     *  \brief  指定アドレスの整数値を取得
+     *  \param[in]  address   アドレス
+     *  \param[in]  size      整数値を構成するバイト数
+     *  \param[in]  little_endian   バイトオーダーがリトルエンディアンならtrueを指定する
+     *  \return     取得した整数値を符号無しで返す。
+     */
+    std::tr1::uintmax_t checker::get( std::size_t address, std::size_t size, bool little_endian ) const
+    {
+      return pimpl_->srec_->get_value( address, size, little_endian );
+    }
+
+  }
+}
Index: /cfg_itronx+oil_gcc/toppers/oil/checker.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/checker.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/checker.hpp	(revision 54)
@@ -0,0 +1,91 @@
+/*
+ *  TOPPERS/ASP Kernel
+ *      Toyohashi Open Platform for Embedded Real-Time Systems/
+ *      Advanced Standard Profile Kernel
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#ifndef TOPPERS_OIL_CHECKER_HPP_
+#define TOPPERS_OIL_CHECKER_HPP_
+
+#include <cstddef>
+#include <string>
+#include "toppers/workaround.hpp"
+#include "toppers/nm_symbol.hpp"
+
+namespace toppers
+{
+  namespace oil
+  {
+
+    class cfg1_out;
+
+    /*!
+     *  \class  checker checker.hpp "toppers/oil/checker.hpp"
+     *  \brief  全体リンク後のパラメータチェック処理クラス
+     */
+    class checker
+    {
+    public:
+      checker();
+      checker( checker const& other );
+      virtual ~checker();
+      checker& operator=( checker const& other )
+      {
+        checker t( other );
+        swap( t );
+        return *this;
+      }
+
+      void load_rom_image( std::string const& srec_file, std::string const& nm_file );
+      bool check( cfg1_out& cfg1out ) const;
+      nm_symbol::entry find( std::string const& symbol ) const;
+      std::tr1::uintmax_t get( std::size_t address, std::size_t size, bool little_endian ) const;
+
+      void swap( checker& other )
+      {
+        implementation* t = pimpl_;
+        pimpl_ = other.pimpl_;
+        other.pimpl_ = t;
+      }
+    protected:
+      struct implementation;
+      explicit checker( implementation* pimpl ) : pimpl_( pimpl ) {}
+    private:
+      implementation* pimpl_;
+    };
+
+  }
+}
+
+#endif  // ! TOPPERS_OIL_CHECKER_HPP_
Index: /cfg_itronx+oil_gcc/toppers/oil/configuration_manager.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/configuration_manager.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/configuration_manager.cpp	(revision 54)
@@ -0,0 +1,211 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2010 by Meika Sugimoto
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <functional>
+
+#include "toppers/global.hpp"
+#include "toppers/oil/configuration_manager.hpp"
+
+using namespace std;
+using namespace toppers::oil;
+using namespace toppers::oil::oil_implementation;
+using namespace toppers::oil::oil_definition;
+
+namespace toppers
+{
+	namespace configuration_manager
+	{
+		// APPMODEを探すファンクタ
+		bool find_appmode_object(object_definition *p)
+		{
+			if(p->get_object_type() == "APPMODE")
+			{
+				return true;
+			}
+			return false;
+		}
+
+		bool config_manage::read_configuration
+			(toppers::text *txt , std::vector<std::string> const& objlist)
+		{
+			  description = txt;
+
+			  // ストリングを作る
+			  description_str = new string();
+			  typedef text::container::const_iterator const_row_iterator;
+			  typedef std::string::size_type size_type;
+			  const_row_iterator first( txt->begin().get_row() ), last( txt->end().get_row() );
+
+			  for ( const_row_iterator iter( first ); iter != last; ++iter )
+			  {
+				  *description_str += iter->buf;
+			  }
+
+			  // パーサの生成
+			  try
+			  {
+				  parser = new ::oil_parser(description_str , objlist);
+			  }
+			  catch( ... )
+			  {
+				  toppers::fatal("Memory allocation error.");
+			  }
+
+			if(parser->do_parse(&oil_impl , &oil_def) == 0)
+			{
+				std::string kernel_type;
+				// APPMODEが定義されていない時はOSDEFAULTAPPMODEを挿入
+				toppers::get_global("kernel" , kernel_type);
+				if((kernel_type == "atk1")
+					&& (oil_def->end() == 
+						(find_if(oil_def->begin() , oil_def->end() , find_appmode_object))))
+				{
+					oil_def->push_back(new object_definition("APPMODE OSDEFAULTAPPMODE"));
+				}
+
+				return true;
+			}
+			else
+			{
+				std::string message;
+				int position;
+				text::const_iterator iter;
+
+				// エラー位置の取得
+				parser->get_error(&position , &message);
+				// 該当行の取得
+				iter = description->line_at(position);
+				text::line_type error_occur = iter.line();
+				
+				// 文法エラーはすぐに終了
+				toppers::fatal(iter.line() , "%1%" , message);
+				
+				return false;
+			}
+		}
+
+		bool object_matching(object_definition* obj , oil_object_impl* impl)
+		{
+			return impl->validate_object_configuration(obj , NULL);
+		}
+
+		bool config_manage::validate_and_assign_default_configuration(void)
+		{
+			bool result = true;
+			std::vector<oil_definition::object_definition*>::iterator p;
+			std::vector<oil_implementation::oil_object_impl*>::iterator q , found;
+			
+			// 全てのオブジェクト定義を実装と整合しているかチェックし、
+			// デフォルトパラメータの補完を行う
+			for(p = oil_def->begin() ; p != oil_def->end() ; p++)
+			{
+				std::vector<toppers::oil::object_ref> object_refs;
+				for(q = oil_impl->begin() ; q != oil_impl->end() ; q++)
+				{
+					if((*q)->validate_object_configuration(*p , &object_refs) == true)
+					{
+						break;
+					}
+				}
+				
+				if(q >= oil_impl->end())
+				{
+					// パラメータの整合性チェック
+					result = false;
+					break;
+				}
+				
+				// リファレンス先が正しいかのチェック
+				result = validate_object_reference((*p)->get_name() , &object_refs);
+			}
+
+			return result;
+		}
+		bool config_manage::validate_object_reference
+				(std::string obj_name , std::vector<object_ref> *obj_refs)
+		{
+			std::vector<oil_definition::object_definition*>::iterator q;
+			std::vector<object_ref>::iterator p;
+			bool result = true;
+			
+			for(p = obj_refs->begin() ; p != obj_refs->end() ; p++)
+			{
+				std::vector<oil_definition::object_definition*> name_match;
+				// 名前が同じものを探索
+				for(q = oil_def->begin() ; q != oil_def->end() ; q++)
+				{
+					if((*p).obj_name == (*q)->get_name())
+					{
+						name_match.push_back(*q);
+					}
+				}
+				// 名前が一致しなければその時点でエラー
+				if(name_match.empty() == true)
+				{
+					toppers::error("Object %1%'s parameter %2% reference %3% , but not found." ,
+										obj_name , (*p).obj_type , (*p).obj_name);
+					result = false;
+					continue;
+				}
+
+				// 参照先のタイプが同じか探索
+				for(q = name_match.begin() ; q != name_match.end() ; q++)
+				{
+					if((*p).obj_type == (*q)->get_object_type())
+					{
+						break;
+					}
+				}
+				// タイプが同じものがなければエラー
+				if(q == name_match.end())
+				{
+					toppers::error("Object %1%'s parameter %2% reference %3% , but referenced object is not %4%_TYPE" , 
+									obj_name , (*p).obj_type , (*p).obj_name , (*p).obj_type);
+					result = false;
+				}
+			}
+
+			return result;
+		}
+
+	}	/* namespace oil */
+
+}	/* namespace toppers */
+
Index: /cfg_itronx+oil_gcc/toppers/oil/configuration_manager.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/configuration_manager.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/configuration_manager.hpp	(revision 54)
@@ -0,0 +1,93 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2009 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+#ifndef CONFIGURATION_MANAGER_H
+#define CONFIGURATION_MANAGER_H
+
+#include <string>
+#include <iostream>
+
+#include "toppers/oil/oil_parser.hpp"
+#include "toppers/text.hpp"
+#include "toppers/diagnostics.hpp"
+
+using namespace toppers::oil;
+
+namespace toppers
+{
+	namespace configuration_manager
+	{
+
+		class config_manage
+		{
+			public:
+				config_manage(void)
+				{
+				}
+				~config_manage()
+				{
+					delete description_str;
+					delete parser;
+				}
+				bool read_configuration
+					(toppers::text *txt , std::vector<std::string> const& objlist);
+				void dump_configuration(void)
+				{
+					parser->dump_implementation();
+					parser->dump_definition();
+				}
+
+				::oil_def* const get_obj_def(void)
+				{
+					return oil_def;
+				}
+				bool validate_and_assign_default_configuration(void);
+			private:
+				bool validate_object_reference
+						(std::string obj_name , std::vector<object_ref> *obj_refs);
+				toppers::text *description;
+				string *description_str;
+				oil_parser *parser;
+				::oil_def *oil_def;
+				::oil_impl *oil_impl;
+		};
+
+	}	/* namespace configuration_manager */
+
+}	/* namespace toppers */
+
+#endif	/* CONFIGURATION_MANAGER_H */
Index: /cfg_itronx+oil_gcc/toppers/oil/factory.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/factory.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/factory.cpp	(revision 54)
@@ -0,0 +1,671 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ *  Copyright (C) 2010 by Meika Sugimoto
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <cstring>
+#include <cstdlib>
+#include <fstream>
+#include <boost/lexical_cast.hpp>
+#include <boost/spirit/include/classic_spirit.hpp>
+#include "toppers/misc.hpp"
+#include "toppers/global.hpp"
+#include "toppers/csv.hpp"
+#include "toppers/nm_symbol.hpp"
+#include "toppers/s_record.hpp"
+#include "toppers/diagnostics.hpp"
+#include "toppers/macro_processor.hpp"
+#include "toppers/io.hpp"
+#include "toppers/cpp.hpp"
+#include "toppers/oil/factory.hpp"
+#include "toppers/oil/cfg1_out.hpp"
+
+namespace toppers
+{
+  namespace oil
+  {
+    namespace
+    {
+
+	  object_definition* find_object(string name , cfg1_out::cfg_obj_map const& obj_def_map)
+	  {
+          // modified by takuya 110823
+		  //std::map< std::string, std::vector<object_definition*>>::const_iterator p;
+		  std::map< std::string, std::vector<object_definition*> >::const_iterator p;
+		  std::vector<object_definition*>::const_iterator q;
+		
+		  // 名前が一致するオブジェクトを検索
+		  for(p = obj_def_map.begin() ; p != obj_def_map.end() ; p++)
+		  {
+			  for(q = (*p).second.begin() ; q != (*p).second.end() ; q++)
+			  {
+				  if((*q)->get_name() == name)
+				  {
+					  return (*q);
+				  }
+			  }
+		  }		 
+		  return NULL;
+	  }
+
+      // カーネルオブジェクト生成・定義用静的APIの各パラメータをマクロプロセッサの変数として設定する。
+      void set_object_vars( cfg1_out::cfg_obj_map const& obj_def_map, macro_processor& mproc )
+      {
+        typedef macro_processor::element element;
+        typedef macro_processor::var_t var_t;
+        std::map< std::string, var_t > order_list_map , obj_parameter;
+        std::map< std::string, long > id_map;
+
+		using namespace toppers::oil::oil_definition;
+        // modified by takuya 110823
+		//std::map< std::string, std::vector<object_definition*>>::const_iterator p;
+		std::map< std::string, std::vector<object_definition*> >::const_iterator p;
+		std::vector<object_definition*>::const_iterator q;
+		std::vector<object_parameter_def*>::const_iterator r;
+
+        for ( p = obj_def_map.begin() ; p != obj_def_map.end() ; p++)
+        {
+			element e;
+			var_t t;
+			string name;
+			long obj_id;
+			long param_id;
+			
+			// パラメータの値代入
+			for(q = (*p).second.begin() ; q != (*p).second.end() ; q++)
+			{
+				std::map< std::string, var_t > obj_parameter;
+				std::map< std::string, var_t >::iterator s;
+				obj_id = (*q)->get_id();
+				name = (*p).first;
+				std::map<std::string , long> id_count;
+				std::map<std::string , long>::iterator id_iter;
+
+				// 値の取り出し
+				e.i = (*q)->get_id();
+				e.s = (*q)->get_name();
+				// 出現順リスト用の情報作成
+				order_list_map[ name ].push_back(e);
+				// オブジェクト自身の値代入
+	            mproc.set_var( toppers::toupper(name), obj_id, var_t( 1, e ) );
+				
+				// オブジェクトメンバの値代入
+				for(r = (*q)->get_params()->begin() ; r != (*q)->get_params()->end() ; r++)
+				{
+					name = (*p).first+ string(".") + (*r)->get_parameter_name();
+					e.s = (*r)->get_value();
+
+					if(e.s == string(""))
+					{
+						continue;
+					}
+
+					// メンバのIDを検索
+					id_iter = id_count.find(name);
+					if(id_iter == id_count.end())
+					{
+						id_count[name] = 0;
+						param_id = 0;
+					}
+					else
+					{
+						param_id = (*id_iter).second + 1;
+						id_count[name] = (*id_iter).second + 1;
+					}
+
+					if((*r)->get_type() == oil::TYPE_UINT)
+					{
+						string value_str(((*r)->get_value()));
+						try
+						{
+							e.i = boost::lexical_cast<uint64_t>((*r)->get_value());
+						}
+						catch( std::exception& exception)
+						{
+							uint64_t temp;
+							// 16進の場合があるので変換
+							/// きれいじゃないのでなんとかしたい
+							if(value_str.find("0x") == 0)
+							{
+                                // modified by takuya 110823
+								//sscanf_s(value_str.c_str() , "0x%I64x" , &temp);
+								sscanf(value_str.c_str() , "0x%llx" , &temp);
+								e.i = temp;
+							}
+							else if(value_str.find("0X") == 0)
+							{
+                                // modified by takuya 110823
+								//sscanf_s(value_str.c_str() , "0X%I64x" , &temp);
+								sscanf(value_str.c_str() , "0X%llx" , &temp);
+								e.i = temp;
+							}
+							else
+							{
+								// キャストに失敗したら0にしておく
+								e.i = 0;
+							}
+
+						}
+					}
+					else if((*r)->get_type() == oil::TYPE_INT)
+					{
+						string value_str(((*r)->get_value()));
+						try
+						{
+							e.i = boost::lexical_cast<int64_t>(value_str);
+						}
+						catch(std::exception& exception)
+						{
+							int64_t temp;
+							// 16進の場合があるので変換
+							/// きれいじゃないのでなんとかしたい
+							if(value_str.find("0x") == 0)
+							{
+                                // modified by takuya 110823
+								//sscanf_s(value_str.c_str() , "0x%I64x" , &temp);
+								sscanf(value_str.c_str() , "0x%llx" , &temp);
+								e.i = temp;
+							}
+							else if(value_str.find("0X") == 0)
+							{
+                                // modified by takuya 110823
+								//sscanf_s(value_str.c_str() , "0X%I64x" , &temp);
+								sscanf(value_str.c_str() , "0X%llx" , &temp);
+								e.i = temp;
+							}
+							else
+							{
+								// キャストに失敗したら0にしておく
+								e.i = 0;
+							}
+						}
+					}
+					else if((*r)->get_type() == oil::TYPE_REF)
+					{
+						object_definition *obj;
+						string refefence_obj_type;
+
+						// オブジェクトIDの探索
+						e.i = 0;
+						obj = find_object((*r)->get_value() , obj_def_map);
+						if(obj != NULL)
+						{
+							e.i = obj->get_id();
+						}
+					}
+					else
+					{
+						e.i = 0;
+					}
+					obj_parameter[name].push_back(e);
+				}
+
+				for(s = obj_parameter.begin() ; s != obj_parameter.end() ; s++)
+				{
+					mproc.set_var((*s).first , obj_id , (*s).second );
+				}
+			}
+
+		}
+		// 順序リストの作成
+        for ( std::map< std::string, var_t >::const_iterator iter( order_list_map.begin() ), last( order_list_map.end() );
+              iter != last;
+              ++iter )
+        {
+          // 出現順リスト $OBJ.ORDER_LIST$ -- ID番号の並び
+          mproc.set_var( toppers::toupper( iter->first + ".order_list" ), iter->second );
+          var_t rorder_list( iter->second );
+
+          // 逆順リスト $OBJ.RORDER_LIST$ -- ID番号の並び
+          std::reverse( rorder_list.begin(), rorder_list.end() );
+          mproc.set_var( toppers::toupper( iter->first + ".rorder_list" ), rorder_list );
+
+          // ID番号リスト $OBJ.ID_LIST$ -- ID番号の並び
+          var_t id_list( iter->second );
+          std::sort( id_list.begin(), id_list.end() );
+          mproc.set_var( toppers::toupper( iter->first + ".id_list" ), id_list );
+        }
+	  }
+
+      // カーネルオブジェクト生成・定義用静的APIの各パラメータをマクロプロセッサの変数として設定する。
+      void set_object_vars( std::vector< object_definition* > const& obj_array, macro_processor& mproc )
+      {
+        typedef macro_processor::element element;
+        typedef macro_processor::var_t var_t;
+        long order = 1;
+        var_t order_list;
+
+        for ( std::vector< object_definition* >::const_iterator v_iter( obj_array.begin() ), v_last( obj_array.end() );
+              v_iter != v_last;
+              ++v_iter )
+        {
+          var_t params;
+          var_t args;
+
+#if 0
+          // 静的APIが出現した行番号
+          element e;
+          // e.s = v_iter->line().file;
+          // e.i = v_iter->line().line;
+          // mproc.set_var( "API.TEXT_LINE", order, var_t( 1, e ) );
+
+          // 静的API名
+          e.s = v_iter->get_name();
+          e.i = boost::none;
+          mproc.set_var( "OBJ.NAME", order, var_t( 1, e ) );
+
+          // オブジェクトタイプ（"TSK", "SEM", ...）
+          e.s = toppers::toupper( v_iter->object_type );
+          mproc.set_var( "OBJ.TYPE", order, var_t( 1 , e ) );
+
+          // 各パラメータ
+          for ( static_api::const_iterator api_iter( v_iter->begin() ), api_last( v_iter->end() );
+                api_iter != api_last;
+                ++api_iter )
+          {
+            std::string name( toppers::toupper( ( boost::format( "%s.%s" ) % info->type % ( api_iter->symbol.c_str() + 1 ) ).str() ) );
+            // 末尾の ? を除去
+            if ( *name.rbegin() == '\?' ) 
+            {
+              name.resize( name.size() - 1 );
+            }
+            // 末尾の ... を除去 & order を付加
+            if ( name.size() > 3 && name.substr( name.size() - 3 ) == "..." )
+            {
+              name.resize( name.size() - 3 );
+              name += boost::lexical_cast< std::string >( api_iter->order );
+            }
+
+            element e;
+            e.s = api_iter->text; // ソースの字面
+            if ( api_iter->symbol[0] != '&' )   // 一般定数式パラメータは値が特定できない
+            {
+              if ( api_iter->symbol[0] == '$' )  // 文字列定数式パラメータ
+              {
+                e.v = api_iter->string; // 展開後の文字列
+              }
+              else
+              {
+                e.i = api_iter->value;
+              }
+            }
+            args.push_back( e );
+
+            e.s = name;
+            e.i = boost::none;
+            params.push_back( e );
+
+            if ( api_iter->symbol[0] == '%' )
+            {
+              continue;
+            }
+          }
+          mproc.set_var( "API.ARGS", order, args );
+          mproc.set_var( "API.PARAMS", order, params );
+          e.s.clear();
+          e.i = order;
+          order_list.push_back( e );
+#endif
+          ++order;
+        }
+        mproc.set_var( "API.ORDER_LIST", order_list );
+
+        element external_id;
+        external_id.i = get_global< bool >( "external-id" );
+        mproc.set_var( "USE_EXTERNAL_ID", var_t( 1, external_id ) );
+      }
+
+
+      // プラットフォーム・コンパイラ依存の値をマクロプロセッサの変数として設定する。
+      void set_platform_vars( cfg1_out const& cfg1out, macro_processor& mproc )
+      {
+        typedef macro_processor::element element;
+        typedef macro_processor::var_t var_t;
+
+        cfg1_out::cfg1_def_table const* def_table = cfg1out.get_def_table();
+        std::size_t sizeof_signed_t;
+        std::size_t sizeof_pointer;
+
+        static cfg1_out::cfg1_def_t const limit_defs[] =
+        {
+          { false, "TOPPERS_cfg_CHAR_BIT",  "CHAR_BIT" },
+          { false, "TOPPERS_cfg_CHAR_MAX",  "CHAR_MAX" },
+          { true, "TOPPERS_cfg_CHAR_MIN",  "CHAR_MIN" },
+          { false, "TOPPERS_cfg_SCHAR_MAX", "SCHAR_MAX" },  // 本来は符号付きだが、負になることはない
+          { false, "TOPPERS_cfg_SHRT_MAX",  "SHRT_MAX" },   // 本来は符号付きだが、負になることはない
+          { false, "TOPPERS_cfg_INT_MAX",   "INT_MAX" },    // 本来は符号付きだが、負になることはない
+          { false, "TOPPERS_cfg_LONG_MAX",  "LONG_MAX" },   // 本来は符号付きだが、負になることはない
+        };
+
+        nm_symbol::entry nm_entry = cfg1out.get_syms()->find( "TOPPERS_cfg_sizeof_signed_t" );
+        sizeof_signed_t = static_cast< std::size_t >( cfg1out.get_srec()->get_value( nm_entry.address, 4, cfg1out.is_little_endian() ) );
+
+        nm_entry = cfg1out.get_syms()->find( "TOPPERS_cfg_sizeof_pointer" );
+        sizeof_pointer = static_cast< std::size_t >( cfg1out.get_srec()->get_value( nm_entry.address, 4, cfg1out.is_little_endian() ) );
+
+        for ( std::size_t i = 0; i < sizeof limit_defs / sizeof limit_defs[ 0 ]; ++i )
+        {
+          element e;
+          e.s = limit_defs[ i ].expression;
+          nm_entry = cfg1out.get_syms()->find( limit_defs[ i ].name );
+          std::tr1::int64_t value = cfg1out.get_srec()->get_value( nm_entry.address, sizeof_signed_t, cfg1out.is_little_endian() );
+          if ( sizeof_signed_t < 8 && limit_defs[ i ].is_signed )
+          {
+            value = cfg1_out::make_signed( static_cast< std::tr1::uint32_t >( value ) );
+          }
+          mproc.set_var( e.s, var_t( 1, e ) );
+        }
+
+        for ( cfg1_out::cfg1_def_table::const_iterator iter( def_table->begin() ), last( def_table->end() );
+              iter != last;
+              ++iter )
+        {
+          element e;
+          std::tr1::int64_t value;
+
+          nm_entry = cfg1out.get_syms()->find( "TOPPERS_cfg_" + iter->name );
+          if ( nm_entry.type >= 0 )
+          {
+            if ( !iter->expression.empty() && iter->expression[ 0 ] == '@' )  // 式が'@'で始まる場合はアドレス定数式
+            {
+              value = cfg1out.get_srec()->get_value( nm_entry.address, sizeof_pointer, cfg1out.is_little_endian() );
+              if ( sizeof_signed_t < 8 && iter->is_signed )
+              {
+                value = cfg1_out::make_signed( static_cast< std::tr1::uint32_t >( value ) );
+              }
+
+              // 先ほど取り出したアドレスを使って間接参照
+              value = cfg1out.get_srec()->get_value( value, 8, cfg1out.is_little_endian() );  // 取り出す値は型に関係なく常に8バイト
+              if ( sizeof_signed_t < 8 && iter->is_signed )
+              {
+                value = cfg1_out::make_signed( static_cast< std::tr1::uint32_t >( value ) );
+              }
+              e.s = iter->expression.c_str() + 1; // 先頭の'@'を除去
+            }
+            else  // アドレスではない通常の整数定数式
+            {
+              value = cfg1out.get_srec()->get_value( nm_entry.address, sizeof_signed_t, cfg1out.is_little_endian() );
+              if ( sizeof_signed_t < 8 && iter->is_signed )
+              {
+                value = cfg1_out::make_signed( static_cast< std::tr1::uint32_t >( value ) );
+              }
+              e.s = iter->expression;
+            }
+            e.i = value;
+            mproc.set_var( iter->name, var_t( 1, e ) );
+          }
+        }
+
+        // バイトオーダー
+        {
+          bool little_endian = cfg1out.is_little_endian();
+          element e;
+          e.i = little_endian;
+          mproc.set_var( "LITTLE_ENDIAN", var_t( 1, e ) );
+
+          e.i = !little_endian;
+          mproc.set_var( "BIG_ENDIAN", var_t( 1, e ) );
+        }
+      }
+
+    }
+
+    //! コンストラクタ
+    factory::factory( std::string const& kernel )
+      : kernel_( tolower( kernel ) )
+    {
+    }
+
+    //! デストラクタ
+    factory::~factory()
+    {
+    }
+
+    //! サポートしているオブジェクト情報の取得
+	std::vector<std::string> const* factory::get_object_definition_info() const
+    {
+      // CSVから静的API情報を読み取り、登録するためのローカルクラス
+      struct init_t
+      {
+        init_t()
+        {
+          boost::any t = global( "api-table" );
+          if ( !t.empty() )
+          {
+            std::vector< std::string > api_tables( boost::any_cast< std::vector< std::string >& >( t ) );
+            for ( std::vector< std::string >::const_iterator iter( api_tables.begin() ), last( api_tables.end() );
+                  iter != last;
+                  ++iter )
+            {
+              std::string buf;
+              std::string api_table_filename = *iter;
+              read( api_table_filename.c_str(), buf );
+              csv data( buf.begin(), buf.end() );
+              for ( csv::const_iterator d_iter( data.begin() ), d_last( data.end() );
+                    d_iter != d_last;
+                    ++d_iter )
+              {
+                  unsigned int i;
+                  for(i = 0 ; i < d_iter->size() ; i++)
+                  {
+                      volatile int x = 1;
+                      object_definition_table.push_back((*d_iter)[i].c_str());
+                  }
+              }
+
+            }
+          }
+        }
+
+        ~init_t()
+        {
+
+        
+        }
+
+		std::vector<std::string> object_definition_table;
+      };
+      static init_t init;
+	  std::vector<std::string> const* result = &init.object_definition_table;
+      return result;
+    }
+
+    /*!
+     * \brief   cfg1_out.c への出力情報テーブルの生成
+     * \return  生成した cfg1_out::cfg1_def_table オブジェクトへのポインタ
+     * \note    この関数が返すポインタは delete してはならない
+     *
+     * --cfg1-def-table オプションで指定したファイルから、cfg1_out.c へ出力する情報を読み取り、
+     * cfg1_out::cfg1_def_table オブジェクトを生成する。
+     *
+     * CSV の形式は以下の通り
+     *
+     *    シンボル名,式[,s|signed]
+     *
+     * 末尾の s または signed は省略可能。省略時は符号無し整数とみなす。s または signed 指定時は
+     * 符号付き整数とみなす。\n
+     * 「式」の最初に # があれば前処理式とみなす。
+     */
+    cfg1_out::cfg1_def_table const* factory::get_cfg1_def_table() const
+    {
+      struct init_t
+      {
+        init_t()
+        {
+          boost::any t = global( "cfg1-def-table" );
+          if ( !t.empty() )
+          {
+            std::vector< std::string > cfg1_def_table = boost::any_cast< std::vector< std::string >& >( t );
+            for ( std::vector< std::string >::const_iterator iter( cfg1_def_table.begin() ), last( cfg1_def_table.end() );
+                  iter != last;
+                  ++iter )
+            {
+              std::string buf;
+              read( iter->c_str(), buf );
+              csv data( buf.begin(), buf.end() );
+              for ( csv::const_iterator d_iter( data.begin() ), d_last( data.end() );
+                    d_iter != d_last;
+                    ++d_iter )
+              {
+                csv::size_type len = d_iter->size();
+                if ( len < 2 )
+                {
+                  toppers::fatal( _( "too little fields in `%1%\'" ), *iter );
+                }
+                cfg1_out::cfg1_def_t def = { 0 };
+                def.name = ( *d_iter )[ 0 ];
+                def.expression = ( *d_iter )[ 1 ];
+                if ( len >= 3 )
+                {
+                  std::string is_signed( ( *d_iter )[ 2 ] );
+                  def.is_signed = ( is_signed == "s" || is_signed == "signed" );
+                }
+                if ( len >= 4)
+                {
+                  def.value1 = ( *d_iter )[ 3 ];
+                }
+                if ( len >= 5)
+                {
+                  def.value2 = ( *d_iter )[ 4 ];
+                }
+                cfg1_def_table_.push_back( def );
+              }
+            }
+          }
+        }
+        cfg1_out::cfg1_def_table cfg1_def_table_;
+      };
+      static init_t init;
+      cfg1_out::cfg1_def_table const* result = &init.cfg1_def_table_;
+      return result;
+    }
+
+    //! オブジェクトの交換
+    void factory::do_swap( factory& other )
+    {
+      kernel_.swap( other.kernel_ );
+    }
+
+    macro_processor::hook_t factory::do_get_hook_on_assign() const
+    {
+//      return &hook_on_assign;
+      return 0;
+    }
+
+    /*!
+     *  \brief  マクロプロセッサの生成
+     *  \param[in]  hook    変数に値を代入した際のフック処理
+     *  \param[in]  cfg1out cfg1_out オブジェクト
+     *  \param[in]  api_map .cfg ファイルに記述された静的API情報
+     *  \return     マクロプロセッサへのポインタ
+     */
+    std::auto_ptr< macro_processor > factory::do_create_macro_processor( macro_processor::hook_t hook, cfg1_out const& cfg1out, cfg1_out::cfg_obj_map const& obj_def_map ) const
+    {
+      typedef macro_processor::element element;
+      typedef macro_processor::var_t var_t;
+      std::auto_ptr< macro_processor > mproc( new macro_processor( hook ) );
+      element e;
+
+      e.s = " ";    mproc->set_var( "SPC", var_t( 1, e ) );  // $SPC$
+      e.s = "\t";   mproc->set_var( "TAB", var_t( 1, e ) );  // $TAB$
+      e.s = "\n";   mproc->set_var( "NL",  var_t( 1, e ) );  // $NL$
+
+      // バージョン情報
+      e.s = toppers::get_global< std::string >( "version" );
+      e.i = toppers::get_global< std::tr1::int64_t >( "timestamp" );
+      mproc->set_var( "CFG_VERSION", var_t( 1, e ) );   // $CFG_VERSION$
+
+      // その他の組み込み変数の設定
+      set_object_vars( obj_def_map, *mproc );
+      set_platform_vars( cfg1out, *mproc );
+      e.s = cfg1out.get_includes();
+      mproc->set_var( "INCLUDES", var_t( 1, e ) );
+
+      // パス情報
+      e.s = boost::lexical_cast< std::string >(toppers::get_global< int >( "pass" ));
+      e.i = toppers::get_global< int >( "pass" );
+      mproc->set_var( "CFG_PASS", var_t( 1, e ) );
+
+      return mproc;
+    }
+
+    /*!
+     *  \brief  マクロプロセッサの生成
+     *  \param[in]  cfg1out cfg1_out オブジェクト
+     *  \param[in]  api_array .cfg ファイルに記述された静的API情報
+     *  \return     マクロプロセッサへのポインタ
+     */
+    std::auto_ptr< macro_processor > factory::do_create_macro_processor( macro_processor::hook_t hook, cfg1_out const& cfg1out, std::vector< object_definition* > const& obj_array ) const
+    {
+      typedef macro_processor::element element;
+      typedef macro_processor::var_t var_t;
+      std::auto_ptr< macro_processor > mproc( new macro_processor( hook ) );
+      element e;
+
+      e.s = " ";    mproc->set_var( "SPC", var_t( 1, e ) );  // $SPC$
+      e.s = "\t";   mproc->set_var( "TAB", var_t( 1, e ) );  // $TAB$
+      e.s = "\n";   mproc->set_var( "NL",  var_t( 1, e ) );  // $NL$
+
+      // バージョン情報
+      e.s = toppers::get_global< std::string >( "version" );
+      e.i = toppers::get_global< std::tr1::int64_t >( "timestamp" );
+      mproc->set_var( "CFG_VERSION", var_t( 1, e ) );   // $CFG_VERSION$
+
+      // その他の組み込み変数の設定
+      set_object_vars( obj_array, *mproc );
+      set_platform_vars( cfg1out, *mproc );
+      e.s = cfg1out.get_includes();
+      mproc->set_var( "INCLUDES", var_t( 1, e ) );
+
+      // パス情報
+      e.s = boost::lexical_cast< std::string >(toppers::get_global< int >( "pass" ));
+      e.i = toppers::get_global< int >( "pass" );
+      mproc->set_var( "CFG_PASS", var_t( 1, e ) );
+
+      return mproc;
+    }
+
+
+    std::auto_ptr< cfg1_out > factory::do_create_cfg1_out( std::string const& filename ) const
+    {
+      return std::auto_ptr< oil::cfg1_out >( new cfg1_out( filename, get_cfg1_def_table() ) );
+    }
+    std::auto_ptr< checker > factory::do_create_checker() const
+    {
+      return std::auto_ptr< oil::checker >( new checker );
+    }
+
+  }
+}
Index: /cfg_itronx+oil_gcc/toppers/oil/factory.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/factory.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/factory.hpp	(revision 54)
@@ -0,0 +1,106 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ *  Copyright (C) 2010 by Meika Sugimoto
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/oil/factory.hpp
+ *  \brief  カーネルまたはモジュールに応じた処理オブジェクト生成に関する宣言定義
+ *
+ *  このファイルで定義されるクラス
+ *  \code
+ *  class factory;
+ *  \endcode
+ */
+#ifndef TOPPERS_OIL_FACTORY_HPP_
+#define TOPPERS_OIL_FACTORY_HPP_
+
+#include <memory>
+#include <string>
+#include <vector>
+#include "toppers/macro_processor.hpp"
+#include "toppers/oil/checker.hpp"
+#include "toppers/oil/cfg1_out.hpp"
+
+namespace toppers
+{
+  namespace oil
+  {
+    /*!
+     *  \class  factory factory.hpp "toppers/oil/factory.hpp"
+     *  \brief  カーネルまたはモジュールに応じた処理オブジェクト生成クラス
+     */
+    class factory
+    {
+    public:
+      explicit factory( std::string const& kernel );
+      virtual ~factory();
+      std::vector<std::string> const* get_object_definition_info() const;
+	  cfg1_out::cfg1_def_table const* get_cfg1_def_table() const;
+      macro_processor::hook_t get_hook_on_assign() const { return do_get_hook_on_assign(); }
+      std::auto_ptr< cfg1_out > create_cfg1_out( std::string const& filename ) const
+      {
+        return do_create_cfg1_out( filename );
+      }
+      std::auto_ptr< checker > create_checker() const
+      {
+        return do_create_checker();
+      }
+      // std::auto_ptr< macro_processor > create_macro_processor( macro_processor::hook_t hook, cfg1_out const& cfg1out, cfg1_out::cfg_obj_map const& obj_def_map ) const
+      std::auto_ptr< macro_processor > create_macro_processor( cfg1_out const& cfg1out, cfg1_out::cfg_obj_map const& obj_def_map ) const
+      {
+        return do_create_macro_processor( this->get_hook_on_assign(), cfg1out, obj_def_map );
+      }
+      std::auto_ptr< macro_processor > create_macro_processor( cfg1_out const& cfg1out, std::vector< object_definition* > const& obj_array ) const
+      {
+        return do_create_macro_processor( this->get_hook_on_assign(), cfg1out, obj_array );
+      }
+      void swap( factory& other ) { do_swap( other ); }
+    protected:
+      virtual void do_swap( factory& other );
+      virtual macro_processor::hook_t do_get_hook_on_assign() const;
+      virtual std::auto_ptr< macro_processor > do_create_macro_processor( macro_processor::hook_t hook, cfg1_out const& cfg1out, cfg1_out::cfg_obj_map const& obj_def_map ) const;
+      virtual std::auto_ptr< macro_processor > do_create_macro_processor( macro_processor::hook_t hook, cfg1_out const& cfg1out, std::vector< object_definition* > const& obj_array ) const;
+    private:
+      virtual std::auto_ptr< cfg1_out > do_create_cfg1_out( std::string const& filename ) const;
+      virtual std::auto_ptr< checker > do_create_checker() const;
+
+      std::string kernel_;
+    };
+
+  }
+}
+
+#endif  // ! TOPPERS_OIL_FACTORY_HPP_
Index: /cfg_itronx+oil_gcc/toppers/oil/oil_object.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/oil_object.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/oil_object.cpp	(revision 54)
@@ -0,0 +1,901 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2010 by Meika Sugimoto
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+#include <boost/regex.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/cast.hpp>
+#include <algorithm>
+#include <functional>
+
+#include "toppers/oil/oil_object.hpp"
+#include "toppers/diagnostics.hpp"
+
+namespace toppers
+{
+	namespace oil
+	{
+		// デバッグ用関数
+		void dump(boost::smatch *r)
+		{
+			unsigned int i;
+
+			for(i = 0 ; i < r->size() ; i++)
+			{
+				cout << "Match[" << i << "] : " << r->str(i) << endl;
+			}
+		}
+		
+		namespace oil_implementation
+		{
+			int oil_object_impl::add_parameter(string param_name , string parameter_description)
+			{
+				if((parameter_description.find("UINT32") == 0)
+					|| (parameter_description.find("UINT64") == 0))
+				{
+					this->params.push_back(
+						(object_parameter_impl *)(new parameter_uint_impl(param_name , parameter_description)));
+				}
+				else if((parameter_description.find("INT32") == 0)
+						|| (parameter_description.find("INT64") == 0))
+				{
+					this->params.push_back(
+						(object_parameter_impl *)(new parameter_int_impl(param_name , parameter_description)));
+				}
+				else if(parameter_description.find("ENUM") == 0)
+				{
+					this->params.push_back(
+						(object_parameter_impl *)(new parameter_enum_impl(param_name , parameter_description)));
+				}
+				else if(parameter_description.find("BOOLEAN") == 0)
+				{
+					boost::regex bool_with_option("\\[\\s*TRUE");
+					string::const_iterator start = parameter_description.begin();
+					string::const_iterator end = parameter_description.end();
+
+					// [ TRUE , FALSE ]がある場合はENUMと同じ扱い、ない場合はSTRINGと同じ扱いとする
+					if(regex_search(start , end , bool_with_option))
+					{
+						this->params.push_back(
+							(object_parameter_impl *)(new parameter_enum_impl(param_name , parameter_description)));
+					}
+					else
+					{
+						this->params.push_back(
+							(object_parameter_impl *)(new parameter_boolean_impl(param_name , parameter_description)));
+					}
+				}
+				else if(parameter_description.find("STRING") == 0)
+				{
+					this->params.push_back(
+						(object_parameter_impl *)(new parameter_string_impl(param_name , parameter_description)));
+				}
+				else if(parameter_description.find("FLOAT") == 0)
+				{
+					this->params.push_back(
+						(object_parameter_impl *)(new parameter_float_impl(param_name , parameter_description)));
+				}
+				else if(parameter_description.find("_TYPE") != string::npos)
+				{
+					this->params.push_back(
+						(object_parameter_impl *)(new parameter_object_ref_impl(param_name , parameter_description)));
+				}
+				else
+				{
+					// ありえない
+				}
+
+				return 0;
+			}
+
+			oil_object_impl::~oil_object_impl()
+			{
+				std::vector<object_parameter_impl*>::iterator p;
+
+				for(p = params.begin() ; p != params.end() ; p++)
+				{
+					delete (*p);
+				}
+			}
+
+			bool oil_object_impl::validate_object_parameter
+				(oil_definition::object_parameter_def *obj_param , bool *multiple ,
+						std::vector<object_ref> *references)
+			{
+				std::vector<object_parameter_impl*>::iterator match;
+				bool result = false;
+
+				// 同じ名前を持つパラメータがあるか検索
+				// ※find_ifだとダウンキャストに失敗した
+				for(match = params.begin() ; match != params.end() ; match++)
+				{
+					if((*match)->validate_parameter_name(obj_param->get_parameter_name())
+						== true)
+					{
+						break;
+					}
+				}
+				
+				// パラメータの属性チェック
+				if(match != params.end())
+				{
+					parameter_object_ref_impl *ref_param;
+					parameter_enum_impl *enum_param;
+
+					ref_param = dynamic_cast<parameter_object_ref_impl*>(*match);
+					if(ref_param != NULL)
+					{
+						if(ref_param->validate_object_parameter(obj_param , references) == true)
+						{
+							*multiple = (*match)->get_multiple();
+							result = true;
+						}
+					}
+					else 
+					{
+						// enumの場合、子要素で参照が出てくる可能性がある
+						enum_param = dynamic_cast<parameter_enum_impl*>(*match);
+						if(enum_param != NULL)
+						{
+							if(enum_param->validate_object_parameter(obj_param , references) == true)
+							{
+								*multiple = (*match)->get_multiple();
+								result = true;
+							}
+							else
+							{
+								// エラー出力はvalidate_object_parameterで行っているため不要．
+								//toppers::error("Object %1%'s parameter %2% can't set %3%." , 
+								//	obj_param->get_parent_name() , obj_param->get_parameter_name() , obj_param->get_value());
+							}
+						}
+						else
+						{
+							if((*match)->validate_object_parameter(obj_param) == true)
+							{
+								*multiple = (*match)->get_multiple();
+								result = true;
+							}
+							else
+							{
+								// エラー出力はvalidate_object_parameterで行っているため不要．
+								//toppers::error("Object %1%'s parameter %2% can't set %3%." , 
+								//	obj_param->get_parent_name() , obj_param->get_parameter_name() , obj_param->get_value());
+							}
+						}
+					}
+				}
+				else
+				{
+					// エラー処理
+					toppers::error("Object %1% can't define parameter %2%." , 
+						obj_param->get_parent_name() , obj_param->get_parameter_name());
+				}
+
+				return result;
+			}
+
+			// 基本パラメータのチェック
+			bool object_parameter_impl::validate_object_parameter
+					(oil_definition::object_parameter_def *obj , bool *auto_param)
+			{
+				// 複数定義はオブジェクト解析側でしか行えない
+				// デフォルト定義かどうかもオブジェクトでしか行えない
+				set_parameter_type(obj);
+								
+				// AUTO属性のチェック
+				if(obj->get_value() == "AUTO")
+				{
+					if(assign_auto == false)
+					{
+						toppers::error("Object %1% : %2% can't use \"AUTO\"" ,
+							obj->get_parent_name().c_str() , obj->get_parameter_name().c_str());
+						return false;
+					}
+					else
+					{
+						*auto_param = true;
+					}
+				}
+				else
+				{
+					*auto_param = false;
+				}
+
+				return true;
+			}
+			
+			template<typename T>
+			bool validate_number_paremeter
+			(VALUE_LIMIT_TYPE type ,T value , T min , T max , vector<T> *value_list)
+			{
+				bool result = true;
+				
+				if(type == LIMIT_RANGE)
+				{
+					if((value < min) || (value > max))
+					{
+						result = false;
+					}
+				}
+				else if(type == LIMIT_LIST)
+				{
+                    // modified by takuya
+					//std::vector<T>::iterator p;
+					typename std::vector<T>::iterator p;
+
+					// 値のリストに存在するかを検索
+					p = find(value_list->begin() , value_list->end() , value);
+					if(p >= value_list->end())
+					{
+						result = false;
+					}
+				}
+				else
+				{
+					// チェックは必要ない
+				}
+
+				return result;
+			}
+
+			template<typename T>
+			void val2string(std::vector<T> *list , std::string *str)
+			{
+                // modified by takuya 110823
+				//std::vector<T>::iterator p;
+				typename std::vector<T>::iterator p;
+
+				for(p = list->begin() ; p != list->end() ; p++)
+				{
+					try
+					{
+						*str += boost::lexical_cast<string>(*p) + " , ";
+					}
+					catch( ... )
+					{
+						toppers::error("cast error");
+					}
+				}
+			}
+
+			bool parameter_int_impl::validate_object_parameter
+					(oil_definition::object_parameter_def *obj)
+			{
+				bool result = false , assign_auto;
+				int64_t value;
+				
+				// 基本属性のチェック
+				if(object_parameter_impl::validate_object_parameter(obj , &assign_auto)
+					== false)
+				{
+					return false;
+				}
+
+				// AUTOパラメータならすぐに抜ける
+				if(assign_auto == true)
+				{
+					return true;
+				}
+
+				// 値に変換
+				if(obj->get_value().find("0x") != string::npos)
+				{
+                    // modified by takuya 110823
+					//(void)sscanf_s(obj->get_value().c_str() , "0x%I64x" , &value);
+					(void)sscanf(obj->get_value().c_str() , "0x%llx" , &value);
+				}
+				else if(obj->get_value().find("0X") != string::npos)
+				{
+                    // modified by takuya 110823
+					//(void)sscanf_s(obj->get_value().c_str() , "0X%I64x" , &value);
+					(void)sscanf(obj->get_value().c_str() , "0X%llx" , &value);
+				}
+				else
+				{
+					try
+					{
+						value = boost::lexical_cast<int64_t>(obj->get_value());
+					}
+					catch(std::exception& exception)
+					{
+						toppers::error("%1%'s %2% is not INT16/INT32." , 
+							obj->get_parent_name() , obj->get_parameter_name());
+
+						return false;
+					}
+				}
+
+				if(validate_number_paremeter
+							(limit_type , value , min , max , &value_list) == false)
+				{
+					if(limit_type == LIMIT_RANGE)
+					{
+						toppers::error("Object %1%'s %2% is \"%3%\" not in range [%4% - %5%]" ,
+							obj->get_parent_name().c_str() , obj->get_parameter_name().c_str() ,
+							obj->get_value() , min , max);
+					}
+					else // if(limit_type == LIMIT_LIST)
+					{
+						std::string str;
+						val2string(&value_list , &str);
+						
+						toppers::error("Object %1%'s %2% is \"%3%\" not in range [%4% - %5%]" ,
+							obj->get_parent_name().c_str() , obj->get_parameter_name().c_str() ,
+							obj->get_value() , min , max);
+					}
+				}
+				else
+				{
+					result = true;
+				}
+
+				return result;
+			}
+
+			void parameter_int_impl::set_parameter_type(oil_definition::object_parameter_def *obj)
+			{
+				obj->set_type(TYPE_INT);
+			}
+
+			bool parameter_uint_impl::validate_object_parameter
+				(oil_definition::object_parameter_def *obj)
+			{
+				bool result = false , assign_auto;
+				uint64_t value;
+				
+				// 基本属性のチェック
+				if(object_parameter_impl::validate_object_parameter(obj , &assign_auto)
+					== false)
+				{
+					return false;
+				}
+
+				// AUTOパラメータならすぐに抜ける
+				if(assign_auto == true)
+				{
+					return true;
+				}
+
+				// 値に変換
+				if(obj->get_value().find("0x") != string::npos)
+				{
+                    // modified by takuya 110823
+					//(void)sscanf_s(obj->get_value().c_str() , "0x%I64x" , &value);
+					(void)sscanf(obj->get_value().c_str() , "0x%llx" , &value);
+				}
+				else if(obj->get_value().find("0X") != string::npos)
+				{
+                    // modified by takuya 110823
+					//(void)sscanf_s(obj->get_value().c_str() , "0X%I64x" , &value);
+					(void)sscanf(obj->get_value().c_str() , "0X%llx" , &value);
+				}
+				else
+				{
+					try
+					{
+						value = boost::lexical_cast<uint64_t>(obj->get_value());
+					}
+					catch(std::exception& exception)
+					{
+						toppers::error("%1% : %2% is not UINT16/UINT32." , 
+							obj->get_parent_name() , obj->get_parameter_name());
+						return false;
+					}
+				}
+
+				if(validate_number_paremeter
+							(limit_type , value , min , max , &value_list) == false)
+				{
+					if(limit_type ==LIMIT_RANGE)
+					{
+						toppers::error("Object %1%'s %2% : %3% is not in range [%4% - %5%]" ,
+							obj->get_parent_name().c_str() , obj->get_parameter_name().c_str() ,
+							obj->get_value() , min , max);
+					}
+					else // if(limit_type == LIMIT_LIST)
+					{
+						std::string str;
+						val2string(&value_list , &str);
+
+						toppers::error("Object %1%'s %2% : %3% is not in range value list [%4%]" ,
+							obj->get_parent_name().c_str() , obj->get_parameter_name().c_str() ,
+							obj->get_value() , str);
+					}
+				}
+				else
+				{
+					result = true;
+				}
+
+				return result;
+			}
+
+			void parameter_uint_impl::set_parameter_type(oil_definition::object_parameter_def *obj)
+			{
+				obj->set_type(TYPE_UINT);
+			}
+
+			bool parameter_float_impl::validate_object_parameter
+				(oil_definition::object_parameter_def *obj)
+			{
+				bool result = false , assign_auto;
+				double value;
+				
+				// 基本属性のチェック
+				if(object_parameter_impl::validate_object_parameter(obj , &assign_auto)
+					== false)
+				{
+					return false;
+				}
+
+				// AUTOパラメータならすぐに抜ける
+				if(assign_auto == true)
+				{
+					return true;
+				}
+
+				// 値に変換
+				try
+				{
+					value = boost::lexical_cast<double>(obj->get_value().c_str());
+				}
+				catch(std::exception& exception)
+				{
+					toppers::error("%1% : %2% is not FLOAT." , 
+						obj->get_parent_name() , obj->get_parameter_name());
+
+					return false;
+				}
+
+				if(validate_number_paremeter
+							(limit_type , value , min , max , &value_list) == false)
+				{
+					if(limit_type ==LIMIT_RANGE)
+					{
+						toppers::error("Object %1%'s %2%  : %3% is not in range [%4% - %5%]" ,
+							obj->get_parent_name().c_str() , obj->get_parameter_name().c_str() ,
+							obj->get_value().c_str() , min , max);
+					}
+					else // if(limit_type == LIMIT_LIST)
+					{
+						std::string str;
+						val2string(&value_list , &str);
+
+						toppers::error("Object %1%' %2% : %3% is not in range value list [%4%]" ,
+							obj->get_parent_name().c_str() , obj->get_parameter_name().c_str() ,
+							obj->get_value().c_str() , str.c_str());
+					}
+				}
+				else
+				{
+					result = true;
+				}
+
+				return result;
+			}
+
+			void parameter_float_impl::set_parameter_type(oil_definition::object_parameter_def *obj)
+			{
+				obj->set_type(TYPE_FLOAT);
+			}
+
+			bool parameter_enum_impl::validate_object_parameter
+					(oil_definition::object_parameter_def *obj , std::vector<toppers::oil::object_ref> *object_refs)
+			{
+				std::map<std::string , oil_object_impl*>::iterator p;
+				bool result = true , assign_auto;
+
+				// 基本属性のチェック
+				if(object_parameter_impl::validate_object_parameter(obj , &assign_auto)
+					== false)
+				{
+					return false;
+				}
+
+				// AUTOパラメータならすぐに抜ける
+				if(assign_auto == true)
+				{
+					return true;
+				}
+
+				// パラメータがENUMのリストにあるか検索(総当たり）
+				std::vector<oil_definition::object_definition*>::iterator s;
+				std::string str;
+				bool hit = false;
+
+				for(p = sub_params.begin() ; p != sub_params.end(); p++)
+				{
+					// エラー処理用のリスト
+					str += (*p).first + " , ";
+					// パラメータ名が一致していなければ先の処理は行わない
+					if(obj->get_value() == (*p).first)
+					{
+						hit = true;
+					}
+				}
+				// リストになかった場合の処理
+				if(hit == false)
+				{
+					toppers::error("Object %1%'s %2% : %3% is not in range [%4%]" ,
+						obj->get_parent_name().c_str() , obj->get_parameter_name().c_str() , 
+						obj->get_value().c_str() , str);
+
+					return false;
+				}
+				
+				// サブパラメータについてもチェック
+				for(s = obj->get_subparams()->begin() ; s != obj->get_subparams()->end() ; s++)
+				{
+					for(p = sub_params.begin() ; p != sub_params.end(); p++)
+					{
+						/* 同名の設定の定義部を見つけたら再帰で検査 */
+						if((*s)->get_parent()->get_value() == (*p).first)
+						{
+							if((*p).second->validate_object_configuration((*s) , object_refs) == true)
+							{
+								result = true;
+							}
+						}
+					}
+					if(result == true)
+					{
+						break;
+					}
+				}
+				// 見つからなければエラー
+				if((obj->get_subparams()->empty() == false)
+					&& (s == obj->get_subparams()->end()))
+				{
+					result = false;
+				}
+
+				return result;
+			}
+
+			bool parameter_object_ref_impl::validate_object_parameter
+					(oil_definition::object_parameter_def *obj , std::vector<toppers::oil::object_ref> *object_refs)
+			{
+				// 基本属性のチェック
+				// リファレンス先のチェックもここで行うべきだが、
+				// リファレンス先のオブジェクト種類を取得できないため後で行う
+				if(object_parameter_impl::validate_object_parameter(obj , &assign_auto)
+					== false)
+				{
+					return false;
+				}
+
+				// チェックするべきリファレンスの代入
+				object_ref ref = { reftype_name , obj->get_value() };
+				object_refs->push_back(ref);
+
+				return true;
+			}
+
+			void parameter_string_impl::set_parameter_type
+					(oil_definition::object_parameter_def *obj)
+			{
+				obj->set_type(TYPE_STRING);
+			}
+
+			void parameter_boolean_impl::set_parameter_type
+					(oil_definition::object_parameter_def *obj)
+			{
+				obj->set_type(TYPE_BOOLEAN);
+			}
+		
+			void parameter_enum_impl::set_parameter_type(oil_definition::object_parameter_def *obj)
+			{
+				obj->set_type(TYPE_ENUM);
+			}
+
+			void parameter_object_ref_impl::set_parameter_type(oil_definition::object_parameter_def *obj)
+			{
+				obj->set_type(TYPE_REF);
+			}
+
+			bool oil_object_impl::validate_object_configuration
+					(oil_definition::object_definition * obj_def , std::vector<object_ref> *references)
+			{
+				std::vector<oil_definition::object_parameter_def*>::iterator p;
+				std::vector<oil_definition::object_parameter_def*> *obj_params;
+				std::vector<object_parameter_impl*>::iterator q;
+				std::vector<string> defined_parameter;
+				std::vector<object_parameter_impl*> undefined_parameter;
+				std::vector<string>::iterator found , s;
+				bool result = true;
+				bool multiple;
+
+				// オブジェクト名が合っているかチェック
+				if(name != obj_def->get_object_type())
+				{
+					return false;
+				}
+
+				// パラメータの整合性チェック
+				obj_params = obj_def->get_params();
+				for(p = obj_params->begin() ; p != obj_params->end() ; p++)
+				{
+					if(validate_object_parameter(*p , &multiple , references) == false)
+					{
+						result = false;
+					}
+
+					// 複数定義可能かのチェック
+					if(((found = find(defined_parameter.begin() , defined_parameter.end() , 
+						(*p)->get_parameter_name())) != defined_parameter.end())
+							&& (multiple == false))
+					{
+						toppers::error("Object %1% : %2% can define once." ,
+							obj_def->get_name().c_str() , (*p)->get_parameter_name().c_str());
+
+						result = false;
+					}
+					else
+					{
+						defined_parameter.push_back((*p)->get_parameter_name());
+					}
+				}
+
+				if(result == true)
+				{
+					//
+					// デフォルトパラメータの補完
+					//
+
+					// オブジェクト定義に記載されていないパラメータの探索
+					for(q = params.begin() ; q != params.end() ; q++)
+					{
+						s = find(defined_parameter.begin() , 
+							defined_parameter.end() , (*q)->get_name());
+
+						if(s == defined_parameter.end())
+						{
+							undefined_parameter.push_back((*q));
+						}
+					}
+
+					// 探索したパラメータに対してのデフォルトパラメータの補完
+					for(q = undefined_parameter.begin() ; q != undefined_parameter.end() ; q++)
+					{
+						string default_value;
+						DEFAULT_TYPE deftype = (*q)->get_default(&default_value);
+
+						if((deftype == HAVE_DEFAULT)
+							|| (deftype == AUTO))
+						{
+							obj_def->add_parameter((*q)->get_name() , default_value);
+						}
+						else if(deftype == NO_DEFAULT)
+						{
+							toppers::error("Object %1% : Parmeter %2% is not defined. %2% doesn't have default value." ,
+								obj_def->get_name().c_str() , (*q)->get_name().c_str());
+
+							result = false;
+						}
+						else	/* deftype == HAVE_NOT_DEFINE */
+						{
+						}
+
+					}
+				}
+
+				return result;
+			}
+
+			bool parameter_string_impl::validate_object_parameter
+					(oil_definition::object_parameter_def *obj)
+			{
+				// 文字属性は特に制約がないため常にtrue
+				return true;
+			}
+			
+			bool parameter_boolean_impl::validate_object_parameter
+					(oil_definition::object_parameter_def *obj)
+			{
+				// TRUEかFALSEでないとならない
+				if((obj->get_value() == "TRUE")
+					|| (obj->get_value() == "FALSE"))
+				{
+					return true;
+				}
+
+				toppers::error("Object %1%'s %2% is \"%3%\" , but can not set [TRUE , FALSE , ]." ,
+					obj->get_parent_name() , obj->get_parameter_name() , obj->get_value());
+
+				return false;
+			}
+
+			void oil_object_impl::display_implementation(void)
+			{
+				std::vector<object_parameter_impl*>::iterator p;
+				
+				cout << "=========== Object Name : " << name << "===========" << endl << endl;
+				for(p = params.begin() ; p != params.end() ; p++)
+				{
+					(*p)->display_implementation();
+				}
+				cout << endl << "==================================" << endl;
+				
+			}
+
+			void object_parameter_impl::set_parameter_type
+					(oil_definition::object_parameter_def *obj)
+			{
+				obj->set_type(TYPE_UNKNOWN);
+			}
+		}
+
+		namespace oil_definition
+		{
+			object_definition* find_object(string name)
+			{
+				return NULL;
+			}
+			
+			int object_definition::add_parameter(string param_name , string param_value)
+			{
+				try
+				{
+					object_parameter_def* param_def =
+						new object_parameter_def(param_name , param_value , name);
+					params.push_back(param_def);
+				}
+				catch(...)
+				{
+					// エラー処理
+				}
+
+				return 0;
+			}
+
+			object_definition::~object_definition()
+			{
+				std::vector<object_parameter_def*>::iterator p;
+
+				for(p = params.begin() ; p != params.end() ; p++)
+				{
+					delete (*p);
+				}
+			}
+
+			void object_definition::display_definition(void)
+			{
+				std::vector<object_parameter_def*>::iterator p;
+				
+				for(p = params.begin() ; p != params.end() ; p++)
+				{
+					(*p)->display_definition();
+				}
+				cout << endl << endl;
+			}
+
+			
+		/*!
+		 *  \brief  オブジェクトID番号の割付け
+		 *  \param[in]  api_map   ソースに記述された静的APIを登録したコンテナ
+		 */
+		void assign_id( cfg_obj_map obj_def_map , long fixed_id)
+		{
+		  using namespace toppers;
+		  using namespace toppers::oil::oil_definition;
+
+          // modified by takuya 110823
+		  //std::map<std::string, std::vector< object_definition* >>::iterator p;
+		  std::map<std::string, std::vector< object_definition* > >::iterator p;
+		  std::vector<object_definition*>::iterator q;
+		  int serial;
+
+		  for(p = obj_def_map.begin() ; p != obj_def_map.end() ; p++)
+		  {
+			  serial = 0;
+			  // オブジェクトごとにID割当て
+			  for(q = (*p).second.begin() ; q != (*p).second.end() ; q++)
+			  {
+				  if(fixed_id == UINT_MAX)
+				  {
+					(*q)->set_id(serial++);
+				  }
+				  else
+				  {
+					(*q)->set_id(fixed_id);
+				  }
+			  }
+		  }
+
+		}
+
+		cfg_obj_map merge(std::vector<object_definition*> *obj_defs , 
+				cfg_obj_map& out , string prefix , string suffix , long fixed_id)
+		{
+		  std::vector<object_definition*>::iterator p , q;
+		  std::vector<object_definition*> *sub_objects;
+		  std::vector<object_parameter_def*>::iterator r;
+		  std::vector<object_parameter_def*> *subparams;   
+		  
+		  for(p = obj_defs->begin() ; p != obj_defs->end() ; p++)
+		  {
+			  string s(prefix + (*p)->get_object_type() + suffix);
+			  out[ s ].push_back(*p);
+		  }
+
+		  // IDを一度割付ける
+		  assign_id(out , fixed_id);
+
+		  for(p = obj_defs->begin() ; p != obj_defs->end() ; p++)
+		  {
+			  long id;
+			  subparams = (*p)->get_params();
+			  // サブパラメータも登録
+			  for(r = subparams->begin() ; r != subparams->end() ; r++)
+			  {
+				  sub_objects = (*r)->get_subparams();
+	   			  id = (*p)->get_id();
+
+				  string s = "." + (*r)->get_value();
+
+				  // サブパラメータの持つ属性は再帰で登録する
+				  if(sub_objects->empty() == false)
+				  {
+					  cfg_obj_map temp;
+					  std::string subparam_name = 
+						  (*p)->get_object_type() + ".";
+					  temp = merge(sub_objects , temp , subparam_name , s , id);
+
+					  // 結果をコピー(ちょうどいいメソッドが無い)
+                      // modified by takuya 110823
+					  // std::map< std::string, std::vector< object_definition* >>::iterator x;
+					  std::map< std::string, std::vector< object_definition* > >::iterator x;
+					  for(x = temp.begin() ; x != temp.end() ; x++ )
+					  {
+						  std::vector< object_definition* >::iterator y;
+						  for(y = (*x).second.begin() ; y != (*x).second.end() ; y++)
+						  {
+							  out[(*x).first].push_back((*y));
+						  }
+						  //out[(*x).first] = (*x).second;
+						  //out[(*x).first].push_back((*x).second);
+					  }
+				  }
+			  }
+		  }
+
+		  return out;
+		}
+		}
+	}	/* oil */
+
+}
Index: /cfg_itronx+oil_gcc/toppers/oil/oil_object.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/oil_object.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/oil_object.hpp	(revision 54)
@@ -0,0 +1,969 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2010 by Meika Sugimoto
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+#ifndef OIL_OBJECT_H
+#define OIL_OBJECT_H
+
+#include <string.h>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <boost/regex.hpp>
+#include <boost/lexical_cast.hpp>
+
+#include "toppers/diagnostics.hpp"
+
+using namespace std;
+
+namespace toppers
+{
+	namespace oil
+	{
+		extern void dump(boost::smatch *r);
+
+		namespace oil_definition
+		{
+			// クラスの前方宣言
+			class object_parameter_def;
+			class object_definition;
+		}
+
+		// パラメータタイプ
+		enum PARAMETER_TYPE
+		{
+			TYPE_UINT = 1 ,
+			TYPE_INT ,
+			TYPE_FLOAT ,
+			TYPE_STRING ,
+			TYPE_BOOLEAN ,
+			TYPE_ENUM , 
+			TYPE_REF ,
+			TYPE_UNKNOWN
+		};
+
+		typedef struct
+		{
+			string obj_type;
+			string obj_name;
+		} object_ref;
+
+		namespace oil_implementation
+		{
+
+			// クラスの前方宣言
+			class object_parameter_impl;
+			
+			class oil_object_impl
+			{
+				public:
+					oil_object_impl(string object_name)
+					{
+						name = object_name;
+					}
+					~oil_object_impl();
+					int add_parameter(string param_name , string parameter_descripition);
+					bool validate_object_configuration
+							(oil_definition::object_definition* obj_def , std::vector<object_ref> *references);
+					void display_implementation(void);
+				private:
+                    // modified by takuya 110823
+					//bool oil_object_impl::validate_object_parameter
+					bool validate_object_parameter
+						(oil_definition::object_parameter_def *obj_param , bool *multiple ,
+								std::vector<object_ref> *references);
+					string name;
+					std::vector<object_parameter_impl*> params;
+			};
+
+			// 値制限の種類
+			enum VALUE_LIMIT_TYPE
+			{
+				LIMIT_RANGE = 1 ,
+				LIMIT_LIST ,
+				LIMIT_NONE
+			};
+			// デフォルト値の種類
+			enum DEFAULT_TYPE
+			{
+				NO_DEFAULT = 1 ,
+				AUTO ,
+				HAVE_DEFAULT ,
+				HAVE_NOT_DEFINE
+			};
+
+			class object_parameter_impl
+			{
+				public:
+					object_parameter_impl(string param_name)
+					{
+						name = param_name;
+					}
+					object_parameter_impl(string param_name , string parameter_description)
+					{
+						name = param_name;
+
+						// AUTO属性の解析
+						if(parameter_description.find("WITH_AUTO") != string::npos)
+						{
+							assign_auto = true;
+						}
+						else
+						{
+							assign_auto = false;
+						}
+
+						/// ENUMのときに問題あり
+						// 複数定義有無の解析
+						boost::regex brace("\\[\\s*\\]\\s*(=.+)?;");
+						if(boost::regex_search(parameter_description , brace))
+						{
+							multiple = true;
+						}
+						else
+						{
+							multiple = false;
+						}
+						
+						// デフォルト値の解析
+						boost::regex default_value("=\\s+(\\S+)\\s*;");
+						boost::smatch result;
+						string::const_iterator start = parameter_description.begin();
+						string::const_iterator end = parameter_description.end();
+						if(boost::regex_search(start , end , result , default_value))
+						{
+							default_description = result.str(1);
+							if(default_description == "AUTO")
+							{
+								default_type = AUTO;
+							}
+							else if(default_description == "NO_DEFAULT")
+							{
+								default_type = NO_DEFAULT;
+							}
+							else
+							{
+								default_type = HAVE_DEFAULT;
+							}
+						}
+						else
+						{
+							default_type = HAVE_NOT_DEFINE;
+							default_description.erase(0);
+						}
+					}
+
+					string get_name(void)
+					{
+						return name;
+					}
+
+					DEFAULT_TYPE get_default(string *str)
+					{
+						if((default_type == HAVE_DEFAULT)
+							|| (default_type == AUTO))
+						{
+							*str = default_description;
+						}
+
+						return default_type;
+					}
+
+					virtual void display_implementation(void)
+					{
+						cout << "Parameter Name : " << name << endl;
+						cout << "Multilple : " << ((multiple == true)? "Yes" : "No") << endl;
+						cout << "Auto Assignment : " << ((assign_auto == true)? "Yes" : "No") << endl;
+						cout << "Default Value : ";
+						if(default_type == NO_DEFAULT)
+						{
+							cout << "NO_DEFAULT";
+						}
+						else if(default_type == AUTO)
+						{
+							cout << "AUTO";
+						}
+						else
+						{
+							cout << "HAVE_DEFAULT";
+						}
+						cout << endl;
+					}
+
+					virtual bool validate_parameter_name(string param_name)
+					{
+						if(name == param_name)
+						{
+							return true;
+						}
+						else
+						{
+							return false;
+						}
+					}
+
+					bool validate_object_parameter
+							(oil_definition::object_parameter_def *obj , bool *auto_param);
+					//virtual bool object_parameter_impl::validate_object_parameter
+					virtual bool validate_object_parameter
+							(oil_definition::object_parameter_def *obj)
+					{
+						return false;
+					}
+					virtual void set_parameter_type(oil_definition::object_parameter_def *obj);
+
+					bool get_multiple(void)
+					{
+						return multiple;
+					}
+				protected:
+					inline const char* return_format(double x , int type)
+					{
+						return "%lf";
+					}
+
+					inline const char* return_format(int64_t x , int type)
+					{
+						if(type == 0)
+						{
+                            // modified by takuya 110823
+							// return "%I64x";
+							return "%llx";
+						}
+						else
+						{
+                            // modified by takuya 110823
+							// return "%I64d";
+							return "%lld";
+						}
+					}
+
+					inline const char* return_format(uint64_t x , int type)
+					{
+						if(type == 0)
+						{
+                            // modified by takuya 110823
+							// return "%I64x";
+							return "%llx";
+						}
+						else
+						{
+                            // modified by takuya 110823
+							// return "%I64u";
+							return "%llu";
+						}
+					}
+
+					template <typename T>
+					T str2val(const char *str , T dummy)
+					{
+						T temp;
+						T zero = 0 , one = 1;
+						if((str[0] == '0') && ((str[1] == 'x') || (str[1] == 'X')))
+						{
+                            // modified by takuya 110823
+							//sscanf_s(&str[2] , return_format(zero , 0) , &temp);
+							sscanf(&str[2] , return_format(zero , 0) , &temp);
+						}
+						else
+						{
+                            // modified by takuya 110823
+							//sscanf_s(&str[0] , return_format(zero , 1) , &temp);
+							sscanf(&str[0] , return_format(zero , 1) , &temp);
+						}
+						return temp;
+					}
+
+					template <typename T>
+					void split_number_list(const char *str , std::vector<T> *list)
+					{
+						const char *p = str;
+						char val[32];
+						int i;
+						T zero = 0;
+					
+						// リストを解析
+						do
+						{
+							i = 0;
+							// スペースをとばす
+							while(*p == ' ')
+							{
+								p++;
+							}
+							// 数値部分の解析
+							while(*p != ' ' && (*p != '\0'))
+							{
+								val[i++] = *p++;
+							}
+							// 後ろのスペースとカンマもとばす
+							while((*p == ' ') || (*p == ','))
+							{
+								p++;
+							}
+							// 数値の解析とリストへの挿入
+							val[i] = '\0';
+							list->push_back((T)str2val(val , zero));
+						}while(*p != '\0');
+					}
+
+					template <class T , typename Y>
+					void dump_limit_value(T* obj)
+					{
+						if(obj->limit_type == LIMIT_RANGE)
+						{
+							cout << "Min value : " << obj->min << endl;
+							cout << "Max value : " << obj->max << endl;
+						}
+						else if(obj->limit_type == LIMIT_LIST)
+						{
+                            // modified by takuya 110823
+							//std::vector<Y>::iterator p;
+							typename std::vector<Y>::iterator p;
+
+							cout << "Limit value : ";
+							for(p = obj->value_list.begin() ; p != obj->value_list.end() ; p++)
+							{
+								cout << *p << ",";
+							}
+							cout << endl;
+						}
+						else
+						{
+							cout << "Limit value : None" << endl;
+						}
+
+						if(obj->default_type == HAVE_DEFAULT)
+						{
+							cout << "Default value : " << obj->default_value << endl;
+						}
+						cout << endl;
+					}
+					
+					int id;
+					string name;
+					bool multiple;
+					string default_description;
+					bool assign_auto;
+					DEFAULT_TYPE default_type;
+			};
+			
+			// INT型（INT32,INT64)
+			class parameter_int_impl : public object_parameter_impl
+			{
+				friend class object_parameter_impl;
+
+				public:
+					parameter_int_impl(string param_name , string parameter_description)
+						: object_parameter_impl(param_name , parameter_description)
+					{
+						// 制限値のパース
+						boost::regex limit_list("\\[\\s*((\\w)+(\\s*,\\s*\\w+)*)\\s*\\]");
+						boost::regex limit_range("\\[\\s*(\\w+)\\s*\\.\\.\\s*(\\w+)\\s*\\]");
+						string::const_iterator start = parameter_description.begin();
+						string::const_iterator end = parameter_description.end();
+						boost::smatch result;
+						
+						// リスト形式かのチェック
+						if(boost::regex_search(start , end , result , limit_list))
+						{
+							limit_type = LIMIT_LIST;
+							string str = result.str(1);
+							split_number_list(str.c_str() , &value_list);
+						}
+						// レンジ形式かのチェック
+						else if(boost::regex_search(start , end , result , limit_range))
+						{
+							limit_type = LIMIT_RANGE;
+							string str;
+
+							// 最小値
+							str = result.str(1);
+							min = str2val(str.c_str() , (int64_t)0);
+							// 最大値
+							str = result.str(2);
+							max = str2val(str.c_str() , (int64_t)0);
+						}
+						else
+						{
+							min = 0;
+							if(parameter_description.find("INT32") != string::npos)
+							{
+								max = INT_MAX;
+							}
+							else
+							{
+								max = INT64_MAX;
+							}
+							limit_type = LIMIT_RANGE;
+						}
+
+						// デフォルト値の算出
+						if(default_type == HAVE_DEFAULT)
+						{
+							default_value = str2val(default_description.c_str() , (int64_t)0);
+						}
+					}
+					virtual void display_implementation(void)
+					{
+						cout << "Parameter types : INT" << endl;
+						object_parameter_impl::display_implementation();
+						dump_limit_value<parameter_int_impl , int64_t>(this);
+					}
+					bool validate_object_parameter(oil_definition::object_parameter_def *obj);
+					void set_parameter_type(oil_definition::object_parameter_def *obj);
+				protected:
+					VALUE_LIMIT_TYPE limit_type;
+					std::vector<int64_t> value_list;
+					int64_t default_value;
+					int64_t max;
+					int64_t min;
+			};
+
+			// UINT型（UINT32,UINT64)
+			class parameter_uint_impl : public object_parameter_impl
+			{
+				friend class object_parameter_impl;
+
+				public:
+					parameter_uint_impl(string param_name , string parameter_description)
+						: object_parameter_impl(param_name , parameter_description)
+					{
+						// 制限値のパース
+						boost::regex limit_list("\\[\\s*((\\w)+(\\s*,\\s*\\w+)*)\\s*\\]");
+						boost::regex limit_range("\\[\\s*(\\w+)\\s*\\.\\.\\s*(\\w+)\\s*\\]");
+						string::const_iterator start = parameter_description.begin();
+						string::const_iterator end = parameter_description.end();
+						boost::smatch result;
+						
+						// リスト形式かのチェック
+						if(boost::regex_search(start , end , result , limit_list))
+						{
+							limit_type = LIMIT_LIST;
+							string str = result.str(1);
+							split_number_list(str.c_str() , &value_list);
+						}
+						// レンジ形式かのチェック
+						else if(boost::regex_search(start , end , result , limit_range))
+						{
+							limit_type = LIMIT_RANGE;
+							string str;
+
+							// 最小値
+							str = result.str(1);
+							min = str2val(str.c_str() , (uint64_t)0);
+							// 最大値
+							str = result.str(2);
+							max = str2val(str.c_str() , (uint64_t)0);
+						}
+						else
+						{
+							min = 0;
+							if(parameter_description.find("UINT32") != string::npos)
+							{
+								max = UINT_MAX;
+							}
+							else
+							{
+								max = UINT64_MAX;
+							}
+							limit_type = LIMIT_RANGE;
+						}
+						// デフォルト値の算出
+						if(default_type == HAVE_DEFAULT)
+						{
+							default_value = str2val(default_description.c_str() , (uint64_t)0);
+						}				
+					}
+
+					virtual void display_implementation(void)
+					{
+						cout << "Parameter types : UINT" << endl;
+						object_parameter_impl::display_implementation();
+						dump_limit_value<parameter_uint_impl , uint64_t>(this);
+					}
+					bool validate_object_parameter(oil_definition::object_parameter_def *obj);
+					void set_parameter_type(oil_definition::object_parameter_def *obj);
+				protected:
+					VALUE_LIMIT_TYPE limit_type;
+					std::vector<uint64_t> value_list;
+					uint64_t max;
+					uint64_t min;
+					uint64_t default_value;
+			};
+			
+			// FLOAT型（FLOAT)
+			class parameter_float_impl : public object_parameter_impl
+			{
+				friend class object_parameter_impl;
+
+				public:
+					parameter_float_impl(string param_name , string parameter_description)
+							: object_parameter_impl(param_name , parameter_description)
+					{
+						// 制限値のパース
+						boost::regex limit_list("\\[\\s*((\\w(\\.\\w+)?)+(\\s*,\\s*\\w+(\\.\\w+)?)*)\\s*\\]");
+						boost::regex limit_range("\\[\\s*(\\w+(\\.\\w+)?)\\s*\\.\\.\\s*(\\w+(\\.\\w+)?)\\s*\\]");
+						string::const_iterator start = parameter_description.begin();
+						string::const_iterator end = parameter_description.end();
+						boost::smatch result;
+						
+						// リスト形式かのチェック
+						if(boost::regex_search(start , end , result , limit_list))
+						{
+							limit_type = LIMIT_LIST;
+							string str = result.str(1);
+							split_number_list(str.c_str() , &value_list);
+						}
+						// レンジ形式かのチェック
+						else if(boost::regex_search(start , end , result , limit_range))
+						{
+							limit_type = LIMIT_RANGE;
+							string str;
+
+							// 最小値
+							str = result.str(1);
+							min = str2val(str.c_str() , (double)0);
+							// 最大値
+							str = result.str(3);
+							max = str2val(str.c_str() , (double)0);
+						}
+						else
+						{
+							limit_type = LIMIT_NONE;
+						}
+						// デフォルト値の算出
+						if(default_type == HAVE_DEFAULT)
+						{
+							default_value = str2val(default_description.c_str() , (double)0);
+						}			
+					}
+					virtual void display_implementation(void)
+					{
+						cout << "Parameter types : FLOAT" << endl;
+						object_parameter_impl::display_implementation();
+						dump_limit_value<parameter_float_impl , double>(this);
+					}
+					bool validate_object_parameter(oil_definition::object_parameter_def *obj);
+					void set_parameter_type(oil_definition::object_parameter_def *obj);
+				protected:
+					VALUE_LIMIT_TYPE limit_type;
+					std::vector<double> value_list;
+					double max;
+					double min;
+					double default_value;
+			};
+			
+			// STRING型
+			class parameter_string_impl : public object_parameter_impl
+			{
+				public:
+					parameter_string_impl(string param_name , string parameter_description)
+							: object_parameter_impl(param_name , parameter_description)
+					{
+						// デフォルト値の代入
+						if(default_type == HAVE_DEFAULT)
+						{
+							default_value = default_description;
+						}			
+					}
+
+					virtual void display_implementation(void)
+					{
+						cout << "Parameter types : STRING" << endl;
+						object_parameter_impl::display_implementation();
+						if(default_type == HAVE_DEFAULT)
+						{
+							cout << "Default value : " << default_value << endl;
+						}		
+					}
+					virtual bool validate_object_parameter
+							(oil_definition::object_parameter_def *obj);
+					virtual void set_parameter_type(oil_definition::object_parameter_def *obj);
+				protected:
+					string default_value;
+			};
+
+			// BOOLEAN型
+			class parameter_boolean_impl : public parameter_string_impl
+			{
+				public:
+					parameter_boolean_impl(string param_name , string parameter_description)
+						: parameter_string_impl(param_name , parameter_description)
+					{
+					}
+					virtual bool validate_object_parameter
+							(oil_definition::object_parameter_def *obj);
+					virtual void set_parameter_type(oil_definition::object_parameter_def *obj);
+			};
+
+			// ENUM型
+			class parameter_enum_impl : public object_parameter_impl
+			{
+				public:
+					parameter_enum_impl(string param_name , string parameter_description)
+							: object_parameter_impl(param_name , parameter_description)
+					{
+						boost::regex enum_description("(\\w+\\s+[^;]+);(\\s*(.+)\\s)*");
+						boost::regex enum_parse("(\\w+\\s+\\[)?\\s*((\\w+)\\s*(\\{([^\\{\\}]*)\\})?)(\\s*,\\s*(.+))*");
+						boost::regex subparam_name("([^\\[\\]\\s]+)\\s+((WITH_AUTO)?\\s+(\\[.+\\])?)?([^\\[\\]\\s]+)");
+						boost::regex space("\\s*");
+						string::const_iterator start = parameter_description.begin();
+						string::const_iterator end = parameter_description.end();
+						boost::smatch result;
+						toppers::oil::oil_implementation::oil_object_impl *sub_impl;
+						string name;
+
+						// 1個ずつパラメータを切り分けて処理
+						while(boost::regex_search(start , end , result , enum_parse))
+						{
+							string temp = result.str(5);
+							string::const_iterator start2 = temp.begin();
+							string::const_iterator end2 = temp.end();
+							boost::smatch result2;
+
+							try
+							{
+								/// try catch
+								sub_impl = new oil_object_impl(param_name);
+								name = result.str(3);
+								// パラメータの切り分け
+								while(boost::regex_search(start2 , end2 , result2 , enum_description))
+								{
+									string temp2 = result2.str(1);
+									string::const_iterator start3 = temp2.begin();
+									string::const_iterator end3 = temp2.end();
+									boost::smatch result3;
+									// パラメータ名の抽出
+									(void)boost::regex_search(start3 , end3 , result3 , subparam_name);
+									
+									sub_impl->add_parameter(result3.str(5) , result2.str(1) + ";");
+									// パラメータがなくなったらループを抜ける
+									if(boost::regex_match(result2.str(3) , space))
+									{
+										break;
+									}
+									temp.erase(0 , temp.find(result2.str(3)));
+									end2 = temp.end();
+								}
+
+								// コンテナへの登録
+								sub_params.insert(pair<string , oil_object_impl*>(name , sub_impl));
+
+								// パラメータがなくなったらループを抜ける
+								if(boost::regex_match(result.str(7) , space))
+								{
+									break;
+								}
+								parameter_description.erase(0 , parameter_description.find(result.str(7)));
+								end = parameter_description.end();
+							}
+							catch( ... )
+							{
+								toppers::fatal("Memory allocation error.");
+							}
+						}
+					}
+
+					~parameter_enum_impl()
+					{
+						std::map<std::string , oil_object_impl*>::iterator p;
+
+						for(p = sub_params.begin() ; p != sub_params.end() ; p++)
+						{
+							delete (*p).second;
+						}
+					}
+
+					virtual void display_implementation(void)
+					{
+						std::map<std::string , oil_object_impl*>::iterator p;
+
+						cout << "Parameter types : ENUM" << endl;
+						object_parameter_impl::display_implementation();
+
+						cout << "-------------- Sub parameters --------------" << endl;
+						for(p = sub_params.begin() ; p != sub_params.end() ; p++)
+						{
+							cout << "Sub param name : " << (*p).first << endl;
+							(*p).second->display_implementation();
+						}
+						cout << "--------------------------------------------" << endl;
+
+					}
+
+					bool validate_object_parameter(oil_definition::object_parameter_def *obj , 
+									std::vector<toppers::oil::object_ref> *object_refs);
+					void set_parameter_type
+						(oil_definition::object_parameter_def *obj);
+				protected:
+					std::map<std::string , oil_object_impl*> sub_params;
+			};
+
+			// 参照型
+			class parameter_object_ref_impl : public object_parameter_impl
+			{
+				public:
+					parameter_object_ref_impl(string param_name , string parameter_description)
+							: object_parameter_impl(param_name , parameter_description)
+					{
+						// 参照するオブジェクト名の抽出
+						boost::regex ref_type("(\\w+)_TYPE");
+						string::const_iterator start = parameter_description.begin();
+						string::const_iterator end = parameter_description.end();
+						boost::smatch result;
+
+						if(boost::regex_search(start , end , result , ref_type))
+						{
+							reftype_name = result.str(1);
+						}
+						/// デフォルト値の読み込み
+					}
+					virtual void display_implementation(void)
+					{
+						cout << "Parameter types : OBJECT REF" << endl;
+						object_parameter_impl::display_implementation();
+						cout << "Reference Type : " << reftype_name << endl << endl;
+					}
+
+					bool validate_object_parameter
+							(oil_definition::object_parameter_def *obj , std::vector<toppers::oil::object_ref> *object_refs);
+					void set_parameter_type(oil_definition::object_parameter_def *obj);
+				protected:
+					string reftype_name;
+			};
+		}
+
+		namespace oil_definition
+		{
+			// オブジェクト定義のクラス
+			class object_definition
+			{
+				public:
+					object_definition(string object_name_type , object_parameter_def* parent = NULL)
+					{
+						boost::regex object_declaration("(\\w+)\\s+([\\w\\.]+)");
+						string::const_iterator start = object_name_type.begin();
+						string::const_iterator end = object_name_type.end();
+						boost::smatch result;
+
+						// 結び付けられているパラメータへのポインタを格納
+						parent_parameter = parent;
+						// タイプとネームをパースして格納
+						if(boost::regex_match(start , end , result , object_declaration))
+						{
+							object_type = result.str(1);
+							name = result.str(2);
+						}
+						else
+						{
+							/* ありえない */
+						}
+					}
+
+					~object_definition();
+
+					int add_parameter(string param_name , string param_value);
+
+					string get_object_type(void)
+					{
+						return object_type;
+					}
+
+					std::vector<object_parameter_def*>* get_params(void)
+					{
+						return &params;
+					}
+					void display_definition(void);
+					void set_id(int obj_id)
+					{
+						id = obj_id;
+					}
+					int get_id(void)
+					{
+						return id;
+					}
+					std::string get_name(void)
+					{
+						return name;
+					}
+					object_parameter_def* get_parent(void)
+					{
+						return parent_parameter;
+					}
+
+				private:
+					int id;
+					string name;
+					string object_type;
+					std::vector<object_parameter_def*> params;
+					object_parameter_def* parent_parameter;
+			};
+
+			// オブジェクト定義パラメータの基本クラス
+			class object_parameter_def
+			{
+				public:
+					object_parameter_def(string def_name , string def_value , string parent)
+					{
+						boost::regex have_subparam("(\\w+)\\s*\\{\\s*(([^\\{\\}])+)\\s*\\}");
+						string::const_iterator start = def_value.begin();
+						string::const_iterator end = def_value.end();
+						boost::smatch result;
+
+						name = def_name;
+						parent_name = parent;
+
+						// サブパラメータがある場合はさらに分解
+						if(boost::regex_search(start , end , result , have_subparam))
+						{
+							string type_name;
+							object_definition *subparam;
+
+							value = result.str(1);
+
+							type_name = result.str(1) + " SUBPARAM";
+
+							// サブパラメータを格納するオブジェクトを生成
+							try
+							{
+								subparam = new object_definition(name + " " + name , this);
+							}
+							catch( std::bad_alloc )
+							{
+								toppers::fatal("Memory allocation error.");
+							}
+
+							boost::regex subparam_regex("((\\w+)\\s*=\\s*([\\w\"]+\\s*(\\{\\s*[^\\{\\}]\\s*\\})?));(.+)");
+							boost::regex space("\\s*");
+							string temp = result.str(2);
+							string::const_iterator start2 = temp.begin();
+							string::const_iterator end2 = temp.end();
+							boost::smatch result2;
+
+							while(boost::regex_search(start2 , end2  , result2 , subparam_regex))
+							{
+								subparam->add_parameter(result2.str(2) , result2.str(3));
+
+								// 分解し終わったら抜ける
+								if(boost::regex_match(result2.str(5) , space))
+								{
+									break;
+								}
+								temp.erase(0 , temp.find(result2.str(5)));
+								end2 = temp.end();
+							}
+							// コンテナに追加
+							subparams.push_back(subparam);
+						}
+						else
+						{
+							value = def_value;
+						}
+					}
+
+					~object_parameter_def()
+					{
+						std::vector<object_definition*>::iterator p;
+
+						for(p = subparams.begin() ; p != subparams.end() ; p++)
+						{
+							delete (*p);
+						}
+					}
+
+					string get_parameter_name(void)
+					{
+						return name;
+					}
+
+					string get_value(void)
+					{
+						return value;
+					}
+
+					string get_parent_name(void)
+					{
+						return parent_name;
+					}
+
+					std::vector<object_definition*>* get_subparams(void)
+					{
+						return &subparams;
+					}
+
+					void display_definition(void)
+					{
+						std::vector<object_definition*>::iterator p;
+
+						cout <<  "\tName : " << name << " Value : " << value << endl;
+						for(p = subparams.begin(); p != subparams.end(); p++)
+						{
+							cout << "\t";
+							(*p)->display_definition();
+						}
+					}
+					void set_type(PARAMETER_TYPE param_type)
+					{
+						type = param_type;
+					}
+					PARAMETER_TYPE get_type(void)
+					{
+						return type;
+					}
+
+				protected:
+					string name;
+					string value;
+					string parent_name;
+					PARAMETER_TYPE type;
+					std::vector<object_definition*> subparams;
+			};
+
+			typedef std::map< std::string, std::vector< object_definition* > > cfg_obj_map;
+			cfg_obj_map merge(std::vector<object_definition*> *obj_defs ,
+				cfg_obj_map& out , string prefix = string("") ,  
+				string suffix = string("")  , long fixed_id = UINT_MAX);
+			void assign_id(cfg_obj_map obj_defs  , long fixed_id = UINT_MAX);
+
+		}	/* oil_definition */
+
+
+	}	/* oil */
+}
+
+
+#endif	/* OIL_OBJECT_H */
Index: /cfg_itronx+oil_gcc/toppers/oil/oil_parse.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/oil_parse.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/oil_parse.cpp	(revision 54)
@@ -0,0 +1,225 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2010 by Meika Sugimoto
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+#include <string>
+#include <iostream>
+
+#include "toppers/oil/oil_parser.hpp"
+#include "toppers/diagnostics.hpp"
+
+using namespace std;
+using namespace boost::spirit::classic;
+using namespace toppers::oil;
+using namespace toppers::oil::oil_implementation;
+using namespace toppers::oil::oil_definition;
+
+
+int oil_parser::do_parse(oil_impl **impl , oil_def **def)
+{
+	oil_grammer grammer(this);
+	parse_info<> info;
+	
+	info = parse(description->c_str() , grammer , space_p);
+	if(info.hit)
+	{
+		*impl = &impl_list;
+		*def = &def_list;
+		return 0;
+	}
+	else
+	{
+		return -1;
+	}
+}
+
+void eval_tree(tree_match<char const *>::tree_iterator const &iter, int nest) {
+	int size; // ノードの子の個数
+	
+	size = iter->children.size(); // ノードの子の個数を取り出す
+	for(int i=0; i<nest; i++)
+	{
+		cout << "  "; // スペース２個分インデント
+	}
+	cout << "Node = '" << string(iter->value.begin(), iter->value.end()) << "'";
+	if (size > 0)
+	{
+		cout << " Child Size = " << size << endl; // 子の個数を表示
+	} else
+	{
+		cout << endl;                             // 子が無ければ個数表示しない
+	}
+	for(int j=0; j<size; j++)
+	{
+		eval_tree(iter->children.begin()+j, nest+1); // 子の個数分再帰呼び出し
+	}
+}
+
+int oil_parser::start_objimpl_analysis(std::string object_name)
+{
+	int result = 0;
+
+	try
+	{
+		// 構成中のオブジェクト実装部を保存
+		current_impl = new oil_object_impl(object_name);
+	}
+	catch( ... )
+	{
+		result = -1;
+	}
+	
+	return result;
+}
+
+int oil_parser::set_nextparam_name(std::string name)
+{
+	if(param_addable == true)
+	{
+		next_param_name = name;
+	}
+
+	return 0;
+}
+
+int oil_parser::add_parameter_objimpl(std::string parameter)
+{
+	// パラメータ解析、追加
+	if(param_addable)
+	{
+		current_impl->add_parameter(next_param_name , parameter);
+	}
+
+	return 0;
+}
+
+int oil_parser::start_objdef_analysis(std::string object_name_type)
+{
+	int result = 0;
+
+	try
+	{
+		// 構成中のオブジェクト実装部を保存
+		current_def = new object_definition(object_name_type);
+	}
+	catch( ... )
+	{
+		result = -1;
+	}
+	return result;
+}
+
+int oil_parser::end_objimpl_analysis(void)
+{
+	// 構成完了、登録
+	impl_list.push_back(current_impl);
+	
+	return 0;
+}
+
+void oil_parser::enable_addparam(bool enabled)
+{
+	param_addable = enabled;
+}
+
+int oil_parser::end_objdef_analysis(void)
+{
+	static std::vector<std::string> defined_object_name;
+	std::string obj_name = current_def->get_name();
+
+	// 既に同じオブジェクトがないかチェック
+	if(find(defined_object_name.begin() , defined_object_name.end() , obj_name)
+			== defined_object_name.end())
+	{
+		// 構成完了、登録
+		def_list.push_back(current_def);
+		// オブジェクト名を追加，登録済みにする
+		defined_object_name.push_back(obj_name);
+	}
+	else
+	{
+		// 同名のオブジェクト名が存在するため，エラー
+		toppers::error("Object %1% redefined." , obj_name);
+	}
+	
+	return 0;
+}
+
+int oil_parser::add_attr_value(string str)
+{
+	attr_description = str;
+
+	if(param_addable == true)
+	{
+		current_def->add_parameter(next_param_name , attr_description);
+	}
+
+	return 0;
+}
+
+void oil_parser::set_error(int position , std::string message)
+{
+	error_position = position;
+	error_message = message;
+}
+
+void oil_parser::get_error(int *position , std::string *message)
+{
+	*position = error_position;
+	*message = error_message;
+}
+
+void oil_parser::dump_implementation(void)
+{
+	std::vector<oil_object_impl*>::iterator p;
+
+	for(p = impl_list.begin(); p != impl_list.end() ; p++)
+	{
+		(*p)->display_implementation();
+	}
+}
+
+void oil_parser::dump_definition(void)
+{
+	std::vector<object_definition*>::iterator p;
+	
+	cout << "************** Object Defition **************" << endl;
+	for(p = def_list.begin(); p != def_list.end() ; p++)
+	{
+		(*p)->display_definition();
+	}
+	cout << "************** Object Defition End **************" << endl;
+}
Index: /cfg_itronx+oil_gcc/toppers/oil/oil_parser.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/oil_parser.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/oil_parser.hpp	(revision 54)
@@ -0,0 +1,560 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2009 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+
+#ifndef OIL_PARSER_H
+#define OIL_PARSER_H
+
+#include <boost/spirit/include/classic_core.hpp>
+#include <boost/spirit/include/classic_error_handling.hpp>
+#include <boost/spirit/include/classic_ast.hpp>
+#include <boost/spirit/include/classic_functor_parser.hpp>
+#include <boost/spirit/include/classic_regex.hpp>
+#include <vector>
+#include <map>
+#include <algorithm>
+
+#include "toppers/text.hpp"
+#include "toppers/oil/oil_object.hpp"
+
+
+
+using namespace boost::spirit::classic;
+
+namespace toppers
+{
+	namespace oil
+	{
+		typedef std::vector<toppers::oil::oil_implementation::oil_object_impl*> oil_impl;
+		typedef std::vector<toppers::oil::oil_definition::object_definition*> oil_def;
+		
+		class oil_parser
+		{
+			public:
+				oil_parser(std::string* txt , std::vector<std::string> const& objlist)
+				{
+					description = txt;
+					param_addable = true;
+					m_object_list = objlist;
+				}
+				~oil_parser()
+				{
+					std::vector<toppers::oil::oil_implementation::oil_object_impl*>::iterator p;
+
+					for(p = impl_list.begin() ; p != impl_list.end() ; p++)
+					{
+						delete *p;
+					}
+
+					std::vector<toppers::oil::oil_definition::object_definition*>::iterator q;
+
+					for(q = def_list.begin() ; q != def_list.end() ; q++)
+					{
+						delete *q;
+					}
+				}
+				int do_parse(oil_impl **impl , oil_def **def);
+				int start_objimpl_analysis(std::string object_name);
+				int start_objdef_analysis(std::string object_name_type);
+				int add_parameter_objimpl(std::string parameter);
+				int set_nextparam_name(std::string name);
+				int add_attr_value(std::string str);
+				int end_objimpl_analysis(void);
+				int end_objdef_analysis(void);
+				void enable_addparam(bool enabled);
+				void dump_implementation(void);
+				void dump_definition(void);
+				void set_error(int position , std::string message);
+				void get_error(int *position , std::string *message);
+
+				std::string* get_description(void)
+				{
+					return description;
+				}
+				std::vector<std::string> m_object_list;
+			protected:
+				std::string *description;
+				oil_impl impl_list;
+				oil_def def_list;
+			private:
+				toppers::oil::oil_implementation::oil_object_impl* current_impl;
+				std::string next_param_name;
+				std::string attr_description;
+				bool param_addable;
+				toppers::oil::oil_definition::object_definition* current_def;
+				std::string error_message;
+				int error_position;
+		};
+
+		// 文法エラー種別
+		enum oil_grammer_error
+		{
+			open_brace , close_brace , semicolon , equal , keyword , comma
+		};
+		// 文法エラー型定義
+		typedef assertion<oil_grammer_error> oil_assertion;
+		typedef boost::spirit::classic::guard<oil_grammer_error> oil_error_guard;
+		
+		// エラー処理ハンドラ
+		struct error_handler
+		{
+			oil_parser* container;
+			error_handler(oil_parser* _container) : container(_container)
+			{
+			}
+			template < class Scanner, class oil_grammer_error >
+			boost::spirit::classic::error_status<> operator()( Scanner const& scan, oil_grammer_error const& error ) const
+			{
+				std::string message;
+				int pos;
+				boost::spirit::classic::error_status<> result =
+					boost::spirit::classic::error_status<>( boost::spirit::classic::error_status<>::fail );
+
+				// エラー出現位置の算出
+				pos = error.where - &((container->get_description()->c_str())[0]);
+				
+				// メッセージの登録
+				switch ( error.descriptor )
+				{
+				case open_brace:
+					message = "missing '{'";
+					break;
+				case close_brace:
+					message = "missing '}'";
+					break;
+				case semicolon:
+					message = "missing ';'";
+					break;
+				case equal:
+					message = "missing '='";
+					break;
+				case keyword:
+					message = "can't use keyword";
+					break;
+				case comma:
+					message = "missing ','";
+					break;
+				}
+
+				container->set_error(pos , message);
+				return result;
+			}
+		};
+
+		// ファンクタ
+		struct match_objimpl_name
+		{
+			oil_parser* container;
+			match_objimpl_name(oil_parser* _container) : container(_container)
+			{
+			}
+			void operator()(char const *first, char const *last) const
+			{
+				std::string str(first , last);
+				std::vector<std::string>::iterator p;
+				bool hit = false;
+
+				for(p = container->m_object_list.begin() ; p != container->m_object_list.end() ; p++)
+				{
+					if(*p == str)
+					{
+						hit = true;
+						break;
+					}
+				}
+				container->start_objimpl_analysis(str);
+			}
+		};
+
+		struct find_implparam_name
+		{
+			oil_parser* container;
+			find_implparam_name(oil_parser* _container) : container(_container)
+			{
+			}
+
+			void operator()(char const *first, char const *last) const
+			{
+				string str(first , last);
+				container->set_nextparam_name(str);
+			}
+		};
+
+		struct match_impl_parameter
+		{
+			oil_parser* container;
+			match_impl_parameter(oil_parser* _container) : container(_container)
+			{
+			}
+
+			void operator()(char const *first, char const *last) const
+			{
+				string str(first , last);
+				container->add_parameter_objimpl(str);
+			}
+		};
+		
+		// 実装部の閉じ括弧を検出するファンクタ
+		struct match_objimpl_end
+		{
+			oil_parser* container;
+			match_objimpl_end(oil_parser* _container) : container(_container)
+			{
+			}
+
+			void operator()(char val) const
+			{
+				container->end_objimpl_analysis();
+			}
+		};
+		
+		// オブジェクト定義先頭を検出するファンクタ
+		struct match_objdef_name
+		{
+			oil_parser* container;
+			match_objdef_name(oil_parser* _container) : container(_container)
+			{
+			}
+			void operator()(char const *first, char const *last) const
+			{
+				string str(first , last);
+				container->start_objdef_analysis(str);
+			}
+		};
+
+		// パラメータ定義を追加するファンクタ
+		struct find_attrname
+		{
+			oil_parser* container;
+			find_attrname(oil_parser* _container) : container(_container)
+			{
+			}
+			void operator()(char const *first, char const *last) const
+			{
+				string str(first , last);
+				container->set_nextparam_name(str);
+			}
+		};
+
+		// オブジェクト定義終端を検出するファンクタ
+		struct match_objdef_end
+		{
+			oil_parser* container;
+			match_objdef_end(oil_parser* _container) : container(_container){}
+
+			void operator()(char val) const
+			{
+				container->end_objdef_analysis();
+			}
+		};
+		
+		// 定義部のパラメータタイプを識別するファンクタ
+		struct find_attribute
+		{
+			oil_parser* container;
+			find_attribute(oil_parser* _container) : container(_container)
+			{
+			}
+			void operator()(char const *first, char const *last) const
+			{
+				string str(first , last);
+				container->add_attr_value(str);
+			}
+		};
+
+		// 定義部のパラメータタイプを識別する(浮動小数点版)
+		struct find_attribute_float
+		{
+			oil_parser* container;
+			find_attribute_float(oil_parser* _container) : container(_container)
+			{
+			}
+			void operator()(double val) const
+			{
+				char buf[256];
+                // modified by takuya 110823
+				//sprintf_s(buf , "%lf" , val);
+				sprintf(buf , "%lf" , val);
+				string str(buf);
+				
+				container->add_attr_value(str);
+			}
+		};
+
+
+		
+		// ENUM中のパラメータ無視するためのファンクタ
+		struct enum_start
+		{
+			oil_parser* container;
+			enum_start(oil_parser* _container) : container(_container){}
+
+			void operator()(char val) const
+			{
+				container->enable_addparam(false);
+			}
+		};
+
+		// ENUM中のパラメータ無視を解除するためのファンクタ
+		struct enum_end
+		{
+			oil_parser* container;
+			enum_end(oil_parser* _container) : container(_container){}
+
+			void operator()(char val) const
+			{
+				container->enable_addparam(true);
+			}
+		};
+		
+		// OILパーサクラス
+		struct oil_grammer :  public grammar<oil_grammer>
+		{
+			oil_parser* m_container;
+			oil_grammer(oil_parser* container)
+			{
+				m_container = container;
+			}
+			template <typename T> struct definition
+			{
+				// 文法エラー種類定義
+				oil_assertion assertion_open_brace , assertion_close_brace , assertion_semicolon;
+				oil_assertion assertion_equal , assertion_keyword , assertion_comma;
+				// エラーハンドリング定義
+				oil_error_guard guard_implementation , guard_object , guard_object_def;
+
+				// BNF
+				rule<T> file;
+				rule<T> oil_version , implementation_definition , application_definition;
+				rule<T> implementation_spec_list , implementation_spec , implementation_def;
+				rule<T> object , object_ref_type , object_name , object_temp;
+				
+				rule<T> name , null_str , boolean , string_literal;
+				rule<T> multiple_specifier , auto_specifier;
+				rule<T> number_range , number_list , number , float_range , default_number , default_float;
+				rule<T> attribute_name;
+				rule<T> default_string , default_bool , default_name;
+				rule<T> bool_values;
+				rule<T> enumerator , enumeration , enumerator_list;
+				
+				rule<T> impl_parameter_list;
+				
+				rule<T> uint32_impl_attr_def , int32_impl_attr_def , uint64_impl_attr_def , int64_impl_attr_def;
+				rule<T> float_impl_attr_def , string_impl_attr_def , bool_impl_attr_def , enum_impl_attr_def;
+				rule<T> reference_name;
+				rule<T> impl_attr_def , impl_ref_def;
+				
+				rule<T> object_definition;
+				rule<T> parameter , attribute_value;
+
+				definition(oil_grammer const& self) :
+					assertion_open_brace(open_brace) ,
+					assertion_close_brace(close_brace) ,
+					assertion_semicolon(semicolon) ,
+					assertion_equal(equal) ,
+					assertion_keyword(keyword) ,
+					assertion_comma(comma)
+				{
+					// 記号関係
+					null_str = str_p("");
+					name = (alpha_p | ch_p('_')) >> +(alnum_p | ch_p('_'));
+					string_literal = ch_p('"') >> name >> ch_p('"');
+					multiple_specifier = !(ch_p('[') >> ch_p(']'));
+					auto_specifier = !str_p("WITH_AUTO");
+					number = (str_p("0x") >> +xdigit_p) | (str_p("0X") >> xdigit_p) | int_p | uint_p;
+					boolean = str_p("TRUE") | str_p("FALSE");
+					
+					// レンジ、デフォルト値
+					number_list = ch_p('[') >> number >> *(ch_p(',') >> number) >> ch_p(']');
+					number_range = !((ch_p('[') >> number >> str_p("..") >> number >> ch_p(']'))
+									| number_list);
+					default_number = !((ch_p('=') >> number)
+										| (ch_p('=') >> str_p("NO_DEFAULT"))
+										| (ch_p('=') >> str_p("AUTO")));
+					float_range = !(ch_p('[') >> real_p >> str_p("..") >> real_p >> ch_p(']'));
+					default_float = !((ch_p('=') >> real_p)
+										| (ch_p('=') >> str_p("NO_DEFAULT"))
+										| (ch_p('=') >> str_p("AUTO")));
+					
+					enumerator = name >> !(ch_p('{') >> implementation_def >> ch_p('}'));
+					enumerator_list = enumerator >> *(ch_p(',') >> enumerator);
+					enumeration = ch_p('[')[enum_start(self.m_container)] >> 
+										enumerator_list >> ch_p(']')[enum_end(self.m_container)];
+
+					default_name = !((ch_p('=') >> name)
+										| (ch_p('=') >> str_p("NO_DEFAULT"))
+										| (ch_p('=') >> str_p("AUTO")));
+					
+					attribute_name = name | object;
+					attribute_value = (boolean >> !(ch_p('{')[enum_start(self.m_container)] >>
+											*parameter >> (ch_p('}')[enum_end(self.m_container)])))
+											[find_attribute(self.m_container)]
+										| number[find_attribute(self.m_container)]
+										| real_p[find_attribute_float(self.m_container)]
+										| string_literal[find_attribute(self.m_container)]
+										/* 
+                                         * modified by takuya 110823
+                                         * AUTOは下の定義で代用可能
+                                         */
+										| (name >> !(ch_p('{')[enum_start(self.m_container)] >>
+											*parameter >> ch_p('}')[enum_end(self.m_container)]))
+											[find_attribute(self.m_container)];
+
+					default_string = !((ch_p('=') >> ch_p('"') >> name >> ch_p('"'))
+										| (ch_p('=') >> str_p("NO_DEFAULT"))
+										| (ch_p('=') >> str_p("AUTO")));
+					default_bool = !((ch_p('=') >> boolean)
+										| (ch_p('=') >> str_p("NO_DEFAULT"))
+										| (ch_p('=') >> str_p("AUTO")));
+					bool_values = !(ch_p('[')[enum_start(self.m_container)] >>
+											str_p("TRUE") >> !(ch_p('{') >> implementation_def >> ch_p('}')) >>
+									ch_p(',') >>
+											str_p("FALSE") >> !(ch_p('{') >> implementation_def >> ch_p('}')) >>
+									ch_p(']')[enum_end(self.m_container)]);
+
+					std::vector<std::string>::iterator p;
+					std::string objtype = "(" , objref = "(";
+					
+					// 正規表現のリストを作成
+					for(p = self.m_container->m_object_list.begin() ; p != self.m_container->m_object_list.end() ; p++)
+					{
+						objtype += (*p) + "|";
+						objref += (*p) + "_TYPE" + "|";
+					}
+					
+					objtype[objtype.size() - 1] = ')';
+					objref[objref.size() - 1] = ')';
+
+					object = regex_p(objtype.c_str());
+					object_ref_type = regex_p(objref.c_str());
+					
+					// オブジェクト定義
+					parameter = attribute_name[find_attrname(self.m_container)] >>
+								assertion_equal(ch_p("=")) >> attribute_value >>
+								assertion_semicolon(ch_p(";"));
+					object_name = (object >> name)[match_objdef_name(self.m_container)];
+					object_definition = guard_object(
+											object_name >> assertion_open_brace(ch_p('{')) >> 
+											*parameter >> assertion_close_brace(ch_p('}')) >> 
+											assertion_semicolon(ch_p(';'))[match_objdef_end(self.m_container)])
+											[error_handler(self.m_container)];
+
+					// 型別のパラメータ指定子
+					uint32_impl_attr_def = str_p("UINT32") >> auto_specifier >> number_range >>
+										attribute_name[find_implparam_name(self.m_container)] >> 
+										multiple_specifier >> default_number >> 
+										assertion_semicolon(ch_p(';'));
+					int32_impl_attr_def = str_p("INT32") >> auto_specifier  >> number_range >> 
+										attribute_name[find_implparam_name(self.m_container)] >>
+										multiple_specifier >> default_number >>
+										assertion_semicolon(ch_p(';'));
+					uint64_impl_attr_def = str_p("UINT64") >> auto_specifier  >> number_range >> 
+										attribute_name[find_implparam_name(self.m_container)] >>
+										multiple_specifier >> default_number >>
+										assertion_semicolon(ch_p(';'));
+					int64_impl_attr_def = str_p("INT64") >> auto_specifier  >> number_range >> 
+										attribute_name[find_implparam_name(self.m_container)] >>
+										multiple_specifier >> default_number >>
+										assertion_semicolon(ch_p(';'));
+					float_impl_attr_def = str_p("FLOAT") >> auto_specifier  >> float_range >> 
+										attribute_name[find_implparam_name(self.m_container)] >>
+										multiple_specifier >> default_float >>
+										assertion_semicolon(ch_p(';'));
+					string_impl_attr_def = str_p("STRING") >> auto_specifier >> 
+										attribute_name[find_implparam_name(self.m_container)] >>
+										multiple_specifier >> default_string >>
+										assertion_semicolon(ch_p(';'));
+					bool_impl_attr_def = str_p("BOOLEAN") >>
+										auto_specifier >> bool_values >>
+										attribute_name[find_implparam_name(self.m_container)] >>
+										multiple_specifier >> default_bool >>
+										assertion_semicolon(ch_p(';'));
+					enum_impl_attr_def = str_p("ENUM") >>
+										auto_specifier >> enumeration >>
+										attribute_name[find_implparam_name(self.m_container)] >>
+										multiple_specifier >> default_name >>
+										assertion_semicolon(ch_p(';'));
+
+					// 属性値
+					impl_attr_def = uint32_impl_attr_def | int32_impl_attr_def
+									| uint64_impl_attr_def | int64_impl_attr_def
+									| float_impl_attr_def | string_impl_attr_def
+									| bool_impl_attr_def | enum_impl_attr_def;
+					
+					reference_name = name | object;
+					impl_ref_def = object_ref_type >> reference_name[find_implparam_name(self.m_container)] >>
+									multiple_specifier >> assertion_semicolon(ch_p(';'));
+					
+					// パラメータの形式
+					implementation_def = *((impl_attr_def | impl_ref_def)
+												[match_impl_parameter(self.m_container)]);
+
+					// 本体定義
+					application_definition = 
+							str_p("CPU") >> name >> ch_p('{') >> 
+							*object_definition >> ch_p('}') >> ch_p(';');
+
+					// 大きな単位の文法
+					implementation_spec = 
+						guard_object(object[match_objimpl_name(self.m_container)] >>
+										assertion_open_brace(ch_p('{')) >>
+										implementation_def >>
+										assertion_close_brace(ch_p('}')) >>
+										assertion_semicolon(ch_p(';')[match_objimpl_end(self.m_container)]))
+										[error_handler(self.m_container)];
+					implementation_spec_list = *implementation_spec;
+					
+					implementation_definition = "IMPLEMENTATION" >> name >> ch_p('{')
+						>> implementation_spec_list >> ch_p('}') >> ch_p(';');
+
+					oil_version = str_p("OIL_VERSION") 
+								>> ch_p('=') >> ch_p('\"') >> real_p >> ch_p('\"') >> ch_p(';');	//
+					file = oil_version >> implementation_definition >> application_definition >> *space_p;
+				};
+				rule<T> const& start() const
+				{
+					return file;                    // 定義したルールを返す
+				}
+			};
+			
+		};
+
+
+	}
+}
+
+#endif	/* OIL_PARSER_H */
Index: /cfg_itronx+oil_gcc/toppers/oil/preprocess.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/preprocess.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/preprocess.cpp	(revision 54)
@@ -0,0 +1,202 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ *
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <cstring>
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include "toppers/io.hpp"
+#include "toppers/cpp.hpp"
+#include "toppers/global.hpp"
+#include "toppers/diagnostics.hpp"
+#include "toppers/oil/preprocess.hpp"
+#include <boost/spirit/include/classic_spirit.hpp>
+
+namespace toppers
+{
+  namespace oil
+  {
+
+    /*!
+     *  \brief  静的API `INCLUDE'の展開
+     *  \param[in]  in      入力ファイルの内容
+     *  \param[out] out     出力ファイルの内容
+     *  \param[in]  codeset 文字コード
+     *  \param[out] dependencies  依存関係の格納先（NULLの場合は格納しない）
+     *  \param[out] onces   #pragma onceが記述されていたファイル名の格納先（NULLの場合は格納しない）
+     *
+     *  `INCLUDE' の引数は、μITRON 仕様のものとは異なり、二重引用符で囲まずに #include 指令と
+     *  同じ形式を用いる。
+     */
+    void expand_include( text const& in, text& out, codeset_t codeset, std::set< std::string >* dependencies, std::set< std::string >* onces )
+    {
+      typedef text::container::const_iterator const_row_iterator;
+      typedef std::string::size_type size_type;
+      size_type const npos = std::string::npos;
+      const_row_iterator first( in.begin().get_row() ), last( in.end().get_row() );
+
+      out.set_line( first->line.file, first->line.line );
+      for ( const_row_iterator iter( first ); iter != last; ++iter )
+      {
+        std::string const& buf = iter->buf;
+        char state = 0;
+
+        for ( size_type i = 0, n = buf.size(); i != n; ++i )
+        {
+          char c = buf[i];
+          if ( c == '\'' || c == '\"' )
+          {
+            if ( state == 0 )
+            {
+              state = c;    // 文字（列）リテラル開始
+            }
+            else if ( buf[i - 1] != '\\' ) //  \' または \" ではない
+            {
+              state = 0;    // 文字（列）リテラル終了
+            }
+            else if ( ( codeset == shift_jis ) && ( i >= 2 ) && is_lead< shift_jis >( buf[i - 2] ) )
+            {
+              state = 0;
+            }
+            out.push_back( c );
+          }
+          else if ( state != 0 )  // 文字（列）リテラル内
+          {
+            out.push_back( c );
+          }
+          else
+          {
+            using namespace boost::spirit::classic;
+            std::string headername;
+            if ( iter == last )
+            {
+              return;
+            }
+            text::const_iterator iter2( iter, i );
+            if ( iter2 == in.end() )
+            {
+              break;
+            }
+            parse_info< text::const_iterator > info
+              = parse( iter2, in.end(),
+				( str_p( "#include" ) >> *space_p
+                            >> '\"' >> ( +( anychar_p - '\"' ) )[ assign( headername ) ] >> '\"'
+                           ) );  // 行番号がずれるので、スキップパーサは使用しない
+            if ( info.hit )
+            {
+              std::vector< std::string > include_paths = get_global< std::vector< std::string > >( "include-path" );
+              std::string hname = search_include_file( include_paths.begin(), include_paths.end(), headername );
+              if ( hname.empty() )  // ヘッダ名が見つからない
+              {
+                fatal( iter->line, _( "cannot open file `%1%\'" ), headername );
+              }
+              else if ( onces == 0 || onces->find( hname ) == onces->end() )
+              {
+                if ( dependencies != 0 )
+                {
+                  dependencies->insert( hname );
+                }
+                out.push_back( ' ' ); // ダミーを挿入しておかないと行番号がずれる
+                preprocess( hname, out, codeset, dependencies, onces );  // ヘッダ名で指定されたファイルに対して前処理を再帰的に行う
+                iter = info.stop.get_row();
+                i = info.stop.get_col() - 1;
+                if ( iter != last )
+                {
+                  out.set_line( iter->line.file, iter->line.line );
+                }
+              }
+            }
+            else
+            {
+              if ( iter2.get_col() == 0 )
+              {
+                info = parse( iter2, in.end(),
+                              ( *( space_p - eol_p ) >>
+                                  ch_p( '#' ) >> *( space_p - eol_p ) >> "pragma" >> *( space_p - eol_p )
+                                    >> "once"
+                                    >> *( space_p - eol_p ) >> eol_p ) );
+                if ( info.hit )
+                {
+                  if ( onces != 0 )
+                  {
+                    onces->insert( iter2.line().file );
+                  }
+                  out.push_back( ' ' );
+                  iter = info.stop.get_row();
+                  if ( iter != last )
+                  {
+                    out.set_line( iter->line.file, iter->line.line );
+                  }
+                  --iter;   // インクリメントされるのでいったん戻す。
+                  break;
+                }
+              }
+              if ( parse( iter2, in.end(),
+				  ( str_p( "#include" ) >> *space_p >> '\"' >> +( anychar_p - ')' ) >> '\"') ).hit )
+              {
+                warning( iter->line, _( "probably, %1% argument of `%2%\' is illegal" ), _( "1st" ), "INCLUDE" );
+              }
+              out.push_back( c );
+            }
+          }
+        }
+      }
+    }
+
+    /*!
+     *  \brief  コンフィギュレーションファイルの前処理
+     *  \param[in]  file    コンフィギュレーションファイル名
+     *  \param[out] result  前処理後の内容
+     *  \param[in]  codeset 文字コード
+     *  \param[out] dependencies  依存関係の格納先（NULLの場合は格納しない）
+     *  \param[out] onces   #pragma onceが記述されていたファイル名の格納先（NULLの場合は格納しない）
+     */
+    void preprocess( std::string const& file, text& result, codeset_t codeset, std::set< std::string >* dependencies, std::set< std::string >* onces )
+    {
+      std::string buf;
+      read( file, buf );
+      if ( buf.empty() )
+      {
+        return;
+      }
+      text txt;
+      txt.set_line( file, 1 );
+      remove_comment( buf.begin(), buf.end(), std::back_inserter( txt ), codeset );
+      expand_include( txt, result, codeset, dependencies, onces );
+    }
+
+  }
+}
Index: /cfg_itronx+oil_gcc/toppers/oil/preprocess.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/oil/preprocess.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/oil/preprocess.hpp	(revision 54)
@@ -0,0 +1,60 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/oil/preprocess.hpp
+ *  \brief  システムコンフィギュレーションファイルの前処理に関する宣言定義
+ */
+#ifndef TOPPERS_OIL__PREPROCESSOR_HPP_
+#define TOPPERS_OIL__PREPROCESSOR_HPP_
+
+#include <string>
+#include <set>
+#include "toppers/text.hpp"
+#include "toppers/cpp.hpp"
+
+namespace toppers
+{
+  namespace oil
+  {
+
+    void expand_include( text const& in, text& out, codeset_t codeset = ascii, std::set< std::string >* dependencies = 0, std::set< std::string >* onces = 0 );
+    void preprocess( std::string const& file, text& result, codeset_t codeset = ascii, std::set< std::string >* dependencies = 0, std::set< std::string >* onces = 0 );
+
+  }
+}
+
+#endif  // ! TOPPERS_OIL__PREPROCESSOR_HPP_
Index: /cfg_itronx+oil_gcc/toppers/output_file.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/output_file.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/output_file.cpp	(revision 54)
@@ -0,0 +1,247 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2011 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+#include <map>
+#include <iostream>
+#include <sstream>
+#include <boost/filesystem/path.hpp>
+#include <boost/filesystem/operations.hpp>
+#include "toppers/workaround.hpp"
+#include "toppers/output_file.hpp"
+#include "toppers/io.hpp"
+#include "toppers/global.hpp"
+#include "toppers/diagnostics.hpp"
+
+namespace toppers
+{
+  namespace
+  {
+    struct context
+    {
+      std::ostringstream ostr;
+      std::string tempname;
+    };
+
+    typedef std::map< std::string, std::tr1::shared_ptr< context > > context_map;
+
+    inline context_map& get_context_map()
+    {
+      static context_map m;
+      return m;
+    }
+  }
+
+  /*!
+   *  \brief  出力ストリームの参照
+   *  \return 出力ストリーム
+   *
+   *  設定されているファイルに出力するための出力ストリームを返す。
+   *  既に出力ストリームが生成されている場合はその参照を返し、そうでなければ新たに出力ストリームを生成する。
+   *
+   *  ファイル名として、"stdout"が設定されていれば標準出力、"stderr"が設定されていれば標準エラー出力になる。
+   */
+  std::ostream& output_file::ostr() const
+  {
+    if ( filename_ == "stdout" )
+    {
+      return std::cout;
+    }
+    else if ( filename_ == "stderr" )
+    {
+      return std::cerr;
+    }
+
+    std::string path( path_name( filename_ ) );
+    context_map::const_iterator iter( get_context_map().find( path ) );
+    if ( iter == get_context_map().end() )
+    {
+      std::tr1::shared_ptr< context > ctx( new context );
+      get_context_map().insert( std::make_pair( path, ctx ) );
+      return ctx->ostr;
+    }
+    return iter->second->ostr;
+  }
+
+  /*!
+   *  \brief  メモリ上に格納されている内容を実際にファイルに出力する。
+   *
+   *  context_map としてメモリ上に格納された内容を、それぞれのファイルに対して出力する。
+   *  出力するにあたり、まず元のファイルを .org を付けたファイル名に変更する。
+   *  ここで、以前にあった .org は破壊される。
+   *  ファイルを順に書き込み、途中でエラーが発生した場合は、.org を元のファイル名に戻す。
+   *  途中でひとつでもエラーが発生した場合は、全ファイルについて .org を元に戻す。
+   *  以前にあった .org は復活しない。
+   */
+  void output_file::save()
+  {
+    namespace fs = boost::filesystem;
+    std::vector< std::string > saved_files;
+
+    try
+    {
+      for ( context_map::const_iterator iter( get_context_map().begin() ), last( get_context_map().end() );
+            iter != last;
+            ++iter )
+      {
+        if ( iter->first != "" )
+        {
+//          fs::path filename( iter->first, fs::native );
+          fs::path filename( iter->first );  // filesystem3対応
+//          fs::path backup( iter->first + ".org", fs::native );
+          fs::path backup( iter->first + ".org" );  // filesystem3対応
+          bool existed = fs::exists( filename );
+
+          try
+          {
+//            std::string file( filename.native_file_string() );
+            std::string file( filename.string() );  // filesystem3対応
+            if ( existed )
+            {
+              fs::rename( filename, backup );
+            }
+            write( file, iter->second->ostr.str() );  // ここで書き込む
+            saved_files.push_back( file );
+            fs::remove( backup );
+          }
+          catch ( ... )
+          {
+            if ( existed )
+            {
+              fs::remove( filename );
+              fs::rename( backup, filename ); 
+            }
+            throw;
+          }
+        }
+      }
+    }
+    catch ( ... )
+    {
+      // すでに書き込んだファイルを元に戻す。
+      for ( std::vector< std::string >::const_iterator iter( saved_files.begin() ), last( saved_files.end() );
+            iter != last;
+            ++iter )
+      {
+//        fs::path filename( *iter, fs::native );
+        fs::path filename( *iter );  // filesystem3対応
+        fs::remove( filename );
+//        fs::path backup( *iter + ".org", fs::native );
+        fs::path backup( *iter + ".org" );  // filesystem3対応
+        if ( fs::exists( backup ) )
+        {
+          fs::rename( backup, filename );
+        }
+      }
+      throw;
+    }
+  }
+
+  /*!
+   *  \brief  指定したファイル名に対応したパス名を返す。
+   *  \param[in]  filename  ファイル名
+   *  \return     パス名
+   *
+   *  --output-directory オプションで指定した出力先ディレクトリを反映したパス名を生成する。
+   *  ただし、下記のファイル名の場合はそのままの文字列を返す。
+   *  - "stdout"
+   *  - "stderr"
+   *  - ""
+   */
+  std::string output_file::path_name( std::string const& filename )
+  {
+    if ( filename == "stdin" || filename == "stderr" || filename == "" )
+    {
+      return filename;
+    }
+    namespace fs = boost::filesystem;
+    boost::any output_directory = global( "output-directory" );
+    if ( output_directory.empty() )
+    {
+      return filename;
+    }
+//    fs::path dir( get_global< std::string >( "output-directory" ), fs::native  );
+    fs::path dir( get_global< std::string >( "output-directory" )  );  // filesystem3対応
+//    return ( dir/filename ).native_file_string();
+    return ( dir/filename ).string();  // filesystem3対応
+  }
+
+  /*!
+   *  \brief  指定ファイルへの書き込みデータを参照
+   *  \param[in]  filename  出力先のファイル名
+   *  \return     書き込みデータ
+   */
+  std::string output_file::get_file_data( std::string const& filename )
+  {
+    context_map::const_iterator iter( get_context_map().find( path_name( filename ) ) ), last( get_context_map().end() );
+    if ( iter != last )
+    {
+      return iter->second->ostr.str();
+    }
+    return "";
+  }
+
+  /*!
+   *  \brief  指定ファイルへの書き込みデータを設定
+   *  \param[in]  filename  出力先のファイル名
+   *  \param[in]  data      書き込みデータ
+   *  \retval     true      設定成功
+   *  \retval     false     設定失敗
+   */
+  bool output_file::set_file_data( std::string const& filename, std::string const& data )
+  {
+    output_file ofile( filename, std::ios_base::out );
+    dynamic_cast< std::ostringstream& >( ofile.ostr() ).str( data );
+    return true;
+  }
+
+  /*!
+   *  \brief  メモリ上に格納されている書き込みようデータを消去
+   *  \param[in]  filename  出力先のファイル名
+   *  \retval     true      データの消去成功
+   *  \retval     false     指定したファイルへの出力データが存在しない
+   */
+  bool output_file::clear_file_data( std::string const& filename )
+  {
+    context_map::const_iterator iter( get_context_map().find( path_name( filename ) ) ), last( get_context_map().end() );
+    if ( iter != last )
+    {
+      iter->second->ostr.str( "" );
+      return true;
+    }
+    return false;
+  }
+
+}
Index: /cfg_itronx+oil_gcc/toppers/output_file.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/output_file.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/output_file.hpp	(revision 54)
@@ -0,0 +1,103 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+/*!
+ *  \file   toppers/output_file.hpp
+ *  \brief  出力ファイル管理を扱うための宣言定義
+ *
+ *  このファイルで定義されるクラス
+ *  \code
+ *  class output_file;
+ *  \endcode
+ */
+#ifndef TOPPERS_OUTPUT_FILE_HPP_
+#define TOPPERS_OUTPUT_FILE_HPP_
+
+#include <ostream>
+#include <string>
+#include "toppers/config.hpp"
+
+namespace toppers
+{
+
+  /*!
+   *  \class  output_file output_file.hpp "toppers/output_file.hpp"
+   *  \brief  出力ファイル管理クラス
+   */
+  class output_file
+  {
+  public:
+    output_file() : omode_( static_cast< std::ios_base::openmode >( 0 ) ) {}
+    output_file( std::string const& filename, std::ios_base::openmode omode )
+      : filename_( filename ), omode_( omode ), enable_( true ) {}
+    virtual ~output_file() {}
+
+    std::ostream& ostr() const;
+    std::string const& file_name() const { return filename_; }
+    bool is_enable() const { return enable_; }
+    void enable( bool flag = true ) { enable_ = flag; }
+    void push_back( char c )
+    {
+      if ( enable_ )
+      {
+        ostr() << c;
+      }
+    }
+
+    static std::string path_name( std::string const& filename );
+    static std::string get_file_data( std::string const& filename );
+    static bool set_file_data( std::string const& filename, std::string const& data );
+    static bool clear_file_data( std::string const& filename );
+    static void save();
+  private:
+    std::string filename_;
+    std::ios_base::openmode omode_;
+    bool enable_;
+  };
+
+  template < typename T >
+    inline output_file const& operator << ( output_file const& ofile, T const& value )
+  {
+    if ( ofile.is_enable() )
+    {
+      ofile.ostr() << value;
+    }
+    return ofile;
+  }
+
+}
+
+#endif  // ! TOPPERS_OUTPUT_FILE_HPP_
Index: /cfg_itronx+oil_gcc/toppers/s_record.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/s_record.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/s_record.cpp	(revision 54)
@@ -0,0 +1,268 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2011 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*
+ *  toppers/s_record.cpp
+ */
+#include "toppers/s_record.hpp"
+#include <istream>
+#include <algorithm>
+#include <iterator>
+#include <cctype>
+#include <cstring>
+
+namespace toppers
+{
+
+  /*!
+   *  \brief  Sレコードのロード
+   *  \param  istr  入力ストリーム
+   */
+  void s_record::load( std::istream& istr )
+  {
+    int type = -1;
+
+    while ( istr )
+    {
+      std::string buf;
+      std::getline( istr, buf );
+      if ( buf.empty() )
+      {
+        break;
+      }
+      record rec = read_record( buf );
+
+      // あまり厳密には処理しない
+      if ( '1' <= rec.type && rec.type <= '3' )
+      {
+        bool done = false;
+        typedef std::vector< value_type >::iterator iterator;
+        for ( iterator iter( data_.begin() ), last( data_.end() ); iter != last; ++iter )
+        {
+          if ( rec.address == iter->first + iter->second.size() )
+          {
+            std::copy( rec.data.begin(), rec.data.end(), std::back_inserter( iter->second ) );
+            done = true;
+          }
+        }
+        if ( !done )
+        {
+          data_.push_back( value_type( rec.address, std::vector< unsigned char >( rec.data.begin(), rec.data.end() ) ) );
+        }
+      }
+      type = rec.type;
+    }
+
+    cache_ = data_.begin();
+  }
+
+  /*!
+   *  \brief  指定アドレスのバイトデータ取得
+   *  \param  address   アドレス指定
+   *  \return address で指定したアドレスのバイトデータを返す
+   */
+  int s_record::operator[]( size_type address ) const
+  {
+    typedef std::vector< value_type >::const_iterator const_iterator;
+    if ( cache_ != data_.end() )
+    {
+      const_iterator iter( cache_ );
+      if ( iter->first <= address && address < iter->first + iter->second.size() )
+      {
+        return iter->second.at( address - iter->first );
+      }
+    }
+    for ( const_iterator iter( cache_ ), last( data_.end() ); iter != last; ++iter )
+    {
+      if ( iter->first <= address && address < iter->first + iter->second.size() )
+      {
+        cache_ = iter;
+        return iter->second.at( address - iter->first );
+      }
+    }
+    for ( const_iterator iter( data_.begin() ), last( cache_ ); iter != last; ++iter )
+    {
+      if ( iter->first <= address && address < iter->first + iter->second.size() )
+      {
+        cache_ = iter;
+        return iter->second.at( address - iter->first );
+      }
+    }
+    return -1;
+  }
+
+  /*!
+   *  \brief  Sレコード中の整数値読み込み
+   *  \param  base  読み込み位置の先頭アドレス
+   *  \param  size  整数値のバイト数
+   *  \param  little_endian リトルエンディアンなら true、ビッグエンディアンなら false を指定
+   *  \return 読み込んだ整数値を返す
+   */
+  boost::uintmax_t s_record::get_value( std::size_t base, std::size_t size, bool little_endian ) const
+  {
+    boost::uintmax_t value = 0;
+    if ( little_endian )
+    {
+      for ( long j = static_cast< long >( size-1 ); j >= 0; j-- )
+      {
+        int t = ( *this )[ base + j ];
+        if ( t < 0 )
+        {
+          throw data_error();
+        }
+        value = ( value << 8 ) | ( t & 0xff );
+      }
+    }
+    else
+    {
+      for ( std::size_t j = 0; j < size; j++ )
+      {
+        int t = ( *this )[ base + j ];
+        if ( t < 0 )
+        {
+          throw data_error();
+        }
+        value = ( value << 8 ) | ( t & 0xff );
+      }
+    }
+    return value;
+  }
+
+  unsigned long s_record::lower_bound() const
+  {
+    return data_.front().first;
+  }
+
+  unsigned long s_record::upper_bound() const
+  {
+    return data_.back().first + data_.back().second.size();
+  }
+
+  /*!
+   *  \brief  Sレコードの１行読み込み
+   *  \param  rec_buf １行バッファ
+   *  \return 読み込み結果を返す
+   */
+  s_record::record const s_record::read_record( std::string const& rec_buf )
+  {
+    std::string buf( rec_buf );
+
+    // 行末に'\r'または'\n'が残留している場合の対策
+    while ( std::isspace( static_cast< unsigned char >( *buf.rbegin() ) ) )
+    {
+      buf = buf.substr( 0, buf.size()-1 );
+    }
+
+    if ( buf.size() < 10 || buf[0] != 'S' )
+    {
+      throw format_error();
+    }
+    int ch = static_cast< unsigned char >( buf[1] );
+    int address_length = 4;
+    std::string::size_type size = buf.size();
+
+    switch ( ch )
+    {
+    case '1':
+    case '9':
+      address_length = 4;
+      break;
+    case '2':
+    case '8':
+      address_length = 6;
+      break;
+    case '3':
+    case '7':
+      address_length = 8;
+      break;
+    default:
+      if ( !std::isdigit( static_cast< unsigned char >( ch ) ) )
+      {
+        throw format_error();
+      }
+      break;
+    }
+    
+    record rec;
+    rec.type = ch;
+    rec.length = xdigit_to_int( buf[2] ) << 4 | xdigit_to_int( buf[3] );
+    if ( rec.length * 2u + 4 != buf.size() )
+    {
+      throw format_error();
+    }
+    rec.length -= address_length/2 + 1; // アドレスとチェックサムの長さを引いて、データ長に直す
+
+    rec.address = 0;
+    int base = 4;
+    for ( int i = 0; i < address_length; i++ )
+    {
+      rec.address = rec.address << 4 | xdigit_to_int( buf[base+i] );
+    }
+
+    base += address_length;
+    rec.data.reserve( rec.length );
+    for ( int i = 0; i < rec.length; i++ )
+    {
+      rec.data.push_back( static_cast< unsigned char >( xdigit_to_int( buf[base+i*2] ) << 4 | xdigit_to_int( buf[base+i*2+1] ) ) );
+    }
+
+    rec.checksum = xdigit_to_int( buf[size-2] ) << 4 | xdigit_to_int( buf[size-1] );
+
+    // チェックサム判定は省略
+
+    return rec;
+  }
+
+  /*!
+   *  \brief  十六進数字から数値への変換
+   *  \param  ch  十六進数字（文字）
+   *  \return ch に対応する数値
+   */
+  int s_record::xdigit_to_int( int ch )
+  {
+    static char const xdigits[] = "0123456789abcdef";
+
+    ch = std::tolower( static_cast< unsigned char >( ch ) );
+    char const* s = std::strchr( xdigits, ch );
+    if ( s == 0 )
+    {
+      return -1;
+    }
+    return s - xdigits;
+  }
+
+}
Index: /cfg_itronx+oil_gcc/toppers/s_record.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/s_record.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/s_record.hpp	(revision 54)
@@ -0,0 +1,148 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2008 by TAKAGI Nobuhisa  
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*!
+ *  \file   toppers/s_record.hpp
+ *  \brief  モトローラSレコードを扱うための宣言定義
+ *
+ *  このファイルで定義されるクラス
+ *  \code
+ *  class s_record;
+ *  struct s_record::record;
+ *  class s_record::format_error;
+ *  class s_record::checksum_error;
+ *  \endcode
+ */
+#ifndef TOPPERS_S_RECORD_HPP_
+#define TOPPERS_S_RECORD_HPP_
+
+#include "toppers/config.hpp"
+#include <iosfwd>
+#include <string>
+#include <vector>
+#include <utility>
+#include <stdexcept>
+#include <boost/cstdint.hpp>
+
+namespace toppers
+{
+
+  /*!
+   *  \class  s_record s_record.hpp "toppers/s_recored.hpp"
+   *  \brief  モトローラSレコードを扱うためのクラス
+   *
+   *  \sa s_record::record, s_record::format_error, s_record::checksum_error
+   */
+  class s_record
+  {
+  public:
+    typedef std::pair< unsigned long, std::vector< unsigned char > > value_type;
+    typedef std::vector< value_type >::size_type size_type;
+
+    /*!
+     *  \struct record s_record.hpp "toppers/s_record.hpp"
+     *  \brief  Sレコードの１行レコード情報を格納するための構造体
+     */
+    struct record
+    {
+      int type;
+      int length;
+      unsigned long address;
+      std::vector< unsigned char > data;
+      int checksum;
+    };
+
+    /*!
+     *  \class  data_error s_record.hpp "toppers/s_record.hpp"
+     *  \brief  Sレコードのデータエラー例外クラス
+     */
+    class data_error : public std::runtime_error
+    {
+    public:
+      data_error() : std::runtime_error( "S-record data error" ) {}
+    };
+    /*!
+     *  \class  format_error s_record.hpp "toppers/s_record.hpp"
+     *  \brief  Sレコードの書式エラー例外クラス
+     */
+    class format_error : public std::runtime_error
+    {
+    public:
+      format_error() : std::runtime_error( "S-record format error" ) {}
+    };
+    /*!
+     *  \class  checksum_error s_record.hpp "toppers/s_record.hpp"
+     *  \brief  Sレコードのチェックサムエラー例外クラス
+     */
+    class checksum_error : public std::runtime_error
+    {
+    public:
+      checksum_error() : std::runtime_error( "S-record checksum error" ) {}
+    };
+
+    /*!
+     *  \brief  デフォルトコンストラクタ
+     */
+    s_record() : cache_( data_.end() ) {}
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  istr  入力ストリーム
+     *
+     *  s_record クラスの生成と同時にデータのロードを行います。
+     */
+    explicit s_record( std::istream& istr ) { load( istr ); }
+    /*!
+     *  \brief  デストラクタ
+     */
+    virtual ~s_record() {}
+
+    void load( std::istream& istr );
+    int operator[]( size_type address ) const;
+    boost::uintmax_t get_value( std::size_t base, std::size_t size, bool little_endian ) const;
+    unsigned long lower_bound() const;
+    unsigned long upper_bound() const;
+  protected:
+    static record const read_record( std::string const& rec_buf );
+    static int xdigit_to_int( int ch );
+  private:
+    std::vector< value_type > data_;
+    mutable std::vector< value_type >::const_iterator cache_;
+  };
+
+}
+
+#endif  // ! TOPPERS_S_RECORD_HPP_
Index: /cfg_itronx+oil_gcc/toppers/text.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/text.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/text.hpp	(revision 54)
@@ -0,0 +1,836 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*!
+ *  \file   toppers/text.hpp
+ *  \brief  テキストデータ管理に関する宣言定義
+ *
+ *  このファイルで定義されるクラス
+ *  \code
+ *  class basic_text< Container, CharT, Traits, Allocator >;
+ *  \endcode
+ */
+#ifndef TOPPERS_TEXT_HPP_
+#define TOPPERS_TEXT_HPP_
+
+#include <algorithm>
+#include <iterator>
+#include <vector>
+#include <numeric>
+#include "toppers/text_line.hpp"
+#include "toppers/misc.hpp"
+#include <boost/utility.hpp>
+#include <boost/iterator/iterator_facade.hpp>
+#include <boost/format.hpp>
+
+namespace toppers
+{
+
+  /*!
+   *  \class  basic_text  text.hpp "toppers/text.hpp"
+   *  \brief  テキストデータ管理テンプレートクラス
+   *
+   *  ファイルから読み込んだテキストデータの管理を行うためのクラスです。
+   *  このクラスでは、テキストデータを単なる文字列としてではなく、入力元の
+   *  ファイル名と行番号を付加した形で管理します。
+   *
+   *  \note   このクラスはテキスト編集の用途を想定したものではありません。
+   */
+  template
+  <
+    template < typename, class > class Container,
+    typename CharT,
+    class Traits = std::char_traits< CharT >,
+    class Allocator = std::allocator< CharT >
+  >
+    class basic_text
+  {
+  public:
+    typedef basic_text< Container, CharT, Traits, Allocator > self_t;
+    typedef std::basic_string< CharT, Traits, Allocator > string_type;
+    typedef ::toppers::text_line line_type;
+    typedef basic_line_buf< CharT, Traits, Allocator > line_buf;
+
+    //  以下は一般的なコンテナとの互換のための型定義
+    ////////////////////////////////////////////////////////////////////////////////
+    typedef CharT value_type;
+    typedef Container< line_buf, std::allocator< line_buf > > container;
+    typedef value_type& reference;
+    typedef value_type const& const_reference;
+    typedef value_type* pointer;
+    typedef value_type const* const_pointer;
+    typedef Allocator allocator_type;
+    typedef typename Allocator::difference_type difference_type;
+    typedef typename Allocator::size_type size_type;
+
+    /*!
+     *  \class  const_iterator text.hpp "toppers/text.hpp"
+     *  \brief  toppers::basic_text のイテレータ
+     */
+    class const_iterator : public boost::iterator_facade< const_iterator, CharT, boost::random_access_traversal_tag, CharT const& >
+    {
+      friend class boost::iterator_core_access;
+    public:
+      typedef boost::iterator_facade< const_iterator, CharT, boost::random_access_traversal_tag, CharT const& > base_t;
+      typedef typename container::const_iterator row_iterator;
+      typedef typename base_t::value_type value_type;
+      typedef typename base_t::reference reference;
+      typedef typename base_t::pointer pointer;
+      typedef typename base_t::difference_type difference_type;
+
+      const_iterator() : row_(), col_( 0 ) {}
+      const_iterator( row_iterator row, size_type col = 0 ) : row_( row ), col_( col ) {}
+      line_type const& line() const { return row_->line; }
+      row_iterator const& get_row() const { return row_; }
+      size_type get_col() const { return col_; }
+    protected:
+      reference dereference() const { return row_->buf[col_]; }
+      bool equal( const_iterator const& rhs ) const { return row_ == rhs.row_ && col_ == rhs.col_; }
+      void increment() { if ( ++col_ == row_->buf.size() ) { col_ = 0; ++row_; } }
+      void decrement() { if ( col_ == 0 ) col_ = ( --row_ )->buf.size(); --col_; }
+      void advance( difference_type n )
+      {
+        typename container::const_iterator row = row_;
+        difference_type col = static_cast< difference_type >( col_ );
+        if ( n >= 0 )
+        {
+          while ( static_cast< size_type>( col + n ) > row->buf.size() )
+          {
+            n -= row->buf.size() - col;
+            ++row;
+            col = 0;
+          }
+          col += n;
+          if ( col == row->buf.size() )
+          {
+            col = 0;
+            ++row;
+          }
+        }
+        else  // n < 0
+        {
+          while ( col + n < -1 )
+          {
+            n += col;
+            --row;
+            col = row->buf.size() - 1;
+          }
+          col += n;
+          if ( col == -1 )
+          {
+            --row;
+            col = row->buf.size() - 1;
+          }
+        }
+        row_ = row;
+        col_ = col;
+      }
+      difference_type distance_to( const_iterator const& rhs ) const
+      {
+        difference_type n;
+        typename container::const_iterator row = row_;
+        if ( rhs.row_ < row_ )
+        {
+          n = -static_cast< difference_type >( col_ + ( rhs.row_->buf.size() - rhs.col_ ) );
+          while ( --row != rhs.row_ )
+          {
+            n -= row->buf.size();
+          }
+        }
+        else if ( row_ < rhs.row_ )
+        {
+          n = col_ + rhs.col_;
+          while ( ++row != rhs.row_ )
+          {
+            n += row->buf.size();
+          }
+        }
+        else
+        {
+          n = static_cast< difference_type >( rhs.col_ ) - static_cast< difference_type >( col_ );
+        }
+        return n;
+      }
+    private:
+      typename container::const_iterator row_;
+      size_type col_;
+    };
+
+    /*!
+     *  \class  iterator text.hpp "toppers/text.hpp"
+     *  \brief  toppers::basic_text のイテレータ
+     */
+    class iterator : public const_iterator
+    {
+    public:
+      typedef typename container::iterator row_iterator;
+      typedef typename const_iterator::value_type value_type;
+      typedef typename const_iterator::reference reference;
+      typedef typename const_iterator::pointer pointer;
+      typedef typename const_iterator::difference_type difference_type;
+
+      iterator() {}
+      explicit iterator( row_iterator row, size_type col = 0 ) : const_iterator( row, col ) {}
+      value_type& operator*() const { return const_cast< value_type& >( const_iterator::dereference() ); }
+      iterator& operator++() { const_iterator::increment(); return *this; }
+      iterator operator++( int ) { iterator t( *this ); const_iterator::increment(); return t; }
+      iterator& operator--() { const_iterator::decrement(); return *this; }
+      iterator operator--( int ) { iterator t( *this ); const_iterator::decrement(); return t; }
+    };
+
+    typedef std::reverse_iterator< const_iterator > const_reverse_iterator;
+    typedef std::reverse_iterator< iterator > reverse_iterator;
+
+  public:
+    /*!
+     *  \brief  デフォルトコンストラクタ
+     */
+    basic_text() {}
+
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  first   初期化に用いるデータ列の先頭
+     *  \param  last    初期化に用いるデータ列の終端+1
+     */
+    basic_text( const_iterator const& first, const_iterator const& last )
+    {
+      if ( first != last )
+      {
+        init( first, last );
+      }
+    }
+
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  first   初期化に用いるデータ列の先頭
+     *  \param  last    初期化に用いるデータ列の終端+1
+     *  \note   ファイル名は"unknown"になります。
+     */
+    template < class InputIterator >
+      basic_text( InputIterator first, InputIterator last )
+    {
+      if ( first != last )
+      {
+        init( first, last, append_directive );
+      }
+    }
+
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  first   初期化に用いるデータ列の先頭
+     *  \param  last    初期化に用いるデータ列の終端+1
+     *  \param  directive １行をコンテナに格納するための処理
+     *  \note   ファイル名は"unknown"になります。
+     *
+     *  directive は void directive( container& cont, line_buf& buf )の形式を
+     *  とる関数へのポインタまたはファンクタであることを想定しています。
+     *  cont は内部でデータの格納に使用するコンテナ、 buf は１行分の文字
+     *  列とファイル名・行番号を格納したバッファです。
+     */
+    template < class InputIterator, class Directive >
+      basic_text( InputIterator first, InputIterator last, Directive directive )
+    {
+      if ( first != last )
+      {
+        init( first, last, directive );
+      }
+    }
+
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  istr    初期化に用いる入力ストリーム
+     *  \note   ファイル名は"unknown"になります。
+     */
+    basic_text( std::basic_istream< CharT, Traits >& istr )
+    {
+      init( istr, append_directive );
+    }
+
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  istr    初期化に用いる入力ストリーム
+     *  \param  directive １行をコンテナに格納するための処理
+     *  \note   ファイル名は"unknown"になります。
+     *
+     *  directive は void directive( container& cont, line_buf& buf )の形式を
+     *  とる関数へのポインタまたはファンクタであることを想定しています。
+     *  cont は内部でデータの格納に使用するコンテナ、 buf は１行分の文字
+     *  列とファイル名・行番号を格納したバッファです。
+     */
+    template < class Directive >
+      basic_text( std::basic_istream< CharT, Traits >& istr, Directive directive )
+    {
+      init( istr, directive );
+    }
+
+    /*!
+     *  \brief  先頭位置の取得
+     *  \return 先頭文字へのイテレータを返す
+     */
+    const_iterator begin() const
+    {
+      return const_iterator( container_.begin() );
+    }
+
+    /*!
+     *  \brief  先頭位置の取得
+     *  \return 先頭文字へのイテレータを返す
+     */
+    iterator begin()
+    {
+      return iterator( container_.begin() );
+    }
+    
+    /*!
+     *  \brief  行数の取得
+     *  \param  pos  先頭文字からのオフセット
+     *  \return posで指定されたオフセットから行数を求め，イテレータを返す
+     */
+    const_iterator line_at(size_type pos) const
+    {
+        // modified by takuya
+        //typedef text::container::const_iterator const_row_iterator;
+        typedef typename container::const_iterator const_row_iterator;
+        const_iterator first( container_.begin() ), last( container_.end() );
+        int count = 0 , buf_size , i;
+        size_type sum = 0;
+
+        while((sum < pos) && (first != last))
+        {
+            const_row_iterator current( first.get_row() );
+            buf_size = current->buf.size();
+            sum += buf_size;
+            i = 0;
+            while(i < buf_size)
+            {
+                i++;
+                first++;
+            }
+            count += 1;
+        }
+        
+        if(first < last)
+        {
+            first -= buf_size;
+            return const_iterator(first);
+        }
+        else
+        {
+            return const_iterator( --last );
+        }
+    }   
+    /*!
+     *  \brief  終端位置+1の取得
+     *  \return 終端文字の次要素へのイテレータを返す
+     */
+    const_iterator end() const
+    {
+      return const_iterator( container_.end() );
+    }
+
+    /*!
+     *  \brief  終端位置+1の取得
+     *  \return 終端文字の次要素へのイテレータを返す
+     */
+    iterator end()
+    {
+      return iterator( container_.end() );
+    }
+
+    /*!
+     *  \brief  逆順先頭位置の取得
+     *  \return 逆順先頭文字への逆イテレータを返す
+     */
+    const_reverse_iterator rbegin() const
+    {
+      string_type const* pbuf = &container_.back().buf;
+      return const_reverse_iterator( container_.rbegin() + pbuf->empty() ? 0 : pbuf->size()-1 );
+    }
+
+    /*!
+     *  \brief  逆順先頭位置の取得
+     *  \return 逆順先頭文字への逆イテレータを返す
+     */
+    reverse_iterator rbegin()
+    {
+      string_type* pbuf = &container_.back().buf;
+      return reverse_iterator( container_.rbegin() + pbuf->empty() ? 0 : pbuf->size()-1 );
+    }
+
+    /*!
+     *  \brief  逆順終端位置+1の取得
+     *  \return 逆順終端文字の次要素への逆イテレータを返す
+     */
+    const_reverse_iterator rend() const
+    {
+      return const_reverse_iterator( container_.rend() );
+    }
+
+    /*!
+     *  \brief  逆順終端位置+1の取得
+     *  \return 逆順終端文字の次要素への逆イテレータを返す
+     */
+    reverse_iterator rend()
+    {
+      return reverse_iterator( container_.rend() );
+    }
+
+    /*!
+     *  \brief  先頭文字の参照
+     *  \return 先頭文字への参照を返す
+     */
+    const_reference front() const
+    {
+      return container_.front().buf[0];
+    }
+
+    /*!
+     *  \brief  先頭文字の参照
+     *  \return 先頭文字への参照を返す
+     */
+    reference front()
+    {
+      return container_.front().buf[0];
+    }
+
+    /*!
+     *  \brief  終端文字の参照
+     *  \return 終端文字への参照を返す
+     */
+    const_reference back() const
+    {
+      string_type const* pbuf = &container_.back().buf;
+      return pbuf->at( pbuf->size()-1 );
+    }
+
+    /*!
+     *  \brief  終端文字の参照
+     *  \return 終端文字への参照を返す
+     */
+    reference back()
+    {
+      string_type* pbuf = &container_.back().buf;
+      return pbuf->at( pbuf->size()-1 );
+    }
+
+    /*!
+     *  \brief  指定位置の文字の参照
+     *  \return 指定位置の文字への参照を返す
+     */
+    const_reference at( size_type pos ) const
+    {
+      return container_.front().buf[pos];
+    }
+
+    /*!
+     *  \brief  指定位置の文字の参照
+     *  \return 指定位置の文字への参照を返す
+     */
+    reference at( size_type pos )
+    {
+      return container_.front().buf[pos];
+    }
+
+    /*!
+     *  \brief  指定範囲のテキストデータを追加
+     *  \param  first 追加に用いるデータ列の先頭
+     *  \param  last  追加に用いるデータ列の終端+1
+     */
+    void append( const_iterator const& first, const_iterator const& last )
+    {
+      if ( first != last )
+      {
+        self_t t( *this );
+        t.init( first, last );
+        swap( t );
+      }
+    }
+
+    /*!
+     *  \brief  指定範囲のテキストデータを追加
+     *  \param  first 追加に用いるデータ列の先頭
+     *  \param  last  追加に用いるデータ列の終端+1
+     *  \note   ファイル名と行番号は追加先の終端のものを継続します。
+     *          追加先にデータがない場合は"unknown"になります。
+     */
+    template < class InputIterator >
+      void append( InputIterator first, InputIterator last )
+    {
+      append( first, last, append_directive );
+    }
+
+    /*!
+     *  \brief  指定範囲のテキストデータを追加
+     *  \param  first 追加に用いるデータ列の先頭
+     *  \param  last  追加に用いるデータ列の終端+1
+     *  \param  directive １行をコンテナに格納するための処理
+     *  \note   ファイル名と行番号は追加先の終端のものを継続します。
+     *          追加先にデータがない場合は"unknown"になります。
+     *
+     *  directive は void directive( container& cont, line_buf& buf )の形式を
+     *  とる関数へのポインタまたはファンクタであることを想定しています。
+     *  cont は内部でデータの格納に使用するコンテナ、 buf は１行分の文字
+     *  列とファイル名・行番号を格納したバッファです。
+     */
+    template < class InputIterator, class Directive >
+      void append( InputIterator first, InputIterator last, Directive directive )
+    {
+      if ( first != last )
+      {
+        self_t t( *this );
+        t.init( first, last, directive );
+        swap( t );
+      }
+    }
+
+    /*!
+     *  \brief  指定範囲のテキストデータを追加
+     *  \param  istr      追加に用いる入力ストリーム
+     *  \note   ファイル名と行番号は追加先の終端のものを継続します。
+     *          追加先にデータがない場合は"unknown"になります。
+     */
+    void append( std::basic_istream< CharT, Traits >& istr )
+    {
+      append( istr, append_directive );
+    }
+
+    /*!
+     *  \brief  指定範囲のテキストデータを追加
+     *  \param  istr      追加に用いる入力ストリーム
+     *  \param  directive １行をコンテナに格納するための処理
+     *  \note   ファイル名と行番号は追加先の終端のものを継続します。
+     *          追加先にデータがない場合は"unknown"になります。
+     *
+     *  directive は void directive( container& cont, line_buf& buf )の形式を
+     *  とる関数へのポインタまたはファンクタであることを想定しています。
+     *  cont は内部でデータの格納に使用するコンテナ、 buf は１行分の文字
+     *  列とファイル名・行番号を格納したバッファです。
+     */
+    template < class Directive >
+      void append( std::basic_istream< CharT, Traits >& istr, Directive directive )
+    {
+      self_t t( *this );
+      t.init( istr, directive );
+      swap( t );
+    }
+
+    /*!
+     *  \brief  指定範囲のテキストデータを代入
+     *  \param  first 代入に用いるデータ列の先頭
+     *  \param  last  代入に用いるデータ列の終端+1
+     */
+    void assign( const_iterator const& first, const_iterator const& last )
+    {
+      self_t t( first, last );
+      swap( t );
+    }
+
+    /*!
+     *  \brief  指定範囲のテキストデータを代入
+     *  \param  first 代入に用いるデータ列の先頭
+     *  \param  last  代入に用いるデータ列の終端+1
+     *  \note   ファイル名は"unknown"になります。
+     */
+    template < class InputIterator >
+      void assign( InputIterator first, InputIterator last )
+    {
+      self_t t( first, last, append_directive );
+      swap( t );
+    }
+
+    /*!
+     *  \brief  指定範囲のテキストデータを代入
+     *  \param  first 代入に用いるデータ列の先頭
+     *  \param  last  代入に用いるデータ列の終端+1
+     *  \param  directive １行をコンテナに格納するための処理
+     *  \note   ファイル名は"unknown"になります。
+     *
+     *  directive は void directive( container& cont, line_buf& buf )の形式を
+     *  とる関数へのポインタまたはファンクタであることを想定しています。
+     *  cont は内部でデータの格納に使用するコンテナ、 buf は１行分の文字
+     *  列とファイル名・行番号を格納したバッファです。
+     */
+    template < class InputIterator, class Directive >
+      void assign( InputIterator first, InputIterator last, Directive directive )
+    {
+      self_t t( first, last, directive );
+      swap( t );
+    }
+
+    /*!
+     *  \brief  指定範囲のテキストデータを代入
+     *  \param  istr      代入に用いる入力ストリーム
+     *  \note   ファイル名と行番号は代入先の終端のものを継続します。
+     *          追加先にデータがない場合は"unknown"になります。
+     */
+    void assign( std::basic_istream< CharT, Traits >& istr )
+    {
+      self_t t( istr, append_directive );
+      swap( t );
+    }
+
+    /*!
+     *  \brief  指定範囲のテキストデータを代入
+     *  \param  istr      代入に用いる入力ストリーム
+     *  \param  directive １行をコンテナに格納するための処理
+     *  \note   ファイル名と行番号は代入先の終端のものを継続します。
+     *          追加先にデータがない場合は"unknown"になります。
+     *
+     *  directive は void directive( container& cont, line_buf& buf )の形式を
+     *  とる関数へのポインタまたはファンクタであることを想定しています。
+     *  cont は内部でデータの格納に使用するコンテナ、 buf は１行分の文字
+     *  列とファイル名・行番号を格納したバッファです。
+     */
+    template < class Directive >
+      void assign( std::basic_istream< CharT, Traits >& istr, Directive directive )
+    {
+      self_t t( istr, directive );
+      swap( t );
+    }
+
+    /*!
+     *  \brief  終端に文字を追加
+     *  \param  value 追加する文字
+     */
+    void push_back( value_type value )
+    {
+      if ( container_.empty() || container_.back().line.file != line_.file )
+      {
+        line_buf buf( initial_line(), string_type( 1, value ) );
+        container_.push_back( buf );
+      }
+      else
+      {
+        string_type const* pbuf = &container_.back().buf;
+        if ( pbuf->at( pbuf->size()-1 ) == widen( '\n' ) )
+        {
+          ++line_.line;
+          line_buf buf( initial_line(), string_type( 1, value ) );
+          container_.push_back( buf );
+        }
+        else
+        {
+          container_.back().buf += value;
+        }
+      }
+    }
+
+    /*!
+     *  \brief  終端から文字を削除
+     */
+    void pop_back()
+    {
+      if ( container_.empty() )
+      {
+        container_.pop_back();
+      }
+      else
+      {
+        string_type const* pbuf = &container_.back().buf;
+        pbuf->resize( pbuf->size()-1 );
+        if ( container_.back().buf.empty() )
+        {
+          container_.pop_back();
+        }
+      }
+    }
+
+    /*!
+     *  \brief  コンテナが空かどうかの判別
+     *  \return 空の場合は true を返す
+     */
+    bool empty() const
+    {
+      return container_.empty();
+    }
+
+    /*!
+     *  \brief  コンテナのサイズ
+     *  \return コンテナに含まれている文字数を返す
+     */
+    size_type size() const
+    {
+      return std::accumulate( container_.begin(), container_.end(), size_type( 0 ), add_line_size );
+    }
+
+    /*!
+     *  \brief  コンテナの交換
+     *  \param  other   交換対象となるコンテナ
+     */
+    void swap( self_t& other )
+    {
+      container_.swap( other.container_ );
+      line_.swap( other.line_ );
+    }
+
+    /*!
+     *  \brief  コンテナのクリア
+     */
+    void clear()
+    {
+      container_.clear();
+      line_.file.clear();
+      line_.line = 0;
+    }
+
+    void set_line( std::string const& file, long line )
+    {
+      line_.file = file;
+      line_.line = line;
+    }
+
+    line_type get_line() const
+    {
+      return line_;
+    }
+  private:
+    //! 同種のコンテナを入力元とする初期化処理
+    void init( const_iterator const& first, const_iterator const& last )
+    {
+      line_buf buf( *first.get_row() );
+      if ( first.get_col() > 0 )
+      {
+        buf.buf = buf.buf.substr( first.get_col() );
+      }
+      container_.push_back( buf );
+      std::copy( boost::next( first ).get_row(), last.get_row(), std::back_inserter( container_ ) );
+      buf = *last.get_row();
+      buf.buf = buf.buf.substr( 0, last.get_col() );
+      container_.push_back( buf );
+      line_ = buf.line;
+    }
+
+    //! 異種のコンテナを入力元とする初期化処理
+    template < class InputIterator, class Directive >
+      void init( InputIterator first, InputIterator last, Directive directive )
+    {
+      line_buf buf( initial_line() );
+      value_type const nl = widen( '\n' );
+      for ( InputIterator iter = first; iter != last; ++iter )
+      {
+        value_type ch = *iter;
+        buf.buf += ch;
+        if ( ch == nl )
+        {
+          directive( container_, buf );
+          line_ = buf.line;
+        }
+      }
+      if ( !buf.buf.empty() )
+      {
+        container_.push_back( buf );
+      }
+      line_ = buf.line;
+    }
+
+    //! 入力ストリームを入力元とする初期化処理
+    template < class Directive >
+      void init( std::basic_istream< CharT, Traits >& istr, Directive directive )
+    {
+      line_buf buf( initial_line() );
+      value_type const nl = widen( '\n' );
+      while ( istr )
+      {
+        value_type ch;
+        istr.get( ch );
+        buf.buf += ch;
+        if ( ch == nl )
+        {
+          directive( container_, buf );
+          line_ = buf.line;
+        }
+      }
+      if ( !buf.buf.empty() )
+      {
+        container_.push_back( buf );
+      }
+      line_ = buf.line;
+    }
+
+    //! ファイル名・行番号の初期情報の取得
+    line_type const initial_line() const
+    {
+      if ( line_.line > 0 )
+      {
+        return line_;
+      }
+      if ( container_.empty() )
+      {
+        return line_type( "unknown", 1 );
+      }
+      return container_.back().line;
+    }
+
+    //! シングルバイト文字から別形式の文字型への変換
+    static value_type widen( char ch )
+    {
+      return ::toppers::widen< value_type >( ch );
+    }
+
+    //! size 関数内で使用する累算処理
+    static size_type add_line_size( size_type value, line_buf const& buf )
+    {
+      return value + buf.buf.size();
+    }
+
+    //! Directive のデフォルト処理
+    static void append_directive( container& cont, line_buf& buf )
+    {
+      cont.push_back( buf );
+      ++buf.line.line;
+      buf.buf.clear();
+    }
+  private:
+    container container_;
+    line_type line_;
+  };
+
+  typedef basic_text< std::vector, char > text;
+
+  inline text_line const& get_text_line( text::const_iterator iter )
+  {
+    return iter.line();
+  }
+
+  inline text_line const& get_text_line( text::iterator iter )
+  {
+    return iter.line();
+  }
+
+}
+
+#endif  // ! TOPPERS_TEXT_HPP_
Index: /cfg_itronx+oil_gcc/toppers/text_line.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/text_line.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/text_line.hpp	(revision 54)
@@ -0,0 +1,166 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2008 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*!
+ *  \file   toppers/text_line.hpp
+ *  \brief  テキストデータの行に関する宣言定義
+ *
+ *  このファイルで定義されるクラス
+ *  \code
+ *  struct text_line;
+ *  struct basic_line_buf< CharT, Traits, Allocator >;
+ *  \endcode
+ */
+#ifndef TOPPERS_TEXTLINE_HPP_
+#define TOPPERS_TEXTLINE_HPP_
+
+#include <iosfwd>
+#include <string>
+#include <algorithm>
+#include "toppers/config.hpp"
+
+namespace toppers
+{
+
+  /*!
+   *  \struct text_line text_line.hpp "toppers/text_line.hpp"
+   *  \brief  ファイル名と行番号の保持クラス
+   */
+  struct text_line
+  {
+    std::string file;   //!< ファイル名
+    long line;          //!< 行番号（1〜）
+
+    /*!
+     *  \brief  デフォルトコンストラクタ
+     */
+    text_line()
+      : line( 0 )
+    {
+    }
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  filename  ファイル名
+     *  \param  lineno    行番号
+     */
+    explicit text_line( std::string const& filename, long lineno = 0 )
+      : file( filename ), line( lineno )
+    {
+    }
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  filename  ファイル名
+     *  \param  lineno    行番号
+     */
+    explicit text_line( char const* filename, long lineno = 0 )
+      : file( filename ), line( lineno )
+    {
+    }
+    /*!
+     *  \brief  オブジェクトの交換
+     *  \param  other   交換対象のオブジェクト
+     */
+    void swap( text_line& other ) throw()
+    {
+      std::swap( line, other.line );
+      file.swap( other.file );
+    }
+  };
+
+  /*!
+   *  \struct line_buf text_line.hpp "toppers/text_line.hpp"
+   *  \brief  1 行テキストの管理クラス
+   */
+  template
+  <
+    typename CharT,
+    class Traits = std::char_traits< CharT >,
+    class Allocator = std::allocator< CharT >
+  >
+  struct basic_line_buf
+  {
+    typedef std::basic_string< CharT, Traits, Allocator > string_type;
+
+    string_type buf; //!< 行データを表す文字列
+    text_line line;  //!< 行番号情報
+
+    /*!
+     *  \brief  デフォルトコンストラクタ
+     */
+    basic_line_buf()
+    {
+    }
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  line  行番号情報
+     */
+    basic_line_buf( text_line const& line )
+      : line( line )
+    {
+    }
+    /*!
+     *  \brief  コンストラクタ
+     *  \param  line  行番号情報
+     *  \param  data  行データ
+     */
+    basic_line_buf( text_line const& line, string_type const& data )
+      : buf( data ), line( line )
+    {
+    }
+  };
+
+  //! char 版の 1 行テキスト管理クラス
+  typedef basic_line_buf< char > line_buf;
+
+  /*!
+   *  \brief  イテレータが保持する行番号情報の取得
+   *  \param  iter  イテレータ
+   *  \return 行番号情報への参照を返す
+   *
+   *  iter で指定したイテレータが行番号情報を保持しているなら、その行番号情報を返します。
+   *  行番号情報を保持していない場合はダミーオブジェクトへの参照を返します。
+   */
+  template < class Iterator >
+  inline text_line const& get_text_line( Iterator iter )
+  {
+    static text_line dummy;
+    return dummy;
+  }
+
+}
+
+#endif  // ! TOPPERS_TEXTLINE_HPP_
Index: /cfg_itronx+oil_gcc/toppers/ucn_parser.cpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/ucn_parser.cpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/ucn_parser.cpp	(revision 54)
@@ -0,0 +1,49 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2005-2010 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*
+ *  toppers/ucn_parser.cpp
+ */
+#include "toppers/c_parser.hpp"
+
+namespace toppers
+{
+
+  //! 国際文字名パーサー
+  boost::spirit::classic::functor_parser< detail::ucn_parse_functor > const ucn_p;
+
+}
Index: /cfg_itronx+oil_gcc/toppers/workaround.hpp
===================================================================
--- /cfg_itronx+oil_gcc/toppers/workaround.hpp	(revision 54)
+++ /cfg_itronx+oil_gcc/toppers/workaround.hpp	(revision 54)
@@ -0,0 +1,81 @@
+/*
+ *  TOPPERS Software
+ *      Toyohashi Open Platform for Embedded Real-Time Systems
+ *
+ *  Copyright (C) 2007-2009 by TAKAGI Nobuhisa
+ * 
+ *  上記著作権者は，以下の(1)〜(4)の条件を満たす場合に限り，本ソフトウェ
+ *  ア（本ソフトウェアを改変したものを含む．以下同じ）を使用・複製・改
+ *  変・再配布（以下，利用と呼ぶ）することを無償で許諾する．
+ *  (1) 本ソフトウェアをソースコードの形で利用する場合には，上記の著作
+ *      権表示，この利用条件および下記の無保証規定が，そのままの形でソー
+ *      スコード中に含まれていること．
+ *  (2) 本ソフトウェアを，ライブラリ形式など，他のソフトウェア開発に使
+ *      用できる形で再配布する場合には，再配布に伴うドキュメント（利用
+ *      者マニュアルなど）に，上記の著作権表示，この利用条件および下記
+ *      の無保証規定を掲載すること．
+ *  (3) 本ソフトウェアを，機器に組み込むなど，他のソフトウェア開発に使
+ *      用できない形で再配布する場合には，次のいずれかの条件を満たすこ
+ *      と．
+ *    (a) 再配布に伴うドキュメント（利用者マニュアルなど）に，上記の著
+ *        作権表示，この利用条件および下記の無保証規定を掲載すること．
+ *    (b) 再配布の形態を，別に定める方法によって，TOPPERSプロジェクトに
+ *        報告すること．
+ *  (4) 本ソフトウェアの利用により直接的または間接的に生じるいかなる損
+ *      害からも，上記著作権者およびTOPPERSプロジェクトを免責すること．
+ *      また，本ソフトウェアのユーザまたはエンドユーザからのいかなる理
+ *      由に基づく請求からも，上記著作権者およびTOPPERSプロジェクトを
+ *      免責すること．
+ * 
+ *  本ソフトウェアは，無保証で提供されているものである．上記著作権者お
+ *  よびTOPPERSプロジェクトは，本ソフトウェアに関して，特定の使用目的
+ *  に対する適合性も含めて，いかなる保証も行わない．また，本ソフトウェ
+ *  アの利用により直接的または間接的に生じたいかなる損害に関しても，そ
+ *  の責任を負わない．
+ * 
+ */
+
+/*!
+ *  \file   toppers/workaroound.hpp
+ *  \brief  処理系未対応の機能に対する代替手段
+ */
+#ifndef TOPPERS_WORKAROUND_HPP_
+#define TOPPERS_WORKAROUND_HPP_
+
+#include "toppers/config.hpp"
+
+#ifndef __STDC_CONSTANT_MACROS
+#define __STDC_CONSTANT_MACROS
+#endif
+#ifndef __STDC_LIMIT_MACROS
+#define __STDC_LIMIT_MACROS
+#endif
+
+#ifdef TOPPERS_HAS_TR1_LIBRARY
+
+// GCC 4.3以降では下記のヘッダでshared_ptr等を使えるが、-std=c++0x（または-std=c++11）
+// オプションが必要になる。そのため、あえて古い形式のヘッダによりTR1ライブラリとして使用する。
+//#include <memory>
+//#include <cstdint>
+
+#include <tr1/memory>
+#include <tr1/cstdint>
+
+#else
+
+#define BOOST_SP_DISABLE_THREADS  1   // shared_ptr の排他制御を抑止
+#include <boost/shared_ptr.hpp>
+#include <boost/weak_ptr.hpp>
+#include <boost/cstdint.hpp>
+
+namespace std
+{
+  namespace tr1
+  {
+    using namespace boost;
+  }
+}
+
+#endif
+
+#endif  // ! TOPPERS_WORKAROUND_HPP_
