C++ でテキストの正規化

(1/1)
>C++でテキストの正規化
日本語テキストに混在する全角・半角文字を統一したり、漢数字を算用数字に変換したり、その逆の変換を一気に行うことができる正規化アプリケーションを作る。正規化したテキストは、クリップボードにコピーしたり、テキストファイルに保存することができる。
また、ソースを共通化してコマンドライン版アプリケーションを作り、バッチや他のプログラムから流し込んだテキストを正規化することができるようにする。
PHPで日本語テキストを正規化(Windowsアプリ版)」で作ったPHPプログラムをC++に移植したものである。

(2022年7月18日)フロントエンド置換機能を追加,saveOption() 修正
(2022年4月29日)制御文字削除機能追加.CUI版に --clip, --paste オプション追加,MeCabユーザー辞書更新,不具合修正
(2022年2月19日)不具合修正
(2022年1月3日)「一律」「何千万」など文字化け対策を品詞を用いて実現.

目次

サンプル・プログラム

圧縮ファイルの内容
normalizetextwin.msiインストーラ
bin/normalizetextwin.exe実行プログラム本体(GUI版)
bin/nmtxt.exe実行プログラム本体(CUI版)
bin/option.txt正規化オプションを保存するファイル
bin/libgcc_s_seh-1.dll
bin/libiconv-2.dll
bin/libmecab-2.dll
bin/libstdc++-6.dll
bin/libwinpthread-1.dll
実行時に必要になるDLL
bin/etc/help.chmヘルプ・ファイル
bin/etc/char.bin
bin/etc/dicrc
bin/etc/matrix.bin
bin/etc/sys.dic
bin/etc/unk.dic
bin/etc/user_wiki.dic
MeCabが参照する辞書ファイル等
sour/normalizetextwin.cppソース・プログラム
sour/resource.hリソース・ヘッダ
sour/resource.rcリソース・ファイル(GUI版)
sour/resource2.rcリソース・ファイル(CUI版)
sour/application.icoアプリケーション・アイコン(GUI版)
sour/application2.icoアプリケーション・アイコン(CUI版)
sour/pahooNormalizeText.cppテキスト正規化クラス(ソース)
sour/pahooNormalizeText.hppテキスト正規化クラス(ヘッダ)
sour/makefileGUI版ビルド
sour/makefile_cmdCUI版ビルド

使用ライブラリ

漢数字と固有名詞(例:『千と千尋の神隠し』)を識別するために、形態素解析エンジン「MeCab (めかぶ) 」を利用する。導入方法は後述する。
また、CUI版でコマンダイン・オプションを操作する場合などに、オープンソースのライブラリ Boost C++ライブラリが必要になる。Boost C++ライブラリの導入方法等については、「C++ 開発環境の準備」をご覧いただきたい。

リソースの準備

Eclipse を起動し、新規プロジェクト normalizetextwin を用意する。
ResEdit を起動し、resource.rc を用意する。

Eclipse に戻り、ソース・プログラム "normalizetextwin.cpp" を追加する。
リンカー・フラグを -mwindows -static-libstdc++ -static-libgcc -lpthread -lwinpthread -static "(任意のパス)\libboost_program_options-mt.dll" -static "(任意のパス)\libmecab-2.dll" に設定する。
また、CUI版をビルドするために、構成 CMD を追加し、リンカー・フラグを -static-libstdc++ -static-libgcc -lpthread -static "(任意のパス)\libboost_program_options-mt.dll" -static "(任意のパス)\libmecab-2.dll"" に設定する。

MSYS2 コマンドラインからビルドするのであれば、"makefile" と "makefile_cmd" を利用してほしい。

MeCabの導入

MeCab については「PHPで MeCabのユーザー辞書を作成する」で紹介している。ユーザー辞書はシフトJISで作成すること。
簡単に振り返っておくと、入力されたテキストを日本語の品詞に分解する形態素解析エンジンと呼ばれるプログラムである。
なぜテキストの正規化に形態素解析エンジンが必要かというと、たとえば「千と千尋の神隠しという映画を見た」というテキストをそのまま正規化してしまうと、「千」を数字と解釈し、「1000と1000尋の神隠しという映画を見た」という変換結果になってしまうためである。
テキスト中にある固有名詞は数字変換の対象としないように除外するため、形態素解析エンジンを利用する。形態素解析エンジンであれば MeCab でなくても構わないのだが、C++から利用可能なDLLファイルが利用できることから、ここでは MeCab を採用する。

MeCab を64ビット環境でビルドすると、"libmecab-2.dll" が得られる。これを適当なディレクトリに配置し、リンクするようにする。

MSYS2 開発環境では、次のように pacman を使い iconvMeCab ライブラリをインストールできる。
64ビット版:
pacman -S mingw-w64-x86_64-libiconv
pacman -S mingw-w64-x86_64-mecab


MeCab のユーザー辞書であるが、前述の通り、固有名詞を識別するのが目的であるので、Wikipediaの見出し語をユーザー辞書として用意することにした。Wikipediaユーザー辞書の作るプログラムは、前述の「PHPで MeCabのユーザー辞書を作成する」で紹介している。

プログラムの流れ

>C++でテキストの正規化
プログラムの流れは上図の通りである。
変換ボタンがクリックされたら、toHankaku メソッドを使って半角か可能な文字を全て半角にする。その後、正規化オプションの値に応じて全角化、漢数字化を行ってゆく。

解説:テキスト正規化クラス

0029: //正規化オプション
0030: #define OPTION_SPC_TRIM1   't'       //行頭・行末の空白文字を除く
0031: #define OPTION_SPC_TRIM2   'T'       //全角文字と隣り合う空白文字を除く
0032: #define OPTION_NUM_HAN     'n'       //数字を半角に統一
0033: #define OPTION_NUM_ZEN     'N'       //数字を全角に統一
0034: #define OPTION_NUM_KAN     'K'       //数字を漢字に統一
0035: #define OPTION_NUM_KAN2        'k'       //数字を漢字(単純)に統一
0036: #define OPTION_ALP_HAN     'a'       //英字を半角に統一
0037: #define OPTION_ALP_ZEN     'A'       //英字を全角に統一
0038: #define OPTION_YAK_HAN     'y'       //記号を半角に統一
0039: #define OPTION_YAK_ZEN     'Y'       //記号を全角に統一
0040: #define OPTION_KANA_HAN        'h'       //カタカナを半角に統一
0041: #define OPTION_KANA_ZEN        'H'       //カタカナを全角に統一
0042: #define OPTION_SPEC_HAN        's'       //特殊文字を半角に統一
0043: #define OPTION_SPEC_ZEN        'S'       //特殊文字を全角に統一
0044: #define OPTION_NUM_SCALE   'F'       //数字を位取り記法にする
0045: #define OPTION_NUM_NOSCALE     'f'       //数字を位取り記法にしない
0046: #define OPTION_CONTROL_DEL     'c'       //制御文字を削除する
0047: 
0048: //正規化オプションの初期値
0049: #define OPTION_INIT            "anYSHF"

正規化オプションは、英文字1文字で識別するようにしている。これを同時に複数指定することができる。ただし、aとAのように排他的であるオプションは、同時に指定しても意味をなさない。

解説:MeCabの呼び出し

0119: private:
0120: MeCab::Tagger *tagger = MeCab::createTagger("--dicdir=etc --userdic=etc/user_wiki.dic --node-format=%M\\t%f[0],%f[1],%f[2],%f[3],%f[4],%f[5],%f[6],%f[7],%f[8]\\n --unk-format=%M\\t%f[0],%f[1],%f[2],%f[3],%f[4],%f[5]\\n");

MeCab はクラス化されており、createTagger メソッドで呼び出す。引数は、MeCab.exe のオプションとほぼ同じである。
ここで、前述のWikipediaユーザー辞書 "user_wiki.dic" などを指定する。

解説:半角数字を漢数字に変換

0221: /**
0222:  * 半角数字を漢数字に変換する
0223:  * @param   wstring instr 半角数字
0224:  *                          小数、負数に対応;指数表記には未対応
0225:  *                          カンマは削除
0226:  * @return  wstring 漢数字
0227: */
0228: wstring pahooNormalizeText::num2kanji(wstring instr) {
0229:     static wchar_t kantbl1[] =
0230:         { L'0', L'1', L'2', L'3', L'4', L'5', L'6', L'7',
0231:             L'8', L'9', L'.', L'-' };
0232:     static wchar_t kantbl2[] =
0233:         { 0x00000x4E000x4E8C0x4E090x56DB0x4E940x516D,    //一〜九
0234:             0x4E030x516B0x4E5D0xFF0E0xFF0D };             //.−
0235:     static wchar_t kantbl3[] = { 0x00000x53410x767E0x5343 };   //十百千
0236:     static wchar_t kantbl4[] = { 0x00000x4E070x51040x51460x4EAC };   //万億兆京
0237: 
0238:     wstring outstr = L"";;
0239:     wstring ws2;
0240:     wchar_t wch1wch2;
0241:     int m = (int)instr.length() / 4;
0242:     //一、万、億、兆‥‥の繰り返し
0243:     for (int i = 0; i <= mi++) {
0244:         ws2 = L"";
0245:         //一、十、百、千の繰り返し
0246:         for (int j = 0; j < 4; j++) {
0247:             int pos = instr.length() - i * 4 - j - 1;
0248:             if (pos >= 0) {
0249:                 wchar_twch  = (wchar_t*)instr.substr(pos, 1).c_str();
0250:                 if (*wch == L',')  continue;        //カンマは無視
0251:                 for (int k = 0; k < (int)(sizeof(kantbl1) / sizeof(kantbl1[0])); k++) {
0252:                     //漢数字 or 半角数字のまま
0253:                     wch1 = 0x0000;
0254:                     if (*wch == kantbl1[k]) {
0255:                         wch1 = kantbl2[k];
0256:                         break;
0257:                     }
0258:                 }
0259:                 wch2 = 0x0000;;
0260:                 if ((j >= 0) && (j <= 3)) {
0261:                     wch2 = kantbl3[j];
0262:                 }
0263: 
0264:                 //冒頭が「一」の場合の処理
0265:                 if (wch1 != 0x0000) {
0266:                     if ((wch1 == 0x4E00) && (wch2 != 0x0000)) {
0267:                         ws2 = (wstring){wch2} + ws2;
0268:                     } else if (wch2 != 0x0000) {
0269:                         ws2 = (wstring){wch1} + (wstring){wch2} + ws2;
0270:                     } else {
0271:                         ws2 = (wstring){wch1} + ws2;
0272:                     }
0273:                 }
0274:             }
0275:         }
0276:         if (ws2 != L"") {
0277:             if (kantbl4[i] == 0x0000) {
0278:                 outstr = ws2 + outstr;
0279:             } else {
0280:                 outstr = ws2 + (wstring){kantbl4[i]} + outstr;
0281:             }
0282:         }
0283:     }
0284: 
0285:     return outstr;
0286: }

半角数字を漢数字に変換するメソッドは num2kanji である。
右から左へ向かって逆順に処理し、4桁ごとに、万、億、兆、京の単位を付けてゆく。各々の4桁の中で、十、百、千を付ける。冒頭が「一」の場合は「一百」にならないよう配慮する。

解説:解説:半角数字を漢数字(単純)に変換

0351: /**
0352:  * 半角数字を漢数字に変換する(単純変換)
0353:  * @param   wstring wsour 半角数字を含む文字列
0354:  * @return  wstring 漢数字
0355: */
0356: wstring pahooNormalizeText::num2kanSimple(wstring wsour) {
0357:     static wchar_t kantbl1[] =
0358:         { L'0', L'1', L'2', L'3', L'4', L'5', L'6', L'7',
0359:             L'8', L'9', L'.', L'-' };
0360:     static wchar_t kantbl2[] =
0361:         { 0x30070x4E000x4E8C0x4E090x56DB0x4E940x516D,    //一〜九
0362:             0x4E030x516B0x4E5D0xFF0E0xFF0D };             //.−
0363: 
0364:     //左から1文字ずつ処理
0365:     wstring wdest = L"";
0366:     wstring wstr;
0367:     wchar_twch;
0368:     bool flag;
0369:     for (int pos = 0; pos < (int)wsour.length(); pos++) {
0370:         flag = FALSE;
0371:         wstr = wsour.substr(pos, 1);
0372:         wch  = (wchar_t*)wstr.c_str();
0373:         for (int k = 0; k < (int)(sizeof(kantbl1) / sizeof(kantbl1[0])); k++) {
0374:             if (*wch == kantbl1[k]) {
0375:                 wdest += (wstring){kantbl2[k]};
0376:                 flag = TRUE;
0377:                 break;
0378:             }
0379:         }
0380:         if (! flag) {
0381:             wdest += *wch;
0382:         }
0383:     }
0384:     return wdest;
0385: }

半角数字を漢数字(単純)に変換するメソッドは num2kanSimple である。2020年(令和2年)を「二〇二〇年」のように変換する。
左から右へ向かって、算用数字にマッチする文字があれば漢数字に置換する。

解説:半角数字を位取り記法に変換

0288: /**
0289:  * 半角数字を位取り記法に変換する
0290:  * @param   wstring instr 半角数字(小数,負数,指数表記は未対応)
0291:  * @return  wstring 位取り記法
0292: */
0293: wstring pahooNormalizeText::num2scale(wstring instr) {
0294:     static wchar_t kantbl[] = { 0x00000x4E070x51040x51460x4EAC };    //万億兆京
0295:     //余計な'0'を除く
0296:     wregex re(_SW("0+([1-9]+)|0+([1-9]+)"));
0297: 
0298:     //桁あふれ
0299:     if (instr.length() > 20) {
0300:         return instr;
0301:     }
0302: 
0303:     //右から1文字ずつ処理
0304:     wstring outstr = L"";
0305:     wstring ws = L"";
0306:     int i = 0;
0307:     bool flag = FALSE;
0308:     for (int pos = instr.length() - 1; pos >= 0; pos--) {
0309:         if (flag) {
0310:             outstr = (wstring){kantbl[(int)(i / 4)]} + outstr;
0311:             flag = FALSE;
0312:         }
0313:         wstring ss = instr.substr(pos, 1);
0314:         ws = ss + ws;
0315:         i++;
0316:         if (i % 4 == 0) {
0317:             if ((ws == L"0000") || (ws == _SW("0000"))) {
0318:                 outstr = (wstring){kantbl[(int)(i / 4)]};
0319:             } else {
0320:                 outstr = regex_replace(wsreL"$1") + outstr;
0321:                 flag = TRUE;
0322:             }
0323:             ws = L"";
0324:         }
0325:     }
0326:     outstr = ws + outstr;
0327: 
0328:     return outstr;
0329: }

「三百億」を算用数字に変換すると「30000000000」となってしまい、視認性が悪くなる。そこで、算用数字に変換した場合でも「300億」になるよう、半角数字を位取り記法に変換するメソッド num2scale を用意した。
前述の num2kanji と同じように右から左へ向かって逆順に処理するが、変換するのは万、億、兆、京の単位だけである。

解説:漢数字を半角数字に変換

0407: /**
0408:  * 漢数字を半角数字に変換する
0409:  * @param   wstring kanji 漢数字
0410:  * @param   int mode 出力書式/1=3桁カンマ区切り,2=漢字混じり, それ以外=ベタ打ち
0411:  * @return  wstring 半角数字
0412: */
0413: wstring pahooNormalizeText::kan2num(wstring kanjiint mode) {
0414:     wstring dest = L"";
0415:     wsmatch mt1;
0416: 
0417:     //全角=半角対応
0418:     const wstring kan_num1 = _SW("0〇○1一壱2二弐3三参4四5五6六7七8八9九");
0419:     const wstring kan_num2 = _SW("000111222333445566778899");
0420: 
0421:     //位取り
0422:     const wstring kan_deci_sub = _SW("十\百千");
0423:     const wstring kan_deci = _SW("万億兆京");
0424: 
0425:     //半角数字が混在していたら何もしない
0426:     wregex re1(_SW("[0-9]+"));
0427:     if (regex_search(kanjimt1re1)) {
0428:         return kanji;
0429:     }
0430: 
0431:     //右側から解釈していく
0432:     size_t ll = kanji.length();
0433:     wstring a = L"";
0434:     long long int deci = 1;
0435:     long long int deci_sub = 1;
0436:     long long int m = 0;
0437:     long long int n = 0;
0438: 
0439:     for (int pos = ll - 1; pos >= 0; pos--) {
0440:         wstring c = kanji.substr(pos, 1);
0441:         size_t ps1 = kan_num1.find(c);
0442:         size_t ps2 = kan_deci_sub.find(c);
0443:         size_t ps3 = kan_deci.find(c);
0444:         if (ps1 != wstring::npos) {
0445:             a = kan_num2.substr(ps1, 1) + a;
0446:         } else if (ps2 != wstring::npos) {
0447:             if (a != L"") {
0448:                 m = m + stol(a) * deci_sub;
0449:             } else if (deci_sub != 1) {
0450:                 m = m + deci_sub;
0451:             }
0452:             a = L"";
0453:             deci_sub = pow(10, ps2 + 1);
0454:         } else if (ps3 != wstring::npos) {
0455:             if (a != L"") {
0456:                 m = m + stol(a) * deci_sub;
0457:             } else if (deci_sub != 1) {
0458:                 m = m + deci_sub;
0459:             }
0460:             n = m * (long long int)deci + n;
0461:             m = 0;
0462:             a = L"";
0463:             deci_sub = 1;
0464:             deci = (long long int)pow(10000, ps3 + 1);
0465:         }
0466:     }
0467: 
0468:     wstring ss = L"";
0469:     wregex re2(_SW("^(0+)"));
0470:     if (regex_search(amt1re2)) {
0471:         ss = mt1[1].str();
0472:     }
0473:     if (a != L"") {
0474:         m = m + stol(a) * deci_sub;
0475:     } else if (deci_sub != 1) {
0476:         m = m + deci_sub;
0477:     }
0478:     n = m * deci + n;
0479: 
0480:     return to_wstring(n);
0481: }

漢数字を算用数字に変換するメソッド kan2num である。単位としては「京」まで対応している。
前述の num2kanji と同じように右から左へ向かって逆順に処理するが、long long型の整数として扱い、最後にテキストに変換する。

解説:日本語テキストを半角に統一

0520: /**
0521:  * 日本語テキストを半角に統一
0522:  * @param   wstring sour 変換元テキスト
0523:  * @param   bool    trim 行頭・行末の空白を除くかどうか
0524:  * @return  string  変換後テキスト
0525: */
0526: wstring pahooNormalizeText::toHankaku(wstring wsourbool trim) {
0527:     regex sep{"\\t|,"};
0528:     wsmatch mt1mt2mt3;
0529:     //数字パターン
0530:     wregex pat_kannum(_SW("^[^数]*[01234567890123456789○〇一二三四五六七八九十\百千万億兆京]+$"));
0531:     //MeCabの品詞パターン
0532:     wregex re1(_SW("[数幾]"));
0533:     //月の漢数字
0534:     wregex re2(_SW("([一二三四五六七八九十\]+)(月)"));
0535:     //名詞接続の場合はそのまま
0536:     wregex re3(_SW("名詞接続"));
0537:     //行頭空白パターン
0538:     wregex re4(_SW("^[  \\t\\n\\r]+"));
0539:     //行末空白パターン
0540:     wregex re5(_SW("[  \\t\\n\\r]+$"));
0541:     //無変換パターン・その1
0542:     wregex re71(_SW("副詞可.+"));
0543:     wregex re72(_SW("接尾|格助詞"));
0544:     //無変換パターン・その2
0545:     wregex re8(_SW("^[千万億兆]+$"));
0546:     //無変換パターン・その3
0547:     wregex re9(_SW("一生"));
0548: 
0549:     //カンマ置換
0550:     wregex re6(_SW(","));
0551:     wsour = regex_replace(wsourre6_SW(""));
0552: 
0553:     //形態素に分解
0554:     string input = _WS(wsour);
0555:     const char *words = tagger->parse(input.c_str());
0556: 
0557:     //変換処理
0558:     bool flag = FALSE;
0559:     bool adverb = FALSE;
0560:     wstring dest = L"";
0561:     wstring numstr = L"";
0562:     wstring surfacepos;
0563: 
0564:     //1行ずつ読み込む
0565:     string ss0;
0566:     stringstream ss;
0567:     ss << words;
0568:     while(ss && getline(ssss0)) {
0569:         int cnt = 0;
0570:         for (std::cregex_token_iterator end,
0571:             ite{ss0.c_str(), ss0.c_str() + strlen(ss0.c_str()), sep, -1};
0572:             ite != end; ++ite) {
0573:             if (cnt == 0)       surface = _SW((*ite).str().c_str());
0574:             else if (cnt == 2)  pos = _SW((*ite).str().c_str());
0575:             cnt++;
0576:         }
0577: //      cout << _WS(surface) << " : " <<  _WS(pos) << endl;
0578: 
0579:         //最後
0580:         if (surface == _SW("EOS")) {
0581:             break;
0582:         //月の処理
0583:         } else if (regex_search(surfacemt1re2)) {
0584:             dest += this->kan2num(mt1[1].str(), 2) + mt1[2].str();
0585:         //無変換
0586:         } else if (regex_search(posmt1re71|| regex_search(surfacemt1re9)) {
0587:             dest += surface;
0588:         } else if (flag == FALSE) {
0589:             //副詞可能な数字
0590:             if (regex_search(posmt2re71)) {
0591:                 numstr = surface;
0592:                 flag = TRUE;
0593:                 adverb = TRUE;
0594:             //漢数字の1文字目
0595:              } else if (regex_search(surfacemt1pat_kannum) && regex_search(posmt2re1)) {
0596:                 numstr = surface;
0597:                 flag = TRUE;
0598:                 adverb = FALSE;
0599:             //数字ではない
0600:             } else {
0601:                 dest += surface;
0602:             }
0603:         } else {
0604:             //無変換(副詞可能+接尾)
0605:             if (adverb && regex_search(posmt2re72)) {
0606:                 dest += (numstr + surface);
0607:                 numstr = L"";
0608:                 flag = FALSE;
0609:                 adverb = FALSE;
0610:             //漢数字の2文字目以降
0611:             } else if (regex_search(surfacemt1pat_kannum)) {
0612:                 numstr += surface;
0613:                 flag = TRUE;
0614:             //数字以外
0615:             } else {
0616:                 //名詞接続の場合はそのまま
0617:                 if (regex_search(posmt2re3)) {
0618:                     dest += (numstr + surface);
0619:                 //無変換パターン
0620:                 } else if (regex_search(numstrmt1re8)) {
0621:                     dest += (numstr + surface);
0622:                 //副詞可能の場合
0623:                 } else if (adverb) {
0624:                     dest += (this->kanword2num(numstr) + surface);
0625:                 //ここまでの漢数字を半角数字に
0626:                 } else {
0627:                     dest += (this->kan2num(numstr, 2) + surface);
0628:                 }
0629:                 numstr = L"";
0630:                 flag = FALSE;
0631:                 adverb = FALSE;
0632:             }
0633:         }
0634:     }
0635: 
0636:     //末尾処理
0637:     if (flag == TRUE) {
0638:         if (adverb == TRUE) {
0639:             dest += numstr;
0640:         } else {
0641:             dest += this->kan2num(numstr, 2);
0642:         }
0643:     }
0644: 
0645:     //行頭・行末空白処理
0646:     if (trim) {
0647:         wstring wss = regex_replace(destre4L"");
0648:         wss = regex_replace(wssre5L"");
0649:         dest = wss + L"\\n";
0650:     }
0651: 
0652:     return wconvString(destLCMAP_HALFWIDTH);
0653: }

正規化処理の前段では、すべてのテキストを半角に変換する。そのためのメソッドが toHankaku である。
MeCab による形態素解析を実行するメソッド parse によってテキストを形態素の分解、個々の形態素に対して、kan2num を実行するかどうかを判断する。
最後に、Win32APIを呼び出す wconvString を使って、変換可能な全ての文字を半角にする。

解説:日本語テキストを全角に変換

0679: /**
0680:  * 半角→全角変換に変換
0681:  * @param   wstring sour 変換元テキスト
0682:  * @param   bool (*func) 該当文字判定関数
0683:  * @return  wstring  変換後テキスト
0684: */
0685: wstring pahooNormalizeText::han2zen(const wstring wsourbool (*func)(wchar_t wch)) {
0686:     wstring wss = L"";
0687:     wstring wdest = L"";
0688:     bool flag = FALSE;
0689: 
0690:     //先頭から1文字ずつ
0691:     for (size_t i = 0; i < wsour.length(); i++) {
0692:         wchar_twch = (wchar_t*)wsour.substr(i, 1).c_str();
0693:         //該当文字ならwss0へ
0694:         if (func(*wch)) {
0695:             wss += (wstring){*wch};
0696:             flag = TRUE;
0697:         //半角→全角変換
0698:         } else if (flag) {
0699:             wdest += wconvString(wssLCMAP_FULLWIDTH);
0700:             wdest += wsour.substr(i, 1);
0701:             flag = FALSE;
0702:             wss = L"";
0703:         } else {
0704:             wdest += wsour.substr(i, 1);
0705:         }
0706:     }
0707:     //最後の1文字が該当文字
0708:     if (flag) {
0709:         wdest += wconvString(wssLCMAP_FULLWIDTH);
0710:     }
0711: 
0712:     return wdest;
0713: }

前述の toHankaku で半角になったテキストから、正規化オプションによって該当する文字だけ全角に変換するメソッドが han2zen である。
文字種変換は、Win32APIを呼び出す wconvString を利用している。

解説:日本語テキストを正規化する

0715: /**
0716:  * 日本語テキストを正規化する
0717:  * @param   wstring sour   漢数字混じりテキスト
0718:  * @param   char*   option 変換オプション
0719:  * @param   bool    trim   行頭・行末の空白を除くかどうか
0720:  * @return  wstring 変換後テキスト
0721: */
0722: wstring pahooNormalizeText::normalizeText(wstring wsourconst charoptionbool trim) {
0723:     wstring wdest = wsour;
0724: 
0725:     //フロントエンド置換
0726:     wdest = this->frontend_replace(wdest);
0727: 
0728:     //制御文字を削除する
0729:     if (strchr(optionOPTION_CONTROL_DEL) != NULL) {
0730:         wregex re2(_SW("([\\t\\r\\r]+)"));
0731:         wdest = regex_replace(wdestre2L"");
0732:     }
0733: 
0734:     //いったん半角に
0735:     wdest = this->toHankaku(wdesttrim);
0736: 
0737:     //全角文字と隣り合う空白文字を除く
0738:     wregex re1(_SW("[  \\t]+([^!-~].)"));
0739:     wdest = regex_replace(wdestre1L"$1");
0740: 
0741:     //英字:半角→全角
0742:     if (strchr(optionOPTION_ALP_ZEN) != NULL) {
0743:         wdest = this->han2zen(wdest_alphabet);
0744:     }
0745:     //数字:位取り記法
0746:     if (strchr(optionOPTION_NUM_SCALE) != NULL) {
0747:         wdest = this->bignum2scale(wdest);
0748:     }
0749:     //数字:半角→全角
0750:     if (strchr(optionOPTION_NUM_ZEN) != NULL) {
0751:         wdest = this->han2zen(wdest_decimal);
0752:     //数字:半角→漢数字
0753:     } else if (strchr(optionOPTION_NUM_KAN) != NULL) {
0754:         wdest = this->num2kan(wdest);
0755:     //数字:半角→漢数字(単純)
0756:     } else if (strchr(optionOPTION_NUM_KAN2) != NULL) {
0757:         wdest = this->num2kanSimple(wdest);
0758:     }
0759:     //記号:半角→全角
0760:     if (strchr(optionOPTION_YAK_ZEN) != NULL) {
0761:         wdest = this->han2zen(wdest_yakumono);
0762:     }
0763:     //カタカナ:半角→全角
0764:     if (strchr(optionOPTION_KANA_ZEN) != NULL) {
0765:         wdest = this->han2zen(wdest_katakana);
0766:     }
0767:     //小数点の全角を半角に変換
0768:     wdest = this->hanfloat(wdest);
0769: 
0770:     //半角文字と隣り合う全角空白は半角空白へ
0771:     wregex re2(_SW("[ ]+([!-~].)"));
0772:     wdest = regex_replace(wdestre2L" $1");
0773: 
0774:     return wdest;
0775: }

これまで紹介してきたメソッドを利用し、正規化オプションにもとづいて日本語テキストを正規化するメソッドが normalizeText である。

解説:定数など

0038: // 定数など ==================================================================
0039: #define MAKER      "pahoo.org"               //作成者
0040: #define APPNAME        "normalizetextwin"        //アプリケーション名
0041: #define APPNAMEJP  "テキストの正規化"        //アプリケーション名(日本語)
0042: #define APPVERSION "1.8"                 //バージョン
0043: #define APPYEAR        "2020-2022"               //作成年
0044: #define REFERENCE  "https://www.pahoo.org/e-soul/webtech/cpp01/cpp01-18-01.shtm" //参考サイト
0045: 
0046: //ヘルプ・ファイル
0047: #define HELPFILE   ".\\etc\\help.chm"
0048: 
0049: //デフォルト保存ファイル名
0050: #define SAVEFILE   "normalizetextwin.txt"
0051: 
0052: //オプション保存ファイル名:変更不可
0053: #define OPTIONFILE "option.txt"
0054: 
0055: //エラー・メッセージ格納用:変更不可
0056: string ErrorMessage;
0057: 
0058: //現在のインターフェイス
0059: HINSTANCE hInst;
0060: 
0061: //アプリケーション・ウィンドウ
0062: HWND hParent;
0063: 
0064: //アプリケーション・ウィンドウ位置
0065: unsigned hParent_XhParent_Y;
0066: 
0067: //pahooNormalizeTextオブジェクト
0068: pahooNormalizeTextpNT;
0069: 
0070: //char*バッファサイズ
0071: #define SIZE_BUFF  5120
0072: 
0073: //変換元テキスト(初期値)
0074: #define DEF_SOUR   "『千と千尋の神隠し』(せんとちひろのかみかくし)は、スタジオジブリ制作の長編アニメーション映画。監督は宮崎駿。二〇〇一年七月二十\日に日本公開。興行収入は三百億円を超え、日本歴代興行収入第一位を達成した。英語のタイトルは『Spirited Away』。\n千尋という名の十\歳の少女が、引っ越し先へ向かう途中に立ち入ったトンネルから、神々の世界へ迷い込んでしまう物語。"

GUIおよびCUI版のプログラムは、"normalizetextwin.cpp" に記述しており、マクロ定数 CMDAPP が定義されている場合にはCUI版が、そうでない場合にはGUI版がビルドできるようにしてある。
とくに注意記載が無い限り、定数は自由に変更できる。

解説:正規化オプション取得・設定

0483: /**
0484:  * 正規化オプションを設定する
0485:  * @param   HWND hDlg   ウィンドウ・ハンドラ
0486:  * @param   string opt  正規化オプション
0487:  * @return  なし
0488:  */
0489: void setOption(HWND hDlgstring opt) {
0490:     for (int i = 0; i < (int)opt.length(); i++) {
0491:         charch = (char*)opt.substr(i, 1).c_str();
0492:         switch (*ch) {
0493:         case OPTION_ALP_HAN:
0494:             SendMessage(GetDlgItem(hDlgIDC_RADIO_ALP_HAN),
0495:                             BM_SETCHECKBST_CHECKED,   0);
0496:             SendMessage(GetDlgItem(hDlgIDC_RADIO_ALP_ZEN),
0497:                             BM_SETCHECKBST_UNCHECKED, 0);
0498:             break;
0499:         case OPTION_ALP_ZEN:
0500:             SendMessage(GetDlgItem(hDlgIDC_RADIO_ALP_HAN),
0501:                             BM_SETCHECKBST_UNCHECKED, 0);
0502:             SendMessage(GetDlgItem(hDlgIDC_RADIO_ALP_ZEN),
0503:                             BM_SETCHECKBST_CHECKED,   0);
0504:             break;
0505:         case OPTION_NUM_HAN:
0506:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_HAN),
0507:                             BM_SETCHECKBST_CHECKED,   0);
0508:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_ZEN),
0509:                             BM_SETCHECKBST_UNCHECKED, 0);
0510:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_KAN),
0511:                             BM_SETCHECKBST_UNCHECKED, 0);
0512:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_KAN2),
0513:                             BM_SETCHECKBST_UNCHECKED, 0);
0514:             break;
0515:         case OPTION_NUM_ZEN:
0516:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_HAN),
0517:                             BM_SETCHECKBST_UNCHECKED, 0);
0518:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_ZEN),
0519:                             BM_SETCHECKBST_CHECKED,   0);
0520:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_KAN),
0521:                             BM_SETCHECKBST_UNCHECKED, 0);
0522:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_KAN2),
0523:                             BM_SETCHECKBST_UNCHECKED, 0);
0524:             break;
0525:         case OPTION_NUM_KAN:
0526:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_HAN),
0527:                             BM_SETCHECKBST_UNCHECKED, 0);
0528:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_ZEN),
0529:                             BM_SETCHECKBST_UNCHECKED, 0);
0530:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_KAN),
0531:                             BM_SETCHECKBST_CHECKED,   0);
0532:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_KAN2),
0533:                             BM_SETCHECKBST_UNCHECKED, 0);
0534:             break;
0535:         case OPTION_NUM_KAN2:
0536:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_HAN),
0537:                             BM_SETCHECKBST_UNCHECKED, 0);
0538:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_ZEN),
0539:                             BM_SETCHECKBST_UNCHECKED, 0);
0540:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_KAN),
0541:                             BM_SETCHECKBST_UNCHECKED, 0);
0542:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_KAN2),
0543:                             BM_SETCHECKBST_CHECKED,   0);
0544:             break;
0545:         case OPTION_NUM_SCALE:
0546:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_SCALE),
0547:                             BM_SETCHECKBST_CHECKED,   0);
0548:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_NOSCALE),
0549:                             BM_SETCHECKBST_UNCHECKED, 0);
0550:             break;
0551:         case OPTION_NUM_NOSCALE:
0552:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_SCALE),
0553:                             BM_SETCHECKBST_UNCHECKED, 0);
0554:             SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_NOSCALE),
0555:                             BM_SETCHECKBST_CHECKED,   0);
0556:             break;
0557:         case OPTION_YAK_HAN:
0558:             SendMessage(GetDlgItem(hDlgIDC_RADIO_YAK_HAN),
0559:                             BM_SETCHECKBST_CHECKED,   0);
0560:             SendMessage(GetDlgItem(hDlgIDC_RADIO_YAK_ZEN),
0561:                             BM_SETCHECKBST_UNCHECKED, 0);
0562:             break;
0563:         case OPTION_YAK_ZEN:
0564:             SendMessage(GetDlgItem(hDlgIDC_RADIO_YAK_HAN),
0565:                             BM_SETCHECKBST_UNCHECKED, 0);
0566:             SendMessage(GetDlgItem(hDlgIDC_RADIO_YAK_ZEN),
0567:                             BM_SETCHECKBST_CHECKED,   0);
0568:             break;
0569:         case OPTION_KANA_HAN:
0570:             SendMessage(GetDlgItem(hDlgIDC_RADIO_KANA_HAN),
0571:                             BM_SETCHECKBST_CHECKED,   0);
0572:             SendMessage(GetDlgItem(hDlgIDC_RADIO_KANA_ZEN),
0573:                             BM_SETCHECKBST_UNCHECKED, 0);
0574:             break;
0575:         case OPTION_KANA_ZEN:
0576:             SendMessage(GetDlgItem(hDlgIDC_RADIO_KANA_HAN),
0577:                             BM_SETCHECKBST_UNCHECKED, 0);
0578:             SendMessage(GetDlgItem(hDlgIDC_RADIO_KANA_ZEN),
0579:                             BM_SETCHECKBST_CHECKED,   0);
0580:             break;
0581:         case OPTION_SPEC_HAN:
0582:             SendMessage(GetDlgItem(hDlgIDC_RADIO_SPEC_HAN),
0583:                             BM_SETCHECKBST_CHECKED,   0);
0584:             SendMessage(GetDlgItem(hDlgIDC_RADIO_SPEC_ZEN),
0585:                             BM_SETCHECKBST_UNCHECKED, 0);
0586:             break;
0587:         case OPTION_SPEC_ZEN:
0588:             SendMessage(GetDlgItem(hDlgIDC_RADIO_SPEC_HAN),
0589:                             BM_SETCHECKBST_UNCHECKED, 0);
0590:             SendMessage(GetDlgItem(hDlgIDC_RADIO_SPEC_ZEN),
0591:                             BM_SETCHECKBST_CHECKED,   0);
0592:             break;
0593:         case OPTION_CONTROL_DEL:
0594:             SendMessage(GetDlgItem(hDlgIDC_CHECK_CONTROL_DEL),
0595:                             BM_SETCHECKBST_CHECKED, 0);
0596:             break;
0597:         default:
0598:             break;
0599:         }
0600:     }
0601: }

0603: /**
0604:  * 正規化オプションを取得する
0605:  * @param   HWND hDlg   ウィンドウ・ハンドラ
0606:  * @return  string 正規化オプション
0607:  */
0608: string getOption(HWND hDlg) {
0609:     string opt = "";
0610:     if (SendMessage(GetDlgItem(hDlgIDC_RADIO_ALP_HAN), BM_GETCHECK, 0, 0)) {
0611:         opt += OPTION_ALP_HAN;
0612:     } else if (SendMessage(GetDlgItem(hDlgIDC_RADIO_ALP_ZEN), BM_GETCHECK, 0, 0)) {
0613:         opt += OPTION_ALP_ZEN;
0614:     }
0615:     if (SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_HAN), BM_GETCHECK, 0, 0)) {
0616:         opt += OPTION_NUM_HAN;
0617:     } else if (SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_ZEN), BM_GETCHECK, 0, 0)) {
0618:         opt += OPTION_NUM_ZEN;
0619:     } else if (SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_KAN), BM_GETCHECK, 0, 0)) {
0620:         opt += OPTION_NUM_KAN;
0621:     } else if (SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_KAN2), BM_GETCHECK, 0, 0)) {
0622:         opt += OPTION_NUM_KAN2;
0623:     }
0624:     if (SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_SCALE), BM_GETCHECK, 0, 0)) {
0625:         opt += OPTION_NUM_SCALE;
0626:     } else if (SendMessage(GetDlgItem(hDlgIDC_RADIO_NUM_NOSCALE), BM_GETCHECK, 0, 0)) {
0627:         opt += OPTION_NUM_NOSCALE;
0628:     }
0629:     if (SendMessage(GetDlgItem(hDlgIDC_RADIO_YAK_HAN), BM_GETCHECK, 0, 0)) {
0630:         opt += OPTION_YAK_HAN;
0631:     } else if (SendMessage(GetDlgItem(hDlgIDC_RADIO_YAK_ZEN), BM_GETCHECK, 0, 0)) {
0632:         opt += OPTION_YAK_ZEN;
0633:     }
0634:     if (SendMessage(GetDlgItem(hDlgIDC_RADIO_KANA_HAN), BM_GETCHECK, 0, 0)) {
0635:         opt += OPTION_KANA_HAN;
0636:     } else if (SendMessage(GetDlgItem(hDlgIDC_RADIO_KANA_ZEN), BM_GETCHECK, 0, 0)) {
0637:         opt += OPTION_KANA_ZEN;
0638:     }
0639:     if (SendMessage(GetDlgItem(hDlgIDC_RADIO_SPEC_HAN), BM_GETCHECK, 0, 0)) {
0640:         opt += OPTION_SPEC_HAN;
0641:     } else if (SendMessage(GetDlgItem(hDlgIDC_RADIO_SPEC_ZEN), BM_GETCHECK, 0, 0)) {
0642:         opt += OPTION_SPEC_ZEN;
0643:     }
0644:     if (SendMessage(GetDlgItem(hDlgIDC_CHECK_CONTROL_DEL), BM_GETCHECK, 0, 0)) {
0645:         opt += OPTION_CONTROL_DEL;
0646:     }
0647: 
0648:     return opt;
0649: }

GUI版は、正規化オプションをラジオボタンに設定したり取り出すために、関数 setOptiongetOption の2種類の関数を用意した。

解説:正規化オプション読込・保存

0317: /**
0318:  * AppDataのパスを取得
0319:  * @param   char* appname アプリケーション名
0320:  * @return  string パス
0321:  */
0322: string getMyPath(const charappname) {
0323:     static TCHAR myPath[MAX_PATH] = "";
0324: 
0325:     if (strlen(myPath) == 0) {
0326:         if (SHGetSpecialFolderPath(NULLmyPathCSIDL_APPDATA, 0)) {
0327:             TCHAR *ptmp = _tcsrchr(myPath_T('\\'));
0328:             if (ptmp != NULL) {
0329:                 ptmp = _tcsinc(ptmp);
0330:                 *ptmp = _T('\0');
0331:             }
0332:             strcat(myPath_T("Roaming"));
0333:             CreateDirectory((LPCTSTR)myPathNULL);
0334:             strcat(myPath_T("\\pahoo.org"));
0335:             CreateDirectory((LPCTSTR)myPathNULL);
0336:             strcat(myPath_T("\\"));
0337:             strcat(myPath_T(appname));
0338:             CreateDirectory((LPCTSTR)myPathNULL);
0339:             strcat(myPath_T("\\"));
0340:         } else {
0341:         }
0342:     }
0343:     return (string)myPath;
0344: }

0346: /**
0347:  * オプションの読み込み
0348:  * @param   なし
0349:  * @return  string オプション
0350:  */
0351: string loadOption(void) {
0352:     hParent_X = 0;
0353:     hParent_Y = 0;
0354:     string option = OPTION_INIT;
0355:     ptree pt;
0356: 
0357:     //XMLファイル読み込み
0358:     try {
0359:         xml_parser::read_xml(getMyPath(APPNAME) + APPNAME + ".xml", pt);
0360: 
0361:         //XML解釈
0362:         try {
0363:             //形式チェック
0364:             if (optional<string>str = pt.get_optional<string>("parameter")) {
0365:             } else {
0366:                 return OPTION_INIT;
0367:             }
0368:             //パラメータ読み込み
0369:             for (auto it : pt.get_child("parameter")) {
0370:                 string typeit.second.get_optional<string>("<xmlattr>.type").value();
0371:                 if (type == "option") {
0372:                     option =(string)it.second.data();
0373:                 } else if (type == "wx") {
0374:                     hParent_X = (unsigned)stoi(it.second.data());
0375:                 } else if (type == "wy") {
0376:                     hParent_Y = (unsigned)stoi(it.second.data());
0377:                 }
0378:             }
0379:         //解釈失敗したら初期値設定
0380:         } catch (xml_parser_errore) {
0381:             hParent_X = 0;
0382:             hParent_Y = 0;
0383:             return OPTION_INIT;
0384:         }
0385:     //読み込み失敗したら初期値設定
0386:     } catch (xml_parser_errore) {
0387:         hParent_X = 0;
0388:         hParent_Y = 0;
0389:         return OPTION_INIT;
0390:     }
0391: 
0392:     //アプリケーション・ウィンドウの位置(デスクトップ範囲外なら原点移動)
0393:     HWND hDesktop = GetDesktopWindow();
0394:     WINDOWINFO windowInfo;
0395:     windowInfo.cbSize = sizeof(WINDOWINFO);
0396:     GetWindowInfo(hDesktop, &windowInfo);
0397:     if (hParent_X >= (unsigned)windowInfo.rcWindow.right) {
0398:         hParent_X = 0;
0399:     }
0400:     if (hParent_Y >= (unsigned)windowInfo.rcWindow.bottom) {
0401:         hParent_Y = 0;
0402:     }
0403: 
0404:     return option;
0405: }

0407: /**
0408:  * オプションの保存
0409:  * @param   string option オプション
0410:  * @return  なし
0411:  */
0412: void saveOption(string option) {
0413: #ifndef CMDAPP
0414:     //アプリケーション・ウィンドウの位置取得
0415:     WINDOWINFO windowInfo;
0416:     windowInfo.cbSize = sizeof(WINDOWINFO);
0417:     GetWindowInfo(hParent, &windowInfo);
0418:     hParent_X = (unsigned)windowInfo.rcWindow.left;
0419:     hParent_Y = (unsigned)windowInfo.rcWindow.top;
0420:     if (hParent_X >= (unsigned)windowInfo.rcWindow.right) {
0421:         hParent_X = 0;
0422:     }
0423:     if (hParent_Y >= (unsigned)windowInfo.rcWindow.bottom) {
0424:         hParent_Y = 0;
0425:     }
0426: #endif
0427: 
0428:     //XMLファイルへ書き込む
0429:     ptree pt;
0430:     ptreechild1 = pt.add("parameter.param", option);
0431:     child1.add("<xmlattr>.type", "option");
0432:     ptreechild2 = pt.add("parameter.param", (string)to_string(hParent_X));
0433:     child2.add("<xmlattr>.type", "wx");
0434:     ptreechild3 = pt.add("parameter.param", (string)to_string(hParent_Y));
0435:     child3.add("<xmlattr>.type", "wy");
0436: 
0437: //  cout << "option=" << option << endl;
0438: 
0439:     const int indent = 4;
0440:     write_xml(getMyPath(APPNAME) + APPNAME + ".xml", ptstd::locale(),
0441:         xml_writer_make_settings<std::string>(' ', indent));
0442: }

プログラム起動時に loadOption 関数によって、正規化オプションを読み込む。また、終了時に saveOption 関数によって、正規化オプションを保存する。変数 option の値をテキスト・ファイルとして読み書きしている。
保存場所は、getMyPath 関数によって、ユーザーのAppDataの下にアプリケーションフォルダを作って、XMLファイルとして保存する。
この処理は、GUI/CUI共通だ。

解説:フロントエンド置換

0186: /**
0187:  * フロントエンド置換:入力直後に文字列置換を行う
0188:  * @param   string wsour 入力テキスト
0189:  * @return  string 変換後文字列
0190: */
0191: wstring pahooNormalizeText::frontend_replace(wstring wsour) {
0192:     wstring tbl[2];
0193: 
0194:     //文字列置換定義ファイルを読み込む
0195:     ifstream ifs(FRONT_REPLACE_CSV);
0196:     //文字列置換定義ファイルが無い
0197:     if (! ifs) {
0198:         return wsour;
0199:     }
0200: 
0201:     //1行ずつ変換
0202:     string ss;
0203:     string delim = "\t";
0204:     list<stringlist_string;
0205:     wstring wstr = L"";
0206:     while (getline(ifsss)) {
0207:         int n = 0;
0208:         boost::split(list_stringssboost::is_any_of(delim));
0209:         BOOST_FOREACH(string slist_string) {
0210:             tbl[n] = _SW(s);
0211:             n++;
0212:             if (n > 2)  break;
0213:         }
0214:         wregex re(tbl[0]);
0215:         wsour = regex_replace(wsourretbl[1]);
0216:     }
0217: 
0218:     return wsour;
0219: }

バージョン1.8でフロントエンド置換機能を追加した、
OCRソフト等を利用して取得したテキストについて、特定のパターンが正しく読み取れない場合がある。そこで、誤認識パターンを正しいテキストに置換するのがフロントエンド置換機能である。
GUI版、CUI版ともに、すべての正規化処理の前に、定数 FRONT_REPLACE_CSV に定義された置換定義ファイルに従って、文字列の置換を行う。
FRONT_REPLACE_CSV には複数のパターンを置換することが可能で、このCSV形式ファイルにはシフトJISで次のように記述する。
置換前文字列1 (TAB) 置換後文字列1
置換前文字列2 (TAB) 置換後文字列2
‥‥
Excelなどを使って、タブ区切りでCSV形式ファイルに保存するといいだろう。
何も記述しない(空ファイル)と、フロントエンド置換機能は働かない。

CUI用メインプログラム

0829: /**
0830:  * CUI用メインプログラム
0831:  * @param   int argc
0832:  * @paramm  char* argv[]
0833:  * @return  int リターンコード
0834:  */
0835: int main(int argccharargv[]) {
0836:     wstring wsour = L"";
0837:     wstring wdest = L"";
0838:     string sour = "";
0839: 
0840:     //正規化オプションの初期値
0841:     string lopt = OPTION_INIT;
0842: 
0843:     //pahooNormalizeTextオブジェクト
0844:     pNT = new pahooNormalizeText();
0845: 
0846:     //コマンドライン・オプションの定義
0847:     options_description options("コマンドライン・オプション");
0848:     options.add_options()
0849:         ("option,o", value<std::string>()->default_value(lopt), "正規化オプション")
0850:         ("sour,s", value<std::string>(), "テキストファイルから入力")
0851:         ("clip,c", "クリップボードから入力")
0852:         ("dest,d", value<std::string>(), "テキストファイルへ出力")
0853:         ("paste,p", "クリップボードへ出力")
0854:         ("help,h", "ヘルプ")
0855:         ("version,v", "バージョン情報")
0856:         ;
0857:     //コマンドライン・オプションの取得
0858:     variables_map vm;
0859:     try {
0860:         store(parse_command_line(argcargvoptions), vm);
0861:     } catch(const boost::program_options::error_with_option_namee) {
0862:         ErrorMessage =  e.what();
0863:         cerr << ErrorMessage << endl;
0864:         return 1;
0865:     }
0866:     notify(vm);
0867: 
0868:     //正規化オプション
0869:     auto opt = vm["option"].as<string>();
0870: 
0871:     //ヘルプ情報
0872:     if (vm.count("help")) {
0873:         wdest = _SW(Help);
0874:     //バージョン情報
0875:     } else if (vm.count("version")) {
0876:         wdest = _SW(Version);
0877: 
0878:     //正規化実行
0879:     } else {
0880:         //入力ファイル
0881:         wsour = _SW(DEF_SOUR);
0882:         if (vm.count("sour")) {
0883:             auto infile = vm["sour"].as<string>();
0884:             ifstream ifs(infile.c_str());
0885:             if (ifs.fail()) {
0886:                 ErrorMessage = infile + " が見つかりません";
0887:                 cerr << ErrorMessage << endl;
0888:                 return 1;
0889:             }
0890:             string ss;
0891:             while (getline(ifsss)) {
0892:                 sour += ss + "\r";
0893:             }
0894:             wsour = _SW(sour);
0895:         //クリップボードから
0896:         } else if (vm.count("clip")) {
0897:             char *ss = getClipboardData();
0898:             sour = ss;
0899:             wsour = _SW(sour);
0900:         //標準入力から
0901:         } else {
0902:             cin >> sour;
0903:             if (sour.length() > 0) {
0904:                 wsour = _SW(sour);
0905:             }
0906:         }
0907:         wdest = pNT->normalizeText(wsouropt.c_str(), FALSE);
0908:     }
0909: 
0910:     //出力ファイル
0911:     if (vm.count("dest")) {
0912:         //改行コード置換
0913:         wregex re(_SW("\r"));
0914:         wdest = regex_replace(wdestre_SW("\n"));
0915:         auto outfile = vm["dest"].as<string>();
0916:         ofstream ofs(outfile.c_str());
0917:         ofs << _WS(wdest);
0918:         if (ofs.bad()) {
0919:             ErrorMessage = outfile + " への書き込みに失敗しました";
0920:             cerr << ErrorMessage << endl;
0921:             return 1;
0922:         }
0923:         ofs.close();
0924:     //クリップボードへ
0925:     } else if (vm.count("paste")) {
0926:         //改行コード置換
0927:         wregex re(_SW("\r"));
0928:         wdest = regex_replace(wdestre_SW("\n"));
0929:         setClipboardData(_WS(wdest));
0930:     //標準出力へ
0931:     } else {
0932:         //改行コード置換
0933:         wregex re(_SW("\r"));
0934:         wdest = regex_replace(wdestre_SW("\n"));
0935:         cout << _WS(wdest);
0936:     }
0937: 
0938:     //オブジェクト解放
0939:     delete pNT;
0940: 
0941:     return 0;
0942: }

CUI版は、昔ながらの main 関数ではじまる。
GUI版の WinMain 関数はマルチスレッド対応で、すべてのスレッドが終わる前にコマンドラインに戻ってきてしまう。また、標準入出力のパイプ処理への対応も面倒であるため、CUI版は実行ファイルを分けることにした。

コマンドラインオプションの解釈は、Boost C++ライブラリoptions を利用した。
その他の関数、ヘルプファイルやインストーラー作成方法については、これまでの連載で説明してきたとおりである。

参考サイト

(この項おわり)
header