mirror of
https://github.com/saymrwulf/uhd.git
synced 2026-05-16 21:10:10 +00:00
967be2a4e8
Applying formatting changes to all .cpp and .hpp files in the following
directories:
```
find host/examples/ -iname *.hpp -o -iname *.cpp | \
xargs clang-format -i -style=file
find host/tests/ -iname *.hpp -o -iname *.cpp | \
xargs clang-format -i -style=file
find host/lib/usrp/dboard/neon/ -iname *.hpp -o -iname *.cpp | \
xargs clang-format -i -style=file
find host/lib/usrp/dboard/magnesium/ -iname *.hpp -o -iname *.cpp | \
xargs clang-format -i -style=file
find host/lib/usrp/device3/ -iname *.hpp -o -iname *.cpp | \
xargs clang-format -i -style=file
find host/lib/usrp/mpmd/ -iname *.hpp -o -iname *.cpp | \
xargs clang-format -i -style=file
find host/lib/usrp/x300/ -iname *.hpp -o -iname *.cpp | \
xargs clang-format -i -style=file
find host/utils/ -iname *.hpp -o -iname *.cpp | \
xargs clang-format -i -style=file
find mpm/ -iname *.hpp -o -iname *.cpp | \
xargs clang-format -i -style=file
```
Also formatted host/include/, except Cpp03 was used as a the language
standard instead of Cpp11.
```
sed -i 's/ Cpp11/ Cpp03/g' .clang-format
find host/include/ -iname *.hpp -o -iname *.cpp | \
xargs clang-format -i -style=file
```
Formatting style was designated by the .clang-format file.
405 lines
15 KiB
C++
405 lines
15 KiB
C++
//
|
|
// Copyright 2015 Ettus Research LLC
|
|
// Copyright 2018 Ettus Research, a National Instruments Company
|
|
//
|
|
// SPDX-License-Identifier: GPL-3.0-or-later
|
|
//
|
|
|
|
#include "../lib/rfnoc/nocscript/function_table.hpp"
|
|
#include "nocscript_common.hpp"
|
|
#include <boost/bind.hpp>
|
|
#include <boost/format.hpp>
|
|
#include <boost/make_shared.hpp>
|
|
#include <boost/test/floating_point_comparison.hpp>
|
|
#include <boost/test/unit_test.hpp>
|
|
#include <algorithm>
|
|
#include <iostream>
|
|
|
|
// We need this global variable for one of the later tests
|
|
int and_counter = 0;
|
|
|
|
BOOST_AUTO_TEST_CASE(test_literals)
|
|
{
|
|
expression_literal literal_int("5", expression::TYPE_INT);
|
|
BOOST_CHECK_EQUAL(literal_int.infer_type(), expression::TYPE_INT);
|
|
BOOST_CHECK_EQUAL(literal_int.get_int(), 5);
|
|
BOOST_CHECK_EQUAL(literal_int.to_bool(), true);
|
|
BOOST_REQUIRE_THROW(literal_int.get_string(), uhd::type_error);
|
|
BOOST_REQUIRE_THROW(literal_int.get_bool(), uhd::type_error);
|
|
|
|
expression_literal literal_int0("0", expression::TYPE_INT);
|
|
BOOST_CHECK_EQUAL(literal_int0.infer_type(), expression::TYPE_INT);
|
|
BOOST_CHECK_EQUAL(literal_int0.to_bool(), false);
|
|
|
|
expression_literal literal_double("2.3", expression::TYPE_DOUBLE);
|
|
BOOST_CHECK_EQUAL(literal_double.infer_type(), expression::TYPE_DOUBLE);
|
|
BOOST_CHECK_CLOSE(literal_double.get_double(), 2.3, 0.01);
|
|
BOOST_CHECK_EQUAL(literal_double.to_bool(), true);
|
|
BOOST_REQUIRE_THROW(literal_double.get_string(), uhd::type_error);
|
|
BOOST_REQUIRE_THROW(literal_double.get_bool(), uhd::type_error);
|
|
|
|
expression_literal literal_bool(true);
|
|
BOOST_CHECK_EQUAL(literal_bool.infer_type(), expression::TYPE_BOOL);
|
|
BOOST_CHECK_EQUAL(literal_bool.get_bool(), true);
|
|
BOOST_CHECK_EQUAL(literal_bool.to_bool(), true);
|
|
BOOST_CHECK_EQUAL(literal_bool.eval().get_bool(), true);
|
|
BOOST_REQUIRE_THROW(literal_bool.get_string(), uhd::type_error);
|
|
BOOST_REQUIRE_THROW(literal_bool.get_int(), uhd::type_error);
|
|
|
|
expression_literal literal_bool_false(false);
|
|
BOOST_CHECK_EQUAL(literal_bool_false.infer_type(), expression::TYPE_BOOL);
|
|
BOOST_CHECK_EQUAL(literal_bool_false.get_bool(), false);
|
|
BOOST_CHECK_EQUAL(literal_bool_false.to_bool(), false);
|
|
BOOST_REQUIRE_EQUAL(literal_bool_false.eval().get_bool(), false);
|
|
BOOST_REQUIRE_THROW(literal_bool_false.get_string(), uhd::type_error);
|
|
BOOST_REQUIRE_THROW(literal_bool_false.get_int(), uhd::type_error);
|
|
|
|
expression_literal literal_string("'foo bar'", expression::TYPE_STRING);
|
|
BOOST_CHECK_EQUAL(literal_string.infer_type(), expression::TYPE_STRING);
|
|
BOOST_CHECK_EQUAL(literal_string.get_string(), "foo bar");
|
|
BOOST_REQUIRE_THROW(literal_string.get_bool(), uhd::type_error);
|
|
BOOST_REQUIRE_THROW(literal_string.get_int(), uhd::type_error);
|
|
|
|
expression_literal literal_int_vec("[1, 2, 3]", expression::TYPE_INT_VECTOR);
|
|
BOOST_CHECK_EQUAL(literal_int_vec.infer_type(), expression::TYPE_INT_VECTOR);
|
|
std::vector<int> test_data{1, 2, 3};
|
|
std::vector<int> result = literal_int_vec.get_int_vector();
|
|
BOOST_CHECK_EQUAL_COLLECTIONS(
|
|
test_data.begin(), test_data.end(), result.begin(), result.end());
|
|
BOOST_REQUIRE_THROW(literal_int_vec.get_bool(), uhd::type_error);
|
|
BOOST_REQUIRE_THROW(literal_int_vec.get_int(), uhd::type_error);
|
|
}
|
|
|
|
|
|
// Need those for the variable testing:
|
|
expression::type_t variable_get_type(const std::string& var_name)
|
|
{
|
|
if (var_name == "spp") {
|
|
std::cout << "Returning type for $spp..." << std::endl;
|
|
return expression::TYPE_INT;
|
|
}
|
|
if (var_name == "is_true") {
|
|
std::cout << "Returning type for $is_true..." << std::endl;
|
|
return expression::TYPE_BOOL;
|
|
}
|
|
|
|
throw uhd::syntax_error("Cannot infer type (unknown variable)");
|
|
}
|
|
|
|
expression_literal variable_get_value(const std::string& var_name)
|
|
{
|
|
if (var_name == "spp") {
|
|
std::cout << "Returning value for $spp..." << std::endl;
|
|
return expression_literal(5);
|
|
}
|
|
if (var_name == "is_true") {
|
|
std::cout << "Returning value for $is_true..." << std::endl;
|
|
return expression_literal(true);
|
|
}
|
|
|
|
throw uhd::syntax_error("Cannot read value (unknown variable)");
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(test_variables)
|
|
{
|
|
BOOST_REQUIRE_THROW(expression_variable v_fail("foo", // Invalid token
|
|
boost::bind(&variable_get_type, _1),
|
|
boost::bind(&variable_get_value, _1)),
|
|
uhd::assertion_error);
|
|
|
|
expression_variable v("$spp", // The token
|
|
boost::bind(&variable_get_type, _1), // type-getter
|
|
boost::bind(&variable_get_value, _1) // value-getter
|
|
);
|
|
BOOST_CHECK_EQUAL(v.infer_type(), expression::TYPE_INT);
|
|
BOOST_CHECK_EQUAL(v.eval().get_int(), 5);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(test_container)
|
|
{
|
|
// Create some sub-expressions:
|
|
expression_literal::sptr l_true = E(true);
|
|
expression_literal::sptr l_false = E(false);
|
|
expression_literal::sptr l_int = E(5);
|
|
BOOST_REQUIRE_EQUAL(l_false->get_bool(), false);
|
|
BOOST_REQUIRE_EQUAL(l_false->to_bool(), false);
|
|
expression_variable::sptr l_boolvar =
|
|
boost::make_shared<expression_variable>("$is_true",
|
|
boost::bind(&variable_get_type, _1),
|
|
boost::bind(&variable_get_value, _1));
|
|
|
|
// This will throw anytime it's evaluated:
|
|
expression_variable::sptr l_failvar =
|
|
boost::make_shared<expression_variable>("$does_not_exist",
|
|
boost::bind(&variable_get_type, _1),
|
|
boost::bind(&variable_get_value, _1));
|
|
|
|
expression_container c;
|
|
std::cout << "One true, OR: " << std::endl;
|
|
c.add(l_true);
|
|
c.set_combiner_safe(expression_container::COMBINE_OR);
|
|
expression_literal ret_val_1 = c.eval();
|
|
BOOST_CHECK_EQUAL(ret_val_1.infer_type(), expression::TYPE_BOOL);
|
|
BOOST_CHECK_EQUAL(ret_val_1.eval().get_bool(), true);
|
|
|
|
std::cout << std::endl << std::endl << "Two true, one false, OR: " << std::endl;
|
|
c.add(l_true);
|
|
c.add(l_false);
|
|
expression_literal ret_val_2 = c.eval();
|
|
BOOST_CHECK_EQUAL(ret_val_2.infer_type(), expression::TYPE_BOOL);
|
|
BOOST_CHECK_EQUAL(ret_val_2.eval().get_bool(), true);
|
|
|
|
expression_container c2;
|
|
c2.add(l_false);
|
|
c2.add(l_false);
|
|
c2.set_combiner(expression_container::COMBINE_AND);
|
|
std::cout << std::endl << std::endl << "Two false, AND: " << std::endl;
|
|
expression_literal ret_val_3 = c2.eval();
|
|
BOOST_CHECK_EQUAL(ret_val_3.infer_type(), expression::TYPE_BOOL);
|
|
BOOST_REQUIRE_EQUAL(ret_val_3.eval().get_bool(), false);
|
|
|
|
c2.add(l_failvar);
|
|
// Will not fail, because l_failvar never gets eval'd:
|
|
expression_literal ret_val_4 = c2.eval();
|
|
BOOST_CHECK_EQUAL(ret_val_4.infer_type(), expression::TYPE_BOOL);
|
|
BOOST_CHECK_EQUAL(ret_val_4.eval().get_bool(), false);
|
|
|
|
// Same here:
|
|
c.add(l_failvar);
|
|
expression_literal ret_val_5 = c.eval();
|
|
BOOST_CHECK_EQUAL(ret_val_5.infer_type(), expression::TYPE_BOOL);
|
|
BOOST_CHECK_EQUAL(ret_val_5.eval().get_bool(), true);
|
|
|
|
// Now it'll throw:
|
|
c.set_combiner(expression_container::COMBINE_ALL);
|
|
BOOST_REQUIRE_THROW(c.eval(), uhd::syntax_error);
|
|
|
|
std::cout << "Checking type inference on ',' sequences: " << std::endl;
|
|
// Check types match
|
|
BOOST_CHECK_EQUAL(c2.infer_type(), expression::TYPE_BOOL);
|
|
expression_container c3;
|
|
c3.set_combiner(expression_container::COMBINE_ALL);
|
|
c3.add(l_false);
|
|
c3.add(l_int);
|
|
BOOST_CHECK_EQUAL(c3.infer_type(), expression::TYPE_INT);
|
|
}
|
|
|
|
|
|
// We'll define two functions here: ADD and XOR. The former shall
|
|
// be defined for INT and DOUBLE
|
|
class functable_mockup_impl : public function_table
|
|
{
|
|
public:
|
|
functable_mockup_impl(void){};
|
|
|
|
bool function_exists(const std::string& name) const
|
|
{
|
|
return name == "ADD" or name == "XOR" or name == "AND";
|
|
}
|
|
|
|
bool function_exists(const std::string& name,
|
|
const expression_function::argtype_list_type& arg_types) const
|
|
{
|
|
if (name == "ADD") {
|
|
if (arg_types.size() == 2 and arg_types[0] == expression::TYPE_DOUBLE
|
|
and arg_types[1] == expression::TYPE_DOUBLE) {
|
|
return true;
|
|
}
|
|
if (arg_types.size() == 2 and arg_types[0] == expression::TYPE_INT
|
|
and arg_types[1] == expression::TYPE_INT) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
if (name == "XOR" or name == "AND") {
|
|
if (arg_types.size() == 2 and arg_types[0] == expression::TYPE_BOOL
|
|
and arg_types[1] == expression::TYPE_BOOL) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
expression::type_t get_type(const std::string& name,
|
|
const expression_function::argtype_list_type& arg_types) const
|
|
{
|
|
if (not function_exists(name, arg_types)) {
|
|
throw uhd::syntax_error(
|
|
str(boost::format(
|
|
"[EXPR_TEXT] get_type(): Unknown function: %s, %d arguments")
|
|
% name % arg_types.size()));
|
|
}
|
|
|
|
if (name == "XOR" or name == "AND") {
|
|
return expression::TYPE_BOOL;
|
|
}
|
|
if (name == "ADD") {
|
|
return arg_types[0];
|
|
}
|
|
UHD_THROW_INVALID_CODE_PATH();
|
|
}
|
|
|
|
expression_literal eval(const std::string& name,
|
|
const expression_function::argtype_list_type& arg_types,
|
|
expression_container::expr_list_type& args)
|
|
{
|
|
if (name == "XOR") {
|
|
if (arg_types.size() != 2 or args.size() != 2
|
|
or arg_types[0] != expression::TYPE_BOOL
|
|
or arg_types[1] != expression::TYPE_BOOL
|
|
or args[0]->infer_type() != expression::TYPE_BOOL
|
|
or args[1]->infer_type() != expression::TYPE_BOOL) {
|
|
throw uhd::syntax_error("eval(): XOR type mismatch");
|
|
}
|
|
return expression_literal(
|
|
bool(args[0]->eval().get_bool() xor args[1]->eval().get_bool()));
|
|
}
|
|
|
|
if (name == "AND") {
|
|
if (arg_types.size() != 2 or args.size() != 2
|
|
or arg_types[0] != expression::TYPE_BOOL
|
|
or arg_types[1] != expression::TYPE_BOOL
|
|
or args[0]->infer_type() != expression::TYPE_BOOL
|
|
or args[1]->infer_type() != expression::TYPE_BOOL) {
|
|
throw uhd::syntax_error("eval(): AND type mismatch");
|
|
}
|
|
std::cout << "Calling AND" << std::endl;
|
|
and_counter++;
|
|
return expression_literal(
|
|
bool(args[0]->eval().get_bool() and args[1]->eval().get_bool()));
|
|
}
|
|
|
|
if (name == "ADD") {
|
|
if (args.size() != 2) {
|
|
throw uhd::syntax_error("eval(): ADD type mismatch");
|
|
}
|
|
if ((args[0]->infer_type() == expression::TYPE_INT)
|
|
and (args[1]->infer_type() == expression::TYPE_INT)) {
|
|
return expression_literal(
|
|
int(args[0]->eval().get_int() + args[1]->eval().get_int()));
|
|
} else if ((args[0]->infer_type() == expression::TYPE_DOUBLE)
|
|
and (args[1]->infer_type() == expression::TYPE_DOUBLE)) {
|
|
return expression_literal(
|
|
double(args[0]->eval().get_double() + args[1]->eval().get_double()));
|
|
}
|
|
throw uhd::syntax_error("eval(): ADD type mismatch");
|
|
}
|
|
throw uhd::syntax_error("eval(): unknown function");
|
|
}
|
|
|
|
// We don't actually need this
|
|
void register_function(const std::string&,
|
|
const function_table::function_ptr&,
|
|
const expression::type_t,
|
|
const expression_function::argtype_list_type&){};
|
|
};
|
|
|
|
|
|
// The annoying part: Testing the test fixtures
|
|
BOOST_AUTO_TEST_CASE(test_functable_mockup)
|
|
{
|
|
functable_mockup_impl functable;
|
|
|
|
BOOST_CHECK(functable.function_exists("ADD"));
|
|
BOOST_CHECK(functable.function_exists("XOR"));
|
|
BOOST_CHECK(not functable.function_exists("FOOBAR"));
|
|
|
|
BOOST_CHECK(functable.function_exists("ADD", two_int_args));
|
|
BOOST_CHECK(functable.function_exists("ADD", two_double_args));
|
|
BOOST_CHECK(functable.function_exists("XOR", two_bool_args));
|
|
BOOST_CHECK(not functable.function_exists("ADD", two_bool_args));
|
|
BOOST_CHECK(not functable.function_exists("ADD", no_args));
|
|
BOOST_CHECK(not functable.function_exists("XOR", no_args));
|
|
|
|
BOOST_CHECK_EQUAL(functable.get_type("ADD", two_int_args), expression::TYPE_INT);
|
|
BOOST_CHECK_EQUAL(
|
|
functable.get_type("ADD", two_double_args), expression::TYPE_DOUBLE);
|
|
BOOST_CHECK_EQUAL(functable.get_type("XOR", two_bool_args), expression::TYPE_BOOL);
|
|
|
|
expression_container::expr_list_type add_args_int{E(2), E(3)};
|
|
expression_container::expr_list_type add_args_dbl{E(2.25), E(5.0)};
|
|
expression_container::expr_list_type xor_args_bool{E(true), E(false)};
|
|
|
|
BOOST_CHECK_EQUAL(
|
|
functable.eval("ADD", two_int_args, add_args_int), expression_literal(5));
|
|
BOOST_CHECK_EQUAL(
|
|
functable.eval("ADD", two_double_args, add_args_dbl), expression_literal(7.25));
|
|
BOOST_CHECK_EQUAL(
|
|
functable.eval("XOR", two_bool_args, xor_args_bool), expression_literal(true));
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(test_function_expression)
|
|
{
|
|
function_table::sptr ft = boost::make_shared<functable_mockup_impl>();
|
|
|
|
// Very simple function: ADD(2, 3)
|
|
expression_function func1("ADD", ft);
|
|
func1.add(E(2));
|
|
func1.add(E(3));
|
|
|
|
BOOST_CHECK_EQUAL(func1.eval(), expression_literal(5));
|
|
|
|
// More elaborate: ADD(ADD(2, 3), ADD(ADD(4, 5), 6)) ?= 20
|
|
// f4 f1 f3 f2
|
|
expression_function f1("ADD", ft);
|
|
f1.add(E(2));
|
|
f1.add(E(3));
|
|
expression_function f2("ADD", ft);
|
|
f2.add(E(4));
|
|
f2.add(E(5));
|
|
expression_function f3("ADD", ft);
|
|
f3.add(boost::make_shared<expression_function>(f2));
|
|
f3.add(E(6));
|
|
expression_function f4("ADD", ft);
|
|
f4.add(boost::make_shared<expression_function>(f1));
|
|
f4.add(boost::make_shared<expression_function>(f3));
|
|
|
|
BOOST_CHECK_EQUAL(f4.eval().get_int(), 20);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(test_function_expression_laziness)
|
|
{
|
|
function_table::sptr ft = boost::make_shared<functable_mockup_impl>();
|
|
|
|
// We run AND(AND(false, false), AND(false, false)).
|
|
// f1 f2 f3
|
|
// That makes three ANDs
|
|
// in total. However, we will only see AND being evaluated twice, because
|
|
// the outcome is clear after running the first AND in the argument list.
|
|
expression_function::sptr f2 = boost::make_shared<expression_function>("AND", ft);
|
|
f2->add(E(false));
|
|
f2->add(E(false));
|
|
BOOST_CHECK(not f2->eval().get_bool());
|
|
|
|
expression_function::sptr f3 = boost::make_shared<expression_function>("AND", ft);
|
|
f3->add(E(false));
|
|
f3->add(E(false));
|
|
BOOST_CHECK(not f3->eval().get_bool());
|
|
|
|
and_counter = 0;
|
|
expression_function::sptr f1 = boost::make_shared<expression_function>("AND", ft);
|
|
f1->add(f2);
|
|
f1->add(f3);
|
|
|
|
BOOST_CHECK(not f1->eval().get_bool());
|
|
BOOST_CHECK_EQUAL(and_counter, 2);
|
|
}
|
|
|
|
BOOST_AUTO_TEST_CASE(test_sptrs)
|
|
{
|
|
expression_container::sptr c = expression_container::make();
|
|
BOOST_CHECK_EQUAL(c->infer_type(), expression::TYPE_BOOL);
|
|
BOOST_CHECK(c->eval().get_bool());
|
|
|
|
expression_variable::sptr v = expression_variable::make("$spp",
|
|
boost::bind(&variable_get_type, _1), // type-getter
|
|
boost::bind(&variable_get_value, _1) // value-getter
|
|
);
|
|
|
|
c->add(v);
|
|
BOOST_REQUIRE_EQUAL(c->infer_type(), expression::TYPE_INT);
|
|
BOOST_CHECK_EQUAL(c->eval().get_int(), 5);
|
|
}
|