diff --git a/libwccl/parser/grammar.g b/libwccl/parser/grammar.g
index 5317b671915daa66728b116744718ee72fc55324..1ba11ff5fea81d052813d610e07916677aa4b5a1 100644
--- a/libwccl/parser/grammar.g
+++ b/libwccl/parser/grammar.g
@@ -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));
}