From 01722a644008208e63be96c918032b891782b9ea Mon Sep 17 00:00:00 2001
From: rk <rk@;.(none)>
Date: Mon, 29 Nov 2010 21:09:21 +0100
Subject: [PATCH] Parser (ANTLR and our Parser) has been moved to Wccl
namespace.
---
libwccl/parser/Parser.cpp | 4 +
libwccl/parser/Parser.h | 4 +
libwccl/parser/grammar.g | 480 ++++++++++++++++++-------------------
wcclparser/bool_main.cpp | 2 +-
wcclparser/main.cpp | 4 +-
wcclparser/strop_main.cpp | 2 +-
wcclparser/tagset_main.cpp | 2 +-
7 files changed, 253 insertions(+), 245 deletions(-)
diff --git a/libwccl/parser/Parser.cpp b/libwccl/parser/Parser.cpp
index 389c8a4..5c591e9 100644
--- a/libwccl/parser/Parser.cpp
+++ b/libwccl/parser/Parser.cpp
@@ -2,6 +2,8 @@
#include "ANTLRLexer.hpp"
#include "ANTLRParser.hpp"
+namespace Wccl {
+
/**
* @desc Parser constructor. Default tagset is NULL
*/
@@ -221,3 +223,5 @@ boost::shared_ptr<ANTLRParserResultBase> Parser::parseAnyOperator(
}
return result;
}
+
+} // end Wccl ns
diff --git a/libwccl/parser/Parser.h b/libwccl/parser/Parser.h
index 1428c29..6e1ae03 100644
--- a/libwccl/parser/Parser.h
+++ b/libwccl/parser/Parser.h
@@ -19,6 +19,8 @@
// ----------------------------------------------------------------------------
+namespace Wccl{
+
class Parser {
public:
Parser(const Corpus2::Tagset&);
@@ -67,4 +69,6 @@ private:
const Corpus2::Tagset &tagset_;
};
+} // end Wccl ns
+
#endif // LIBWCCL_PARSER_PARSER_H
diff --git a/libwccl/parser/grammar.g b/libwccl/parser/grammar.g
index 181c344..58f2468 100644
--- a/libwccl/parser/grammar.g
+++ b/libwccl/parser/grammar.g
@@ -1,6 +1,6 @@
header {
//don't try to add all the headers inside our namespace
- // ANTLR_END_NAMESPACE
+ ANTLR_END_NAMESPACE
#include <libwccl/parser/ParserException.h>
@@ -53,13 +53,13 @@ header {
#include <libwccl/parser/ANTLRParserResult.h>
// start our namespace again
- // ANTLR_BEGIN_NAMESPACE(Wccl)
+ ANTLR_BEGIN_NAMESPACE(Wccl)
}
options {
language = "Cpp";
genHashLines = false;
-// namespace = "Wccl";
+ namespace = "Wccl";
// genHashLines = true;
}
@@ -131,13 +131,13 @@ private:
///////////////////////////////////////////////////////////////////////////////
// ----------------------------------------------------------------------------
// Rules for parsing string operators in scope (variables).
-// Returns boost::shared_ptr<Wccl::Function<Wccl::StrSet> >
+// Returns boost::shared_ptr<Function<StrSet> >
parse_string_operator
[const Corpus2::Tagset &tagset]
- returns [boost::shared_ptr<ANTLRParserResult<Wccl::StrSet> > res]
+ returns [boost::shared_ptr<ANTLRParserResult<StrSet> > res]
{
- res.reset(new ANTLRParserResult<Wccl::StrSet>());
- boost::shared_ptr<Wccl::Function<Wccl::StrSet> > op;
+ res.reset(new ANTLRParserResult<StrSet>());
+ boost::shared_ptr<Function<StrSet> > op;
}
: op = string_operators [tagset, *res->variables.get()] {
res->op = op;
@@ -147,13 +147,13 @@ parse_string_operator
// ----------------------------------------------------------------------------
// Rules for parsing predicates in scope (variables).
-// Returns boost::shared_ptr<Wccl::Function<Wccl::Bool> >
+// Returns boost::shared_ptr<Function<Bool> >
parse_predicates
[const Corpus2::Tagset &tagset]
- returns [boost::shared_ptr<ANTLRParserResult<Wccl::Bool> > res]
+ returns [boost::shared_ptr<ANTLRParserResult<Bool> > res]
{
- res.reset(new ANTLRParserResult<Wccl::Bool>());
- boost::shared_ptr<Wccl::Function<Wccl::Bool> > op;
+ res.reset(new ANTLRParserResult<Bool>());
+ boost::shared_ptr<Function<Bool> > op;
}
: op = logical_predicates [tagset, *res->variables.get()] {
res->op = op;
@@ -163,13 +163,13 @@ parse_predicates
// ----------------------------------------------------------------------------
// Rules for parsing tagset (symbol set) operators
-// Returns boost::shared_ptr<Wccl::Function<Wccl::TSet> >
+// Returns boost::shared_ptr<Function<TSet> >
parse_sym_set_operator
[const Corpus2::Tagset &tagset]
- returns [boost::shared_ptr<ANTLRParserResult<Wccl::TSet> > res]
+ returns [boost::shared_ptr<ANTLRParserResult<TSet> > res]
{
- res.reset(new ANTLRParserResult<Wccl::TSet>());
- boost::shared_ptr<Wccl::Function<Wccl::TSet> > op;
+ res.reset(new ANTLRParserResult<TSet>());
+ boost::shared_ptr<Function<TSet> > op;
}
: op = sym_set_operators [tagset, *res->variables.get()] {
res->op = op;
@@ -179,13 +179,13 @@ parse_sym_set_operator
// ----------------------------------------------------------------------------
// Rules for parsing position operators
-// Returns boost::shared_ptr<Wccl::Function<Wccl::Position> >
+// Returns boost::shared_ptr<Function<Position> >
parse_position_operator
[const Corpus2::Tagset &tagset]
- returns [boost::shared_ptr<ANTLRParserResult<Wccl::Position> > res]
+ returns [boost::shared_ptr<ANTLRParserResult<Position> > res]
{
- res.reset(new ANTLRParserResult<Wccl::Position>());
- boost::shared_ptr<Wccl::Function<Wccl::Position> > op;
+ res.reset(new ANTLRParserResult<Position>());
+ boost::shared_ptr<Function<Position> > op;
}
: op = position_operators [tagset, *res->variables.get()] {
res->op = op;
@@ -201,11 +201,11 @@ parse_position_operator
// ----------------------------------------------------------------------------
// Single or muliple values in string set:
// [] ['a'] ['a', 'b'] ["a"] ["a", "b"] ['a', "b"]
-// Returns boost::shared_ptr<Wccl::StrSet>
+// Returns boost::shared_ptr<StrSet>
str_set_literal
- returns [boost::shared_ptr<Wccl::StrSet> s_set]
+ returns [boost::shared_ptr<StrSet> s_set]
{
- s_set.reset(new Wccl::StrSet());
+ s_set.reset(new StrSet());
}
: s0: STRING {
s_set->insert(token_ref_to_ustring(s0));
@@ -222,14 +222,14 @@ str_set_literal
RBRACKET
;
// Constrant string set
-// Returns boost::shared_ptr<Wccl::Constant<Wccl::StrSet> >
+// Returns boost::shared_ptr<Constant<StrSet> >
str_set_value
- returns [boost::shared_ptr<Wccl::Constant<Wccl::StrSet> > val]
+ returns [boost::shared_ptr<Constant<StrSet> > val]
{
- boost::shared_ptr<Wccl::StrSet> set;
+ boost::shared_ptr<StrSet> set;
}
: set = str_set_literal {
- val.reset(new Wccl::Constant<Wccl::StrSet>(*set.get()));
+ val.reset(new Constant<StrSet>(*set.get()));
}
;
@@ -237,7 +237,7 @@ str_set_value
// Element of sym set. This rule, inset element into set.
// Element may be: a or `a `
sym_set_elem
- [const Corpus2::Tagset& tagset, boost::shared_ptr<Wccl::TSet>& t_set]
+ [const Corpus2::Tagset& tagset, boost::shared_ptr<TSet>& t_set]
: s1: SYMBOL {
try {
t_set->insert_symbol(tagset, str_token_rem_grav(s1));
@@ -250,12 +250,12 @@ sym_set_elem
// sym set literal
// {} {sym_set_elem} {sym_set_elem, ..., sym_set_elem}
-// Returns boost::shared_ptr<Wccl::TSet>
+// Returns boost::shared_ptr<TSet>
sym_set_literal
[const Corpus2::Tagset& tagset]
- returns [boost::shared_ptr<Wccl::TSet> t_set]
+ returns [boost::shared_ptr<TSet> t_set]
{
- t_set.reset(new Wccl::TSet());
+ t_set.reset(new TSet());
}
: sym_set_elem[tagset, t_set]
| LCURLY
@@ -263,70 +263,70 @@ sym_set_literal
RCURLY
;
// Constant symbol set
-// Returns boost::shared_ptr<Wccl::Constant<Wccl::TSet> >
+// Returns boost::shared_ptr<Constant<TSet> >
sym_set_value
[const Corpus2::Tagset& tagset]
- returns [boost::shared_ptr<Wccl::Constant<Wccl::TSet> > val]
+ returns [boost::shared_ptr<Constant<TSet> > val]
{
- boost::shared_ptr<Wccl::TSet> set;
+ boost::shared_ptr<TSet> set;
}
: set = sym_set_literal [tagset] {
- val.reset(new Wccl::Constant<Wccl::TSet>(*set.get()));
+ val.reset(new Constant<TSet>(*set.get()));
}
;
// ----------------------------------------------------------------------------
// boolean value:
// Literal bool value may be True or False
-// Returns boost::shared_ptr<Wccl::Bool>
+// Returns boost::shared_ptr<Bool>
bool_literal
- returns [boost::shared_ptr<Wccl::Bool> val]
- : "True" { val.reset(new Wccl::Bool(Wccl::Bool(true ))); }
- | "False" { val.reset(new Wccl::Bool(Wccl::Bool(false))); }
+ returns [boost::shared_ptr<Bool> val]
+ : "True" { val.reset(new Bool(Bool(true ))); }
+ | "False" { val.reset(new Bool(Bool(false))); }
;
// Constat bool Value
-// Returns boost::shared_ptr<Wccl::Constant<Wccl::Bool> >
+// Returns boost::shared_ptr<Constant<Bool> >
boolean_value
- returns [boost::shared_ptr<Wccl::Constant<Wccl::Bool> > val]
+ returns [boost::shared_ptr<Constant<Bool> > val]
{
- boost::shared_ptr<Wccl::Bool> bool_lit;
+ boost::shared_ptr<Bool> bool_lit;
}
: bool_lit = bool_literal {
- val.reset(new Wccl::Constant<Wccl::Bool>(*bool_lit));
+ val.reset(new Constant<Bool>(*bool_lit));
}
;
// ----------------------------------------------------------------------------
// position value:
// Position literal may be (+|-)?(0-9)+ or begin or end or nowhere
-// returns boost::shared_ptr<Wccl::Position>
+// returns boost::shared_ptr<Position>
position_literal
- returns [boost::shared_ptr<Wccl::Position> val]
+ returns [boost::shared_ptr<Position> val]
{
int i = 0;
}
: i = number {
- val.reset(new Wccl::Position(Wccl::Position(i)));
+ val.reset(new Position(Position(i)));
}
| "begin" {
- val.reset(new Wccl::Position(Wccl::Position(Wccl::Position::Begin)));
+ val.reset(new Position(Position(Position::Begin)));
}
| "end" {
- val.reset(new Wccl::Position(Wccl::Position(Wccl::Position::End)));
+ val.reset(new Position(Position(Position::End)));
}
| "nowhere" {
- val.reset(new Wccl::Position(Wccl::Position(Wccl::Position::Nowhere)));
+ val.reset(new Position(Position(Position::Nowhere)));
}
;
// Constant position value
-// Returns boost::shared_ptr<Wccl::Constant<Wccl::Position> >
+// Returns boost::shared_ptr<Constant<Position> >
position_value
- returns [boost::shared_ptr<Wccl::Constant<Wccl::Position> > val]
+ returns [boost::shared_ptr<Constant<Position> > val]
{
- boost::shared_ptr<Wccl::Position> pos_lit;
+ boost::shared_ptr<Position> pos_lit;
}
: pos_lit = position_literal {
- val.reset(new Wccl::Constant<Wccl::Position>(*pos_lit));
+ val.reset(new Constant<Position>(*pos_lit));
}
;
@@ -347,130 +347,130 @@ number returns [int ret]
///////////////////////////////////////////////////////////////////////////////
// ----------------------------------------------------------------------------
// Position: $name
-// Returns boost::shared_ptr<Wccl::VariableAccessor<Wccl::Position> >
+// Returns boost::shared_ptr<VariableAccessor<Position> >
position_variable_acc
- [Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::VariableAccessor<Wccl::Position> > pos_acc]
+ [Variables& vars]
+ returns [boost::shared_ptr<VariableAccessor<Position> > pos_acc]
: POS_PREFIX n: SYMBOL {
- vars.get_put<Wccl::Position>(str_token_rem_grav(n));
+ vars.get_put<Position>(str_token_rem_grav(n));
- Wccl::VariableAccessor<Wccl::Position> acc =
- vars.create_accessor<Wccl::Position>(str_token_rem_grav(n));
+ VariableAccessor<Position> acc =
+ vars.create_accessor<Position>(str_token_rem_grav(n));
- pos_acc.reset(new Wccl::VariableAccessor<Wccl::Position>(acc));
+ pos_acc.reset(new VariableAccessor<Position>(acc));
}
;
// Position vargetter
-// Returs boost::shared_ptr<Wccl::VarGetter<Wccl::Position> >
+// Returs boost::shared_ptr<VarGetter<Position> >
position_variable
- [Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::VarGetter<Wccl::Position> > op]
+ [Variables& vars]
+ returns [boost::shared_ptr<VarGetter<Position> > op]
{
- boost::shared_ptr<Wccl::VariableAccessor<Wccl::Position> > pos_acc;
+ boost::shared_ptr<VariableAccessor<Position> > pos_acc;
}
: pos_acc = position_variable_acc [vars] {
- op.reset(new Wccl::VarGetter<Wccl::Position>(*pos_acc.get()));
+ op.reset(new VarGetter<Position>(*pos_acc.get()));
}
;
// ----------------------------------------------------------------------------
// realtive position
relpos
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Position> > ret]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Position> > ret]
{
int n = 0;
- boost::shared_ptr<Wccl::Function<Wccl::Position> > pos;
+ boost::shared_ptr<Function<Position> > pos;
}
: "relpos" LPAREN pos = op_position [tagset, vars] COMMA n = number RPAREN {
- ret.reset(new Wccl::RelativePosition(pos, n));
+ ret.reset(new RelativePosition(pos, n));
}
;
// ----------------------------------------------------------------------------
// String set, $s:name
// This expression gets variable of the type StrSet from string-named variable
-// Returns boost::shared_ptr<Wccl::VariableAccessor<Wccl::StrSet> >
+// Returns boost::shared_ptr<VariableAccessor<StrSet> >
str_set_variable_acc
- [Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::VariableAccessor<Wccl::StrSet> > strset_acc]
+ [Variables& vars]
+ returns [boost::shared_ptr<VariableAccessor<StrSet> > strset_acc]
: STR_PREFIX n: SYMBOL {
// get/put variable to variables
- vars.get_put<Wccl::StrSet>(str_token_rem_grav(n));
+ vars.get_put<StrSet>(str_token_rem_grav(n));
// makes accessor for value
- Wccl::VariableAccessor<Wccl::StrSet> acc =
- vars.create_accessor<Wccl::StrSet>(str_token_rem_grav(n));
+ VariableAccessor<StrSet> acc =
+ vars.create_accessor<StrSet>(str_token_rem_grav(n));
- strset_acc.reset(new Wccl::VariableAccessor<Wccl::StrSet>(acc));
+ strset_acc.reset(new VariableAccessor<StrSet>(acc));
}
;
// Vargetter for StrSet variable
-// Returns boost::shared_ptr<Wccl::VarGetter<Wccl::StrSet> >
+// Returns boost::shared_ptr<VarGetter<StrSet> >
str_set_variable
- [Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::VarGetter<Wccl::StrSet> > op]
+ [Variables& vars]
+ returns [boost::shared_ptr<VarGetter<StrSet> > op]
{
- boost::shared_ptr<Wccl::VariableAccessor<Wccl::StrSet> > strset_acc;
+ boost::shared_ptr<VariableAccessor<StrSet> > strset_acc;
}
: strset_acc = str_set_variable_acc [vars] {
- op.reset(new Wccl::VarGetter<Wccl::StrSet>(*strset_acc.get()));
+ op.reset(new VarGetter<StrSet>(*strset_acc.get()));
}
;
// ----------------------------------------------------------------------------
// Symbol set: $t:name
-// Returns boost::shared_ptr<Wccl::VariableAccessor<Wccl::TSet> >
+// Returns boost::shared_ptr<VariableAccessor<TSet> >
sym_set_variable_acc
- [Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::VariableAccessor<Wccl::TSet> > symset_acc]
+ [Variables& vars]
+ returns [boost::shared_ptr<VariableAccessor<TSet> > symset_acc]
: TST_PREFIX n: SYMBOL {
- vars.get_put<Wccl::TSet>(str_token_rem_grav(n));
+ vars.get_put<TSet>(str_token_rem_grav(n));
- Wccl::VariableAccessor<Wccl::TSet> acc =
- vars.create_accessor<Wccl::TSet>(str_token_rem_grav(n));
+ VariableAccessor<TSet> acc =
+ vars.create_accessor<TSet>(str_token_rem_grav(n));
- symset_acc.reset(new Wccl::VariableAccessor<Wccl::TSet>(acc));
+ symset_acc.reset(new VariableAccessor<TSet>(acc));
}
;
// Vargetter for symbol set variable
-// Returns boost::shared_ptr<Wccl::VarGetter<Wccl::TSet> >
+// Returns boost::shared_ptr<VarGetter<TSet> >
sym_set_variable
- [Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::VarGetter<Wccl::TSet> > op]
+ [Variables& vars]
+ returns [boost::shared_ptr<VarGetter<TSet> > op]
{
- boost::shared_ptr<Wccl::VariableAccessor<Wccl::TSet> > symset_acc;
+ boost::shared_ptr<VariableAccessor<TSet> > symset_acc;
}
: symset_acc = sym_set_variable_acc [vars] {
- op.reset(new Wccl::VarGetter<Wccl::TSet>(*symset_acc.get()));
+ op.reset(new VarGetter<TSet>(*symset_acc.get()));
}
;
// ----------------------------------------------------------------------------
// Bool: $b:name
-// Returns boost::shared_ptr<Wccl::VariableAccessor<Wccl::Bool> >
+// Returns boost::shared_ptr<VariableAccessor<Bool> >
boolean_variable_acc
- [Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::VariableAccessor<Wccl::Bool> > bool_acc]
+ [Variables& vars]
+ returns [boost::shared_ptr<VariableAccessor<Bool> > bool_acc]
: BOOL_PREFIX n: SYMBOL {
- vars.get_put<Wccl::Bool>(str_token_rem_grav(n));
+ vars.get_put<Bool>(str_token_rem_grav(n));
- Wccl::VariableAccessor<Wccl::Bool> acc =
- vars.create_accessor<Wccl::Bool>(str_token_rem_grav(n));
+ VariableAccessor<Bool> acc =
+ vars.create_accessor<Bool>(str_token_rem_grav(n));
- bool_acc.reset(new Wccl::VariableAccessor<Wccl::Bool>(acc));
+ bool_acc.reset(new VariableAccessor<Bool>(acc));
}
;
// Vargetter for bool variable
-// Returns boost::shared_ptr<Wccl::VarGetter<Wccl::Bool> >
+// Returns boost::shared_ptr<VarGetter<Bool> >
boolean_variable
- [Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::VarGetter<Wccl::Bool> > op]
+ [Variables& vars]
+ returns [boost::shared_ptr<VarGetter<Bool> > op]
{
- boost::shared_ptr<Wccl::VariableAccessor<Wccl::Bool> > bool_acc;
+ boost::shared_ptr<VariableAccessor<Bool> > bool_acc;
}
: bool_acc = boolean_variable_acc [vars] {
- op.reset(new Wccl::VarGetter<Wccl::Bool>(*bool_acc.get()));
+ op.reset(new VarGetter<Bool>(*bool_acc.get()));
}
;
@@ -482,11 +482,11 @@ boolean_variable
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Setvar operator
-// Returns boost::shared_ptr<Wccl::Function<Wccl::Bool> >
+// Returns boost::shared_ptr<Function<Bool> >
// ----------------------------------------------------------------------------
setvar_op
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > ret]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > ret]
: "setvar" LPAREN
(
ret = setvar_body_pos [tagset, vars]
@@ -499,79 +499,79 @@ setvar_op
// Implementations of setvar:
// ----------------------------------------------------------------------------
setvar_body_pos
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > op]
{
- boost::shared_ptr<Wccl::Function<Wccl::Position> > ret_op;
- boost::shared_ptr<Wccl::VariableAccessor<Wccl::Position> > ret_acc;
+ boost::shared_ptr<Function<Position> > ret_op;
+ boost::shared_ptr<VariableAccessor<Position> > ret_acc;
}
: ret_acc = position_variable_acc [vars]
COMMA
ret_op = op_position [tagset, vars] {
- op.reset(new Wccl::VarSetter<Wccl::Position>(*ret_acc.get(), ret_op));
+ op.reset(new VarSetter<Position>(*ret_acc.get(), ret_op));
}
;
// ----------------------------------------------------------------------------
setvar_body_bool
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > op]
{
- boost::shared_ptr<Wccl::Function<Wccl::Bool> > ret_op;
- boost::shared_ptr<Wccl::VariableAccessor<Wccl::Bool> > ret_acc;
+ boost::shared_ptr<Function<Bool> > ret_op;
+ boost::shared_ptr<VariableAccessor<Bool> > ret_acc;
}
: ret_acc = boolean_variable_acc [vars]
COMMA
ret_op = logical_predicates [tagset, vars] {
- op.reset(new Wccl::VarSetter<Wccl::Bool>(*ret_acc.get(), ret_op));
+ op.reset(new VarSetter<Bool>(*ret_acc.get(), ret_op));
}
;
// ----------------------------------------------------------------------------
setvar_body_sset
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > op]
{
- boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ret_op;
- boost::shared_ptr<Wccl::VariableAccessor<Wccl::StrSet> > ret_acc;
+ boost::shared_ptr<Function<StrSet> > ret_op;
+ boost::shared_ptr<VariableAccessor<StrSet> > ret_acc;
}
: ret_acc = str_set_variable_acc [vars]
COMMA ret_op = string_operators [tagset, vars] {
- op.reset(new Wccl::VarSetter<Wccl::StrSet>(*ret_acc.get(), ret_op));
+ op.reset(new VarSetter<StrSet>(*ret_acc.get(), ret_op));
}
;
// ----------------------------------------------------------------------------
setvar_body_tset
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > op]
{
- boost::shared_ptr<Wccl::Function<Wccl::TSet> > ret_op;
- boost::shared_ptr<Wccl::VariableAccessor<Wccl::TSet> > ret_acc;
+ boost::shared_ptr<Function<TSet> > ret_op;
+ boost::shared_ptr<VariableAccessor<TSet> > ret_acc;
}
: ret_acc = sym_set_variable_acc [vars]
COMMA
ret_op = sym_set_operators [tagset, vars] {
- op.reset(new Wccl::VarSetter<Wccl::TSet>(*ret_acc.get(), ret_op));
+ op.reset(new VarSetter<TSet>(*ret_acc.get(), ret_op));
}
;
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Symbol set (tagset) operators
-// Returns boost::shared_ptr<Wccl::Function<Wccl::TSet> >
+// Returns boost::shared_ptr<Function<TSet> >
// ----------------------------------------------------------------------------
sym_set_operators
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::TSet> > ret]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<TSet> > ret]
: ret = op_sym_set [tagset, vars]
| ret = condit_sym [tagset, vars]
;
// Implementations of symbol set operators:
// ----------------------------------------------------------------------------
op_sym_set
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::TSet> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<TSet> > op]
: op = sym_set_variable [vars]
| op = sym_set_value [tagset]
;
@@ -580,46 +580,46 @@ op_sym_set
// if (Bool, TSet, TSet)
// ? TSet ? Bool : {}
condit_sym
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::TSet> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<TSet> > op]
{
- boost::shared_ptr<Wccl::Function<Wccl::Bool> > test;
- boost::shared_ptr<Wccl::Function<Wccl::TSet> > p_true, p_false;
+ boost::shared_ptr<Function<Bool> > test;
+ boost::shared_ptr<Function<TSet> > p_true, p_false;
}
: "if" LPAREN test = logical_predicates [tagset, vars] COMMA
p_true = sym_set_operators [tagset, vars]
(COMMA p_false = sym_set_operators [tagset, vars])?
RPAREN {
if (p_false) {
- op.reset(new Wccl::Conditional<Wccl::TSet>(test, p_true, p_false));
+ op.reset(new Conditional<TSet>(test, p_true, p_false));
}
else {
- op.reset(new Wccl::Conditional<Wccl::TSet>(test, p_true));
+ op.reset(new Conditional<TSet>(test, p_true));
}
}
| Q_MARK
(p_true = sym_set_operators [tagset, vars])
Q_MARK
(test = logical_predicates [tagset, vars]) {
- op.reset(new Wccl::Conditional<Wccl::TSet>(test, p_true));
+ op.reset(new Conditional<TSet>(test, p_true));
}
;
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Position operators
-// Returns boost::shared_ptr<Wccl::Function<Wccl::Position> >
+// Returns boost::shared_ptr<Function<Position> >
// ----------------------------------------------------------------------------
position_operators
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Position> > ret]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Position> > ret]
: ret = op_position [tagset, vars]
;
// Implementations of symbol set operators:
// ----------------------------------------------------------------------------
op_position
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Position> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Position> > op]
: op = position_variable [vars]
| op = position_value
| op = relpos [tagset, vars]
@@ -629,11 +629,11 @@ op_position
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Stiring operators
-// Returns boost::shared_ptr<Wccl::Function<Wccl::StrSet> >
+// Returns boost::shared_ptr<Function<StrSet> >
// ----------------------------------------------------------------------------
string_operators
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ret]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<StrSet> > ret]
: ret = op_orth [tagset, vars]
| ret = op_base [tagset, vars]
| ret = op_lower [tagset, vars]
@@ -645,21 +645,21 @@ string_operators
// Implementations of string operators:
// ----------------------------------------------------------------------------
op_orth
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ret]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<StrSet> > ret]
{
- boost::shared_ptr<Wccl::Function<Wccl::Position> > pos;
+ boost::shared_ptr<Function<Position> > pos;
}
: "orth" LBRACKET pos = op_position [tagset, vars] RBRACKET {
- ret.reset(new Wccl::GetOrth(pos));
+ ret.reset(new GetOrth(pos));
}
;
// ----------------------------------------------------------------------------
op_base
- [const Corpus2::Tagset& /*tagset*/, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ret]
+ [const Corpus2::Tagset& /*tagset*/, Variables& vars]
+ returns [boost::shared_ptr<Function<StrSet> > ret]
{
- boost::shared_ptr<Wccl::VarGetter<Wccl::Position> > pos;
+ boost::shared_ptr<VarGetter<Position> > pos;
}
: "base" LBRACKET pos = position_variable [vars] RBRACKET {
// ret = TODO
@@ -667,44 +667,44 @@ op_base
;
// ----------------------------------------------------------------------------
op_lower
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ret]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<StrSet> > ret]
{
- boost::shared_ptr<Wccl::Function<Wccl::StrSet> > o_ret;
+ boost::shared_ptr<Function<StrSet> > o_ret;
}
: "lower" LPAREN o_ret = string_operators[tagset, vars] RPAREN {
- ret.reset(new Wccl::ToLower(o_ret));
+ ret.reset(new ToLower(o_ret));
}
;
// ----------------------------------------------------------------------------
op_upper
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ret]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<StrSet> > ret]
{
- boost::shared_ptr<Wccl::Function<Wccl::StrSet> > o_ret;
+ boost::shared_ptr<Function<StrSet> > o_ret;
}
: "upper" LPAREN o_ret = string_operators[tagset, vars] RPAREN {
- ret.reset(new Wccl::ToUpper(o_ret));
+ ret.reset(new ToUpper(o_ret));
}
;
// ----------------------------------------------------------------------------
op_affix
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ret]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<StrSet> > ret]
{
int offset = 0;
- boost::shared_ptr<Wccl::Function<Wccl::StrSet> > o_ret;
+ boost::shared_ptr<Function<StrSet> > o_ret;
}
: "affix" LPAREN
o_ret = string_operators[tagset, vars] COMMA offset = number
RPAREN {
- ret.reset(new Wccl::Affix(o_ret, offset));
+ ret.reset(new Affix(o_ret, offset));
}
;
// ----------------------------------------------------------------------------
op_str_set
- [const Corpus2::Tagset& /*tagset*/, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > op]
+ [const Corpus2::Tagset& /*tagset*/, Variables& vars]
+ returns [boost::shared_ptr<Function<StrSet> > op]
: op = str_set_variable [vars]
| op = str_set_value
;
@@ -712,39 +712,39 @@ op_str_set
// if (Bool, StrSet, StrSet)
// ? StrSet ? Bool : []
condit_str
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::StrSet> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<StrSet> > op]
{
- boost::shared_ptr<Wccl::Function<Wccl::Bool> > test;
- boost::shared_ptr<Wccl::Function<Wccl::StrSet> > p_true, p_false;
+ boost::shared_ptr<Function<Bool> > test;
+ boost::shared_ptr<Function<StrSet> > p_true, p_false;
}
: "if" LPAREN test = logical_predicates [tagset, vars] COMMA
p_true = string_operators [tagset, vars]
(COMMA p_false = string_operators [tagset, vars])?
RPAREN {
if (p_false) {
- op.reset(new Wccl::Conditional<Wccl::StrSet>(test, p_true, p_false));
+ op.reset(new Conditional<StrSet>(test, p_true, p_false));
}
else {
- op.reset(new Wccl::Conditional<Wccl::StrSet>(test, p_true));
+ op.reset(new Conditional<StrSet>(test, p_true));
}
}
| Q_MARK
p_true = string_operators [tagset, vars]
Q_MARK
test = logical_predicates [tagset, vars] {
- op.reset(new Wccl::Conditional<Wccl::StrSet>(test, p_true));
+ op.reset(new Conditional<StrSet>(test, p_true));
}
;
// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------
// Logical predicates
-// Returns boost::shared_ptr<Wccl::Function<Wccl::Bool> >
+// Returns boost::shared_ptr<Function<Bool> >
// ----------------------------------------------------------------------------
logical_predicates
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > ret]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > ret]
: ret = lpred_and [tagset, vars]
| ret = lpred_or [tagset, vars]
| ret = lpred_nor [tagset, vars]
@@ -760,14 +760,14 @@ logical_predicates
// ----------------------------------------------------------------------------
// comma-separated predicates
logical_predicates_comma_sep
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
+ [const Corpus2::Tagset& tagset, Variables& vars]
returns [boost::shared_ptr<
- std::vector<boost::shared_ptr<Wccl::Function<Wccl::Bool> > >
+ std::vector<boost::shared_ptr<Function<Bool> > >
> ret_v]
{
- boost::shared_ptr<Wccl::Function<Wccl::Bool> > pred;
+ boost::shared_ptr<Function<Bool> > pred;
ret_v.reset(
- new std::vector<boost::shared_ptr<Wccl::Function<Wccl::Bool> > >
+ new std::vector<boost::shared_ptr<Function<Bool> > >
);
}
: pred = logical_predicates [tagset, vars] {
@@ -779,57 +779,57 @@ logical_predicates_comma_sep
;
// ----------------------------------------------------------------------------
lpred_and
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > op]
{
boost::shared_ptr<
- std::vector<boost::shared_ptr<Wccl::Function<Wccl::Bool> > >
+ std::vector<boost::shared_ptr<Function<Bool> > >
> ret_v;
}
: "and" LPAREN ret_v = logical_predicates_comma_sep [tagset, vars] RPAREN {
- op.reset(new Wccl::And(ret_v));
+ op.reset(new And(ret_v));
}
;
// ----------------------------------------------------------------------------
lpred_or
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > op]
{
boost::shared_ptr<
- std::vector<boost::shared_ptr<Wccl::Function<Wccl::Bool> > >
+ std::vector<boost::shared_ptr<Function<Bool> > >
> ret_v;
}
: "or" LPAREN ret_v = logical_predicates_comma_sep [tagset, vars] RPAREN {
- op.reset(new Wccl::Or(ret_v));
+ op.reset(new Or(ret_v));
}
;
// ----------------------------------------------------------------------------
lpred_nor
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > op]
{
boost::shared_ptr<
- std::vector<boost::shared_ptr<Wccl::Function<Wccl::Bool> > >
+ std::vector<boost::shared_ptr<Function<Bool> > >
> ret_v;
}
: "not" LPAREN ret_v = logical_predicates_comma_sep [tagset, vars] RPAREN {
- op.reset(new Wccl::Nor(ret_v));
+ op.reset(new Nor(ret_v));
}
;
// ----------------------------------------------------------------------------
lpred_bool
- [const Corpus2::Tagset& /*tagset*/, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
+ [const Corpus2::Tagset& /*tagset*/, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > op]
: op = boolean_variable [vars]
| op = boolean_value
;
// ----------------------------------------------------------------------------
lpred_in
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > op]
{
- boost::shared_ptr<Wccl::Function<Wccl::TSet> > t1, t2;
- boost::shared_ptr<Wccl::Function<Wccl::StrSet> > s1, s2;
+ boost::shared_ptr<Function<TSet> > t1, t2;
+ boost::shared_ptr<Function<StrSet> > s1, s2;
}
:
"in" LPAREN
@@ -838,14 +838,14 @@ lpred_in
(
t1 = sym_set_operators [tagset, vars] COMMA
t2 = sym_set_operators [tagset, vars] {
- op.reset(new Wccl::IsSubsetOf<Wccl::TSet>(t1, t2));
+ op.reset(new IsSubsetOf<TSet>(t1, t2));
}
)
|
(
s1 = string_operators [tagset, vars] COMMA
s2 = string_operators [tagset, vars] {
- op.reset(new Wccl::IsSubsetOf<Wccl::StrSet>(s1, s2));
+ op.reset(new IsSubsetOf<StrSet>(s1, s2));
}
)
)
@@ -855,11 +855,11 @@ lpred_in
// ----------------------------------------------------------------------------
lpred_inter
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > op]
{
- boost::shared_ptr<Wccl::Function<Wccl::TSet> > t1, t2;
- boost::shared_ptr<Wccl::Function<Wccl::StrSet> > s1, s2;
+ boost::shared_ptr<Function<TSet> > t1, t2;
+ boost::shared_ptr<Function<StrSet> > s1, s2;
}
:
"inter" LPAREN
@@ -868,14 +868,14 @@ lpred_inter
(
t1 = sym_set_operators [tagset, vars] COMMA
t2 = sym_set_operators [tagset, vars] {
- op.reset(new Wccl::Intersects<Wccl::TSet>(t1, t2));
+ op.reset(new Intersects<TSet>(t1, t2));
}
)
|
(
s1 = string_operators [tagset, vars] COMMA
s2 = string_operators [tagset, vars] {
- op.reset(new Wccl::Intersects<Wccl::StrSet>(s1, s2));
+ op.reset(new Intersects<StrSet>(s1, s2));
}
)
)
@@ -884,13 +884,13 @@ lpred_inter
// ----------------------------------------------------------------------------
lpred_eq
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > op]
{
- boost::shared_ptr<Wccl::Function<Wccl::TSet> > t1, t2;
- boost::shared_ptr<Wccl::Function<Wccl::Bool> > b1, b2;
- boost::shared_ptr<Wccl::Function<Wccl::StrSet> > s1, s2;
- boost::shared_ptr<Wccl::Function<Wccl::Position> > p1, p2;
+ boost::shared_ptr<Function<TSet> > t1, t2;
+ boost::shared_ptr<Function<Bool> > b1, b2;
+ boost::shared_ptr<Function<StrSet> > s1, s2;
+ boost::shared_ptr<Function<Position> > p1, p2;
}
: "equal" LPAREN
(
@@ -898,7 +898,7 @@ lpred_eq
(
p1 = position_operators [tagset, vars] COMMA
p2 = position_operators [tagset, vars] {
- op.reset(new Wccl::Equals<Wccl::Position>(p1, p2));
+ op.reset(new Equals<Position>(p1, p2));
}
)
|
@@ -906,7 +906,7 @@ lpred_eq
(
t1 = sym_set_operators [tagset, vars] COMMA
t2 = sym_set_operators [tagset, vars] {
- op.reset(new Wccl::Equals<Wccl::TSet>(t1, t2));
+ op.reset(new Equals<TSet>(t1, t2));
}
)
|
@@ -914,14 +914,14 @@ lpred_eq
(
s1 = string_operators [tagset, vars] COMMA
s2 = string_operators [tagset, vars] {
- op.reset(new Wccl::Equals<Wccl::StrSet>(s1, s2));
+ op.reset(new Equals<StrSet>(s1, s2));
}
)
|
(
b1 = logical_predicates [tagset, vars] COMMA
b2 = logical_predicates [tagset, vars] {
- op.reset(new Wccl::Equals<Wccl::Bool>(b1, b2));
+ op.reset(new Equals<Bool>(b1, b2));
}
)
)
@@ -930,28 +930,28 @@ lpred_eq
// ----------------------------------------------------------------------------
lpred_regex
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > op]
{
- boost::shared_ptr<Wccl::Function<Wccl::StrSet> > expr;
+ boost::shared_ptr<Function<StrSet> > expr;
}
: "regex" LPAREN expr = string_operators [tagset, vars] COMMA reg: STRING RPAREN {
- op.reset(new Wccl::Regex(expr, token_ref_to_ustring(reg)));
+ op.reset(new Regex(expr, token_ref_to_ustring(reg)));
}
;
// ----------------------------------------------------------------------------
lpred_inout
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > op]
{
- boost::shared_ptr<Wccl::Function<Wccl::Position> > ret_pos;
+ boost::shared_ptr<Function<Position> > ret_pos;
}
: "inside" LPAREN ret_pos = position_operators [tagset, vars] RPAREN {
- op.reset(new Wccl::IsInside(ret_pos));
+ op.reset(new IsInside(ret_pos));
}
| "outside" LPAREN ret_pos = position_operators [tagset, vars] RPAREN {
- op.reset(new Wccl::IsOutside(ret_pos));
+ op.reset(new IsOutside(ret_pos));
}
;
@@ -959,27 +959,27 @@ lpred_inout
// if (Bool, Bool, Bool)
// ? Bool ? Bool : False
condit_bool
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Bool> > op]
{
- boost::shared_ptr<Wccl::Function<Wccl::Bool> > test, p_true, p_false;
+ boost::shared_ptr<Function<Bool> > test, p_true, p_false;
}
: "if" LPAREN test = logical_predicates [tagset, vars] COMMA
p_true = logical_predicates [tagset, vars]
(COMMA p_false = logical_predicates [tagset, vars])?
RPAREN {
if (p_false) {
- op.reset(new Wccl::Conditional<Wccl::Bool>(test, p_true, p_false));
+ op.reset(new Conditional<Bool>(test, p_true, p_false));
}
else {
- op.reset(new Wccl::Conditional<Wccl::Bool>(test, p_true));
+ op.reset(new Conditional<Bool>(test, p_true));
}
}
| Q_MARK
p_true = logical_predicates [tagset, vars]
Q_MARK
test = logical_predicates [tagset, vars] {
- op.reset(new Wccl::Conditional<Wccl::Bool>(test, p_true));
+ op.reset(new Conditional<Bool>(test, p_true));
}
;
@@ -987,28 +987,28 @@ condit_bool
// if (Bool, Position, Position)
// ? Position ? Bool : 0
condit_position
- [const Corpus2::Tagset& tagset, Wccl::Variables& vars]
- returns [boost::shared_ptr<Wccl::Function<Wccl::Position> > op]
+ [const Corpus2::Tagset& tagset, Variables& vars]
+ returns [boost::shared_ptr<Function<Position> > op]
{
- boost::shared_ptr<Wccl::Function<Wccl::Bool> > test;
- boost::shared_ptr<Wccl::Function<Wccl::Position> > p_true, p_false;
+ boost::shared_ptr<Function<Bool> > test;
+ boost::shared_ptr<Function<Position> > p_true, p_false;
}
: "if" LPAREN test = logical_predicates [tagset, vars] COMMA
p_true = position_operators [tagset, vars]
(COMMA p_false = position_operators [tagset, vars])?
RPAREN {
if (p_false) {
- op.reset(new Wccl::Conditional<Wccl::Position>(test, p_true, p_false));
+ op.reset(new Conditional<Position>(test, p_true, p_false));
}
else {
- op.reset(new Wccl::Conditional<Wccl::Position>(test, p_true));
+ op.reset(new Conditional<Position>(test, p_true));
}
}
| Q_MARK
p_true = position_operators [tagset, vars]
Q_MARK
test = logical_predicates [tagset, vars] {
- op.reset(new Wccl::Conditional<Wccl::Position>(test, p_true));
+ op.reset(new Conditional<Position>(test, p_true));
}
;
diff --git a/wcclparser/bool_main.cpp b/wcclparser/bool_main.cpp
index b8a6dce..e63a5c3 100644
--- a/wcclparser/bool_main.cpp
+++ b/wcclparser/bool_main.cpp
@@ -14,7 +14,7 @@ int main()
{
std::string str_in;
Corpus2::Tagset tagset;
- Parser parser(tagset);
+ Wccl::Parser parser(tagset);
boost::shared_ptr<const Wccl::Bool> retVal;
boost::shared_ptr<ANTLRParserResult<Wccl::Bool> > retOp;
diff --git a/wcclparser/main.cpp b/wcclparser/main.cpp
index 7bb1a81..3d2d786 100644
--- a/wcclparser/main.cpp
+++ b/wcclparser/main.cpp
@@ -90,7 +90,7 @@ void libedit_read_loop(boost::function<bool (const std::string&)>& line_cb)
}
#endif
-bool process_line(const std::string& line, Parser& parser,
+bool process_line(const std::string& line, Wccl::Parser& parser,
Wccl::SentenceContext& sc, bool all_positions)
{
if (line.empty() || line == "exit" || line == "quit") {
@@ -209,7 +209,7 @@ int main(int argc, char** argv)
Wccl::SentenceContext sc(sentence);
int pos = atoi(position.c_str());
sc.set_position(pos);
- Parser parser(tagset);
+ Wccl::Parser parser(tagset);
if (!query.empty()) {
process_line(query, parser, sc, position == "all");
return 0;
diff --git a/wcclparser/strop_main.cpp b/wcclparser/strop_main.cpp
index 6475d24..96a837f 100644
--- a/wcclparser/strop_main.cpp
+++ b/wcclparser/strop_main.cpp
@@ -15,7 +15,7 @@ int main()
{
std::string str_in;
Corpus2::Tagset tagset;
- Parser parser(tagset);
+ Wccl::Parser parser(tagset);
boost::shared_ptr<const Wccl::StrSet> retVal;
boost::shared_ptr<ANTLRParserResult<Wccl::StrSet> > retOp;
diff --git a/wcclparser/tagset_main.cpp b/wcclparser/tagset_main.cpp
index e31e066..7229a73 100644
--- a/wcclparser/tagset_main.cpp
+++ b/wcclparser/tagset_main.cpp
@@ -17,7 +17,7 @@ int main()
{
std::string str_in;
const Corpus2::Tagset& tagset = Corpus2::get_named_tagset("kipi");
- Parser parser(tagset);
+ Wccl::Parser parser(tagset);
boost::shared_ptr<const Wccl::TSet> retVal;
boost::shared_ptr<ANTLRParserResult<Wccl::TSet> > retOp;
--
GitLab