mikanya.parser

class Scanner;

スキャナー

this(wchar[] value);

Params:

wchar[] value

解析対象列

void advance();

次の解析対象に移る

bool atEnd();

解析が終了したら true を返す

wchar get();

解析対象を一つ取り出す

interface Parser;

パーサー共通のインターフェース

abstract Difference opSub(Parser p);
abstract Difference opSub(wchar c);
abstract Difference opSub(wchar[] c);

abstract Alternative opOr(Parser p);
abstract Alternative opOr(wchar c);
abstract Alternative opOr_r(wchar c);
abstract Alternative opOr(wchar[] c);
abstract Alternative opOr_r(wchar[] c);

abstract Sequence opShr(Parser p);
abstract Sequence opShr(wchar c);
abstract Sequence opShr_r(wchar c);
abstract Sequence opShr(wchar[] c);
abstract Sequence opShr_r(wchar[] c);

abstract Actor opIndex(void(* fp)(wchar[]));
abstract Actor opIndex(void delegate(wchar[]) dg);

abstract bool parse(Scanner s);

class ParserImpl: mikanya.parser.Parser;

パーサー基底クラス

Difference opSub(Parser p);
Difference opSub(wchar c);
Difference opSub(wchar[] c);

Difference パーサーを返す

Returns:
Difference パーサー

Alternative opOr(Parser p);
Alternative opOr(wchar c);
Alternative opOr_r(wchar c);
Alternative opOr(wchar[] c);
Alternative opOr_r(wchar[] c);

Alternative パーサーを返す

Returns:
Alternative パーサー

Sequence opShr(Parser p);
Sequence opShr(wchar c);
Sequence opShr_r(wchar c);
Sequence opShr(wchar[] c);
Sequence opShr_r(wchar[] c);

Sequence パーサーを返す

Returns:
Sequence パーサー

Actor opIndex(void(* action)(wchar[]));
Actor opIndex(void delegate(wchar[]) action);

Actor パーサーを返す

Returns:
Actor パーサー

bool parse(Scanner scanner);

構文解析する

サブクラスでオーバーライドすること

Params:

Scanner scanner

解析対象

Returns:
解析できたらtrue

class Operator: mikanya.parser.ParserImpl;

演算子パーサーの基底クラス

class BinaryOperator: mikanya.parser.Operator;

二項演算子パーサーの基底クラス base

this(Parser lhs, Parser rhs);

Params:

Parser lhs	演算子の左側
Parser rhs	演算子の右側

class UnaryOperator: mikanya.parser.Operator;

単項算子パーサーの基底クラス base

this(Parser operand);

Params:

Parser operand

被演算子

class Alternative: mikanya.parser.BinaryOperator;

Alternative parser

選択

this(Parser lhs, Parser rhs);

Params:

Parser lhs	演算子の左側
Parser rhs	演算子の右側

bool parse(Scanner s);

構文解析する

左側または右側のパーサーが解析が成功したらtrue

Params:

scanner

解析対象

Returns:
解析できたらtrue

class Sequence: mikanya.parser.BinaryOperator;

Sequence parser

順序

this(Parser lhs, Parser rhs);

Params:

Parser lhs	演算子の左側
Parser rhs	演算子の右側

bool parse(Scanner s);

構文解析する

左側が解析が成功しかつ右側の解析が成功したらtrue

Params:

scanner

解析対象

Returns:
解析できたらtrue

class Difference: mikanya.parser.BinaryOperator;

Difference parser

差

this(Parser lhs, Parser rhs);

Params:

Parser lhs	演算子の左側
Parser rhs	演算子の右側

bool parse(Scanner s);

構文解析する

左側が解析が成功しかつ右側の解析が失敗したらtrue

Params:

scanner

解析対象

Returns:
解析できたらtrue

class Actor: mikanya.parser.UnaryOperator;

解析が成功したら登録されたアクションを実行する

this(Parser operand, void(* action)(wchar[]));
this(Parser operand, void delegate(wchar[]) action);

bool parse(Scanner s);

class More;

class Repeat(int MIN,int MAX): UnaryOperator;
class Repeat(int MIN,MAX : More): UnaryOperator;

Repeat parser

繰り返し

this(Parser operand);

Params:

operand

被演算子

bool parse(Scanner s);

構文解析する

被演算子が MIN 以上 MAX 以下回成功したら true

Params:

scanner

解析対象

Returns:
解析できたらtrue

template rep_p(int MIN,int MAX)
template rep_p(int MIN,MAX : More)

Repeat parser generator

被演算子が MIN 回以上成功したら true

Params:

MIN	最低回数
MAX	最大回数

Returns:
Repeatクラス

Repeat!(MIN,MAX) rep_p(Parser operand);
Repeat!(MIN,MAX) rep_p(ScannerT c);
Repeat!(MIN,MAX) rep_p(ScannerT[] s);

class ZeroOrMore: mikanya.parser.UnaryOperator;

Zero or more parse

０回以上の出現

this(Parser operand);

Params:

Parser operand

被演算子

bool parse(Scanner s);

構文解析する

０回以上出現したら true

Params:

scanner

解析対象

Returns:
解析できたらtrue

ZeroOrMore zom_p(Parser operand);
ZeroOrMore zom_p(wchar c);
ZeroOrMore zom_p(wchar[] s);

ZeroOrMore parser generator

Params:

Parser operand

被演算子

Returns:
ZeroOrMoreクラス

class OneOrMore: mikanya.parser.UnaryOperator;

One or more parse

１回以上の出現

this(Parser operand);

Params:

Parser operand

被演算子

bool parse(Scanner s);

構文解析する

１回以上出現したら true

Params:

scanner

解析対象

Returns:
解析できたらtrue

OneOrMore oom_p(Parser operand);
OneOrMore oom_p(wchar c);
OneOrMore oom_p(wchar[] s);

OneOrMore parser generator

Params:

Parser operand

被演算子

Returns:
OneOrMoreクラス

class Optional: mikanya.parser.UnaryOperator;

Optional parser

this(Parser operand);

Params:

Parser operand

被演算子

bool parse(Scanner s);

構文解析する

０回または１回出現したら true

Params:

scanner

解析対象

Returns:
解析できたらtrue

Optional opt_p(Parser operand);
Optional opt_p(wchar c);
Optional opt_p(wchar[] s);

Optional parser generator

Params:

Parser operand

被演算子

Returns:
Optionalクラス

class Postfix;
alias _;

static ZeroOrMore opMul_r(wchar c);
static ZeroOrMore opMul_r(wchar[] s);
static ZeroOrMore opMul_r(Parser p);

static OneOrMore opAdd_r(wchar c);
static OneOrMore opAdd_r(wchar[] s);
static OneOrMore opAdd_r(Parser p);

class Character: mikanya.parser.ParserImpl;

Character parser

this(wchar value);

Params:

wchar value

出現するべき文字

bool parse(Scanner s);

構文解析する

出現したら true

Params:

scanner

解析対象

Returns:
解析できたらtrue

Character ch_p(wchar value);

Character parser generator

Params:

wchar value

出現するべき文字

Returns:
Characterクラス

class Range: mikanya.parser.ParserImpl;

Range paser

this(wchar min, wchar max);

Params:

wchar min	出現するべき文字の下限
wchar max	出現するべき文字の上限

bool parse(Scanner s);

構文解析する

範囲内の文字が出現したら true

Params:

scanner

解析対象

Returns:
解析できたらtrue

Range range_p(wchar min, wchar max);

Range paser generator

Params:

wchar min	出現するべき文字の下限
wchar max	出現するべき文字の上限

Returns:
Range クラス

class String: mikanya.parser.ParserImpl;

String parser

this(wchar[] value);

Params:

wchar[] value

出現するべき文字列

bool parse(Scanner s);

構文解析する

出現したら true

Params:

scanner

解析対象

Returns:
解析できたらtrue

String str_p(wchar[] value);

String parser generator

Params:

wchar[] value

出現するべき文字列

Returns:
Stringクラス

class Epsilon: mikanya.parser.ParserImpl;

Epsilon

bool parse(Scanner s);

構文解析する スキャナは前進しない

Params:

scanner

解析対象

Returns:
常にtrue

Epsilon eps_p();

Epsilon parser generator

Returns:
Epsilonクラス