...

パッケージ syntax

import "regexp/syntax"
概要
目次

概要 ▾

syntax パッケージは,正規表現をパースしてパースツリーを作成し,パースツリーをコンパイルしてプログラムにします。 たいていの場合,このパッケージではなく, regexp パッケージの機能 (たとえば,Compile や Match) を使えば十分です。

構文

このパッケージが Perl フラグで解析するときに理解する正規表現の構文は次のとおりです。 構文の一部は, Parse に代替フラグを渡すことで無効にできます。

単一文字:

.              任意の文字,改行を含むかもしれない (フラグ s=true)
[xyz]          文字クラス
[^xyz]         否定文字クラス
\d             Perl 文字クラス
\D             否定 Perl 文字クラス
[[:alpha:]]    ASCII 文字クラス
[[:^alpha:]]   否定 ASCII 文字クラス
\pN            Unicode 文字クラス (1 文字の名前)
\p{Greek}      Unicode 文字クラス
\PN            否定 Unicode 文字クラス (1 文字の名前)
\P{Greek}      否定 Unicode 文字クラス

複合:

xy             x のあとに y が続く
x|y            x あるいは y (x を優先)

繰り返し:

x*             x をゼロ以上, 多いのを優先
x+             x を 1 つ以上, 多いのを優先
x?             x を ゼロか 1 つ, 1 つを優先
x{n,m}         x を n か n+1 か ... か m, 多いのを優先
x{n,}          x を n 以上, 多いのを優先
x{n}           x をちょうど n 個
x*?            x をゼロ以上, 少ないのを優先
x+?            x を 1 つ以上, 少ないのを優先
x??            x を ゼロか 1 つ, ゼロを優先
x{n,m}?        x を n か n+1 か ... か m, 少ないのを優先
x{n,}?         x を n 以上, 少ないのを優先
x{n}?          x をちょうど n 個

実装上の制限: カウント形式 x{n,m}, x{n,} ,および x{n} は, 1000 を超える最小または最大の繰り返し数を作成する形式を拒否します。 無制限の繰り返しは,この制限の対象にはなりません。

グループ化:

(re)           番号付き捕捉グループ (部分マッチ)
(?P<name>re)   名前と番号付き捕捉グループ (部分マッチ)
(?:re)         非捕捉グループ
(?flags)       現在のグループ内にフラグを設定する。非捕捉
(?flags:re)    re 中にフラグを設定します。非捕捉

フラグの構文は, xyz (設定) または -xyz (クリア) または xy-z (設定 xy, クリア z) です。
フラグは以下のとおりです。

i              大文字と小文字を区別しない (デフォルトは false)
m              複数行モード: ^ と $ は,テキストの開始/終了に加えて行の開始/終了行にマッチします (デフォルトは false)
s              . を \n にマッチさせる (デフォルトは false)
U              貪欲でない: x* と x*?, x+ と x+? などの意味の交換 (デフォルトは false)

空の文字列:

^              テキストまたは行の先頭 (フラグ m=true)
$              テキストの末尾 (Perl の \Z ではなく \z のように) または行の末尾 (フラグ m=true)
\A             テキストの先頭
\b             ASCII ワード境界 (片側に \w ,反対側に \W , \A ,または \z)
\B             ASCII ワード境界でない
\z             テキストの末尾

エスケープシーケンス:

\a             ベル (== \007)
\f             フォームフィード (== \014)
\t             水平タブ (== \011)
\n             改行 (== \012)
\r             キャリッジリターン (== \015)
\v             垂直タブ文字 (== \013)
\*             リテラル *,(* は任意の句読文字)
\123           8 進文字コード (up to three digits)
\x7F           16 進文字コード (exactly two digits)
\x{10FFFF}     16 進文字コード
\Q...\E        リテラルテキスト ... (... に句読点があっても)

文字クラス要素:

x              単一文字
A-Z            文字範囲 (両端を含む)
\d             Perl 文字クラス
[:foo:]        ASCII 文字クラス foo
\p{Foo}        Unicode 文字クラス Foo
\pF            Unicode 文字クラス F (1 文字の名前)

文字クラス要素としての名前付き文字クラス:

[\d]           数字 (== \d)
[^\d]          数字ではない (== \D)
[\D]           数字ではない (== \D)
[^\D]          数字ではないではない (== \d)
[[:name:]]     文字クラス内の名前付き ASCII クラス (== [:name:])
[^[:name:]]    名前付き ASCII クラス内の否定された文字クラス (== [:^name:])
[\p{Name}]     文字クラス内の名前付き Unicode プロパティ (== \p{Name})
[^\p{Name}]    否定文字クラス内の名前付き Unicode プロパティ (== \P{Name})

Perl 文字クラス (すべて ASCII のみ):

\d             数字 (== [0-9])
\D             数字ではない (== [^0-9])
\s             空白 (== [\t\n\f\r ])
\S             空白ではない (== [^\t\n\f\r ])
\w             単語文字 (== [0-9A-Za-z_])
\W             単語文字ではない (== [^0-9A-Za-z_])

ASCII 文字クラス:

[[:alnum:]]    英数字 (== [0-9A-Za-z])
[[:alpha:]]    アルファベット (== [A-Za-z])
[[:ascii:]]    ASCII (== [\x00-\x7F])
[[:blank:]]    空白 (== [\t ])
[[:cntrl:]]    コントロール (== [\x00-\x1F\x7F])
[[:digit:]]    数字 (== [0-9])
[[:graph:]]    グラフィカル (== [!-~] == [A-Za-z0-9!"#$%&'()*+,\-./:;<=>?@[\\\]^_`{|}~])
[[:lower:]]    小文字 (== [a-z])
[[:print:]]    表示可能 (== [ -~] == [ [:graph:]])
[[:punct:]]    句読点 (== [!-/:-@[-`{-~])
[[:space:]]    空白 (== [\t\n\v\f\r ])
[[:upper:]]    大文字 (== [A-Z])
[[:word:]]     単語文字 (== [0-9A-Za-z_])
[[:xdigit:]]   16 進数 (== [0-9A-Fa-f])

func IsWordChar

func IsWordChar(r rune) bool

IsWordChar は, \b および \B ゼロ幅アサーションの評価中に, r が " 単語文字 " と見なされるかどうかを報告します。 これらのアサーションは ASCII のみです。 単語の文字は [A-Za-z0-9_] です。

type EmptyOp

EmptyOp は,ゼロ幅アサーションの種類または混在を指定します。

type EmptyOp uint8
const (
    EmptyBeginLine EmptyOp = 1 << iota
    EmptyEndLine
    EmptyBeginText
    EmptyEndText
    EmptyWordBoundary
    EmptyNoWordBoundary
)

func EmptyOpContext

func EmptyOpContext(r1, r2 rune) EmptyOp

EmptyOpContext は,ルーン r1 と r2 の間の位置で満たされるゼロ幅アサーションを返します。 r1 == -1 を渡すと,位置がテキストの先頭にあることを示します。 r2 == -1 を渡すと,位置がテキストの末尾にあることを示します。

type Error

エラーは,正規表現を解析できなかったことを表し,問題のある表現を表します。

type Error struct {
    Code ErrorCode
    Expr string
}

func (*Error) Error

func (e *Error) Error() string

type ErrorCode

ErrorCode は,正規表現を解析できなかったことを表します。

type ErrorCode string
const (
    // 予期しないエラー
    ErrInternalError ErrorCode = "regexp/syntax: internal error"

    // 解析エラー
    ErrInvalidCharClass      ErrorCode = "invalid character class"
    ErrInvalidCharRange      ErrorCode = "invalid character class range"
    ErrInvalidEscape         ErrorCode = "invalid escape sequence"
    ErrInvalidNamedCapture   ErrorCode = "invalid named capture"
    ErrInvalidPerlOp         ErrorCode = "invalid or unsupported Perl syntax"
    ErrInvalidRepeatOp       ErrorCode = "invalid nested repetition operator"
    ErrInvalidRepeatSize     ErrorCode = "invalid repeat count"
    ErrInvalidUTF8           ErrorCode = "invalid UTF-8"
    ErrMissingBracket        ErrorCode = "missing closing ]"
    ErrMissingParen          ErrorCode = "missing closing )"
    ErrMissingRepeatArgument ErrorCode = "missing argument to repetition operator"
    ErrTrailingBackslash     ErrorCode = "trailing backslash at end of expression"
    ErrUnexpectedParen       ErrorCode = "unexpected )"
)

func (ErrorCode) String

func (e ErrorCode) String() string

type Flags

フラグはパーサーの振る舞いを制御し,正規表現コンテキストに関する情報を記録します。

type Flags uint16
const (
    FoldCase      Flags = 1 << iota // 大文字と小文字を区別しない
    Literal                         // パターンをリテラル文字列として扱う
    ClassNL                         // [^a-z] や [[:space:]] のような文字クラスを改行にマッチさせる
    DotNL                           // 許可します。
    DotNL                           // 改行に合わせる
    OneLine                         // ^ と $ をテキストの最初と最後でのみ一致するものとして扱います。
    NonGreedy                       // 繰り返し演算子をデフォルトで非欲張りにする
    PerlX                           // Perl 拡張を許可する
    UnicodeGroups                   // Unicode グループと否定に \p{Han} , \P{Han} を許可
    WasDollar                       // 正規表現 OpEndText は $ ではなく, \z でした
    Simple                          // 正規表現にカウントされた繰り返しが含まれていません

    MatchNL = ClassNL | DotNL

    Perl        = ClassNL | OneLine | PerlX | UnicodeGroups // できるだけ Perl に近い
    POSIX Flags = 0                                         // POSIX の構文
)

type Inst

Inst は,正規表現プログラム内の 1 つの命令です。

type Inst struct {
    Op   InstOp
    Out  uint32 // InstMatch, InstFail を除くすべて
    Arg  uint32 // InstAlt, InstAltMatch, InstCapture, InstEmptyWidth
    Rune []rune
}

func (*Inst) MatchEmptyWidth

func (i *Inst) MatchEmptyWidth(before rune, after rune) bool

MatchEmptyWidth は,命令が前後のルーンの間の空の文字列と一致するかどうかを報告します。 i.Op == InstEmptyWidth の場合にのみ呼び出されるべきです。

func (*Inst) MatchRune

func (i *Inst) MatchRune(r rune) bool

MatchRune は,命令が r に一致する (そして消費する) かどうかを報告します。 i.Op == InstRune の場合にのみ呼び出されるべきです。

func (*Inst) MatchRunePos 1.3

func (i *Inst) MatchRunePos(r rune) int

MatchRunePos は,命令が r に一致する (そして消費する) かどうかをチェックします。 一致する場合, MatchRunePos は一致するルーンペアのインデックスを返します (または, len(i.Rune) == 1 の場合は rune シングルトン) 。 そうでない場合, MatchRunePos は -1 を返します。 MatchRunePos は i.Op == InstRune の場合にのみ呼び出されるべきです。

func (*Inst) String

func (i *Inst) String() string

type InstOp

InstOp は命令オペコードです。

type InstOp uint8
const (
    InstAlt InstOp = iota
    InstAltMatch
    InstCapture
    InstEmptyWidth
    InstMatch
    InstFail
    InstNop
    InstRune
    InstRune1
    InstRuneAny
    InstRuneAnyNotNL
)

func (InstOp) String 1.3

func (i InstOp) String() string

type Op

Op は 1 つの正規表現演算子です。

type Op uint8
const (
    OpNoMatch        Op = 1 + iota // 文字列にマッチしない
    OpEmptyMatch                   // 空の文字列とマッチ
    OpLiteral                      // ルーン文字列とマッチ
    OpCharClass                    // 範囲ペアリストとして解釈されるルーン文字にマッチします
    OpAnyCharNotNL                 // 改行以外の任意の文字とマッチします
    OpAnyChar                      // 任意の文字にマッチ
    OpBeginLine                    // 行頭の空文字列にマッチ
    OpEndLine                      // 行末の空文字列にマッチ
    OpBeginText                    // テキストの先頭の空文字列にマッチ
    OpEndText                      // テキストの末尾の空の文字列にマッチ
    OpWordBoundary                 // 単語境界 `\b` にマッチ
    OpNoWordBoundary               // 境界ではない単語 `\B` にマッチ
    OpCapture                      // インデックス Cap で部分式をキャプチャする,オプションの名前 Name
    OpStar                         // Sub[0] に 0 回以上マッチします
    OpPlus                         // Sub[0] に 1 回以上マッチ
    OpQuest                        // Sub[0] に 0 回または 1 回マッチ
    OpRepeat                       // Sub[0] と最低 Min 回,最大 Max とマッチします (Max == -1 は無制限) 。
    OpConcat                       // Subs の連結にマッチします
    OpAlternate                    // 潜水艦の交代にマッチ
)

func (Op) String 1.11

func (i Op) String() string

type Prog

Prog はコンパイルされた正規表現プログラムです。

type Prog struct {
    Inst   []Inst
    Start  int // 開始命令のインデックス
    NumCap int // 再インストール中の InstCapture インスタンスの数
}

func Compile

func Compile(re *Regexp) (*Prog, error)

コンパイルは,正規表現を実行するプログラムにコンパイルします。 正規表現はすでに単純化されているはずです (re.Simplify から返されます) 。

func (*Prog) Prefix

func (p *Prog) Prefix() (prefix string, complete bool)

Prefix は,正規表現に一致するすべての文字列で始まるリテラル文字列を返します。 prefix が全体マッチの場合, complete が true になります。

func (*Prog) StartCond

func (p *Prog) StartCond() EmptyOp

StartCond は,どの一致にも当てはまる必要がある先行する空幅条件を返します。 一致しない場合は ^EmptyOp(0) を返します。

func (*Prog) String

func (p *Prog) String() string

type Regexp

正規表現は正規表現の構文木の中のノードです。

type Regexp struct {
    Op       Op // オペレーター
    Flags    Flags
    Sub      []*Regexp  // もしあれば,部分式
    Sub0     [1]*Regexp // 短い Sub 用のストレージ
    Rune     []rune     // OpLiteral, OpCharClass に対応するルーン文字
    Rune0    [2]rune    // 短いルーンの収納
    Min, Max int        // OpRepeat の最小,最大
    Cap      int        // OpCapture 用のキャプチャインデックス
    Name     string     // OpCapture のキャプチャ名
}

func Parse

func Parse(s string, flags Flags) (*Regexp, error)

Parse は,指定された Flags によって制御されている正規表現文字列 s を解析し,正規表現解析木を返します。 構文はトップレベルのコメントで説明されています。

func (*Regexp) CapNames

func (re *Regexp) CapNames() []string

CapNames は正規表現をたどってキャプチャグループの名前を見つけます。

func (*Regexp) Equal

func (x *Regexp) Equal(y *Regexp) bool

Equal は, x と y が同じ構造を持つかどうかを報告します。

func (*Regexp) MaxCap

func (re *Regexp) MaxCap() int

MaxCap は最大キャプチャインデックスを見つけるために正規表現をたどります。

func (*Regexp) Simplify

func (re *Regexp) Simplify() *Regexp

Simplify は, re と同等の正規表現を返しますが,回数付き繰り返しをなしにしたり, /(?:a+)+/ を /a+/ に書き換えるなど,その他のさまざまな単純化を行います。 結果の正規表現は正しく実行されますが,その文字列表現は同じ解析木を生成しません。 これは,括弧を取り込むことが重複しているか削除されている可能性があるためです。 たとえば, /(x){1,2}/ の単純化された形式は /(x)(x)?/ ですが,両方の括弧は $1 としてキャプチャされます。 返された正規表現は,元の構造と構造を共有しているか,元の構造である可能性があります。

func (*Regexp) String

func (re *Regexp) String() string