Skip to content
Snippets Groups Projects
Commit 955722de authored by ilor's avatar ilor
Browse files

Merge branch 'master' of nlp.pwr.wroc.pl:wccl 

Conflicts:
	libwccl/parser/grammar.g
parents 2e8bc0f8 9b51ebe7
Branches
No related merge requests found
Hide whitespace changes
Inline Side-by-side
libwccl/ops/equals.h
+ 1
− 1
View file @ 955722de
......@@ -83,7 +83,7 @@ public:
* @returns Name of the function: "equals".
*/
std::string raw_name() const {
return "equals";
return "equal";
}
protected:
......
libwccl/ops/intersects.h
+ 5
− 2
View file @ 955722de
......@@ -12,6 +12,8 @@ template <class T>
class Intersects : public SetPredicate<T>
{
public:
typedef typename SetPredicate<T>::SetFunctionPtr SetFunctionPtr;
Intersects(const SetFunctionPtr& set1_expr, const SetFunctionPtr& set2_expr)
: SetPredicate<T>(set1_expr, set2_expr)
{
......@@ -25,13 +27,14 @@ public:
}
protected:
typedef FunctionBase::BaseRetValPtr BaseRetValPtr;
/**
* Take values for both sets and return True if they intersect,
* False otherwise.
*/
BaseRetValPtr apply_internal(const FunExecContext& context) const {
boost::shared_ptr<T> set1 = this->set1_expr_->apply(context);
boost::shared_ptr<T> set2 = this->set2_expr_->apply(context);
const boost::shared_ptr<const T>& set1 = this->set1_expr_->apply(context);
const boost::shared_ptr<const T>& set2 = this->set2_expr_->apply(context);
return Predicate::evaluate(set1->intersects(*set2), context);
}
......
libwccl/ops/issubsetof.h
+ 3
− 2
View file @ 955722de
......@@ -28,6 +28,7 @@ public:
}
protected:
typedef FunctionBase::BaseRetValPtr BaseRetValPtr;
/**
* Take value of possible subset in question. If it is an empty set, return False.
* Otherwise, take value of the set that is being compared to.
......@@ -36,10 +37,10 @@ protected:
* set is considered not to be "in" any other set so False is returned.
*/
BaseRetValPtr apply_internal(const FunExecContext& context) const {
boost::shared_ptr<T> possible_subset = this->set1_expr_->apply(context);
const boost::shared_ptr<const T>& possible_subset = this->set1_expr_->apply(context);
if(!possible_subset->empty())
{
boost::shared_ptr<T> set_compared_to = this->set2_expr_->apply(context);
const boost::shared_ptr<const T>& set_compared_to = this->set2_expr_->apply(context);
return Predicate::evaluate(possible_subset->is_subset_of(*set_compared_to), context);
}
return Predicate::False(context);
......
libwccl/parser/grammar.g
+ 112
− 70
View file @ 955722de
......@@ -29,9 +29,14 @@ header {
#include <libwccl/ops/functions.h>
#include <libwccl/ops/vargetter.h>
#include <libwccl/ops/varsetter.h>
// #include <libwccl/ops/intersects.h>
// #include <libwccl/ops/issubsetof.h>
#include <libwccl/ops/logicalpredicate.h>
#include <libwccl/ops/intersects.h>
#include <libwccl/ops/issubsetof.h>
#include <libwccl/ops/setpredicate.h>
#include <libwccl/ops/isinside.h>
#include <libwccl/ops/isoutside.h>
// Unicode String
#include <unicode/uniset.h>
......@@ -72,15 +77,10 @@ private:
}
// TODO
// - nie mozna utworzyc in/inter/equal z operatorem?
// - jak utworzyc TSet (dodac element do TSet)
// - nie mozna utworzy Const::Value i na tym robic specjalizowany reset?
// - base, orth
// -> Dodac do regul _variable podregule zwracajaca accessor, a nadregula
// powinna zwracac VarGetter. I wlasnie reguly zwracajace accessor podpiac
// do setvara
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// "GLOBAL" RULES
......@@ -241,16 +241,28 @@ position_value
///////////////////////////////////////////////////////////////////////////////
// Position: $name
// ----------------------------------------------------------------------------
position_variable
// returns accessor
position_variable_acc
[Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::VarGetter<Wccl::Position> > op]
returns [boost::shared_ptr<Wccl::VariableAccessor<Wccl::Position> > pos_acc]
: DOLLAR n: SYMBOL {
vars.get_put<Wccl::Position>(token_ref_to_std_string(n));
vars.get_put<Wccl::Position>(token_ref_to_std_string(n));
Wccl::VariableAccessor<Wccl::Position> acc =
vars.create_accessor<Wccl::Position>(token_ref_to_std_string(n));
op.reset(new Wccl::VarGetter<Wccl::Position>(acc));
pos_acc.reset(new Wccl::VariableAccessor<Wccl::Position>(acc));
}
;
// returs vargetter
position_variable
[Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::VarGetter<Wccl::Position> > op]
{
boost::shared_ptr<Wccl::VariableAccessor<Wccl::Position> > pos_acc;
}
: pos_acc = position_variable_acc [vars] {
op.reset(new Wccl::VarGetter<Wccl::Position>(*pos_acc.get()));
}
;
// ----------------------------------------------------------------------------
......@@ -265,10 +277,10 @@ position_ref_variable
// ----------------------------------------------------------------------------
// String set, call examples: $name, $sName, $s_name, $s_Name etc.
// This expression gets variable of tyme StrSet from string-named variable
// Returns Wccl::VarGetter<Wccl::StrSet> from Set-variables
str_set_variable
// returns accessor
str_set_variable_acc
[Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::VarGetter<Wccl::StrSet> > op]
returns [boost::shared_ptr<Wccl::VariableAccessor<Wccl::StrSet> > strset_acc]
: DOLLAR STR_PREFIX n: SYMBOL {
// get/put variable to variables
vars.get_put<Wccl::StrSet>(token_ref_to_std_string(n));
......@@ -277,35 +289,70 @@ str_set_variable
Wccl::VariableAccessor<Wccl::StrSet> acc =
vars.create_accessor<Wccl::StrSet>(token_ref_to_std_string(n));
op.reset(new Wccl::VarGetter<Wccl::StrSet>(acc));
strset_acc.reset(new Wccl::VariableAccessor<Wccl::StrSet>(acc));
}
;
// vargetter
str_set_variable
[Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::VarGetter<Wccl::StrSet> > op]
{
boost::shared_ptr<Wccl::VariableAccessor<Wccl::StrSet> > strset_acc;
}
: strset_acc = str_set_variable_acc [vars] {
op.reset(new Wccl::VarGetter<Wccl::StrSet>(*strset_acc.get()));
}
;
// ----------------------------------------------------------------------------
// Symbol set: $tName
sym_set_variable
// returns accessor
sym_set_variable_acc
[Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::VarGetter<Wccl::TSet> > op]
returns [boost::shared_ptr<Wccl::VariableAccessor<Wccl::TSet> > symset_acc]
: DOLLAR TST_PREFIX n: SYMBOL {
vars.get_put<Wccl::TSet>(token_ref_to_std_string(n));
Wccl::VariableAccessor<Wccl::TSet> acc =
vars.create_accessor<Wccl::TSet>(token_ref_to_std_string(n));
op.reset(new Wccl::VarGetter<Wccl::TSet>(acc));
symset_acc.reset(new Wccl::VariableAccessor<Wccl::TSet>(acc));
}
;
// returns vargetter
sym_set_variable
[Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::VarGetter<Wccl::TSet> > op]
{
boost::shared_ptr<Wccl::VariableAccessor<Wccl::TSet> > symset_acc;
}
: symset_acc = sym_set_variable_acc [vars] {
op.reset(new Wccl::VarGetter<Wccl::TSet>(*symset_acc.get()));
}
;
// ----------------------------------------------------------------------------
// Bool: $bName
boolean_variable
// returns accessor
boolean_variable_acc
[Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::VarGetter<Wccl::Bool> > op]
returns [boost::shared_ptr<Wccl::VariableAccessor<Wccl::Bool> > bool_acc]
: DOLLAR BOOL_PREFIX n: SYMBOL {
vars.get_put<Wccl::Bool>(token_ref_to_std_string(n));
Wccl::VariableAccessor<Wccl::Bool> acc =
vars.create_accessor<Wccl::Bool>(token_ref_to_std_string(n));
op.reset(new Wccl::VarGetter<Wccl::Bool>(acc));
bool_acc.reset(new Wccl::VariableAccessor<Wccl::Bool>(acc));
}
;
// returns vargetter
boolean_variable
[Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::VarGetter<Wccl::Bool> > op]
{
boost::shared_ptr<Wccl::VariableAccessor<Wccl::Bool> > bool_acc;
}
: bool_acc = boolean_variable_acc [vars] {
op.reset(new Wccl::VarGetter<Wccl::Bool>(*bool_acc.get()));
}
;
......@@ -335,73 +382,53 @@ setvar_pos
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<Wccl::Function<Wccl::Position> > ret_op;
boost::shared_ptr<Wccl::VarGetter<Wccl::Position> > ret_var;
boost::shared_ptr<Wccl::VariableAccessor<Wccl::Position> > ret_acc;
}
: "setvar" LPAREN ret_var = position_variable [vars] COMMA
ret_op = op_position [vars] RPAREN {
/*
Wccl::VariableAccessor<Wccl::Position> acc =
vars.create_accessor<Wccl::Position>(ret_var->acc_name());
op.reset(new Wccl::VarSetter<Wccl::Position>(acc, ret_op));
*/
: "setvar" LPAREN ret_acc = position_variable_acc [vars] COMMA
ret_op = op_position [vars] RPAREN {
op.reset(new Wccl::VarSetter<Wccl::Position>(*ret_acc.get(), ret_op));
}
;
;
// ----------------------------------------------------------------------------
setvar_bool
[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::VarGetter<Wccl::Bool> > ret_var;
boost::shared_ptr<Wccl::VariableAccessor<Wccl::Bool> > ret_acc;
}
: "setvar" LPAREN ret_var = boolean_variable [vars] COMMA
ret_op = logical_predicates [vars] RPAREN {
/*
Wccl::VariableAccessor<Wccl::Bool> acc =
vars.create_accessor<Wccl::Bool>(ret_var->acc_name());
op.reset(new Wccl::VarSetter<Wccl::Bool>(acc, ret_op));
*/
: "setvar" LPAREN ret_acc = boolean_variable_acc [vars] COMMA
ret_op = logical_predicates [vars] RPAREN {
op.reset(new Wccl::VarSetter<Wccl::Bool>(*ret_acc.get(), ret_op));
}
;
// ----------------------------------------------------------------------------
setvar_sset
[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::VarGetter<Wccl::StrSet> > ret_var;
boost::shared_ptr<Wccl::VariableAccessor<Wccl::StrSet> > ret_acc;
}
: "setvar" LPAREN ret_var = str_set_variable [vars] COMMA
ret_op = string_operators [vars] RPAREN {
/*
Wccl::VariableAccessor<Wccl::StrSet> acc =
vars.create_accessor<Wccl::StrSet>(ret_var->acc_name());
op.reset(new Wccl::VarSetter<Wccl::StrSet>(acc, ret_op));
*/
: "setvar" LPAREN ret_acc = str_set_variable_acc [vars] COMMA
ret_op = string_operators [vars] RPAREN {
op.reset(new Wccl::VarSetter<Wccl::StrSet>(*ret_acc.get(), ret_op));
}
;
// ----------------------------------------------------------------------------
setvar_tset
[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::VarGetter<Wccl::TSet> > ret_var;
boost::shared_ptr<Wccl::VariableAccessor<Wccl::TSet> > ret_acc;
}
: "setvar" LPAREN ret_var = sym_set_variable [vars] COMMA
ret_op = sym_set_operators [vars] RPAREN {
/*
Wccl::VariableAccessor<Wccl::TSet> acc =
vars.create_accessor<Wccl::TSet>(ret_var->acc_name());
op.reset(new Wccl::VarSetter<Wccl::TSet>(acc, ret_op));
*/
: "setvar" LPAREN ret_acc = sym_set_variable_acc [vars] COMMA
ret_op = sym_set_operators [vars] RPAREN {
op.reset(new Wccl::VarSetter<Wccl::TSet>(*ret_acc.get(), ret_op));
}
;
......@@ -539,6 +566,7 @@ logical_predicates
| ret = lpred_eq [vars]
| ret = lpred_regex [vars]
| ret = setvar_op [vars]
| ret = lpred_inout [vars]
;
// ----------------------------------------------------------------------------
// comma-separated predicates
......@@ -614,17 +642,14 @@ lpred_in
boost::shared_ptr<Wccl::Function<Wccl::TSet> > ts1, ts2;
boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ss1, ss2;
boost::shared_ptr<Wccl::Function<Wccl::Position> > p1, p2;
boost::shared_ptr<Wccl::Function<Wccl::StrSet> > expr;
}
: "in" LPAREN ss1 = string_operators [vars] COMMA
ss2 = string_operators [vars] RPAREN {
op.reset(
// new Wccl::IsSubsetOf<Wccl::StrSet>(ss1, ss2)
);
op.reset(new Wccl::IsSubsetOf<Wccl::StrSet>(ss1, ss2));
}
| "in" LPAREN ts1 = sym_set_operators [vars] COMMA
ts2 = sym_set_operators [vars] RPAREN {
// op.reset(new Wccl::IsSubsetOf(*ts1.get(), *ts2.get()));
op.reset(new Wccl::IsSubsetOf<Wccl::TSet>(ts1, ts2));
}
/*
| "in" LPAREN p1 = position_operators [vars] COMMA
......@@ -633,23 +658,24 @@ lpred_in
}
*/
;
// ----------------------------------------------------------------------------
lpred_inter
[Wccl::Variables& vars]
returns [boost::shared_ptr<Wccl::Function<Wccl::Bool> > op]
{
boost::shared_ptr<Wccl::Function<Wccl::TSet> > ts1, ts2;
boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ss1, ss2;
boost::shared_ptr<Wccl::Function<Wccl::Position> > p1, p2;
boost::shared_ptr<Wccl::Function<Wccl::StrSet> > ss1, ss2;
boost::shared_ptr<Wccl::Function<Wccl::TSet> > ts1, ts2;
boost::shared_ptr<Wccl::Function<Wccl::Position> > p1, p2;
}
: "inter" LPAREN ss1 = string_operators [vars] COMMA
ss2 = string_operators [vars] RPAREN {
// op.reset(new Wccl::Intersects(*ss1.get(), *ss2.get()));
op.reset(new Wccl::Intersects<Wccl::StrSet>(ss1, ss2));
}
| "inter" LPAREN ts1 = sym_set_operators [vars] COMMA
ts2 = sym_set_operators [vars] RPAREN {
// op.reset(new Wccl::Intersects(*ts1.get(), *ts2.get()));
op.reset(new Wccl::Intersects<Wccl::TSet>(ts1, ts2));
}
/*
| "inter" LPAREN p1 = position_operators [vars] COMMA
......@@ -658,6 +684,7 @@ lpred_inter
}
*/
;
// ----------------------------------------------------------------------------
lpred_eq
[Wccl::Variables& vars]
......@@ -695,6 +722,21 @@ lpred_regex
}
;
// ----------------------------------------------------------------------------
lpred_inout
[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 {
op.reset(new Wccl::IsInside(ret_pos));
}
| "outside" LPAREN ret_pos = position_operators [vars] RPAREN {
op.reset(new Wccl::IsOutside(ret_pos));
}
;
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// ANTLR LEXER
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment