SRELL

概要

std::regexと同じクラス構成

　SRELLはECMAScript (JavaScript) 互換の正規表現エンジンを、"std::regex"（C++11で導入された正規表現ライブラリ）とクラス構成が同じになるようにラッピングしたものです。クラスデザインが同じですので、std::regexや、その基となったboost::regexと同じ感覚で扱えます。

Unicodeに特化した実装

　SRELLはUnicodeに特化した正規表現ライブラリです。

• 特別な設定をせずとも既定でUTF-8/UTF-16/UTF-32文字列が扱えます。'.' がUTF-16文字列でサロゲートペアの片割れだけにマッチしたり、UTF-8文字列のコードユニットにマッチしたりするようなことがありません。
• 文字クラス内でプレーン1以降の文字も [丈𠀋] のように指定できます。また [\u{1b000}-\u{1b0ff}] のような範囲指定もできます。
• ギリシア文字のΣのように小文字が2種類ある字（\u03c2 [ς] と \u03c3 [σ]）や、クロアチア語で使われるラテン文字DŽのように、「大文字DŽ (upper-case)」・「小文字dž (lower-case) 」に加えて、「頭文字Dž (title-case)」なる第3のcaseがある文字でも、icase検索（大文字・小文字を区別しない検索）時にきちんと処理されます。

※ちなみにC++11のstd::regexは、us-asciiやiso-8859-*のような1文字が固定長の文字コードを前提としています。そのため1文字が可変長であるUTF-8やUTF-16の文字列はうまく扱えません。
　C++0x（現C++11）にchar16_t/char32_t型が導入されることになった時に、C++の作業部会内でu16stringやu32stringに加えてregexも対応するかどうか議論があったようですが、反対意見が多かったため見送られてそのままになっているようです。

　C++11に向けた改訂作業の中でもregexは比較的初期に提案された拡張であったことから、まったくと言って良いほどC++11の新機能に依存していません。そのためC++11より前のコンパイラであっても、C++のテンプレートを正しく解釈するものであればSRELLは利用可能です（動作確認済みコンパイラのうちもっとも古いものはVC++2005です）。

Download

• SRELL 2.500 (BSD License) 2019年11月18日版（更新履歴）

使い方

　パスの通ったところに srell*.hpp（srell.hpp, srell_ucfdata.hpp, srell_updata.hpp の3ファイル）を置いて srell.hpp をincludeするだけです。

//  Example 01:
#include <cstdio>
#include <string>
#include <iostream>
#include "srell.hpp"

int main()
{
    srell::regex e;     //  正規表現オブジェクト。
    srell::cmatch m;    //  結果を納めるオブジェクト。

    e = "\\d+[^-\\d]+"; //  正規表現をコンパイル。
    if (srell::regex_search("1234-5678-90ab-cdef", m, e))
    {
        //  printfを使うなら。
        const std::string s(m[0].first, m[0].second);
            //  上は下のどちらかでも良い。
            //  const std::string s(m[0].str());
            //  const std::string s(m.str(0));
        std::printf("result: %s\n", s.c_str());

        //  iostreamを使うなら。
        std::cout << "result: " << m[0] << std::endl;
    }
    return 0;
}
	

　この例のように、SRELLを構成するクラスやアルゴリズムはすべてnamespace srellの下に置かれています。この点を除けば使い方はstd::regexに準じます。

　現時点ではまだstd::regexに関する日本語の文書があまりないようですので、さしあたってSRELLを使ううえで必要となりそうな情報を次のページにまとめました。

• SRELLの使い方

　Zipアーカイヴ内の reame_ja.txt も併せてご覧ください。

#if defined(__cpp_unicode_characters) && !defined(SRELL_CPP11_CHAR1632_ENABLED)
  #define SRELL_CPP11_CHAR1632_ENABLED  //  char16_t, char32_t用のtypedefを行う。
#endif
#ifdef __cpp_initializer_lists
  #include <initializer_list>
  #ifndef SRELL_CPP11_INITIALIZER_LIST_ENABLED
  #define SRELL_CPP11_INITIALIZER_LIST_ENABLED  //  引数にinitializer_listを渡せるようにする。
  #endif
#endif
#ifdef __cpp_rvalue_references
  #ifndef SRELL_CPP11_MOVE_ENABLED
  #define SRELL_CPP11_MOVE_ENABLED  //  コンストラクタや代入でmoveを有効にする。
  #endif
#endif
		

#ifdef __cpp_char8_t
  #ifdef __cpp_lib_char8_t
  #define SRELL_CPP20_CHAR8_ENABLED 2   //  char8_t対応とstd::u8string対応との両方を行う。
  #else
  #define SRELL_CPP20_CHAR8_ENABLED 1   //  char8_t対応のみ行う。
  #endif
#endif
		

SRELLの正規表現

　SRELL 2ではECMAScript 2019 (ES10.0) のRegExp互換の正規表現が使えます。

　具体的には次の通りです。

註

• 正規表現が '\' で終わっていたり '\' がこの表にない組み合わせで使われたりした時は、error_escapeがthrowされてきます。後者についてはSRELL 2.300まで「'\' に続く文字そのもの」として解釈されていましたが、2.301以降はECMAScriptの仕様に合わせてエラー扱いするようになりました。
• 後方参照の直後に数字を書きたい時、これらが続けて解釈されるのを防ぐ方法としては「/\1\u0030/ のように数字のほうはコードポイントで書く」「/\1[0]/ のように、数字のほうはその1文字だけからなる文字クラスとして書く」の2つがあります。SRELLのパターンコンパイラはどちらの書き方も同じ内部表現に変換します。
• ECMAScriptの正規表現には \ooo や \0ooo のような8進数表現が存在しません。ECMAScriptの仕様では、\に0が続く時は<NUL> (\u0000) として解釈し、1-9で始まる数字が続く時は後方参照として解釈、その際対応する()が正規表現中に存在しなければエラーと定められています。
• ECMAScript 2017 (ES8.0) 以前の正規表現には、Perlにあるようなシングルラインモードが存在しませんでした。そのためSRELL 1にもシングルラインモードがありません。「何にでもマッチする1文字」が必要な時は [^] （空集合の補集合）で代用できます。
• 肯定先読みを使うことで、Javaなどで利用可能な文字クラス同士のAND演算が出来ます（例：/(?=[cgkq])[a-z]/）。またこの応用で、否定先読みを使うと減算相当の処理も出来ます（例：/(?![cgkq])[a-z]/）。

std::regexとの相違点

Unicode対応のためのSRELL拡張

　Unicode対応のために、次のような型がSRELLには追加されています。

basic_regex

basic_regexのtypedef一覧

入力型	UTF-8用	UTF-16用	UTF-32用	備考
char	u8cregex	-	-	SRELL_CPP20_CHAR8_ENABLEDマクロ非定義時はu8regexとしてもtypedefされる。
wchar_t	-	u16wregex	u32wregex	WCHAR_MAXが0xffff以上、0x10ffff未満ならu16wregexが定義され、WCHAR_MAXが0x10ffff以上ならu32wregexが定義される。排他的。
char8_t	u8regex	-	-	SRELL_CPP20_CHAR8_ENABLEDマクロ定義時のみ。
char16_t	-	u16regex	-	SRELL_CPP11_CHAR1632_ENABLEDマクロ定義時のみ。
char32_t	-	-	u32regex

//  UTF-8文字列用。
#if defined(SRELL_CPP20_CHAR8_ENABLED)
    typedef basic_regex<char8_t, u8regex_traits<char8_t> > u8regex;
#endif
typedef basic_regex<char, u8regex_traits<char> > u8cregex;
#if !defined(SRELL_CPP20_CHAR8_ENABLED)
    typedef u8cregex u8regex;
#endif

#if defined(SRELL_CPP11_CHAR1632_ENABLED)
    //  C++11対応コンパイラ用。
    typedef basic_regex<char16_t, u16regex_traits<char16_t> > u16regex;
    typedef basic_regex<char32_t> u32regex;
#endif

//  wchar_tの大きさにより、u32wregex か u16wregex かにtypedefする。
#if defined(WCHAR_MAX)
    #if WCHAR_MAX >= 0x10ffff
        typedef wregex u32wregex;
    #elif WCHAR_MAX >= 0xffff
        typedef basic_regex<wchar_t, u16regex_traits<wchar_t> > u16wregex;
    #endif
#endif
				

　UTF-8やUTF-16に固有の処理をしているのはそれぞれ上記のu8regex_traits、u16regex_traitsです。このことを利用して、たとえば basic_regex<uint32_t, u16regex_traits<uint32_t> > のような「UTF-16文字列をuint32_t型の配列で処理する型」なるものを作ることもできます。

match_results

match_resultsのtypedef一覧

入力型	UTF-8用	UTF-16用	UTF-32用	備考
char	u8ccmatch u8csmatch	-	-	SRELL_CPP20_CHAR8_ENABLEDマクロ非定義時はそれぞれu8[cs]matchにもtypedefされる。
wchar_t	-	u16wcmatch u16wsmatch	u32wcmatch u32wsmatch	WCHAR_MAXが0xffff以上、0x10ffff未満ならu16w[cs]matchが定義され、WCHAR_MAXが0x10ffff以上ならu32w[cs]matchが定義される。排他的。
char8_t	u8cmatch u8smatch	-	-	SRELL_CPP20_CHAR8_ENABLEDマクロ定義時のみ。
char16_t	-	u16cmatch u16smatch	-	SRELL_CPP11_CHAR1632_ENABLEDマクロ定義時のみ。
char32_t	-	-	u32cmatch u32smatch

//  UTF-8文字列用。
#if defined(SRELL_CPP20_CHAR8_ENABLED)
    typedef match_results<const char8_t *> u8cmatch;
#endif
#if defined(SRELL_CPP20_CHAR8_ENABLED) && SRELL_CPP20_CHAR8_ENABLED >= 2
    typedef match_results<std::u8string::const_iterator> u8smatch;
#endif
typedef cmatch u8ccmatch;
typedef smatch u8csmatch;
#if !defined(SRELL_CPP20_CHAR8_ENABLED)
    typedef u8ccmatch u8cmatch;
#endif
#if !defined(SRELL_CPP20_CHAR8_ENABLED) || SRELL_CPP20_CHAR8_ENABLED < 2
    typedef u8csmatch u8smatch;
#endif

#if defined(SRELL_CPP11_CHAR1632_ENABLED)
    //  C++11対応コンパイラ用。
    typedef match_results<const char16_t *> u16cmatch;
    typedef match_results<const char32_t *> u32cmatch;
    typedef match_results<std::u16string::const_iterator> u16smatch;
    typedef match_results<std::u32string::const_iterator> u32smatch;
#endif

//  wchar_tの大きさにより、w[cs]match を u32w[cs]match か u16w[cs]match かにtypedefする。
#if defined(WCHAR_MAX)
    #if WCHAR_MAX >= 0x10ffff
        typedef wcmatch u32wcmatch;
        typedef wsmatch u32wsmatch;
    #elif WCHAR_MAX >= 0xffff
        typedef wcmatch u16wcmatch;
        typedef wsmatch u16wsmatch;
    #endif
#endif
				

　この他にversion 2.300以降は、match_resultsクラスにはBidirectionalIterator lookbehind_limitというメンバが追加されています。詳細はmatch_lblim_availフラグの説明のところに記してあります。

sub_match

sub_matchのtypedef一覧

入力型	UTF-8用	UTF-16用	UTF-32用	備考
char	u8ccsub_match u8cssub_match	-	-	SRELL_CPP20_CHAR8_ENABLEDマクロ非定義時はそれぞれu8[cs]sub_matchにもtypedefされる。
wchar_t	-	u16wcsub_match u16wssub_match	u32wcsub_match u32wssub_match	WCHAR_MAXが0xffff以上、0x10ffff未満ならu16w[cs]sub_matchが定義され、WCHAR_MAXが0x10ffff以上ならu32w[cs]sub_matchが定義される。排他的。
char8_t	u8csub_match u8ssub_match	-	-	SRELL_CPP20_CHAR8_ENABLEDマクロ定義時のみ。
char16_t	-	u16csub_match u16ssub_match	-	SRELL_CPP11_CHAR1632_ENABLEDマクロ定義時のみ。
char32_t	-	-	u32csub_match u32ssub_match

//  UTF-8文字列用。
#if defined(SRELL_CPP20_CHAR8_ENABLED)
    typedef sub_match_results<const char8_t *> u8csub_match;
#endif
#if !defined(SRELL_CPP20_CHAR8_ENABLED) && SRELL_CPP20_CHAR8_ENABLED >= 2
    typedef sub_match_results<std::u8string::const_iterator> u8ssub_match;
#endif
typedef csub_match u8ccsub_match;
typedef ssub_match u8cssub_match;
#if !defined(SRELL_CPP20_CHAR8_ENABLED)
    typedef u8ccsub_match u8csub_match;
#endif
#if !defined(SRELL_CPP20_CHAR8_ENABLED) || SRELL_CPP20_CHAR8_ENABLED < 2
    typedef u8cssub_match u8ssub_match;
#endif

#if defined(SRELL_CPP11_CHAR1632_ENABLED)
    //  C++11対応コンパイラ用。
    typedef sub_match_results<const char16_t *> u16csub_match;
    typedef sub_match_results<const char32_t *> u32csub_match;
    typedef sub_match_results<std::u16string::const_iterator> u16ssub_match;
    typedef sub_match_results<std::u32string::const_iterator> u32ssub_match;
#endif

//  wchar_tの大きさにより、w[cs]submatch を u32w[cs]submatch か u16w[cs]submatch かにtypedefする。
#if defined(WCHAR_MAX)
    #if WCHAR_MAX >= 0x10ffff
        typedef wcsub_match u32wcsub_match;
        typedef wssub_match u32wssub_match;
    #elif WCHAR_MAX >= 0xffff
        typedef wcsub_match u16wcsub_match;
        typedef wssub_match u16wssub_match;
    #endif
#endif
				

　各prefixの意味するところは次の通りです。

• u8: コンパイラがchar8_t型に対応しているかどうか（SRELL_CPP20_CHAR8_ENABLEDマクロ定義の有無で判断）で次のように変わります。
  • char8_t対応なら：char8_t型配列またはstd::u8string型インスタンスをUTF-8文字列として扱う。
  • char8_t未対応なら：u8c-に同じ。
• u16: char16_t型配列またはstd::u16string型インスタンスをUTF-16文字列として扱う。
• u32: char32_t型配列またはstd::u32string型インスタンスをUTF-32文字列として扱う。

• u8c: char型配列またはstd::string型インスタンスをUTF-8文字列として扱う（SRELL 2.100で導入。SRELL 2.002まではこれがu8-というprefixを使用していました）。
• u16w: wchar_t型配列またはstd::wstring型インスタンスをUTF-16文字列として扱う（WCHAR_MAXが0xffff以上0x10ffff未満の時のみ定義）。
• u32w: wchar_t型配列またはstd::wstring型インスタンスをUTF-32文字列として扱う（WCHAR_MAXが0x10ffff以上の時のみ定義）。

　このルールに基づいて、regex_iteratorやregex_token_iteratorでも同じようにu(8c?|16w?|32w?) prefixの付いた型がtypedefされています。

　基本的な使い方は次の通りです。

srell::u8regex u8re(u8"UTF-8文字列による正規表現");
srell::u8cmatch u8cm;
std::printf("%s\n", srell::regex_search(u8"検索対象となるUTF-8文字列", u8cm, u8re) ? "found!" : "not found...");

srell::u16regex u16re(u"UTF-16文字列による正規表現");
srell::u16cmatch u16cm;
std::printf("%s\n", srell::regex_search(u"検索対象となるUTF-16文字列", u16cm, u16re) ? "found!" : "not found...");

srell::u32regex u32re(U"UTF-32文字列による正規表現");
srell::u32cmatch u32cm;
std::printf("%s\n", srell::regex_search(U"検索対象となるUTF-32文字列", u32cm, u32re) ? "found!" : "not found...");

srell::u16wregex u16wre(L"UTF-16文字列による正規表現");
srell::u16wcmatch u16wcm;
std::printf("%s\n", srell::regex_search(L"検索対象となるUTF-16文字列", u16wcm, u16wre) ? "found!" : "not found...");
    //  上3行と下3行とは排他的。wchar_tが21ビット未満なら上、以上なら下。
srell::u32wregex u32wre(L"UTF-32文字列による正規表現");
srell::u32wcmatch u32wcm;
std::printf("%s\n", srell::regex_search(L"検索対象となるUTF-32文字列", u32wcm, u32wre) ? "found!" : "not found...");
			

　C++11より前のコンパイラでは、wchar_tが16ビット以上かつ21ビット未満の環境ならu8c-型とu16w-型とが、wchar_tが21ビット以上ある環境ならu8c-型とu32w-型とがそれぞれ利用可能です。もっともそのような環境でも、SRELLをincludeする前に次のようなコードを書いておけば、u8c-型、u16-型、u32-型を3つとも利用することができます。

typedef uint_least16_t char16_t;    //  16ビット以上ある符号無しの型をtypedefする。
typedef uint_least32_t char32_t;    //  32ビット以上ある符号無しの型をtypedefする。

namespace std
{
    typedef basic_string<char16_t> u16string;
    typedef basic_string<char32_t> u32string;
}

#define SRELL_CPP11_CHAR1632_ENABLED    //  手動でonにする。
			

名前付きキャプチャ用のSRELL拡張

　SRELL 2では名前付きキャプチャ (named-capture) 用に、次のメンバ函数がmatch_resultsクラスに追加されています。

difference_type length(const string_type &sub) const;
difference_type position(const string_type &sub) const;
string_type str(const string_type &sub) const;
const_reference operator[](const string_type &sub) const;
			

　使い方はstd::regexにある同名の函数と同じです。ただ引数として括弧の番号ではなく括弧の名前を渡すという点のみが異なります。

//  使用例。
srell::regex e("-(?<digits>\\d+)-");
srell::cmatch m;

if (srell::regex_search("1234-5678-90ab-cdef", m, e))
{
    const std::string by_number(m.str(1));      //  std::regexにもある括弧の番号を使ったアクセス。
    const std::string by_name(m.str("digits")); //  名前を使って同じ括弧へアクセス。SRELL 2の独自拡張。

    std::printf("results: bynumber=%s byname=%s\n", by_number.c_str(), by_name.c_str());
}
//  results: bynumber=5678 byname=5678 と表示される。
			

syntax_option_typeへのSRELL拡張

　SRELL 2には次のフラグオプションが追加されています。

namespace regex_constants
{
    static const syntax_option_type dotall; //  シングルライン指定。
        //  シングルラインモード用フラグオプションを参照。
}
			

　他のsyntax_option_type型の値と同様に、この値はbasic_regex内でも定義されています。

dotall（シングルラインモード指定用フラグオプション）

　正規表現パターンのコンパイル時に dotall フラグオプション（regex_constants::syntax_option_type型またはbasic_regex::flag_type型）が指定されていると '.' の挙動が変わります。
　このフラグオプションはPerl 5の //s に相当します。

match_flag_typeへのSRELL拡張

　次のフラグオプションが追加されています。

namespace regex_constants
{
    //  SRELL 2.300以降。
    static const match_flag_type match_lblim_avail;
}
			

match_lblim_avail（Lookbehindの逆行限界を指定するフラグオプション）

　match_lblim_availフラグがセットされると戻り読み (lookbehind) が行われる際、アルゴリズム函数に渡したmatch_results型インスタンスのlookbehind_limitメンバの値を「逆行できる限界」と見なすようになります。

const char text[] = "0123456789abcdefghijklmnopqrstuvwxyz";
const char* const begin = text;
const char* const end = text + std::strlen(text);
const char* const first = text + 10;    //  'a' の位置に合わせる。
const srell::regex re("(?<=^\\d+).");
srell::cmatch match;

match.lookbehind_limit = begin;

std::printf("matched %d\n", srell::regex_search(first, end, match, re));
    //  戻り読みも [first, end) の範囲でのみ行われるのでマッチしない。

std::printf("matched %d\n", srell::regex_search(first, end, match, re, srell::regex_constants::match_lblim_avail));
    //  match.lookbehind_limitまで逆行できるのでマッチする。
    //  即ち match_lblim_avail指定時は [match.lookbehind_limit, end) というシークウェンスに対して
    //  firstよりsearchを始める。
				

　上の例にもあります通りmatch_lblim_availが指定された時は、^ は first ではなく match.lookbehind_limit にマッチするようになります。

※逆行限界を渡す手段としては少し不格好ですので、P1844の帰趨を見てちゃんとした方法に改める予定です。

正規表現エンジンとフラグ

　std::regexは、次の6つの正規表現エンジンから選択する仕組みになっています（既定はECMAScript）。

std::regexの正規表現エンジン

ECMAScript （既定）	ECMAScriptの正規表現からUnicodeに依存した要素（\sの定義など）を取り除き、代わりにlocale依存の処理とC++の規格書29.13 [re.grammar] にある拡張とを追加したもの。 \uxxxxのような表現も使用可能ではあるものの、現在のlocaleの文字集合にない文字が指定された場合どうなるのかは不明。
basic	POSIXのbasic regular expression相当。
extended	POSIXのextended regular expression相当。
awk	POSIXのawk相当。
grep	POSIXのgrep相当。
egrep	POSIXのegrep相当。

　一方SRELLにはこのような選択肢はなく、常にECMAScript互換のエンジンで動きます。この関係で、std::regexで定義されているフラグオプションのうち次のものは、たとえ指定してもSRELLでは無視されます。

syntax_option_type（かつbasic_regexのflag_type）

• icaseとmultiline以外のすべて

match_flag_type

• match_any
• format_sed

　std::regexのECMAScriptモードとSRELLとの違いは次の通りです。

• std::regexのECMAScriptモード: ECMAScript 3rd editionのRegExpの仕様から「Unicode依存の定義」を取り去り、「localeへの依存」「[:クラス名:], [.クラス名.], [=クラス名=]という表現」を追加。
• SRELL 2: ECMAScript 2018のRegExpの仕様に準拠。
• SRELL 1: ECMAScript 2017のRegExpの仕様に「固定幅の戻り読み」を追加。

　同じECMAScriptベースでありながらもstd::regexとSRELLとはどちらもどちらの上位互換になっていません。

長考対策

　ECMAScriptの正規表現（およびその元となったPerlの正規表現）では通常、バックトラッキングと呼ばれる方法を使って照合が行われます。このバックトラッキング方式には、「量指定子（回数指定）が入れ子になっている正規表現」や「量指定子を伴う文字ないし文字クラスが連続していて、かつそれらが互いに排他的な集合になっていない正規表現」で検索を行うと、オートマトンが著しい長考に入ってしまうことがあるという問題が存在します。

　次のような例が有名です。

• "aaaaaaaaaaaaaaaaaaaaaaaaaaaaa" =~ /(a*)*b/
• "aaaaaaaaaaaaaaaaaaaaaaaaaaaaa" =~ /a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?aaaaaaaaaaaaaaaaaaaaaaaaaaaaa/

　残念ながらこの現象に対しては、あらゆる状況に適用できる根本的な解決策というものが見つかっていません。そこで制御が長時間返ってこなくなる事態を避けるため、SRELLは特定の位置からの照合が一定回数以上失敗すると、regex_error(regex_constants::error_complexity) を throw するようになっています。
　回数の既定値は16777216（256の3乗）ですが、regex_search()やregex_match()に渡すbasic_regex型インスタンスのlimit_counter変数に任意の値を代入することで変更することも出来ます。

非互換の変更

"abcd" =~ /(?<=(.){2})./
//  固定幅の戻り読み: $& = "c", $1 = "b".
//  オートマトンは戻り読み内でも通常通り左から右へと文字列を照合してゆくため、
//  "c" の直前にある "b" が「$1によって最後にキャプチャされたもの」となる。

//  可変幅の戻り読み: $& = "c", $1 = "a".
//  オートマトンは戻り読み内では右から左へと走るため、"c" から2つ離れた
//  "a"が「$1によって最後にキャプチャされたもの」となる。
		

関連リンク

• SRELLの使い方
• Unicode Property Escapesについての補説

　以下は外部のサイトです。