Skip to content
Snippets Groups Projects
Commit 939cdc62 authored by Paweł Kędzia's avatar Paweł Kędzia
Browse files

Fixed grammar

parent 028d0fb0
No related branches found
No related tags found
No related merge requests found
Show whitespace changes
Inline Side-by-side
libwccl/parser/grammar.g
+ 119
− 107
View file @ 939cdc62
......@@ -112,10 +112,10 @@ parse_string_operator
res.reset(new ANTLRParserResult<Wccl::StrSet>());
boost::shared_ptr<Wccl::Function<Wccl::StrSet> > op;
}
: op = string_operators [*res->variables.get()] {
: op = string_operators [tagset, *res->variables.get()] {
res->op = op;
}
| op = condit_str [*res->variables.get()] {
| op = condit_str [tagset, *res->variables.get()] {
res->op = op;
}
;
......@@ -130,10 +130,10 @@ parse_predicates
res.reset(new ANTLRParserResult<Wccl::Bool>());
boost::shared_ptr<Wccl::Function<Wccl::Bool> > op;
}
: op = logical_predicates [*res->variables.get()] {
: op = logical_predicates [tagset, *res->variables.get()] {
res->op = op;
}
| op = condit_bool [*res->variables.get()] {
| op = condit_bool [tagset, *res->variables.get()] {
res->op = op;
}
;
......@@ -148,10 +148,10 @@ parse_sym_set_operator
res.reset(new ANTLRParserResult<Wccl::TSet>());
boost::shared_ptr<Wccl::Function<Wccl::TSet> > op;
}
: op = sym_set_operators [*res->variables.get()] {
: op = sym_set_operators [tagset, *res->variables.get()] {
res->op = op;
}
| op = condit_sym [*res->variables.get()] {
| op = condit_sym [tagset, *res->variables.get()] {
res->op = op;
}
;
......@@ -196,33 +196,45 @@ str_set_value
// Element of sym set. This rule, inset element into set.
// Element may be: a or `a `
sym_set_elem
[boost::shared_ptr<Wccl::TSet> &t_set]
[const Corpus2::Tagset& tagset, boost::shared_ptr<Wccl::TSet>& t_set]
: s1: SYMBOL {
// t_set->insert(token_ref_to_ustring(s1));
try {
t_set->insert_symbol(tagset, token_ref_to_std_string(s1));
}
catch(Corpus2::TagParseError &e) {
throw(ParserException(e.info()));
}
}
| G_MARK s2: SYMBOL G_MARK {
// t_set->insert(token_ref_to_ustring(s2));
try {
t_set->insert_symbol(tagset, token_ref_to_std_string(s2));
}
catch(Corpus2::TagParseError &e) {
throw(ParserException(e.info()));
}
}
;
// sym set literal
// {} {sym_set_elem} {sym_set_elem, ..., sym_set_elem}
// Returns boost::shared_ptr<Wccl::TSet>
sym_set_literal
[const Corpus2::Tagset& tagset]
returns [boost::shared_ptr<Wccl::TSet> t_set]
{
t_set.reset(new Wccl::TSet());
}
: LCURLY RCURLY
| LCURLY sym_set_elem[t_set] (COMMA sym_set_elem[t_set]) *
| LCURLY sym_set_elem[tagset, t_set] (COMMA sym_set_elem[tagset, t_set]) *
;
// Constant symbol set
// Returns boost::shared_ptr<Wccl::Constant<Wccl::TSet> >
sym_set_value
[const Corpus2::Tagset& tagset]
returns [boost::shared_ptr<Wccl::Constant<Wccl::TSet> > val]
{
boost::shared_ptr<Wccl::TSet> set;
}
: set = sym_set_literal {
: set = sym_set_literal [tagset] {
val.reset(new Wccl::Constant<Wccl::TSet>(*set.get()));
}
;
......@@ -410,17 +422,17 @@ boolean_variable
// Returns boost::shared_ptr<Wccl::Function<Wccl::Bool> >
// ----------------------------------------------------------------------------
setvar_op
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > ret]
: ret = setvar_pos [vars]
| ret = setvar_bool [vars]
| ret = setvar_sset [vars]
| ret = setvar_tset [vars]
: ret = setvar_pos [tagset, vars]
| ret = setvar_bool [tagset, vars]
| ret = setvar_sset [tagset, vars]
| ret = setvar_tset [tagset, vars]
;
// Implementations of setvar:
// ----------------------------------------------------------------------------
setvar_pos
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<Wccl::Function<Wccl::Position> > ret_op;
......@@ -434,42 +446,42 @@ setvar_pos
// ----------------------------------------------------------------------------
setvar_bool
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<Wccl::Function<Wccl::Bool> > ret_op;
boost::shared_ptr<Wccl::VariableAccessor<Wccl::Bool> > ret_acc;
}
: "setvar" LPAREN ret_acc = boolean_variable_acc [vars] COMMA
ret_op = logical_predicates [vars] RPAREN {
ret_op = logical_predicates [tagset, vars] RPAREN {
op.reset(new Wccl::VarSetter<Wccl::Bool>(*ret_acc.get(), ret_op));
}
;
// ----------------------------------------------------------------------------
setvar_sset
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ret_op;
boost::shared_ptr<Wccl::VariableAccessor<Wccl::StrSet> > ret_acc;
}
: "setvar" LPAREN ret_acc = str_set_variable_acc [vars] COMMA
ret_op = string_operators [vars] RPAREN {
ret_op = string_operators [tagset, vars] RPAREN {
op.reset(new Wccl::VarSetter<Wccl::StrSet>(*ret_acc.get(), ret_op));
}
;
// ----------------------------------------------------------------------------
setvar_tset
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<Wccl::Function<Wccl::TSet> > ret_op;
boost::shared_ptr<Wccl::VariableAccessor<Wccl::TSet> > ret_acc;
}
: "setvar" LPAREN ret_acc = sym_set_variable_acc [vars] COMMA
ret_op = sym_set_operators [vars] RPAREN {
ret_op = sym_set_operators [tagset, vars] RPAREN {
op.reset(new Wccl::VarSetter<Wccl::TSet>(*ret_acc.get(), ret_op));
}
;
......@@ -480,33 +492,33 @@ setvar_tset
// Returns boost::shared_ptr<Wccl::Function<Wccl::TSet> >
// ----------------------------------------------------------------------------
sym_set_operators
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::TSet> > ret]
: ret = op_sym_set [vars]
: ret = op_sym_set [tagset, vars]
// | ret = condit_sym [vars]
;
// Implementations of symbol set operators:
// ----------------------------------------------------------------------------
op_sym_set
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::TSet> > op]
: op = sym_set_variable [vars]
| op = sym_set_value
| op = sym_set_value [tagset]
;
// ----------------------------------------------------------------------------
// if (Bool, TSet, TSet)
// ? TSet ? Bool : {}
condit_sym
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::TSet> > op]
{
boost::shared_ptr<Wccl::Function<Wccl::Bool> > test;
boost::shared_ptr<Wccl::Function<Wccl::TSet> > p_true, p_false;
}
: "if" LPAREN test = logical_predicates [vars] COMMA
p_true = sym_set_operators [vars]
(COMMA p_false = sym_set_operators [vars])?
: "if" LPAREN test = logical_predicates [tagset, vars] COMMA
p_true = sym_set_operators [tagset, vars]
(COMMA p_false = sym_set_operators [tagset, vars])?
{
if (p_false) {
op.reset(new Wccl::Conditional<Wccl::TSet>(test, p_true, p_false));
......@@ -516,9 +528,9 @@ condit_sym
}
}
| Q_MARK
(p_true = sym_set_operators [vars] | p_true = condit_sym [vars])
(p_true = sym_set_operators [tagset, vars] | p_true = condit_sym [tagset, vars])
Q_MARK
(test = logical_predicates [vars] | test = condit_bool [vars])
(test = logical_predicates [tagset, vars] | test = condit_bool [tagset, vars])
{
op.reset(new Wccl::Conditional<Wccl::TSet>(test, p_true));
}
......@@ -529,7 +541,7 @@ condit_sym
// Returns boost::shared_ptr<Wccl::Function<Wccl::Position> >
// ----------------------------------------------------------------------------
position_operators
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Position> > ret]
: ret = op_position [vars]
;
......@@ -548,20 +560,20 @@ op_position
// Returns boost::shared_ptr<Wccl::Function<Wccl::StrSet> >
// ----------------------------------------------------------------------------
string_operators
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ret]
: ret = op_orth [vars]
| ret = op_base [vars]
| ret = op_lower [vars]
| ret = op_upper [vars]
| ret = op_affix [vars]
| ret = op_str_set [vars]
: ret = op_orth [tagset, vars]
| ret = op_base [tagset, vars]
| ret = op_lower [tagset, vars]
| ret = op_upper [tagset, vars]
| ret = op_affix [tagset, vars]
| ret = op_str_set [tagset, vars]
// | ret = condit_str [vars]
;
// Implementations of string operators:
// ----------------------------------------------------------------------------
op_orth
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ret]
{
boost::shared_ptr<Wccl::VarGetter<Wccl::Position> > pos;
......@@ -572,7 +584,7 @@ op_orth
;
// ----------------------------------------------------------------------------
op_base
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ret]
{
boost::shared_ptr<Wccl::VarGetter<Wccl::Position> > pos;
......@@ -583,40 +595,40 @@ op_base
;
// ----------------------------------------------------------------------------
op_lower
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ret]
{
boost::shared_ptr<Wccl::Function<Wccl::StrSet> > o_ret;
}
: "lower" LPAREN o_ret = string_operators[vars] RPAREN {
: "lower" LPAREN o_ret = string_operators[tagset, vars] RPAREN {
ret.reset(new Wccl::ToLower(o_ret));
}
;
// ----------------------------------------------------------------------------
op_upper
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ret]
{
boost::shared_ptr<Wccl::Function<Wccl::StrSet> > o_ret;
}
: "upper" LPAREN o_ret = string_operators[vars] RPAREN {
: "upper" LPAREN o_ret = string_operators[tagset, vars] RPAREN {
ret.reset(new Wccl::ToUpper(o_ret));
}
;
// ----------------------------------------------------------------------------
op_affix
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ret]
{
boost::shared_ptr<Wccl::Function<Wccl::StrSet> > o_ret;
}
: "affix" LPAREN o_ret = string_operators[vars] COMMA offset: INT RPAREN {
: "affix" LPAREN o_ret = string_operators[tagset, vars] COMMA offset: INT RPAREN {
ret.reset(new Wccl::Affix(o_ret, token_ref_to_int(offset)));
}
;
// ----------------------------------------------------------------------------
op_str_set
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > op]
: op = str_set_variable [vars]
| op = str_set_value
......@@ -625,15 +637,15 @@ op_str_set
// if (Bool, StrSet, StrSet)
// ? StrSet ? Bool : []
condit_str
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > op]
{
boost::shared_ptr<Wccl::Function<Wccl::Bool> > test;
boost::shared_ptr<Wccl::Function<Wccl::StrSet> > p_true, p_false;
}
: "if" LPAREN test = logical_predicates [vars] COMMA
p_true = string_operators [vars]
(COMMA p_false = string_operators [vars])?
: "if" LPAREN test = logical_predicates [tagset, vars] COMMA
p_true = string_operators [tagset, vars]
(COMMA p_false = string_operators [tagset, vars])?
{
if (p_false) {
op.reset(new Wccl::Conditional<Wccl::StrSet>(test, p_true, p_false));
......@@ -643,9 +655,9 @@ condit_str
}
}
| Q_MARK
(p_true = string_operators [vars] | p_true = condit_str [vars])
(p_true = string_operators [tagset, vars] | p_true = condit_str [tagset, vars])
Q_MARK
(test = logical_predicates [vars] | test = condit_bool [vars])
(test = logical_predicates [tagset, vars] | test = condit_bool [tagset, vars])
{
op.reset(new Wccl::Conditional<Wccl::StrSet>(test, p_true));
}
......@@ -657,24 +669,24 @@ condit_str
// Returns boost::shared_ptr<Wccl::Function<Wccl::Bool> >
// ----------------------------------------------------------------------------
logical_predicates
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > ret]
: ret = lpred_and [vars]
| ret = lpred_or [vars]
| ret = lpred_nor [vars]
| ret = lpred_bool [vars]
| ret = lpred_in [vars]
| ret = lpred_inter [vars]
| ret = lpred_eq [vars]
| ret = lpred_regex [vars]
| ret = setvar_op [vars]
| ret = lpred_inout [vars]
: ret = lpred_and [tagset, vars]
| ret = lpred_or [tagset, vars]
| ret = lpred_nor [tagset, vars]
| ret = lpred_bool [tagset, vars]
| ret = lpred_in [tagset, vars]
| ret = lpred_inter [tagset, vars]
| ret = lpred_eq [tagset, vars]
| ret = lpred_regex [tagset, vars]
| ret = setvar_op [tagset, vars]
| ret = lpred_inout [tagset, vars]
// | ret = condit_bool [vars]
;
// ----------------------------------------------------------------------------
// comma-separated predicates
logical_predicates_comma_sep
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<
std::vector<boost::shared_ptr<Wccl::Function<Wccl::Bool> > >
> ret_v]
......@@ -684,98 +696,98 @@ logical_predicates_comma_sep
new std::vector<boost::shared_ptr<Wccl::Function<Wccl::Bool> > >
);
}
: pred = logical_predicates [vars] {
: pred = logical_predicates [tagset, vars] {
ret_v->push_back(pred);
} (
COMMA pred = logical_predicates [vars] {
COMMA pred = logical_predicates [tagset, vars] {
ret_v->push_back(pred);
})*
;
// ----------------------------------------------------------------------------
lpred_and
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<
std::vector<boost::shared_ptr<Wccl::Function<Wccl::Bool> > >
> ret_v;
}
: "and" LPAREN ret_v = logical_predicates_comma_sep [vars] RPAREN {
: "and" LPAREN ret_v = logical_predicates_comma_sep [tagset, vars] RPAREN {
op.reset(new Wccl::And(ret_v));
}
;
// ----------------------------------------------------------------------------
lpred_or
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<
std::vector<boost::shared_ptr<Wccl::Function<Wccl::Bool> > >
> ret_v;
}
: "or" LPAREN ret_v = logical_predicates_comma_sep [vars] RPAREN {
: "or" LPAREN ret_v = logical_predicates_comma_sep [tagset, vars] RPAREN {
op.reset(new Wccl::Or(ret_v));
}
;
// ----------------------------------------------------------------------------
lpred_nor
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<
std::vector<boost::shared_ptr<Wccl::Function<Wccl::Bool> > >
> ret_v;
}
: "nor" LPAREN ret_v = logical_predicates_comma_sep [vars] RPAREN {
: "nor" LPAREN ret_v = logical_predicates_comma_sep [tagset, vars] RPAREN {
op.reset(new Wccl::Nor(ret_v));
}
;
// ----------------------------------------------------------------------------
lpred_bool
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
: op = boolean_variable [vars]
| op = boolean_value
;
// ----------------------------------------------------------------------------
lpred_in
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<Wccl::Function<Wccl::TSet> > t1, t2;
boost::shared_ptr<Wccl::Function<Wccl::StrSet> > s1, s2;
}
: "in" LPAREN t1 = sym_set_operators [vars] COMMA
t2 = sym_set_operators [vars] RPAREN {
: "in" LPAREN t1 = sym_set_operators [tagset, vars] COMMA
t2 = sym_set_operators [tagset, vars] RPAREN {
op.reset(new Wccl::IsSubsetOf<Wccl::TSet>(t1, t2));
}
| "in" LPAREN s1 = string_operators [vars] COMMA
s2 = string_operators [vars] RPAREN {
| "in" LPAREN s1 = string_operators [tagset, vars] COMMA
s2 = string_operators [tagset, vars] RPAREN {
op.reset(new Wccl::IsSubsetOf<Wccl::StrSet>(s1, s2));
}
;
// ----------------------------------------------------------------------------
lpred_inter
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<Wccl::Function<Wccl::TSet> > t1, t2;
boost::shared_ptr<Wccl::Function<Wccl::StrSet> > s1, s2;
}
: "inter" LPAREN s1 = string_operators [vars] COMMA
s2 = string_operators [vars] RPAREN {
: "inter" LPAREN s1 = string_operators [tagset, vars] COMMA
s2 = string_operators [tagset, vars] RPAREN {
op.reset(new Wccl::Intersects<Wccl::StrSet>(s1, s2));
}
| "inter" LPAREN t1 = sym_set_operators [vars] COMMA
t2 = sym_set_operators [vars] RPAREN {
| "inter" LPAREN t1 = sym_set_operators [tagset, vars] COMMA
t2 = sym_set_operators [tagset, vars] RPAREN {
op.reset(new Wccl::Intersects<Wccl::TSet>(t1, t2));
}
;
// ----------------------------------------------------------------------------
lpred_eq
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<Wccl::Function<Wccl::TSet> > t1, t2;
......@@ -783,47 +795,47 @@ lpred_eq
boost::shared_ptr<Wccl::Function<Wccl::StrSet> > s1, s2;
boost::shared_ptr<Wccl::Function<Wccl::Position> > p1, p2;
}
: "equal" LPAREN s1 = string_operators [vars] COMMA
s2 = string_operators [vars] RPAREN {
: "equal" LPAREN s1 = string_operators [tagset, vars] COMMA
s2 = string_operators [tagset, vars] RPAREN {
op.reset(new Wccl::Equals<Wccl::StrSet>(s1, s2));
}
| "equal" LPAREN t1 = sym_set_operators [vars] COMMA
t2 = sym_set_operators [vars] RPAREN {
| "equal" LPAREN t1 = sym_set_operators [tagset, vars] COMMA
t2 = sym_set_operators [tagset, vars] RPAREN {
op.reset(new Wccl::Equals<Wccl::TSet>(t1, t2));
}
| "equal" LPAREN p1 = position_operators [vars] COMMA
p2 = position_operators [vars] RPAREN {
| "equal" LPAREN p1 = position_operators [tagset, vars] COMMA
p2 = position_operators [tagset, vars] RPAREN {
op.reset(new Wccl::Equals<Wccl::Position>(p1, p2));
}
| "equal" LPAREN b1 = logical_predicates [vars] COMMA
b2 = logical_predicates [vars] RPAREN {
| "equal" LPAREN b1 = logical_predicates [tagset, vars] COMMA
b2 = logical_predicates [tagset, vars] RPAREN {
op.reset(new Wccl::Equals<Wccl::Bool>(b1, b2));
}
;
// ----------------------------------------------------------------------------
lpred_regex
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<Wccl::Function<Wccl::StrSet> > expr;
}
: "regex" LPAREN expr = string_operators [vars] COMMA reg: STRING RPAREN {
: "regex" LPAREN expr = string_operators [tagset, vars] COMMA reg: STRING RPAREN {
op.reset(new Wccl::Regex(expr, token_ref_to_ustring(reg)));
}
;
// ----------------------------------------------------------------------------
lpred_inout
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<Wccl::Function<Wccl::Position> > ret_pos;
}
: "inside" LPAREN ret_pos = position_operators [vars] RPAREN {
: "inside" LPAREN ret_pos = position_operators [tagset, vars] RPAREN {
op.reset(new Wccl::IsInside(ret_pos));
}
| "outside" LPAREN ret_pos = position_operators [vars] RPAREN {
| "outside" LPAREN ret_pos = position_operators [tagset, vars] RPAREN {
op.reset(new Wccl::IsOutside(ret_pos));
}
;
......@@ -832,14 +844,14 @@ lpred_inout
// if (Bool, Bool, Bool)
// ? Bool ? Bool : False
condit_bool
[Wccl::Variables& vars]
[const Corpus2::Tagset& tagset, Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<Wccl::Function<Wccl::Bool> > test, p_true, p_false;
}
: "if" LPAREN test = logical_predicates [vars] COMMA
p_true = logical_predicates [vars]
(COMMA p_false = logical_predicates [vars])?
: "if" LPAREN test = logical_predicates [tagset, vars] COMMA
p_true = logical_predicates [tagset, vars]
(COMMA p_false = logical_predicates [tagset, vars])?
{
if (p_false) {
op.reset(new Wccl::Conditional<Wccl::Bool>(test, p_true, p_false));
......@@ -849,9 +861,9 @@ condit_bool
}
}
| Q_MARK
(p_true = logical_predicates [vars] | p_true = condit_bool [vars])
(p_true = logical_predicates [tagset, vars] | p_true = condit_bool [tagset, vars])
Q_MARK
(test = logical_predicates [vars] | test = condit_bool [vars])
(test = logical_predicates [tagset, vars] | test = condit_bool [tagset, vars])
{
op.reset(new Wccl::Conditional<Wccl::Bool>(test, p_true));
}
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment