OPTPiX SpriteStudio SDK
 All Classes Namespaces Functions Variables Enumerations Enumerator Pages
babel.h
1 /******************************************************************************
2  バベル -babel-
3  バベルモジュールヘッダファイル
4  Coded by Wraith in July 14, 2002.
5 ******************************************************************************/
6 
7 //　Tab幅を４文字に設定して表示させてください。
8 
10 //
11 // ■ babel.h
12 // http://tricklib.com/cxx/ex/babel/babel.h
13 //
14 // □ 関連ファイル
15 // 本モジュールの本体
16 // http://tricklib.com/cxx/ex/babel/babel.cpp
17 // 本モジュールで使用するスコアマッピングCSV
18 // http://tricklib.com/cxx/ex/babel/scoremap.csv
19 // 本モジュールで使用するCP932マッピングCSV
20 // http://tricklib.com/cxx/ex/babel/cp932.csv
21 // 本モジュールで使用するUTCマッピングCSV
22 // http://tricklib.com/cxx/ex/babel/utc.csv
23 // 本モジュールで使用するアップルマッピングCSV
24 // http://tricklib.com/cxx/ex/babel/apple.csv
25 // 本モジュールで使用するSJIS-EUCマッピングCSV
26 // http://tricklib.com/cxx/ex/babel/sjis-euc.csv
27 // 本モジュールで使用するEUC-UNICODEマッピングCSV
28 // http://tricklib.com/cxx/ex/babel/euc-uni.csv
29 // 本モジュールで使用するCP932マッピングデータファイル
30 // http://tricklib.com/cxx/ex/babel/c932-uni.dat
31 // http://tricklib.com/cxx/ex/babel/uni-c932.dat
32 // 本モジュールで使用するUTCマッピングデータファイル
33 // http://tricklib.com/cxx/ex/babel/utc-uni.dat
34 // http://tricklib.com/cxx/ex/babel/uni-utc.dat
35 // 本モジュールで使用するSJIS-EUCマッピングデータファイル
36 // http://tricklib.com/cxx/ex/babel/sjis-euc.dat
37 // http://tricklib.com/cxx/ex/babel/euc-sjis.dat
38 // 本モジュールで使用するEUC-UNICODEマッピングデータファイル
39 // http://tricklib.com/cxx/ex/babel/uni-euc.dat
40 // http://tricklib.com/cxx/ex/babel/euc2-uni.dat
41 // http://tricklib.com/cxx/ex/babel/euc3-uni.dat
42 // 本モジュールで使用するスコアマッピングデータファイル
43 // http://tricklib.com/cxx/ex/babel/sjis-scr.dat
44 // http://tricklib.com/cxx/ex/babel/euc-scr.dat
45 // http://tricklib.com/cxx/ex/babel/uni-scr.dat
46 // 全ファイルパック
47 // http://tricklib.com/cxx/ex/babel/babel.lzh
48 // http://tricklib.com/cxx/ex/babel/babel.zip
49 //
50 // □ リファレンス・サポートページ
51 // http://tricklib.com/cxx/ex/babel/
52 //
53 // □ ライセンス情報
54 // http://tricklib.com/license.htm
55 //
56 
57 #ifndef __BABEL_BABEL_H__
58 
59 #define __BABEL_BABEL_H__
60 
61 #if !defined(__WITH_BABEL__)
62 # define __WITH_BABEL__
63 #endif
64 
65 #include <cassert>
66 
67 #if defined(NDEBUG) && defined(_DEBUG)
68 # define _DEBUG
69 #endif
70 
71 namespace {
72 // int unimplemented;
73 };
74 
75 //
76 // ★コンパイラ情報による各種自動判別
77 //
78 
79  // Borland ...
80 # if defined(__BORLANDC__)
81 # if !defined(__UNICODE_CHAR_SIZE_2__)
82 # define __UNICODE_CHAR_SIZE_2__
83 # endif
84 # if !defined(__LITTLE_ENDIAN_COMPUTER__)
85 # define __LITTLE_ENDIAN_COMPUTER__
86 # endif
87 # if !(defined(__USING_ANSI__) || defined(__USING_SJIS__) || defined(__USING_EUC__) || defined(__USING_UTF8__) || defined(__USING_UNKNOWN__))
88 # define __USING_SJIS__
89 # endif
90 # endif
91 
92  // CodeWarrior ...
93 # if defined(__MWERKS__)
94 # endif
95 
96  // Microsoft ...
97 # if defined(_MSC_VER)
98 # if !defined(__UNICODE_CHAR_SIZE_2__)
99 # define __UNICODE_CHAR_SIZE_2__
100 # endif
101 # if !defined(__LITTLE_ENDIAN_COMPUTER__)
102 # define __LITTLE_ENDIAN_COMPUTER__
103 # endif
104 # if !(defined(__USING_ANSI__) || defined(__USING_SJIS__) || defined(__USING_EUC__) || defined(__USING_UTF8__) || defined(__USING_UNKNOWN__))
105 # define __USING_SJIS__
106 # endif
107 # endif
108 
109  // gcc/g++ ...
110 # if defined(__GNUC__)
111 # endif
112 
113 
114 //
115 // ☆ベースエンコーディング指定マクロ
116 //
117 
118 // コンパイル時に指定するのが面倒な場合は以下のコメント行から適切な指定を
119 // (コメントを解除して)有効にしてください。いっさい指定がなされない場合で
120 // も自動判別されますが、正確に判断されなっかたり判別の為に(余分)コードが
121 // 生成されたりする可能性があります。
122 //
123 //#define __UNICODE_CHAR_SIZE_2__
124 //#define __UNICODE_CHAR_SIZE_4__
125 
126 # if !(defined(__UNICODE_CHAR_SIZE_2__) || defined(__UNICODE_CHAR_SIZE_4__))
127 # define __UNICODE_CHAR_SIZE_UNKNOWN__
128 # endif
129 
130 
131 //
132 // ☆エンディアン指定マクロ
133 //
134 
135 // コンパイル時に指定するのが面倒な場合は以下のコメント行から適切な指定を
136 // (コメントを解除して)有効にしてください。いっさい指定がなされない場合で
137 // も自動判別されますが、正確に判断されなっかたり判別の為に(余分)コードが
138 // 生成されたりする可能性があります。
139 //
140 //#define __LITTLE_ENDIAN_COMPUTER__
141 //#define __BIG_ENDIAN_COMPUTER__
142 
143 # if !(defined(__LITTLE_ENDIAN_COMPUTER__) || defined(__BIG_ENDIAN_COMPUTER__))
144 # define __UNKNOWN_ENDIAN_COMPUTER__
145 # endif
146 
147 
148 //
149 // ☆ベースエンコーディング指定マクロ
150 //
151 
152 // コンパイル時に指定するのが面倒な場合は以下のコメント行から適切な指定を
153 // (コメントを解除して)有効にしてください。いっさい指定がなされない場合で
154 // も自動判別されますが、正確に判断されなっかたり判別の為に(余分)コードが
155 // 生成されたりする可能性があります。
156 //
157 //#define __USING_ANSI__
158 //#define __USING_SJIS__
159 //#define __USING_EUC__
160 //#define __USING_UTF8__
161 
162 # if !(defined(__USING_ANSI__) || defined(__USING_SJIS__) || defined(__USING_EUC__) || defined(__USING_UTF8__) || defined(__USING_UNKNOWN__))
163 # define __USING_UNKNOWN__
164 # endif
165 
166 
167 //
168 // ☆デフォルト文字列型指定マクロ
169 //
170 
171 // コンパイル時に指定するのが面倒な場合は以下のコメント行から適切な指定を
172 // (コメントを解除して)有効にしてください。指定された型が各種テンプレート
173 // のデフォルトの型として定義され、(一部の)テンプレートを使用する際に型の
174 // 指定を省略できます。
175 //
176 //#define __BBL_STRING_DEFAULT__
177 //#define __BBL_WSTRING_DEFAULT__
178 
179 # if !(defined(__BBL_STRING_DEFAULT__) || defined(__BBL_WSTRING_DEFAULT__))
180 # define __BBL_STRING_DEFAULT__
181 # endif
182 
183 
184 //
185 // ☆精密変換指定マクロ
186 //
187 
188 // コンパイル時に指定するのが面倒な場合は以下のコメント行を(コメントを解除
189 // して)有効にしてください。このマクロが指定されると EUC 及び JIS から SJIS
190 // への変換を UNICODE を経由して行います。UNICODE を経由することにより SJIS
191 // でも表現可能な一部の補助漢字を正しくマッピングします。ただし、UNICODE
192 // を経由する分処理速度は落ちます。また、__BBL_DISABLE_UNICODE__ が定義さ
193 // れていないことが前提となります。
194 //
195 //#define __BBL_STRICT_TRANSLATE__
196 
197 
198 //
199 // ☆マッピング実装方法指定マクロ
200 //
201 
202 // コンパイル時に指定するのが面倒な場合は以下のコメント行から適切な指定を
203 // (コメントを解除して)有効にしてください。デフォルトのマッピングに関して
204 // は実装指定マクロが定義されていなくても実装されます。
205 //
206 //#define __BBL_USING_STATIC_TABLE__
207 //#define __BBL_USING_STDMAP_TABLE__
208 
209 # if defined(__BBL_USING_STATIC_TABLE__) && defined(__BBL_USING_STDMAP_TABLE__)
210 # error マッピング実装方法指定マクロはどれか一つにしてください。
211 # endif
212 
213 # if !(defined(__BBL_USING_STATIC_TABLE__) || defined(__BBL_USING_STDMAP_TABLE__))
214 # define __BBL_USING_STATIC_TABLE__
215 # endif
216 
217 
218 
219 //
220 // ☆UNICODE⇔Shift_JISマッピング実装指定マクロ
221 //
222 
223 // コンパイル時に指定するのが面倒な場合は以下のコメント行から適切な指定を
224 // (コメントを解除して)有効にしてください。デフォルトのマッピングに関して
225 // は実装指定マクロが定義されていなくても実装されます。
226 //
227 // cf. 各種UNICODEマッピングについて
228 // http://tricklib.com/cxx/ex/babel/#unicode_map
229 //
230 //#define __BBL_LOAD_UNICODE_MAP_CP932__
231 //#define __BBL_LOAD_UNICODE_MAP_UTC__
232 //#define __BBL_LOAD_UNICODE_MAP_APPLE__
233 
234 
235 //
236 // ☆UNICODE⇔Shift_JISマッピングデフォルト指定マクロ
237 //
238 
239 // コンパイル時に指定するのが面倒な場合は以下のコメント行から適切な指定を
240 // (コメントを解除して)有効にしてください。
241 //
242 // cf. 各種UNICODEマッピングについて
243 // http://tricklib.com/cxx/ex/babel/#unicode_map
244 //
245 //#define __BBL_USE_UNICODE_MAP_CP932__
246 //#define __BBL_USE_UNICODE_MAP_UTC__
247 //#define __BBL_USE_UNICODE_MAP_APPLE__
248 
249 # if defined(__BBL_USE_UNICODE_MAP_CP932__) && defined(__BBL_USE_UNICODE_MAP_UTC__) || \
250  defined(__BBL_USE_UNICODE_MAP_CP932__) && defined(__BBL_USE_UNICODE_MAP_APPLE__) || \
251  defined(__BBL_USE_UNICODE_MAP_UTC__) && defined(__BBL_USE_UNICODE_MAP_APPLE__)
252 # error UNICODE⇔Shift_JISマッピングデフォルト指定マクロはどれか一つにしてください。
253 # endif
254 
255 # if !(defined(__BBL_USE_UNICODE_MAP_CP932__) || defined(__BBL_USE_UNICODE_MAP_UTC__) || defined(__BBL_USE_UNICODE_MAP_APPLE__))
256 # define __BBL_USE_UNICODE_MAP_CP932__
257 # endif
258 
259 // 逆意定義
260 
261 # if defined(__BBL_USE_UNICODE_MAP_CP932__) && !defined(__BBL_LOAD_UNICODE_MAP_CP932__)
262 # define __BBL_LOAD_UNICODE_MAP_CP932__
263 # endif
264 
265 # if defined(__BBL_USE_UNICODE_MAP_UTC__) && !defined(__BBL_LOAD_UNICODE_MAP_UTC__)
266 # define __BBL_LOAD_UNICODE_MAP_UTC__
267 # endif
268 
269 # if defined(__BBL_USE_UNICODE_MAP_APPLE__) && !defined(__BBL_LOAD_UNICODE_MAP_APPLE__)
270 # define __BBL_LOAD_UNICODE_MAP_APPLE__
271 # endif
272 
273 
274 //
275 // ☆Private Use Area コード除去回避指定マクロ
276 //
277 
278 // コンパイル時に指定するのが面倒な場合は以下のコメント行を(コメントを解除
279 // して)有効にしてください。デフォルトの動作ではUNICODE文字列(UTF-8を含む)
280 // を非UNICODE文字列(SJIS,JIS,EUC)に変換する際、Private Use Area の文字コー
281 // ドは除去されますが、このマクロが指定されている場合は除去しません。(ただし
282 // Private Use Area の文字コードは一般的に非UNICODE文字列に正しく変換でき
283 // ませんので babel::bbl_term::broken_char に置き換えられるだけです。)
284 
285 //
286 //#define __BBL_DISABLE_DISPEL_PRIVATE_USE_AREA__
287 
288 
289 //
290 // ☆実装拒否指定マクロ
291 //
292 
293 // コンパイル時に指定するのが面倒な場合は以下のコメント行から適切な指定を
294 // (コメントを解除して)有効にしてください。デフォルトのマッピングに関して
295 // は実装指定マクロが定義されていなくても実装されます。
296 //
297 //#define __BBL_DISABLE_UNICODE__
298 //#define __BBL_DISABLE_BINARY__
299 #define __BBL_DISABLE_UTF32__ // UTF-32 の実装を他では見かけないのでバベルでも(実装してもあまり意味がないので)デフォルトでは off 。
300 //#define __BBL_DISABLE_SELECTORS__
301 
302 // 依存関係
303 
304 # if defined(__BBL_DISABLE_UNICODE__)
305 # if defined(__BBL_LOAD_UNICODE_MAP_CP932__)
306 # undef __BBL_LOAD_UNICODE_MAP_CP932__
307 # endif
308 # if defined(__BBL_LOAD_UNICODE_MAP_UTC__)
309 # undef __BBL_LOAD_UNICODE_MAP_UTC__
310 # endif
311 # if defined(__BBL_LOAD_UNICODE_MAP_APPLE__)
312 # undef __BBL_LOAD_UNICODE_MAP_APPLE__
313 # endif
314 # if defined(__BBL_STRICT_TRANSLATE__)
315 # undef __BBL_STRICT_TRANSLATE__
316 # endif
317 # if !defined(__BBL_DISABLE_BINARY__)
318 # define __BBL_DISABLE_BINARY__
319 # endif
320 # if !defined(__BBL_DISABLE_UTF32__)
321 # define __BBL_DISABLE_UTF32__
322 # endif
323 # endif
324 
325 # if defined(__BBL_DISABLE_BINARY__)
326 # if !defined(__BBL_DISABLE_UTF32__)
327 # define __BBL_DISABLE_UTF32__
328 # endif
329 # endif
330 
331 // 逆意定義
332 
333 # if !defined(__BBL_DISABLE_UNICODE__)
334 # if !defined(__BBL_USE_UNICODE__)
335 # define __BBL_USE_UNICODE__
336 # endif
337 # endif
338 
339 # if !defined(__BBL_DISABLE_BINARY__)
340 # if !defined(__BBL_USE_BINARY__)
341 # define __BBL_USE_BINARY__
342 # endif
343 # endif
344 
345 # if !defined(__BBL_DISABLE_UTF32__)
346 # if !defined(__BBL_USE_UTF32__)
347 # define __BBL_USE_UTF32__
348 # endif
349 # endif
350 
351 # if !defined(__BBL_DISABLE_SELECTORS__)
352 # if !defined(__BBL_USE_SELECTORS__)
353 # define __BBL_USE_SELECTORS__
354 # endif
355 # endif
356 
357 
358 //
359 // EnBOM/DeBOM処理実装方法
360 //
361 
362 //#define __BBL_SMALL_BOM_LOGIC__
363 #define __BBL_LARGE_BOM_LOGIC__
364 
365 
366 /******************************************************************************
367  □■□■ TrickPalace □■□■
368  ■□■□ http://www.trickpalace.net/ ■□■□
369 ******************************************************************************/
370 
371 # if defined(__BORLANDC__)
372 # pragma warn -8027
373 # endif
374 
375 
376 //
377 // ●babel
378 //
379 namespace babel {
380 
381 // ★バベルモジュール初期化関数★
382 void init_babel();
383 
384 
385 //
386 // クラス化関数基本クラステンプレート(として demi を使う)
387 //
388  template<class T> class bbl_demi {
389  public:
390  T value;
391 
392  bbl_demi() {}
393  bbl_demi(const T &X_value) :value(X_value) {}
394  bbl_demi(const bbl_demi<T> &X) :value(X.value) {}
395 
396  operator T& () { return value; }
397  operator const T& () const { return value; }
398 
399  T * operator & () { return &value; }
400  const T * operator & () const { return &value; }
401 
402  T & operator () () { return value; }
403  const T & operator () () const { return value; }
404  };
405  //
406  // cf. http://tricklib.com/cxx/dagger/tips.h
407  //
408 
409 //
410 // ▼使用する文字列クラス [ 〆 ]
411 //
412 }
413 #include <string>
414 
415 //
416 // バベルに対するバグベアードの適用
417 //
418 #if defined(__BABEL_WITH_BUG__)
419 //
420 // ステートメントハックＯＮ！
421 //
422 #define __BUG_STATEMENT_HACK__ // ステートメントハックの指定
423 #include "..\bugbeard\bug.h"
424 #endif // defined(__BABEL_WITH_BUG__)
425 
426 namespace babel {
427 typedef std::string bbl_binary;
428 typedef std::string bbl_string;
429 #if defined(__BBL_USE_UNICODE__)
430 // typedef std::wstring bbl_wstring; // g++ のヽ(｀Д´)ノボケェ！
431 typedef std::basic_string<wchar_t> bbl_wstring;
432 #endif // defined(__BBL_USE_UNICODE__)
433 
434 inline const bbl_string & binary_to_string(const bbl_binary &X) { return X; }
435 inline const bbl_binary & string_to_binary(const bbl_string &X) { return X; }
436 
437 #if defined(__BBL_STRING_DEFAULT__)
438 typedef bbl_string bbl_default_string;
439 #else
440 typedef bbl_wstring bbl_default_string;
441 #endif
442 
443 
444 //
445 // ●ターム [ 〆 ]
446 //
447 namespace bbl_term {
448  const bbl_string broken_char = "?"; // ２文字以上でも可、ANSI以外は不可。
449  const bbl_string empty = "";
450 #if defined(__BBL_USE_UNICODE__)
451  const bbl_wstring broken_wchar = L"?"; // ２文字以上でも可、ANSI以外は不可。
452  const bbl_wstring wempty = L"";
453 #endif // defined(__BBL_USE_UNICODE__)
454 #if defined(__BBL_USE_UNICODE__)
455  const bbl_string utf8_FEFF = "\xEF\xBB\xBF";
456 // const bbl_wstring unicode_bom = L"\uFEFF"; // g++ のヽ(｀Д´)ノボケェ！
457  const bbl_wstring unicode_bom((bbl_wstring::size_type)1, (bbl_wstring::value_type)0xFEFF);
458 #endif // defined(__BBL_USE_UNICODE__)
459  const bbl_string babel_version = "information>\n"
460  "\tmodule>\tid=babel\n"
461  "\t\tname=バベル -babel- \n"
462  "\t\turl=http://tricklib.com/cxx/ex/babel/\n"
463  "\t\tversion=ベータ\n"
464  "\tauthor>\tid=wraith\n"
465  "\t\tname=道化師\n"
466  "\t\turl=http://www.trickpalace.net/\n"
467  "\t\tmail=wraith@trickpalace.net\n";
468 
469  struct get_broken_char {
470  operator const bbl_string &() const { return broken_char; }
471 #if defined(__BBL_USE_UNICODE__)
472  operator const bbl_wstring &() const { return broken_wchar; }
473 #endif // defined(__BBL_USE_UNICODE__)
474  };
475 
476 #if defined(__BBL_USE_UNICODE__)
477  struct get_bom {
478  operator const bbl_string &() const { return utf8_FEFF; }
479  operator const bbl_wstring &() const { return unicode_bom; }
480  };
481 #endif // defined(__BBL_USE_UNICODE__)
482 
483  struct get_empty {
484  operator const bbl_string &() const { return empty; }
485 #if defined(__BBL_USE_UNICODE__)
486  operator const bbl_wstring &() const { return wempty; }
487 #endif // defined(__BBL_USE_UNICODE__)
488  };
489 }
490 
491 /******************************************************************************
492  □■□■ cppll ML □■□■
493  ■□■□ http://www.trickpalace.net/cppll/ ■□■□
494 ******************************************************************************/
495 
496 #if defined(__BBL_USE_UNICODE__)
497 inline const int get_base_wstring_size() {
498  return sizeof(bbl_wstring::value_type);
499 }
500 #endif // defined(__BBL_USE_UNICODE__)
501 
502 namespace base_endian {
503  enum {
504  unknown,
505  little_endian,
506  big_endian,
507  bi_endian,
508  };
509 };
510 inline const int get_base_endian() {
511  using namespace base_endian;
512 #ifdef __LITTLE_ENDIAN_COMPUTER__
513  return little_endian;
514 #endif
515 #ifdef __BIG_ENDIAN_COMPUTER__
516  return big_endian;
517 #endif
518 #ifdef __UNKNOWN_ENDIAN_COMPUTER__
519  const int fingerprint = 0x01;
520  return 0x01 == *((char*)&fingerprint) ? little_endian: big_endian;
521 #endif
522 }
523 
524 namespace base_encoding {
525  enum {
526  unknown,
527  binary,
528  ansi,
529  sjis,
530  jis,
531  euc,
532  iso2022jp,
533  utf8,
534  utf16be,
535  utf16le,
536  utf32be,
537  utf32le,
538 #ifdef __LITTLE_ENDIAN_COMPUTER__
539  utf16 = utf16le,
540  utf32 = utf32le,
541 #endif
542 #ifdef __BIG_ENDIAN_COMPUTER__
543  utf16 = utf16be,
544  utf32 = utf32be,
545 #endif
546 #ifdef __UNKNOWN_ENDIAN_COMPUTER__
547  utf16,
548  utf32,
549 #endif
550 #ifdef __UNICODE_CHAR_SIZE_2__
551  unicode = utf16,
552 #endif
553 #ifdef __UNICODE_CHAR_SIZE_4__
554  unicode = utf32,
555 #endif
556 #ifdef __UNICODE_CHAR_SIZE_UNKNOWN__
557  unicode,
558 #endif
559  };
560 };
561 
562 // ↓ちょっと遊んでただけから気にしないで。
563 
564 /*
565 template<class T, int size> class auto_array_class :public bbl_demi<T[size]>{
566  public:
567  auto_array_class(const T *X_value) {
568  for(int i = 0; i < size; ++i) {
569  value[i] = X_value[i];
570  }
571  }
572  auto_array_class(const T *X_value, const T &X_value_end) {
573  for(int i = 0; i < size -1; ++i) {
574  value[i] = X_value[i];
575  }
576  value[size -1] = X_value_end;
577  }
578  auto_array_class<T, size +1> operator()(const T &X_value) {
579  return auto_array_class<T, size +1>(value, X_value);
580  }
581 
582  T & operator [] (unsigned int index) { return value[index]; }
583  const T & operator [] (unsigned int index) const { return value[index]; }
584 };
585 template<class T> auto_array_class<T, 1> auto_array(const T &X_value) {
586  return auto_array_class<T, 1>(&X_value);
587 }
588 */
589 
590 /*
591 template<class T, int size> class auto_array_class :public bbl_demi<T>{
592  unsigned int index;
593  public:
594  auto_array_class(unsigned int X_index, const T &X_value) :index(X_index), bbl_demi(X_value) {
595  }
596  auto_array_class<T, size +1> operator()(const T &X_value) {
597  return auto_array_class<T, size +1>(index, (index == size) ? X_value: value);
598  }
599 };
600 template<class T> auto_array_class<T, 0> auto_array(unsigned int index, const T &default_value = T()) {
601  return auto_array_class<T, 0>(index, default_value);
602 }
603 */
604 
605 /*
606 template<class T> const T & get_array_item(unsigned int index, const T &first_item...) {
607  if (0 == index) {
608  return first_item;
609  }
610  va_list X;
611  va_start(X, first_item);
612  for(unsinged int i = 1; i < index; ++i) {
613  va_arg(X, T);
614  }
615  const T &item = va_arg(X, T);
616  va_end(X);
617  return item;
618 
619 // return *(index + &first_item);
620 }
621 */
622 
623 // ↑ちょっと遊んでただけから気にしないで。
624 
625 
626 namespace profile_for_UI {
627  // get_list_size_for_UI(), get_id_for_UI(), get_name_for_UI() は三つで
628  // セットの関数です。ユーザにエンコードを指定させる場合にご活用ください。
629  inline const unsigned int get_list_size_for_UI() {
630 #if defined(__BBL_USE_UNICODE__)
631  return 5;
632 #else // defined(__BBL_USE_UNICODE__)
633 # if defined(__BBL_USE_UTF32__)
634  return 8;
635 # else // defined(__BBL_USE_UTF32__)
636  return 10;
637 # endif // defined(__BBL_USE_UTF32__)
638 #endif // defined(__BBL_USE_UNICODE__)
639  }
640  inline const int get_id_for_UI(unsigned int index) {
641  assert(index < get_list_size_for_UI());
642  using namespace base_encoding;
643  const int id_for_UI[] = {
644  ansi,
645  sjis,
646  jis,
647  euc,
648  iso2022jp,
649 #if defined(__BBL_USE_UNICODE__)
650  utf8,
651  utf16be,
652  utf16le,
653 # if defined(__BBL_USE_UTF32__)
654  utf32be,
655  utf32le,
656 # endif // defined(__BBL_USE_UTF32__)
657 #endif // defined(__BBL_USE_UNICODE__)
658  };
659  assert(sizeof(id_for_UI) /sizeof(id_for_UI[0]) == get_list_size_for_UI());
660  return id_for_UI[index];
661  // return auto_array(ansi)(sjis)(jis)(euc)(iso2022jp)(utf8)
662  // (utf16be)(utf16le)(utf32be)(utf32le)[index];
663  // return get_array_item(index, ansi, sjis, jis, euc, iso2022jp, utf8,
664  // utf16be, utf16le, utf32be, utf32le);
665  }
666  inline const bbl_string get_name_for_UI(unsigned int index) {
667  assert(index < get_list_size_for_UI());
668  const char * name_for_UI[] = {
669  "ANSI",
670  "シフトJIS",
671  "JIS(半角カナ可)",
672  "EUC-JP",
673  "ISO-2022-JP",
674 #if defined(__BBL_USE_UNICODE__)
675  "UTF-8",
676  "UTF-16",
677  "UTF-16le",
678 # if defined(__BBL_USE_UTF32__)
679  "UTF-32",
680  "UTF-32le",
681 # endif // defined(__BBL_USE_UTF32__)
682 #endif // defined(__BBL_USE_UNICODE__)
683  };
684  return name_for_UI[index];
685  // return auto_array("ANSI")("シフトJIS")("JIS(半角カナ可)")("EUC-JP")
686  // ("ISO-2022-JP")("UTF-8")("UTF-16")
687  // ("UTF-16le")("UTF-32")("UTF-32le")[index];
688  }
689 
690  // get_base_encoding_name()はエンコードのIDから表示用の文字列を取得する為
691  // の関数ですが、get_name_for_UI()と混同しないように気をつけてください。
692  inline const bbl_string get_base_encoding_name(unsigned int index) {
693  const char *base_encoding_name[] = {
694  "不明",
695  "バイナリ",
696  "ANSI",
697  "シフトJIS",
698  "JIS(半角カナ可)",
699  "EUC-JP",
700  "ISO-2022-JP",
701  "UTF-8",
702  "UTF-16be",
703  "UTF-16le",
704  "UTF-32be",
705  "UTF-32le",
706  "UTF-16",
707  "UTF-32",
708  };
709  return base_encoding_name[index];
710  }
711 }
712 
713 
714 inline const int get_base_encoding() {
715  using namespace base_encoding;
716 #ifdef __USING_ANSI__
717  return ansi;
718 #endif
719 #ifdef __USING_SJIS__
720  return sjis;
721 #endif
722 #ifdef __USING_EUC__
723  return euc;
724 #endif
725 #ifdef __USING_UTF8__
726  return utf8;
727 #endif
728 #ifdef __USING_UNKNOWN__
729  const int fingerprint = ((unsigned char*)("漢字"))[0];
730  if (0x8A == fingerprint) {
731  return sjis;
732  }
733  if (0x84 == fingerprint) {
734  return euc;
735  }
736  if (0xE6 == fingerprint) {
737  return utf8;
738  }
739  return ansi;
740 #endif
741 }
742 
743 
744 bbl_binary::size_type get_aspect_position(const bbl_binary &X);
745 
746 class analyze_result {
747  typedef int value_type;
748  const value_type hunch_result;
749  const value_type strict_result;
750  public:
751  analyze_result(const value_type X_hunch_result)
752  :hunch_result(X_hunch_result), strict_result(X_hunch_result) { }
753  analyze_result(
754  const value_type X_hunch_result,
755  const value_type X_strict_result)
756  :hunch_result(X_hunch_result), strict_result(X_strict_result) { }
757  const int & get_hunch_result() const { return hunch_result; }
758  const int & get_strict_result() const { return strict_result; }
759  operator const int &() const { return get_hunch_result(); }
760 };
761 analyze_result analyze_base_encoding(const bbl_binary &X, const unsigned int max_scan_size = 8192);
762 
763 class bbl_smart_base {
764  public:
765  typedef bbl_smart_base this_type;
766  private:
767  volatile int ref_count;
768  protected:
769  bbl_smart_base() :ref_count(0) {}
770  virtual ~bbl_smart_base() { assert(0 == ref_count); }
771 
772  public:
773  void inc_ref() volatile {
774  if (NULL != this) {
775  ++ref_count;
776  }
777  }
778  void dec_ref() volatile {
779  if (NULL != this) {
780  if (--ref_count <= 0) {
781  assert(0 == ref_count);
782  delete this;
783  }
784  }
785  }
786 };
787 template<class target_object>
788 class bbl_smart_shell {
789  public:
790  typedef bbl_smart_shell<target_object> this_type;
791  typedef target_object target_type;
792 
793  private:
794  target_type *value;
795 
796  public:
797  bbl_smart_shell(target_type *X_value = NULL) :value(X_value) {
798  value->inc_ref();
799  }
800  bbl_smart_shell(const this_type &X) :value(X.value) {
801  value->inc_ref();
802  }
803  ~bbl_smart_shell() {
804  value->dec_ref();
805  }
806 
807  this_type & operator = (target_type *X_value) {
808  if (value != X_value) {
809  value->dec_ref();
810  value = X_value;
811  value->inc_ref();
812  }
813  return *this;
814  }
815  this_type & operator = (const this_type &X) {
816  if (value != X.value) {
817  value->dec_ref();
818  value = X.value;
819  value->inc_ref();
820  }
821  return *this;
822  }
823 
824  bool operator == (const this_type &X) const {
825  return value == X.value;
826  }
827  bool operator != (const this_type &X) const {
828  return value != X.value;
829  }
830  bool operator == (const target_type *X_value) const {
831  return value == X_value;
832  }
833  bool operator != (const target_type *X_value) const {
834  return value != X_value;
835  }
836 
837  bool operator ! () const { return !value; }
838  operator target_type* () { return value; }
839  operator const target_type* () const { return value; }
840  target_type& operator*() { return *value; }
841  const target_type& operator*() const { return *value; }
842  target_type* operator->() { return value; }
843  const target_type* operator->() const { return value; }
844  bool is_null() const { return NULL == value; }
845  bool is_not_null() const { return NULL != value; }
846 };
847 
848 template<class from_string = bbl_default_string, class to_string = bbl_default_string> class bbl_translater;
849 
850 template<class from_string = bbl_default_string, class to_string = bbl_default_string>
851 class bbl_translate_engine :public bbl_smart_base {
852  public:
853  typedef bbl_translate_engine<from_string, to_string> this_type;
854  typedef bbl_translater<from_string, to_string> bbl_translater_type;
855  typedef from_string from_string_type;
856  typedef to_string to_string_type;
857 // friend class bbl_translater_type;
858  friend class bbl_translater<from_string, to_string>; // VC のヽ(｀Д´)ノアホォ！
859  protected:
860  from_string_type untranslated_buffer;
861  to_string_type translated_buffer;
862  public:
863  virtual void translate() = 0;
864  virtual void flush() {
865  for(int i = 0, length = untranslated_buffer.length(); i < length; ++i) {
866  translated_buffer += bbl_term::get_broken_char();
867  }
868  untranslated_buffer = bbl_term::get_empty();
869  }
870  virtual void clear() {
871  untranslated_buffer = bbl_term::get_empty();
872  translated_buffer = bbl_term::get_empty();
873  }
874 
875  const to_string_type & ignite(const from_string_type &X) {
876  untranslated_buffer = X;
877  translate();
878  flush();
879  return translated_buffer;
880  }
881 };
882 
883 //
884 // ■無能変換エンジン
885 //
886 template<class from_string = bbl_default_string, class to_string = bbl_default_string>
887 class dull_engine :public bbl_translate_engine<from_string, to_string> {
888  public:
889  typedef dull_engine<from_string, to_string> this_type;
890  typedef bbl_translate_engine<from_string, to_string> base_type;
891  typedef typename base_type::bbl_translater_type bbl_translater_type;
892 // typedef typename base_type::from_string_type from_string_type;
893 // typedef typename base_type::to_string_type to_string_type;
894  typedef from_string from_string_type; // bcc のヽ(｀Д´)ノばかぁ！
895  typedef to_string to_string_type; // bcc のヽ(｀Д´)ノばかぁ！
896  private:
897  dull_engine() {}
898  public: // ←無駄な警告回避の為 ... g++ のヽ(｀Д´)ノボケェ！
899  ~dull_engine() {} // bcc のヽ(｀Д´)ノばかぁ！
900  protected:
901  void translate() { }
902  void flush() { base_type::untranslated_buffer = bbl_term::get_empty(); }
903  public:
904 static bbl_translater_type create() { return new this_type; }
905 static const to_string_type ignite(const from_string_type &X) { return bbl_term::get_empty(); }
906 };
907 
908 template<class first_engine, class second_engine> class twin_translate_engine;
909 
910 //
911 // ■コード変換クラス(エンジンのシェル)
912 //
913 template<class from_string, class to_string> // 先行宣言で既に指定しているのでここではデフォルトを指定しない。
914 class bbl_translater {
915  public:
916  typedef bbl_translater this_type;
917  typedef bbl_translate_engine<from_string, to_string> engine_type;
918  typedef dull_engine<from_string, to_string> dull_engine_type;
919  typedef from_string from_string_type;
920  typedef to_string to_string_type;
921 
922  private:
923  bbl_smart_shell<engine_type> engine;
924  public:
925  bbl_translater(engine_type *X_engine) :engine(X_engine) { }
926  bbl_translater(const bbl_translater &X = dull_engine_type::create())
927  :engine(X.engine) { }
928  ~bbl_translater() { }
929 
930  bbl_translater & operator = (engine_type *X_engine) {
931  engine = X_engine;
932  return *this;
933  }
934  bbl_translater & operator = (const bbl_translater &X) {
935  engine = X.engine;
936  return *this;
937  }
938  bool operator == (const bbl_translater &X) const {
939  return engine == X.engine;
940  }
941  bool operator != (const bbl_translater &X) const {
942  return engine != X.engine;
943  }
944 
945  this_type & translate(const from_string_type &X) {
946  engine->untranslated_buffer += X;
947  engine->translate();
948  return *this;
949  }
950  this_type & flush() {
951  //engine->translate();
952  engine->flush();
953  return *this;
954  }
955  this_type & clear() {
956  engine->clear();
957  //↓必ずしもバッファがクリアされるとは限らないのでこの二つの assert はコメントアウトしました。
958  //assert(0 == engine->untranslated_buffer.length());
959  //assert(0 == engine->translated_buffer.length());
960  return *this;
961  }
962 
963  this_type & operator = (const from_string_type &X) { return clear().translate(X).flush(); }
964  operator const to_string_type & () const { return get_string(); }
965  const to_string_type & get_string() const { return engine->translated_buffer; }
966  const char * c_str() const { return get_string().c_str(); }
967  const to_string_type pook_buffer() {
968  to_string_type buffer = engine->translated_buffer;
969 // engine->translated_buffer.clear(); // g++ のヽ(｀Д´)ノボケェ！
970  engine->translated_buffer.erase();
971  return buffer;
972  }
973 
974  this_type & operator << (const from_string_type &X) { return translate(X); }
975  this_type & operator >> (to_string_type &X) {
976  X = engine->translated_buffer;
977 // engine->translated_buffer.clear(); // g++ のヽ(｀Д´)ノボケェ！
978  engine->translated_buffer.erase();
979  return *this;
980  }
981  const to_string_type & operator () (const from_string_type &X) {
982  return clear().translate(X).flush().get_string();
983  }
984 };
985 
986 template<class target_string = bbl_default_string>
987 class through_engine :public bbl_translate_engine<target_string, target_string> {
988  public:
989  typedef through_engine<target_string> this_type;
990  typedef bbl_translate_engine<target_string, target_string> base_type;
991  typedef typename base_type::bbl_translater_type bbl_translater_type;
992  typedef typename base_type::from_string_type from_string_type;
993  typedef typename base_type::to_string_type to_string_type;
994 // private: // VC のヽ(｀Д´)ノアホォ！
995  protected:
996  through_engine() {}
997  protected:
998  void translate() {
999  base_type::translated_buffer += base_type::untranslated_buffer;
1000 // untranslated_buffer.clear(); // g++ のヽ(｀Д´)ノボケェ！
1001  base_type::untranslated_buffer.erase();
1002  }
1003  void flush() { }
1004  public:
1005 static bbl_translater_type create() { return new this_type; }
1006 // static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1007 static const to_string_type & ignite(const from_string_type &X) { return X; }
1008 };
1009 
1010 #if defined(__BBL_USE_UNICODE__)
1011 class ansi_to_unicode_engine :public bbl_translate_engine<bbl_string, bbl_wstring> {
1012  public:
1013  typedef ansi_to_unicode_engine this_type;
1014  typedef bbl_translate_engine<bbl_string, bbl_wstring> base_type;
1015  typedef base_type::bbl_translater_type bbl_translater_type;
1016  typedef base_type::from_string_type from_string_type;
1017  typedef base_type::to_string_type to_string_type;
1018 // private: // VC のヽ(｀Д´)ノアホォ！
1019  protected:
1020  ansi_to_unicode_engine() { }
1021  protected:
1022  void translate();
1023  public:
1024 static bbl_translater_type create() { return new this_type; }
1025 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1026 };
1027 
1028 class unicode_to_ansi_engine :public bbl_translate_engine<bbl_wstring, bbl_string> {
1029  public:
1030  typedef unicode_to_ansi_engine this_type;
1031  typedef bbl_translate_engine<bbl_wstring, bbl_string> base_type;
1032  typedef base_type::bbl_translater_type bbl_translater_type;
1033  typedef base_type::from_string_type from_string_type;
1034  typedef base_type::to_string_type to_string_type;
1035 // private: // VC のヽ(｀Д´)ノアホォ！
1036  protected:
1037  unicode_to_ansi_engine() { }
1038  protected:
1039  void translate();
1040  public:
1041 static bbl_translater_type create() { return new this_type; }
1042 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1043 };
1044 #endif // defined(__BBL_USE_UNICODE__)
1045 
1046 class sjis_to_euc_engine :public bbl_translate_engine<bbl_string, bbl_string> {
1047  public:
1048  typedef sjis_to_euc_engine this_type;
1049  typedef bbl_translate_engine<bbl_string, bbl_string> base_type;
1050  typedef base_type::bbl_translater_type bbl_translater_type;
1051  typedef base_type::from_string_type from_string_type;
1052  typedef base_type::to_string_type to_string_type;
1053 // private: // VC のヽ(｀Д´)ノアホォ！
1054  protected:
1055  sjis_to_euc_engine() { }
1056  protected:
1057  void translate();
1058  public:
1059 static bbl_translater_type create() { return new this_type; }
1060 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1061 };
1062 class sjis_to_jis_engine :public bbl_translate_engine<bbl_string, bbl_string> {
1063  public:
1064  typedef sjis_to_jis_engine this_type;
1065  typedef bbl_translate_engine<bbl_string, bbl_string> base_type;
1066  typedef base_type::bbl_translater_type bbl_translater_type;
1067  typedef base_type::from_string_type from_string_type;
1068  typedef base_type::to_string_type to_string_type;
1069 // private: // VC のヽ(｀Д´)ノアホォ！
1070  protected:
1071  int status;
1072  sjis_to_jis_engine() :status(0) { }
1073  protected:
1074  void translate();
1075  void flush();
1076  void clear() {
1077  base_type::clear();
1078  status = 0;
1079  }
1080  public:
1081 static bbl_translater_type create() { return new this_type; }
1082 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1083 };
1084 
1085 #if defined(__BBL_USE_UNICODE__)
1086 # if defined(__BBL_USE_UNICODE_MAP_CP932__)
1087 class unicode_to_sjis_cp932_engine;
1088 typedef unicode_to_sjis_cp932_engine unicode_to_sjis_engine;
1089 class sjis_cp932_to_unicode_engine;
1090 typedef sjis_cp932_to_unicode_engine sjis_to_unicode_engine;
1091 # endif
1092 # if defined(__BBL_USE_UNICODE_MAP_UTC__)
1093 class unicode_to_sjis_utc_engine;
1094 typedef unicode_to_sjis_utc_engine unicode_to_sjis_engine;
1095 class sjis_utc_to_unicode_engine;
1096 typedef sjis_utc_to_unicode_engine sjis_to_unicode_engine;
1097 # endif
1098 # if defined(__BBL_USE_UNICODE_MAP_APPLE__)
1099 class unicode_to_sjis_apple_engine;
1100 typedef unicode_to_sjis_apple_engine unicode_to_sjis_engine;
1101 class sjis_apple_to_unicode_engine
1102 typedef sjis_apple_to_unicode_engine sjis_to_unicode_engine;
1103 # endif
1104 #endif // defined(__BBL_USE_UNICODE__)
1105 
1106 #if defined(__BBL_STRICT_TRANSLATE__)
1107 class euc_to_unicode_engine;
1108 typedef twin_translate_engine<euc_to_unicode_engine, unicode_to_sjis_engine> euc_to_sjis_engine;
1109 #else // defined(__BBL_STRICT_TRANSLATE__);
1110 class euc_to_sjis_engine :public bbl_translate_engine<bbl_string, bbl_string> {
1111  public:
1112  typedef euc_to_sjis_engine this_type;
1113  typedef bbl_translate_engine<bbl_string, bbl_string> base_type;
1114  typedef base_type::bbl_translater_type bbl_translater_type;
1115  typedef base_type::from_string_type from_string_type;
1116  typedef base_type::to_string_type to_string_type;
1117 // private: // VC のヽ(｀Д´)ノアホォ！
1118  protected:
1119  euc_to_sjis_engine() { }
1120  protected:
1121  void translate();
1122  public:
1123 static bbl_translater_type create() { return new this_type; }
1124 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1125 };
1126 #endif // defined(__BBL_STRICT_TRANSLATE__);
1127 class euc_to_jis_engine :public bbl_translate_engine<bbl_string, bbl_string> {
1128  public:
1129  typedef euc_to_jis_engine this_type;
1130  typedef bbl_translate_engine<bbl_string, bbl_string> base_type;
1131  typedef base_type::bbl_translater_type bbl_translater_type;
1132  typedef base_type::from_string_type from_string_type;
1133  typedef base_type::to_string_type to_string_type;
1134 // private: // VC のヽ(｀Д´)ノアホォ！
1135  protected:
1136  int status;
1137  euc_to_jis_engine() :status(0) { }
1138  protected:
1139  void translate();
1140  void flush();
1141  void clear() {
1142  base_type::clear();
1143  status = 0;
1144  }
1145  public:
1146 static bbl_translater_type create() { return new this_type; }
1147 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1148 };
1149 
1150 #if defined(__BBL_USE_UNICODE__)
1151 class euc_to_unicode_engine :public bbl_translate_engine<bbl_string, bbl_wstring> {
1152  public:
1153  typedef euc_to_unicode_engine this_type;
1154  typedef bbl_translate_engine<bbl_string, bbl_wstring> base_type;
1155  typedef base_type::bbl_translater_type bbl_translater_type;
1156  typedef base_type::from_string_type from_string_type;
1157  typedef base_type::to_string_type to_string_type;
1158 // private: // VC のヽ(｀Д´)ノアホォ！
1159  protected:
1160  euc_to_unicode_engine() {
1161 #ifdef __BBL_SMALL_BOM_LOGIC__
1162  translated_buffer = bbl_term::unicode_bom;
1163 #endif // __BBL_SMALL_BOM_LOGIC__
1164  }
1165  protected:
1166  void translate();
1167 #ifdef __BBL_SMALL_BOM_LOGIC__
1168  void clear() {
1169  base_type::clear();
1170  translated_buffer = bbl_term::unicode_bom;
1171  }
1172 #endif // __BBL_SMALL_BOM_LOGIC__
1173  public:
1174 static bbl_translater_type create() { return new this_type; }
1175 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1176 };
1177 class unicode_to_euc_engine :public bbl_translate_engine<bbl_wstring, bbl_string> {
1178  public:
1179  typedef unicode_to_euc_engine this_type;
1180  typedef bbl_translate_engine<bbl_wstring, bbl_string> base_type;
1181  typedef base_type::bbl_translater_type bbl_translater_type;
1182  typedef base_type::from_string_type from_string_type;
1183  typedef base_type::to_string_type to_string_type;
1184 // private: // VC のヽ(｀Д´)ノアホォ！
1185  protected:
1186  unicode_to_euc_engine() { }
1187  protected:
1188  void translate();
1189  public:
1190 static bbl_translater_type create() { return new this_type; }
1191 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1192 };
1193 #endif // defined(__BBL_USE_UNICODE__)
1194 
1195 #if defined(__BBL_STRICT_TRANSLATE__)
1196 class jis_to_euc_engine;
1197 typedef twin_translate_engine<jis_to_euc_engine, euc_to_sjis_engine> jis_to_sjis_engine;
1198 #else // defined(__BBL_STRICT_TRANSLATE__);
1199 class jis_to_sjis_engine :public bbl_translate_engine<bbl_string, bbl_string> {
1200  public:
1201  typedef jis_to_sjis_engine this_type;
1202  typedef bbl_translate_engine<bbl_string, bbl_string> base_type;
1203  typedef base_type::bbl_translater_type bbl_translater_type;
1204  typedef base_type::from_string_type from_string_type;
1205  typedef base_type::to_string_type to_string_type;
1206 // private: // VC のヽ(｀Д´)ノアホォ！
1207  protected:
1208  int status;
1209  jis_to_sjis_engine() :status(0) { }
1210  protected:
1211  void translate();
1212  void flush();
1213  void clear() {
1214  base_type::clear();
1215  status = 0;
1216  }
1217  public:
1218 static bbl_translater_type create() { return new this_type; }
1219 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1220 };
1221 #endif // defined(__BBL_STRICT_TRANSLATE__)
1222 class jis_to_euc_engine :public bbl_translate_engine<bbl_string, bbl_string> {
1223  public:
1224  typedef jis_to_euc_engine this_type;
1225  typedef bbl_translate_engine<bbl_string, bbl_string> base_type;
1226  typedef base_type::bbl_translater_type bbl_translater_type;
1227  typedef base_type::from_string_type from_string_type;
1228  typedef base_type::to_string_type to_string_type;
1229 // private: // VC のヽ(｀Д´)ノアホォ！
1230  protected:
1231  int status;
1232  jis_to_euc_engine() :status(0) { }
1233  protected:
1234  void translate();
1235  void flush();
1236  void clear() {
1237  base_type::clear();
1238  status = 0;
1239  }
1240  public:
1241 static bbl_translater_type create() { return new this_type; }
1242 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1243 };
1244 class jis_to_iso2022jp_engine :public bbl_translate_engine<bbl_string, bbl_string> {
1245  public:
1246  typedef jis_to_iso2022jp_engine this_type;
1247  typedef bbl_translate_engine<bbl_string, bbl_string> base_type;
1248  typedef base_type::bbl_translater_type bbl_translater_type;
1249  typedef base_type::from_string_type from_string_type;
1250  typedef base_type::to_string_type to_string_type;
1251 // private: // VC のヽ(｀Д´)ノアホォ！
1252  protected:
1253  int from_status;
1254  int to_status;
1255  jis_to_iso2022jp_engine() :from_status(0), to_status(0) { }
1256  protected:
1257  void translate();
1258  void flush();
1259  void clear() {
1260  base_type::clear();
1261  from_status = 0;
1262  to_status = 0;
1263  }
1264  public:
1265 static bbl_translater_type create() { return new this_type; }
1266 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1267 };
1268 
1269 #if defined(__BBL_LOAD_UNICODE_MAP_CP932__)
1270 class sjis_cp932_to_unicode_engine :public bbl_translate_engine<bbl_string, bbl_wstring> {
1271  public:
1272  typedef sjis_cp932_to_unicode_engine this_type;
1273  typedef bbl_translate_engine<bbl_string, bbl_wstring> base_type;
1274  typedef base_type::bbl_translater_type bbl_translater_type;
1275  typedef base_type::from_string_type from_string_type;
1276  typedef base_type::to_string_type to_string_type;
1277 // private: // VC のヽ(｀Д´)ノアホォ！
1278  protected:
1279  sjis_cp932_to_unicode_engine() {
1280 #ifdef __BBL_SMALL_BOM_LOGIC__
1281  translated_buffer = bbl_term::unicode_bom;
1282 #endif // __BBL_SMALL_BOM_LOGIC__
1283  }
1284  protected:
1285  void translate();
1286 #ifdef __BBL_SMALL_BOM_LOGIC__
1287  void clear() {
1288  base_type::clear();
1289  translated_buffer = bbl_term::unicode_bom;
1290  }
1291 #endif // __BBL_SMALL_BOM_LOGIC__
1292  public:
1293 static bbl_translater_type create() { return new this_type; }
1294 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1295 };
1296 class unicode_to_sjis_cp932_engine :public bbl_translate_engine<bbl_wstring, bbl_string> {
1297  public:
1298  typedef unicode_to_sjis_cp932_engine this_type;
1299  typedef bbl_translate_engine<bbl_wstring, bbl_string> base_type;
1300  typedef base_type::bbl_translater_type bbl_translater_type;
1301  typedef base_type::from_string_type from_string_type;
1302  typedef base_type::to_string_type to_string_type;
1303 // private: // VC のヽ(｀Д´)ノアホォ！
1304  protected:
1305  unicode_to_sjis_cp932_engine() { }
1306  protected:
1307  void translate();
1308  public:
1309 static bbl_translater_type create() { return new this_type; }
1310 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1311 };
1312 #endif // defined(__BBL_LOAD_UNICODE_MAP_CP932__)
1313 
1314 #if defined(__BBL_LOAD_UNICODE_MAP_UTC__)
1315 class sjis_utc_to_unicode_engine :public bbl_translate_engine<bbl_string, bbl_wstring> {
1316  public:
1317  typedef sjis_utc_to_unicode_engine this_type;
1318  typedef bbl_translate_engine<bbl_string, bbl_wstring> base_type;
1319  typedef base_type::bbl_translater_type bbl_translater_type;
1320  typedef base_type::from_string_type from_string_type;
1321  typedef base_type::to_string_type to_string_type;
1322 // private: // VC のヽ(｀Д´)ノアホォ！
1323  protected:
1324  sjis_utc_to_unicode_engine() {
1325 #ifdef __BBL_SMALL_BOM_LOGIC__
1326  translated_buffer = bbl_term::unicode_bom;
1327 #endif // __BBL_SMALL_BOM_LOGIC__
1328  }
1329  protected:
1330  void translate();
1331 #ifdef __BBL_SMALL_BOM_LOGIC__
1332  void clear() {
1333  base_type::clear();
1334  translated_buffer = bbl_term::unicode_bom;
1335  }
1336 #endif // __BBL_SMALL_BOM_LOGIC__
1337  public:
1338 static bbl_translater_type create() { return new this_type; }
1339 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1340 };
1341 class unicode_to_sjis_utc_engine :public bbl_translate_engine<bbl_wstring, bbl_string> {
1342  public:
1343  typedef unicode_to_sjis_utc_engine this_type;
1344  typedef bbl_translate_engine<bbl_wstring, bbl_string> base_type;
1345  typedef base_type::bbl_translater_type bbl_translater_type;
1346  typedef base_type::from_string_type from_string_type;
1347  typedef base_type::to_string_type to_string_type;
1348 // private: // VC のヽ(｀Д´)ノアホォ！
1349  protected:
1350  unicode_to_sjis_utc_engine() { }
1351  protected:
1352  void translate();
1353  public:
1354 static bbl_translater_type create() { return new this_type; }
1355 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1356 };
1357 #endif // defined(__BBL_LOAD_UNICODE_MAP_UTC__)
1358 
1359 #if defined(__BBL_LOAD_UNICODE_MAP_APPLE__)
1360 class sjis_apple_to_unicode_engine :public bbl_translate_engine<bbl_string, bbl_wstring> {
1361  public:
1362  typedef sjis_apple_to_unicode_engine this_type;
1363  typedef bbl_translate_engine<bbl_string, bbl_wstring> base_type;
1364  typedef base_type::bbl_translater_type bbl_translater_type;
1365  typedef base_type::from_string_type from_string_type;
1366  typedef base_type::to_string_type to_string_type;
1367 // private: // VC のヽ(｀Д´)ノアホォ！
1368  protected:
1369  sjis_apple_to_unicode_engine() {
1370 #ifdef __BBL_SMALL_BOM_LOGIC__
1371  translated_buffer = bbl_term::unicode_bom;
1372 #endif // __BBL_SMALL_BOM_LOGIC__
1373  }
1374  protected:
1375  void translate();
1376 #ifdef __BBL_SMALL_BOM_LOGIC__
1377  void clear() {
1378  base_type::clear();
1379  translated_buffer = bbl_term::unicode_bom;
1380  }
1381 #endif // __BBL_SMALL_BOM_LOGIC__
1382  public:
1383 static bbl_translater_type create() { return new this_type; }
1384 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1385 };
1386 class unicode_to_sjis_apple_engine :public bbl_translate_engine<bbl_wstring, bbl_string> {
1387  public:
1388  typedef unicode_to_sjis_apple_engine this_type;
1389  typedef bbl_translate_engine<bbl_wstring, bbl_string> base_type;
1390  typedef base_type::bbl_translater_type bbl_translater_type;
1391  typedef base_type::from_string_type from_string_type;
1392  typedef base_type::to_string_type to_string_type;
1393 // private: // VC のヽ(｀Д´)ノアホォ！
1394  protected:
1395  unicode_to_sjis_apple_engine() { }
1396  protected:
1397  void translate();
1398  void flush();
1399  public:
1400 static bbl_translater_type create() { return new this_type; }
1401 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1402 };
1403 #endif // defined(__BBL_LOAD_UNICODE_MAP_APPLE__)
1404 
1405 #if defined(__BBL_USE_UNICODE__)
1406 class unicode_to_utf8_engine :public bbl_translate_engine<bbl_wstring, bbl_string> {
1407  public:
1408  typedef unicode_to_utf8_engine this_type;
1409  typedef bbl_translate_engine<bbl_wstring, bbl_string> base_type;
1410  typedef base_type::bbl_translater_type bbl_translater_type;
1411  typedef base_type::from_string_type from_string_type;
1412  typedef base_type::to_string_type to_string_type;
1413 // private: // VC のヽ(｀Д´)ノアホォ！
1414  protected:
1415  unicode_to_utf8_engine() { }
1416  protected:
1417  void translate();
1418  public:
1419 static bbl_translater_type create() { return new this_type; }
1420 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1421 };
1422 class utf8_to_unicode_engine :public bbl_translate_engine<bbl_string, bbl_wstring> {
1423  public:
1424  typedef utf8_to_unicode_engine this_type;
1425  typedef bbl_translate_engine<bbl_string, bbl_wstring> base_type;
1426  typedef base_type::bbl_translater_type bbl_translater_type;
1427  typedef base_type::from_string_type from_string_type;
1428  typedef base_type::to_string_type to_string_type;
1429 // private: // VC のヽ(｀Д´)ノアホォ！
1430  protected:
1431  utf8_to_unicode_engine() { }
1432  protected:
1433  void translate();
1434  public:
1435 static bbl_translater_type create() { return new this_type; }
1436 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1437 };
1438 
1439 #ifdef __BBL_LARGE_BOM_LOGIC__
1440 template<class target_string = bbl_default_string>
1441 class enbom_engine :public through_engine<target_string> {
1442  public:
1443  typedef enbom_engine<target_string> this_type;
1444  typedef through_engine<target_string> base_type;
1445  typedef typename base_type::bbl_translater_type bbl_translater_type;
1446  typedef typename base_type::from_string_type from_string_type;
1447  typedef typename base_type::to_string_type to_string_type;
1448  private:
1449  enbom_engine() {
1450  base_type::translated_buffer = bbl_term::get_bom();
1451  }
1452  protected:
1453  void clear() {
1454  base_type::clear();
1455  base_type::translated_buffer = bbl_term::get_bom();
1456  }
1457  public:
1458 static bbl_translater_type create() { return new this_type; }
1459 //static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); } // VC のヽ(｀Д´)ノアホォ！
1460 static const to_string_type ignite(const from_string_type &X) { return enbom_engine<target_string>().through_engine<target_string>::ignite(X); }
1461 };
1462 
1463 template<class target_string = bbl_default_string>
1464 class debom_engine :public through_engine<target_string> {
1465  public:
1466  typedef debom_engine<target_string> this_type;
1467  typedef through_engine<target_string> base_type;
1468  typedef typename base_type::bbl_translater_type bbl_translater_type;
1469  typedef typename base_type::from_string_type from_string_type;
1470  typedef typename base_type::to_string_type to_string_type;
1471  private:
1472  debom_engine() {}
1473  protected:
1474  void translate() {
1475  typename from_string_type::size_type p_bom;
1476  while(from_string_type::npos != (p_bom = base_type::untranslated_buffer.find(bbl_term::get_bom()))) {
1477  base_type::untranslated_buffer.erase(p_bom, 1);
1478  }
1479  base_type::translate();
1480  }
1481  public:
1482 static bbl_translater_type create() { return new this_type; }
1483 //static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); } // VC のヽ(｀Д´)ノアホォ！
1484 static const to_string_type ignite(const from_string_type &X) { return debom_engine<target_string>().through_engine<target_string>::ignite(X); }
1485 };
1486 #endif // __BBL_LARGE_BOM_LOGIC__
1487 
1488 
1489 #endif // defined(__BBL_USE_UNICODE__)
1490 
1491 const int translate_buffer_full_size = 1024; // 8〜4096
1492 const int translate_buffer_size = 1000; // translate_buffer_full_size -α
1493 //const int translate_buffer_full_size = 128; // 8〜4096
1494 //const int translate_buffer_size = 100; // translate_buffer_full_size -α
1495 
1496 //
1497 // ■合成変換エンジン
1498 //
1499 template<class first_engine, class second_engine>
1500 class twin_translate_engine :public bbl_translate_engine<typename first_engine::from_string_type, typename second_engine::to_string_type> {
1501  public:
1502  typedef twin_translate_engine<first_engine, second_engine> this_type;
1503  typedef first_engine first_engine_type;
1504  typedef second_engine second_engine_type;
1505  typedef bbl_translate_engine<typename first_engine::from_string_type, typename second_engine::to_string_type> base_type;
1506  typedef typename base_type::bbl_translater_type bbl_translater_type;
1507  typedef typename base_type::from_string_type from_string_type;
1508  typedef typename base_type::to_string_type to_string_type;
1509 // private: // VC のヽ(｀Д´)ノアホォ！
1510  protected:
1511  typename first_engine_type::bbl_translater_type engine1;
1512  typename second_engine_type::bbl_translater_type engine2;
1513 
1514  twin_translate_engine()
1515  :engine1(first_engine_type::create()),
1516  engine2(second_engine_type::create()) { }
1517 
1518  protected:
1519  void translate() {
1520  engine1.translate(base_type::untranslated_buffer);
1521 // untranslated_buffer.clear(); // g++ のヽ(｀Д´)ノボケェ！
1522  base_type::untranslated_buffer.erase();
1523  engine2.translate(engine1.pook_buffer());
1524  base_type::translated_buffer += engine2.pook_buffer();
1525  }
1526  void flush() {
1527  engine1.flush();
1528 
1529 // untranslated_buffer.clear(); // g++ のヽ(｀Д´)ノボケェ！
1530  base_type::untranslated_buffer.erase();
1531  engine2.translate(engine1.pook_buffer()).flush();
1532  base_type::translated_buffer += engine2.pook_buffer();
1533  }
1534  void clear() {
1535  base_type::clear();
1536  engine1.clear();
1537  engine2.clear();
1538  }
1539  public:
1540 static bbl_translater_type create() { return new this_type; }
1541 static const to_string_type ignite(const from_string_type &X) {
1542  return second_engine_type::ignite(first_engine_type::ignite(X));
1543 // return this_type().base_type::ignite(X);
1544  }
1545 };
1546 
1547 #if defined(__BBL_USE_UNICODE__)
1548 typedef twin_translate_engine<jis_to_euc_engine, euc_to_unicode_engine> jis_to_unicode_engine;
1549 typedef twin_translate_engine<unicode_to_euc_engine, euc_to_jis_engine> unicode_to_jis_engine;
1550 typedef twin_translate_engine<sjis_to_unicode_engine, unicode_to_utf8_engine> sjis_to_utf8_engine;
1551 typedef twin_translate_engine<euc_to_unicode_engine, unicode_to_utf8_engine> euc_to_utf8_engine;
1552 typedef twin_translate_engine<jis_to_unicode_engine, unicode_to_utf8_engine> jis_to_utf8_engine;
1553 typedef twin_translate_engine<utf8_to_unicode_engine, unicode_to_sjis_engine> utf8_to_sjis_engine;
1554 typedef twin_translate_engine<utf8_to_unicode_engine, unicode_to_euc_engine> utf8_to_euc_engine;
1555 typedef twin_translate_engine<utf8_to_euc_engine, euc_to_jis_engine> utf8_to_jis_engine;
1556 //typedef twin_translate_engine<euc_to_sjis_engine, sjis_to_unicode_engine> euc_to_unicode_engine;
1557 //typedef twin_translate_engine<unicode_to_sjis_engine, sjis_to_euc_engine> unicode_to_euc_engine;
1558 #endif // defined(__BBL_USE_UNICODE__)
1559 
1560 //
1561 // □コード変換関数(エイリアス)
1562 //
1563 const bbl_string (* const sjis_to_euc)(const bbl_string &) = sjis_to_euc_engine::ignite;
1564 const bbl_string (* const sjis_to_jis)(const bbl_string &) = sjis_to_jis_engine::ignite;
1565 const bbl_string (* const euc_to_sjis)(const bbl_string &) = euc_to_sjis_engine::ignite;
1566 const bbl_string (* const euc_to_jis)(const bbl_string &) = euc_to_jis_engine::ignite;
1567 const bbl_string (* const jis_to_sjis)(const bbl_string &) = jis_to_sjis_engine::ignite;
1568 const bbl_string (* const jis_to_euc)(const bbl_string &) = jis_to_euc_engine::ignite;
1569 const bbl_string (* const jis_to_iso2022jp)(const bbl_string &) = jis_to_iso2022jp_engine::ignite;
1570 #if defined(__BBL_USE_UNICODE__)
1571 const bbl_string (* const sjis_to_utf8)(const bbl_string &) = sjis_to_utf8_engine::ignite;
1572 const bbl_wstring (* const sjis_to_unicode)(const bbl_string &) = sjis_to_unicode_engine::ignite;
1573 const bbl_string (* const euc_to_utf8)(const bbl_string &) = euc_to_utf8_engine::ignite;
1574 const bbl_wstring (* const euc_to_unicode)(const bbl_string &) = euc_to_unicode_engine::ignite;
1575 const bbl_string (* const jis_to_utf8)(const bbl_string &) = jis_to_utf8_engine::ignite;
1576 const bbl_wstring (* const jis_to_unicode)(const bbl_string &) = jis_to_unicode_engine::ignite;
1577 const bbl_string (* const utf8_to_sjis)(const bbl_string &) = utf8_to_sjis_engine::ignite;
1578 const bbl_string (* const utf8_to_euc)(const bbl_string &) = utf8_to_euc_engine::ignite;
1579 const bbl_string (* const utf8_to_jis)(const bbl_string &) = utf8_to_jis_engine::ignite;
1580 const bbl_wstring (* const utf8_to_unicode)(const bbl_string &) = utf8_to_unicode_engine::ignite;
1581 const bbl_string (* const unicode_to_sjis)(const bbl_wstring &) = unicode_to_sjis_engine::ignite;
1582 const bbl_string (* const unicode_to_euc)(const bbl_wstring &) = unicode_to_euc_engine::ignite;
1583 const bbl_string (* const unicode_to_jis)(const bbl_wstring &) = unicode_to_jis_engine::ignite;
1584 const bbl_string (* const unicode_to_utf8)(const bbl_wstring &) = unicode_to_utf8_engine::ignite;
1585 #endif // defined(__BBL_USE_UNICODE__)
1586 
1587 
1588 /******************************************************************************
1589  □■□■ cuppa □■□■
1590  ■□■□ http://www.unittest.org/ ■□■□
1591 ******************************************************************************/
1592 
1593 #if defined(__BBL_USE_BINARY__)
1594 class WORD_to_unicode_engine :public bbl_translate_engine<bbl_binary, bbl_wstring> {
1595  public:
1596  typedef WORD_to_unicode_engine this_type;
1597  typedef bbl_translate_engine<bbl_binary, bbl_wstring> base_type;
1598  typedef base_type::bbl_translater_type bbl_translater_type;
1599  typedef base_type::from_string_type from_string_type;
1600  typedef base_type::to_string_type to_string_type;
1601 // private: // VC のヽ(｀Д´)ノアホォ！
1602  protected:
1603  WORD_to_unicode_engine() { }
1604  protected:
1605  void translate();
1606  void flush();
1607  public:
1608 static bbl_translater_type create() { return new this_type; }
1609 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1610 };
1611 class unicode_to_WORD_engine :public bbl_translate_engine<bbl_wstring, bbl_binary> {
1612  public:
1613  typedef unicode_to_WORD_engine this_type;
1614  typedef bbl_translate_engine<bbl_wstring, bbl_binary> base_type;
1615  typedef base_type::bbl_translater_type bbl_translater_type;
1616  typedef base_type::from_string_type from_string_type;
1617  typedef base_type::to_string_type to_string_type;
1618 // private: // VC のヽ(｀Д´)ノアホォ！
1619  protected:
1620  unicode_to_WORD_engine() { }
1621  protected:
1622  void translate();
1623  void flush();
1624  public:
1625 static bbl_translater_type create() { return new this_type; }
1626 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1627 };
1628 class cross_WORD_to_unicode_engine :public bbl_translate_engine<bbl_binary, bbl_wstring> {
1629  public:
1630  typedef cross_WORD_to_unicode_engine this_type;
1631  typedef bbl_translate_engine<bbl_binary, bbl_wstring> base_type;
1632  typedef base_type::bbl_translater_type bbl_translater_type;
1633  typedef base_type::from_string_type from_string_type;
1634  typedef base_type::to_string_type to_string_type;
1635 // private: // VC のヽ(｀Д´)ノアホォ！
1636  protected:
1637  cross_WORD_to_unicode_engine() { }
1638  protected:
1639  void translate();
1640  void flush();
1641  public:
1642 static bbl_translater_type create() { return new this_type; }
1643 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1644 };
1645 class unicode_to_cross_WORD_engine :public bbl_translate_engine<bbl_wstring, bbl_binary> {
1646  public:
1647  typedef unicode_to_cross_WORD_engine this_type;
1648  typedef bbl_translate_engine<bbl_wstring, bbl_binary> base_type;
1649  typedef base_type::bbl_translater_type bbl_translater_type;
1650  typedef base_type::from_string_type from_string_type;
1651  typedef base_type::to_string_type to_string_type;
1652 // private: // VC のヽ(｀Д´)ノアホォ！
1653  protected:
1654  unicode_to_cross_WORD_engine() { }
1655  protected:
1656  void translate();
1657  void flush();
1658  public:
1659 static bbl_translater_type create() { return new this_type; }
1660 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1661 };
1662 
1663 const bbl_wstring WORD_to_unicode(const bbl_binary &X);
1664 const bbl_binary unicode_to_WORD(const bbl_wstring &X);
1665 const bbl_wstring cross_WORD_to_unicode(const bbl_binary &X);
1666 const bbl_binary unicode_to_cross_WORD(const bbl_wstring &X);
1667 
1668 inline const unsigned int WORD_cross_endian(const unsigned int &X) {
1669  assert(X <= 0xFFFF);
1670  return ((X &0x00FF) *0x100)
1671  |(X /0x100);
1672 }
1673 
1674 
1675 # if defined(__BBL_USE_UTF32__)
1676 class DWORD_to_unicode_engine :public bbl_translate_engine<bbl_binary, bbl_wstring> {
1677  public:
1678  typedef DWORD_to_unicode_engine this_type;
1679  typedef bbl_translate_engine<bbl_binary, bbl_wstring> base_type;
1680  typedef base_type::bbl_translater_type bbl_translater_type;
1681  typedef base_type::from_string_type from_string_type;
1682  typedef base_type::to_string_type to_string_type;
1683 // private: // VC のヽ(｀Д´)ノアホォ！
1684  protected:
1685  DWORD_to_unicode_engine() { }
1686  protected:
1687  void translate();
1688  void flush();
1689  public:
1690 static bbl_translater_type create() { return new this_type; }
1691 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1692 };
1693 class unicode_to_DWORD_engine :public bbl_translate_engine<bbl_wstring, bbl_binary> {
1694  public:
1695  typedef unicode_to_DWORD_engine this_type;
1696  typedef bbl_translate_engine<bbl_wstring, bbl_binary> base_type;
1697  typedef base_type::bbl_translater_type bbl_translater_type;
1698  typedef base_type::from_string_type from_string_type;
1699  typedef base_type::to_string_type to_string_type;
1700 // private: // VC のヽ(｀Д´)ノアホォ！
1701  protected:
1702  unicode_to_DWORD_engine() { }
1703  protected:
1704  void translate();
1705  void flush();
1706  public:
1707 static bbl_translater_type create() { return new this_type; }
1708 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1709 };
1710 class cross_DWORD_to_unicode_engine :public bbl_translate_engine<bbl_binary, bbl_wstring> {
1711  public:
1712  typedef cross_DWORD_to_unicode_engine this_type;
1713  typedef bbl_translate_engine<bbl_binary, bbl_wstring> base_type;
1714  typedef base_type::bbl_translater_type bbl_translater_type;
1715  typedef base_type::from_string_type from_string_type;
1716  typedef base_type::to_string_type to_string_type;
1717 // private: // VC のヽ(｀Д´)ノアホォ！
1718  protected:
1719  cross_DWORD_to_unicode_engine() { }
1720  protected:
1721  void translate();
1722  void flush();
1723  public:
1724 static bbl_translater_type create() { return new this_type; }
1725 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1726 };
1727 class unicode_to_cross_DWORD_engine :public bbl_translate_engine<bbl_wstring, bbl_binary> {
1728  public:
1729  typedef unicode_to_cross_DWORD_engine this_type;
1730  typedef bbl_translate_engine<bbl_wstring, bbl_binary> base_type;
1731  typedef base_type::bbl_translater_type bbl_translater_type;
1732  typedef base_type::from_string_type from_string_type;
1733  typedef base_type::to_string_type to_string_type;
1734 // private: // VC のヽ(｀Д´)ノアホォ！
1735  protected:
1736  unicode_to_cross_DWORD_engine() { }
1737  protected:
1738  void translate();
1739  void flush();
1740  public:
1741 static bbl_translater_type create() { return new this_type; }
1742 static const to_string_type ignite(const from_string_type &X) { return this_type().base_type::ignite(X); }
1743 };
1744 
1745 const bbl_wstring DWORD_to_unicode(const bbl_binary &X);
1746 const bbl_binary unicode_to_DWORD(const bbl_wstring &X);
1747 const bbl_wstring cross_DWORD_to_unicode(const bbl_binary &X);
1748 const bbl_binary unicode_to_cross_DWORD(const bbl_wstring &X);
1749 
1750 inline const unsigned int DWORD_cross_endian(const unsigned int &X) {
1751  return (X *0x1000000)
1752  |((X &0x0000FF00) *0x100)
1753  |((X &0x00FF0000) /0x100)
1754  |(X /0x1000000);
1755 }
1756 # endif //defined(__BBL_USE_UTF32__)
1757 
1758 #endif // defined(__BBL_USE_BINARY__)
1759 
1760 
1761 #if defined(__BBL_USE_SELECTORS__)
1762 //
1763 // ■translate_to_string-, auto_translate-, translate_to_binary-, manual_translate-
1764 //
1765 
1766 // □使い分け
1767 //
1768 // translate_engine get_translate_engine(目的, エンコードタイプが分かっている = false) {
1769 // switch(目的) {
1770 // case 入力:
1771 // if(エンコードタイプが分かっている) {
1772 // return translate_to_string_engine;
1773 // } else {
1774 // return auto_translate_engine;
1775 // }
1776 //
1777 // case 出力:
1778 // return translate_to_binary_engine;
1779 //
1780 // default:
1781 // return manual_translate_engine;
1782 // }
1783 // }
1784 
1785 // □クラス階層図
1786 //
1787 // [manual_translate_engine]
1788 // 　│
1789 // 　├─[translate_to_string_engine]
1790 // 　│　　│
1791 // 　│　　└─[auto_translate_engine]
1792 // 　│
1793 // 　└─[translate_to_binary_engine]
1794 //
1795 
1796 
1797 // クラスメンバ
1798 // コンストラクタ
1799 // traslate系
1800 // order系
1801 // 簡易関数インターフェイス
1802 
1803 template<class from_string = bbl_default_string, class to_string = bbl_default_string>
1804 class manual_translate_engine :public bbl_translate_engine<from_string, to_string> {
1805  public:
1806  typedef manual_translate_engine this_type;
1807  typedef bbl_translate_engine<from_string, to_string> base_type;
1808  typedef typename base_type::bbl_translater_type bbl_translater_type;
1809  typedef typename base_type::from_string_type from_string_type;
1810  typedef typename base_type::to_string_type to_string_type;
1811 // private: // VC のヽ(｀Д´)ノアホォ！
1812  protected:
1813  bbl_translater_type engine;
1814  manual_translate_engine(int from_base_encoding, int to_base_encoding = babel::get_base_encoding())
1815  :engine(this_type::order(from_base_encoding, to_base_encoding)) {}
1816 #ifdef __BBL_LARGE_BOM_LOGIC__
1817  manual_translate_engine(const bbl_translater_type & X_engine)
1818  :engine(X_engine) {}
1819 #endif // __BBL_LARGE_BOM_LOGIC__
1820  protected:
1821  void translate() {
1822  engine.translate(base_type::untranslated_buffer);
1823 // untranslated_buffer.clear(); // g++ のヽ(｀Д´)ノボケェ！
1824  base_type::untranslated_buffer.erase();
1825  base_type::translated_buffer += engine.pook_buffer();
1826  }
1827  void flush() {
1828  engine.flush();
1829 // untranslated_buffer.clear(); // g++ のヽ(｀Д´)ノボケェ！
1830  base_type::untranslated_buffer.erase();
1831  base_type::translated_buffer += engine.pook_buffer();
1832  }
1833  void clear() {
1834  base_type::clear();
1835  engine.clear();
1836  }
1837  public:
1838 static bbl_translater_type create(int from_base_encoding, int to_base_encoding = babel::get_base_encoding()) {
1839  return new this_type(from_base_encoding, to_base_encoding);
1840  }
1841 //static const to_string_type ignite(
1842 // const from_string_type &X, int from_base_encoding, int to_base_encoding = babel::get_base_encoding()) {
1843 // return this_type(from_base_encoding, to_base_encoding).base_type::ignite(X);
1844 // }
1845 static const to_string_type ignite(const from_string_type &X, int from_base_encoding, int to_base_encoding = babel::get_base_encoding());
1846 static bbl_translater_type order(int from_base_encoding, int to_base_encoding = babel::get_base_encoding());
1847 };
1848 
1849 // specialize の先行宣言
1850 
1851 template<>
1852 manual_translate_engine<bbl_string, bbl_string>::bbl_translater_type
1853 manual_translate_engine<bbl_string, bbl_string>::order(int X_from_base_encoding, int X_to_base_encoding);
1854 
1855 template<>
1856 const bbl_string manual_translate_engine<bbl_string, bbl_string>::ignite(const bbl_string &X, int X_from_base_encoding, int X_to_base_encoding);
1857 
1858 # if defined(__BBL_USE_UNICODE__)
1859 template<>
1860 manual_translate_engine<bbl_string, bbl_wstring>::bbl_translater_type
1861 manual_translate_engine<bbl_string, bbl_wstring>::order(int X_from_base_encoding, int X_to_base_encoding);
1862 
1863 template<>
1864 const bbl_wstring manual_translate_engine<bbl_string, bbl_wstring>::ignite(const bbl_string &X, int X_from_base_encoding, int X_to_base_encoding);
1865 
1866 template<>
1867 manual_translate_engine<bbl_wstring, bbl_string>::bbl_translater_type
1868 manual_translate_engine<bbl_wstring, bbl_string>::order(int X_from_base_encoding, int X_to_base_encoding);
1869 
1870 template<>
1871 const bbl_string manual_translate_engine<bbl_wstring, bbl_string>::ignite(const bbl_wstring &X, int X_from_base_encoding, int X_to_base_encoding);
1872 
1873 template<>
1874 manual_translate_engine<bbl_wstring, bbl_wstring>::bbl_translater_type
1875 manual_translate_engine<bbl_wstring, bbl_wstring>::order(int X_from_base_encoding, int X_to_base_encoding);
1876 
1877 template<>
1878 const bbl_wstring manual_translate_engine<bbl_wstring, bbl_wstring>::ignite(const bbl_wstring &X, int X_from_base_encoding, int X_to_base_encoding);
1879 # endif // defined(__BBL_USE_UNICODE__)
1880 
1881 
1882 template<class string_type = bbl_default_string>
1883 class translate_to_string_engine :public manual_translate_engine<bbl_binary, string_type> {
1884 //
1885 // このクラスは from_string_type が bbl_binary に固定されている以外は機能的に
1886 // manual_translate_engine と全く同一です。
1887 //
1888 // ・・・このクラスには将来的にBOM関連の小細工を施すかもしれません。
1889 //
1890 public:
1891  typedef translate_to_string_engine<string_type> this_type;
1892  typedef manual_translate_engine<bbl_binary, string_type> parent_type;
1893  typedef bbl_translate_engine<bbl_binary, string_type> base_type;
1894  typedef typename base_type::bbl_translater_type bbl_translater_type;
1895  typedef typename base_type::from_string_type from_string_type;
1896  typedef typename base_type::to_string_type to_string_type;
1897 // private: // VC のヽ(｀Д´)ノアホォ！
1898  protected:
1899 #ifdef __BBL_LARGE_BOM_LOGIC__
1900  translate_to_string_engine(int from_base_encoding, int to_base_encoding = babel::get_base_encoding())
1901  :parent_type(this_type::order(from_base_encoding, to_base_encoding)) {}
1902 #else // __BBL_LARGE_BOM_LOGIC__
1903  translate_to_string_engine(int from_base_encoding, int to_base_encoding = babel::get_base_encoding())
1904  :parent_type(from_base_encoding, to_base_encoding) {}
1905 #endif // __BBL_LARGE_BOM_LOGIC__
1906  protected:
1907  public:
1908 #ifdef __BBL_LARGE_BOM_LOGIC__
1909 static bbl_translater_type create(int from_base_encoding, int to_base_encoding = babel::get_base_encoding()) {
1910  return new this_type(from_base_encoding, to_base_encoding);
1911  }
1912 static const to_string_type ignite(const from_string_type &X, int from_base_encoding, int to_base_encoding = babel::get_base_encoding());
1913 static bbl_translater_type order(int from_base_encoding, int to_base_encoding = babel::get_base_encoding());
1914 #endif // __BBL_LARGE_BOM_LOGIC__
1915 };
1916 
1917 
1918 template<class to_string = bbl_default_string>
1919 class auto_translate_engine :public translate_to_string_engine<to_string> {
1920  public:
1921  typedef auto_translate_engine this_type;
1922  typedef translate_to_string_engine<to_string> base_type;
1923  typedef typename base_type::bbl_translater_type bbl_translater_type;
1924  typedef typename base_type::from_string_type from_string_type;
1925  typedef typename base_type::to_string_type to_string_type;
1926 // private: // VC のヽ(｀Д´)ノアホォ！
1927  protected:
1928  int from_base_encoding, to_base_encoding;
1929  auto_translate_engine(int X_to_base_encoding = babel::get_base_encoding())
1930  :base_type(X_to_base_encoding, X_to_base_encoding), from_base_encoding(X_to_base_encoding), to_base_encoding(X_to_base_encoding) {}
1931  protected:
1932  void translate() {
1933  int new_from_base_encoding = analyze_base_encoding(base_type::untranslated_buffer);
1934  if (from_base_encoding != new_from_base_encoding) {
1935  from_base_encoding = new_from_base_encoding;
1936  base_type::engine = base_type::order(from_base_encoding, to_base_encoding);
1937  } else {
1938 // engine.clear();
1939  }
1940  base_type::engine.translate(base_type::untranslated_buffer);
1941 // untranslated_buffer.clear(); // g++ のヽ(｀Д´)ノボケェ！
1942  base_type::untranslated_buffer.erase();
1943  base_type::translated_buffer = base_type::engine.pook_buffer();
1944  }
1945  public:
1946 static bbl_translater_type create(int X_to_base_encoding = babel::get_base_encoding()) {
1947  return new this_type(X_to_base_encoding);
1948  }
1949 static const to_string_type ignite(const from_string_type &X, int X_to_base_encoding = babel::get_base_encoding()) {
1950 #if defined(__BORLANDC__)
1951  // 理由はよくわからんが↓こうしておかないと Borland のコンパイラはトチ狂ったコードを吐く。
1952  this_type temp(X_to_base_encoding);
1953  return temp.base_type::ignite(X, analyze_base_encoding(X), X_to_base_encoding);
1954 #else
1955  return this_type(X_to_base_encoding).base_type::ignite(X, analyze_base_encoding(X), X_to_base_encoding);
1956 #endif
1957  }
1958 };
1959 
1960 
1961 template<class from_string = bbl_default_string, class to_string = bbl_default_string>
1962 class manual_translate :public bbl_demi<to_string> {
1963  public:
1964  manual_translate(const from_string &X, int from_base_encoding, int to_base_encoding = babel::get_base_encoding())
1965  :bbl_demi<to_string>(manual_translate_engine<from_string, to_string>::ignite(X, from_base_encoding, to_base_encoding)) { }
1966 };
1967 
1968 template<class to_string = bbl_default_string>
1969 class translate_to_string :public bbl_demi<to_string> {
1970  public:
1971  translate_to_string(const bbl_binary &X, int from_base_encoding, int to_base_encoding = babel::get_base_encoding())
1972  :bbl_demi<to_string>(translate_to_string_engine<to_string>::ignite(X, from_base_encoding, to_base_encoding)) { }
1973 };
1974 
1975 template<class to_string = bbl_default_string>
1976 class auto_translate :public bbl_demi<to_string> {
1977  public:
1978  auto_translate(const bbl_binary &X, int to_base_encoding = babel::get_base_encoding())
1979  :bbl_demi<to_string>(auto_translate_engine<to_string>::ignite(X, to_base_encoding)) { }
1980 };
1981 
1982 
1983 template<class string_type = bbl_default_string>
1984 class translate_to_binary_engine :public manual_translate_engine<string_type, bbl_binary> {
1985 //
1986 // このクラスは to_string_type が bbl_binary に固定されていることと
1987 // from_base_encoding のデフォルト値が設定されていること以外は機能的に
1988 // manual_translate_engine と全く同一です。
1989 //
1990 // ・・・このクラスには将来的にBOM関連の小細工を施すかもしれません。
1991 //
1992 public:
1993  typedef translate_to_binary_engine<string_type> this_type;
1994  typedef manual_translate_engine<bbl_binary, string_type> parent_type;
1995  typedef bbl_translate_engine<bbl_binary, string_type> base_type;
1996  typedef typename base_type::bbl_translater_type bbl_translater_type;
1997  typedef typename base_type::from_string_type from_string_type;
1998  typedef typename base_type::to_string_type to_string_type;
1999 // private: // VC のヽ(｀Д´)ノアホォ！
2000  protected:
2001 #ifdef __BBL_LARGE_BOM_LOGIC__
2002  translate_to_binary_engine(int from_base_encoding = babel::get_base_encoding(), int to_base_encoding = babel::get_base_encoding())
2003  :parent_type(this_type::order(from_base_encoding, to_base_encoding)) {}
2004 #else // __BBL_LARGE_BOM_LOGIC__
2005  translate_to_binary_engine(int from_base_encoding = babel::get_base_encoding(), int to_base_encoding = babel::get_base_encoding())
2006  :parent_type(from_base_encoding, to_base_encoding) {}
2007 #endif // __BBL_LARGE_BOM_LOGIC__
2008  protected:
2009  public:
2010 #ifdef __BBL_LARGE_BOM_LOGIC__
2011 static bbl_translater_type create(int from_base_encoding, int to_base_encoding = babel::get_base_encoding()) {
2012  return new this_type(from_base_encoding, to_base_encoding);
2013  }
2014 static const to_string_type ignite(const from_string_type &X, int from_base_encoding, int to_base_encoding = babel::get_base_encoding());
2015 static bbl_translater_type order(int from_base_encoding, int to_base_encoding = babel::get_base_encoding());
2016 #endif // __BBL_LARGE_BOM_LOGIC__
2017 };
2018 
2019 inline const bbl_binary translate_to_binary(const bbl_string &X, int X_to_base_encoding, int X_from_base_encoding = babel::get_base_encoding()) {
2020  return manual_translate_engine<bbl_string, bbl_binary>::ignite(X, X_from_base_encoding, X_to_base_encoding);
2021 }
2022 # if defined(__BBL_USE_UNICODE__)
2023 inline const bbl_binary translate_to_binary(const bbl_wstring &X, int X_to_base_encoding, int X_from_base_encoding = babel::base_encoding::unicode) {
2024  return manual_translate_engine<bbl_wstring, bbl_binary>::ignite(X, X_from_base_encoding, X_to_base_encoding);
2025 }
2026 # endif // defined(__BBL_USE_UNICODE__)
2027 #endif // defined(__BBL_USE_SELECTORS__)
2028 
2029 /******************************************************************************
2030  □■□■ Trick Library 'dagger' □■□■
2031  ■□■□ http://tricklib.com/cxx/dagger/ ■□■□
2032 ******************************************************************************/
2033 
2034 } // namespace babel
2035 
2036 #if defined(__BORLANDC__)
2037 # pragma warn .8027
2038 #endif
2039 
2040 #endif // __BABEL_BBL_H__
2041 
2042 /******************************************************************************
2043  □■□■ Wraith the Trickster □■□■
2044  ■□■□ 〜I'll go with heaven's advantage and fool's wisdom.〜 ■□■□
2045 ******************************************************************************/
2046