From 04722ba053fa6225c5a71d34316cbac093b87f66 Mon Sep 17 00:00:00 2001
From: Martin Braun <martin.braun@ettus.com>
Date: Fri, 18 Jan 2019 13:46:12 -0800
Subject: formatting: Apply clang-format to nocscript files
---
host/lib/rfnoc/nocscript/block_iface.cpp | 176 ++++++------
host/lib/rfnoc/nocscript/block_iface.hpp | 38 +--
host/lib/rfnoc/nocscript/expression.cpp | 189 ++++++-------
host/lib/rfnoc/nocscript/expression.hpp | 112 ++++----
host/lib/rfnoc/nocscript/function_table.cpp | 72 +++--
host/lib/rfnoc/nocscript/function_table.hpp | 43 ++-
host/lib/rfnoc/nocscript/parser.cpp | 414 ++++++++++++++--------------
host/lib/rfnoc/nocscript/parser.hpp | 12 +-
8 files changed, 499 insertions(+), 557 deletions(-)
(limited to 'host/lib')
diff --git a/host/lib/rfnoc/nocscript/block_iface.cpp b/host/lib/rfnoc/nocscript/block_iface.cpp
index f0a4e89b5..48adc8ab2 100644
--- a/host/lib/rfnoc/nocscript/block_iface.cpp
+++ b/host/lib/rfnoc/nocscript/block_iface.cpp
@@ -18,108 +18,81 @@
using namespace uhd::rfnoc;
using namespace uhd::rfnoc::nocscript;
-block_iface::block_iface(block_ctrl_base *block_ptr)
- : _block_ptr(block_ptr)
+block_iface::block_iface(block_ctrl_base* block_ptr) : _block_ptr(block_ptr)
{
function_table::sptr ft = function_table::make();
// Add the SR_WRITE() function
- expression_function::argtype_list_type sr_write_args = boost::assign::list_of
- (expression::TYPE_STRING)
- (expression::TYPE_INT)
- ;
- ft->register_function(
- "SR_WRITE",
+ expression_function::argtype_list_type sr_write_args =
+ boost::assign::list_of(expression::TYPE_STRING)(expression::TYPE_INT);
+ ft->register_function("SR_WRITE",
boost::bind(&block_iface::_nocscript__sr_write, this, _1),
expression::TYPE_BOOL,
- sr_write_args
- );
+ sr_write_args);
// Add read access to arguments ($foo)
- expression_function::argtype_list_type arg_set_args_wo_port = boost::assign::list_of
- (expression::TYPE_STRING)
- (expression::TYPE_INT)
- ;
- expression_function::argtype_list_type arg_set_args_w_port = boost::assign::list_of
- (expression::TYPE_STRING)
- (expression::TYPE_INT)
- (expression::TYPE_INT)
- ;
-#define REGISTER_ARG_SETTER(noctype, setter_func) \
- arg_set_args_wo_port[1] = expression::noctype; \
- arg_set_args_w_port[1] = expression::noctype; \
- ft->register_function( \
- "SET_ARG", \
+ expression_function::argtype_list_type arg_set_args_wo_port =
+ boost::assign::list_of(expression::TYPE_STRING)(expression::TYPE_INT);
+ expression_function::argtype_list_type arg_set_args_w_port = boost::assign::list_of(
+ expression::TYPE_STRING)(expression::TYPE_INT)(expression::TYPE_INT);
+#define REGISTER_ARG_SETTER(noctype, setter_func) \
+ arg_set_args_wo_port[1] = expression::noctype; \
+ arg_set_args_w_port[1] = expression::noctype; \
+ ft->register_function("SET_ARG", \
boost::bind(&block_iface::setter_func, this, _1), \
- expression::TYPE_BOOL, \
- arg_set_args_wo_port \
- ); \
- ft->register_function( \
- "SET_ARG", \
+ expression::TYPE_BOOL, \
+ arg_set_args_wo_port); \
+ ft->register_function("SET_ARG", \
boost::bind(&block_iface::setter_func, this, _1), \
- expression::TYPE_BOOL, \
- arg_set_args_w_port \
- );
- REGISTER_ARG_SETTER(TYPE_INT, _nocscript__arg_set_int);
- REGISTER_ARG_SETTER(TYPE_STRING, _nocscript__arg_set_string);
- REGISTER_ARG_SETTER(TYPE_DOUBLE, _nocscript__arg_set_double);
+ expression::TYPE_BOOL, \
+ arg_set_args_w_port);
+ REGISTER_ARG_SETTER(TYPE_INT, _nocscript__arg_set_int);
+ REGISTER_ARG_SETTER(TYPE_STRING, _nocscript__arg_set_string);
+ REGISTER_ARG_SETTER(TYPE_DOUBLE, _nocscript__arg_set_double);
REGISTER_ARG_SETTER(TYPE_INT_VECTOR, _nocscript__arg_set_intvec);
// Add read/write access to local variables
- expression_function::argtype_list_type set_var_args = boost::assign::list_of
- (expression::TYPE_STRING)
- (expression::TYPE_INT)
- ;
- const expression_function::argtype_list_type get_var_args = boost::assign::list_of
- (expression::TYPE_STRING)
- ;
-#define REGISTER_VAR_ACCESS(noctype, typestr) \
- set_var_args[1] = expression::noctype; \
- ft->register_function( \
- "SET_VAR", \
+ expression_function::argtype_list_type set_var_args =
+ boost::assign::list_of(expression::TYPE_STRING)(expression::TYPE_INT);
+ const expression_function::argtype_list_type get_var_args =
+ boost::assign::list_of(expression::TYPE_STRING);
+#define REGISTER_VAR_ACCESS(noctype, typestr) \
+ set_var_args[1] = expression::noctype; \
+ ft->register_function("SET_VAR", \
boost::bind(&block_iface::_nocscript__var_set, this, _1), \
- expression::TYPE_BOOL, \
- set_var_args \
- ); \
- ft->register_function( \
- "GET_"#typestr, \
+ expression::TYPE_BOOL, \
+ set_var_args); \
+ ft->register_function("GET_" #typestr, \
boost::bind(&block_iface::_nocscript__var_get, this, _1), \
- expression::noctype, \
- get_var_args \
- );
+ expression::noctype, \
+ get_var_args);
REGISTER_VAR_ACCESS(TYPE_INT, INT);
REGISTER_VAR_ACCESS(TYPE_STRING, STRING);
REGISTER_VAR_ACCESS(TYPE_DOUBLE, DOUBLE);
REGISTER_VAR_ACCESS(TYPE_INT_VECTOR, INT_VECTOR);
// Create the parser
- _parser = parser::make(
- ft,
+ _parser = parser::make(ft,
boost::bind(&block_iface::_nocscript__arg_get_type, this, _1),
- boost::bind(&block_iface::_nocscript__arg_get_val, this, _1)
- );
+ boost::bind(&block_iface::_nocscript__arg_get_val, this, _1));
}
-void block_iface::run_and_check(const std::string &code, const std::string &error_message)
+void block_iface::run_and_check(const std::string& code, const std::string& error_message)
{
boost::mutex::scoped_lock local_interpreter_lock(_lil_mutex);
- UHD_NOCSCRIPT_LOG() << "[NocScript] Executing and asserting code: " << code ;
- expression::sptr e = _parser->create_expr_tree(code);
+ UHD_NOCSCRIPT_LOG() << "[NocScript] Executing and asserting code: " << code;
+ expression::sptr e = _parser->create_expr_tree(code);
expression_literal result = e->eval();
if (not result.to_bool()) {
if (error_message.empty()) {
- throw uhd::runtime_error(str(
- boost::format("[NocScript] Code returned false: %s")
- % code
- ));
+ throw uhd::runtime_error(
+ str(boost::format("[NocScript] Code returned false: %s") % code));
} else {
- throw uhd::runtime_error(str(
- boost::format("[NocScript] Error: %s")
- % error_message
- ));
+ throw uhd::runtime_error(
+ str(boost::format("[NocScript] Error: %s") % error_message));
}
}
@@ -127,25 +100,26 @@ void block_iface::run_and_check(const std::string &code, const std::string &erro
}
-expression_literal block_iface::_nocscript__sr_write(expression_container::expr_list_type args)
+expression_literal block_iface::_nocscript__sr_write(
+ expression_container::expr_list_type args)
{
const std::string reg_name = args[0]->eval().get_string();
- const uint32_t reg_val = uint32_t(args[1]->eval().get_int());
- bool result = true;
+ const uint32_t reg_val = uint32_t(args[1]->eval().get_int());
+ bool result = true;
try {
- UHD_NOCSCRIPT_LOG() << "[NocScript] Executing SR_WRITE() " ;
+ UHD_NOCSCRIPT_LOG() << "[NocScript] Executing SR_WRITE() ";
_block_ptr->sr_write(reg_name, reg_val);
- } catch (const uhd::exception &e) {
- UHD_LOGGER_ERROR("RFNOC") << boost::format("[NocScript] Error while executing SR_WRITE(%s, 0x%X):\n%s")
- % reg_name % reg_val % e.what()
- ;
+ } catch (const uhd::exception& e) {
+ UHD_LOGGER_ERROR("RFNOC")
+ << boost::format("[NocScript] Error while executing SR_WRITE(%s, 0x%X):\n%s")
+ % reg_name % reg_val % e.what();
result = false;
}
return expression_literal(result);
}
-expression::type_t block_iface::_nocscript__arg_get_type(const std::string &varname)
+expression::type_t block_iface::_nocscript__arg_get_type(const std::string& varname)
{
const std::string var_type = _block_ptr->get_arg_type(varname);
if (var_type == "int") {
@@ -161,7 +135,7 @@ expression::type_t block_iface::_nocscript__arg_get_type(const std::string &varn
}
}
-expression_literal block_iface::_nocscript__arg_get_val(const std::string &varname)
+expression_literal block_iface::_nocscript__arg_get_val(const std::string& varname)
{
const std::string var_type = _block_ptr->get_arg_type(varname);
if (var_type == "int") {
@@ -177,46 +151,50 @@ expression_literal block_iface::_nocscript__arg_get_val(const std::string &varna
}
}
-expression_literal block_iface::_nocscript__arg_set_int(const expression_container::expr_list_type &args)
+expression_literal block_iface::_nocscript__arg_set_int(
+ const expression_container::expr_list_type& args)
{
const std::string var_name = args[0]->eval().get_string();
const int val = args[1]->eval().get_int();
- size_t port = 0;
+ size_t port = 0;
if (args.size() == 3) {
port = size_t(args[2]->eval().get_int());
}
- UHD_NOCSCRIPT_LOG() << "[NocScript] Setting $" << var_name ;
+ UHD_NOCSCRIPT_LOG() << "[NocScript] Setting $" << var_name;
_block_ptr->set_arg<int>(var_name, val, port);
return expression_literal(true);
}
-expression_literal block_iface::_nocscript__arg_set_string(const expression_container::expr_list_type &args)
+expression_literal block_iface::_nocscript__arg_set_string(
+ const expression_container::expr_list_type& args)
{
const std::string var_name = args[0]->eval().get_string();
const std::string val = args[1]->eval().get_string();
- size_t port = 0;
+ size_t port = 0;
if (args.size() == 3) {
port = size_t(args[2]->eval().get_int());
}
- UHD_NOCSCRIPT_LOG() << "[NocScript] Setting $" << var_name ;
+ UHD_NOCSCRIPT_LOG() << "[NocScript] Setting $" << var_name;
_block_ptr->set_arg<std::string>(var_name, val, port);
return expression_literal(true);
}
-expression_literal block_iface::_nocscript__arg_set_double(const expression_container::expr_list_type &args)
+expression_literal block_iface::_nocscript__arg_set_double(
+ const expression_container::expr_list_type& args)
{
const std::string var_name = args[0]->eval().get_string();
- const double val = args[1]->eval().get_double();
- size_t port = 0;
+ const double val = args[1]->eval().get_double();
+ size_t port = 0;
if (args.size() == 3) {
port = size_t(args[2]->eval().get_int());
}
- UHD_NOCSCRIPT_LOG() << "[NocScript] Setting $" << var_name ;
+ UHD_NOCSCRIPT_LOG() << "[NocScript] Setting $" << var_name;
_block_ptr->set_arg<double>(var_name, val, port);
return expression_literal(true);
}
-expression_literal block_iface::_nocscript__arg_set_intvec(const expression_container::expr_list_type &)
+expression_literal block_iface::_nocscript__arg_set_intvec(
+ const expression_container::expr_list_type&)
{
UHD_THROW_INVALID_CODE_PATH();
}
@@ -226,20 +204,22 @@ block_iface::sptr block_iface::make(uhd::rfnoc::block_ctrl_base* block_ptr)
return sptr(new block_iface(block_ptr));
}
-expression_literal block_iface::_nocscript__var_get(const expression_container::expr_list_type &args)
+expression_literal block_iface::_nocscript__var_get(
+ const expression_container::expr_list_type& args)
{
expression_literal expr = _vars[args[0]->eval().get_string()];
- //std::cout << "[NocScript] Getting var " << args[0]->eval().get_string() << " == " << expr ;
- //std::cout << "[NocScript] Type " << expr.infer_type() ;
- //return _vars[args[0]->eval().get_string()];
+ // std::cout << "[NocScript] Getting var " << args[0]->eval().get_string() << " == "
+ // << expr ; std::cout << "[NocScript] Type " << expr.infer_type() ; return
+ // _vars[args[0]->eval().get_string()];
return expr;
}
-expression_literal block_iface::_nocscript__var_set(const expression_container::expr_list_type &args)
+expression_literal block_iface::_nocscript__var_set(
+ const expression_container::expr_list_type& args)
{
_vars[args[0]->eval().get_string()] = args[1]->eval();
- //std::cout << "[NocScript] Set var " << args[0]->eval().get_string() << " to " << _vars[args[0]->eval().get_string()] ;
- //std::cout << "[NocScript] Type " << _vars[args[0]->eval().get_string()].infer_type() ;
+ // std::cout << "[NocScript] Set var " << args[0]->eval().get_string() << " to " <<
+ // _vars[args[0]->eval().get_string()] ; std::cout << "[NocScript] Type " <<
+ // _vars[args[0]->eval().get_string()].infer_type() ;
return expression_literal(true);
}
-
diff --git a/host/lib/rfnoc/nocscript/block_iface.hpp b/host/lib/rfnoc/nocscript/block_iface.hpp
index 3fafcb4d0..9d13fd4ab 100644
--- a/host/lib/rfnoc/nocscript/block_iface.hpp
+++ b/host/lib/rfnoc/nocscript/block_iface.hpp
@@ -11,7 +11,7 @@
#include <boost/thread/mutex.hpp>
#ifndef INCLUDED_LIBUHD_NOCSCRIPT_BLOCK_IFACE_HPP
-#define INCLUDED_LIBUHD_NOCSCRIPT_BLOCK_IFACE_HPP
+# define INCLUDED_LIBUHD_NOCSCRIPT_BLOCK_IFACE_HPP
namespace uhd { namespace rfnoc { namespace nocscript {
@@ -22,14 +22,14 @@ namespace uhd { namespace rfnoc { namespace nocscript {
* NocScript function calls that require access to the original block
* controller class.
*/
-class block_iface {
+class block_iface
+{
+public:
+ typedef boost::shared_ptr<block_iface> sptr;
- public:
- typedef boost::shared_ptr<block_iface> sptr;
+ static sptr make(uhd::rfnoc::block_ctrl_base* block_ptr);
- static sptr make(uhd::rfnoc::block_ctrl_base* block_ptr);
-
- block_iface(uhd::rfnoc::block_ctrl_base* block_ptr);
+ block_iface(uhd::rfnoc::block_ctrl_base* block_ptr);
/*! Execute \p code and make sure it returns 'true'.
*
@@ -39,9 +39,9 @@ class block_iface {
* \throws uhd::runtime_error if the expression returns false.
* \throws uhd::syntax_error if the expression is invalid.
*/
- void run_and_check(const std::string &code, const std::string &error_message="");
+ void run_and_check(const std::string& code, const std::string& error_message = "");
- private:
+private:
//! For the local interpreter lock (lil)
boost::mutex _lil_mutex;
@@ -49,22 +49,26 @@ class block_iface {
expression_literal _nocscript__sr_write(expression_container::expr_list_type);
//! Argument type getter that can be used within NocScript
- expression::type_t _nocscript__arg_get_type(const std::string &argname);
+ expression::type_t _nocscript__arg_get_type(const std::string& argname);
//! Argument value getter that can be used within NocScript
- expression_literal _nocscript__arg_get_val(const std::string &argname);
+ expression_literal _nocscript__arg_get_val(const std::string& argname);
//! Argument value setters:
- expression_literal _nocscript__arg_set_int(const expression_container::expr_list_type &);
- expression_literal _nocscript__arg_set_string(const expression_container::expr_list_type &);
- expression_literal _nocscript__arg_set_double(const expression_container::expr_list_type &);
- expression_literal _nocscript__arg_set_intvec(const expression_container::expr_list_type &);
+ expression_literal _nocscript__arg_set_int(
+ const expression_container::expr_list_type&);
+ expression_literal _nocscript__arg_set_string(
+ const expression_container::expr_list_type&);
+ expression_literal _nocscript__arg_set_double(
+ const expression_container::expr_list_type&);
+ expression_literal _nocscript__arg_set_intvec(
+ const expression_container::expr_list_type&);
//! Variable value getter
- expression_literal _nocscript__var_get(const expression_container::expr_list_type &);
+ expression_literal _nocscript__var_get(const expression_container::expr_list_type&);
//! Variable value setter
- expression_literal _nocscript__var_set(const expression_container::expr_list_type &);
+ expression_literal _nocscript__var_set(const expression_container::expr_list_type&);
//! Raw pointer to the block class. Note that since block_iface may
// only live as a member of a block_ctrl_base, we don't really need
diff --git a/host/lib/rfnoc/nocscript/expression.cpp b/host/lib/rfnoc/nocscript/expression.cpp
index 1a7f3ee94..32065bda1 100644
--- a/host/lib/rfnoc/nocscript/expression.cpp
+++ b/host/lib/rfnoc/nocscript/expression.cpp
@@ -8,121 +8,110 @@
#include "expression.hpp"
#include "function_table.hpp"
#include <uhd/utils/cast.hpp>
-#include <boost/format.hpp>
#include <boost/algorithm/string.hpp>
+#include <boost/format.hpp>
using namespace uhd::rfnoc::nocscript;
-std::map<expression::type_t, std::string> expression::type_repr{
- {TYPE_INT, "INT"},
+std::map<expression::type_t, std::string> expression::type_repr{{TYPE_INT, "INT"},
{TYPE_DOUBLE, "DOUBLE"},
{TYPE_STRING, "STRING"},
{TYPE_BOOL, "BOOL"},
- {TYPE_INT_VECTOR, "INT_VECTOR"}
-};
+ {TYPE_INT_VECTOR, "INT_VECTOR"}};
/********************************************************************
* Literal expressions (constants)
*******************************************************************/
expression_literal::expression_literal(
- const std::string token_val,
- expression::type_t type
-) : _bool_val(false)
- , _int_val(0)
- , _double_val(0.0)
- , _val(token_val)
- , _type(type)
+ const std::string token_val, expression::type_t type)
+ : _bool_val(false), _int_val(0), _double_val(0.0), _val(token_val), _type(type)
{
switch (_type) {
- case expression::TYPE_STRING:
- // Remove the leading and trailing quotes:
- _val = _val.substr(1, _val.size()-2);
- break;
-
- case expression::TYPE_INT:
- if (_val.substr(0, 2) == "0x") {
- _int_val = uhd::cast::hexstr_cast<int>(_val);
- } else {
- _int_val = std::stoi(_val);
- }
- break;
-
- case expression::TYPE_DOUBLE:
- _double_val = std::stod(_val);
- break;
-
- case expression::TYPE_BOOL:
- if (boost::to_upper_copy(_val) == "TRUE") {
- _bool_val = true;
- } else {
- // lexical cast to bool is too picky
- _bool_val = bool(std::stoi(_val));
- }
- break;
-
- case expression::TYPE_INT_VECTOR:
- {
- std::string str_vec = _val.substr(1, _val.size()-2);
- std::vector<std::string> subtoken_list;
- boost::split(subtoken_list, str_vec, boost::is_any_of(", "), boost::token_compress_on);
- for(const std::string &t: subtoken_list) {
- _int_vector_val.push_back(std::stoi(t));
- }
- break;
+ case expression::TYPE_STRING:
+ // Remove the leading and trailing quotes:
+ _val = _val.substr(1, _val.size() - 2);
+ break;
+
+ case expression::TYPE_INT:
+ if (_val.substr(0, 2) == "0x") {
+ _int_val = uhd::cast::hexstr_cast<int>(_val);
+ } else {
+ _int_val = std::stoi(_val);
+ }
+ break;
+
+ case expression::TYPE_DOUBLE:
+ _double_val = std::stod(_val);
+ break;
+
+ case expression::TYPE_BOOL:
+ if (boost::to_upper_copy(_val) == "TRUE") {
+ _bool_val = true;
+ } else {
+ // lexical cast to bool is too picky
+ _bool_val = bool(std::stoi(_val));
+ }
+ break;
+
+ case expression::TYPE_INT_VECTOR: {
+ std::string str_vec = _val.substr(1, _val.size() - 2);
+ std::vector<std::string> subtoken_list;
+ boost::split(
+ subtoken_list, str_vec, boost::is_any_of(", "), boost::token_compress_on);
+ for (const std::string& t : subtoken_list) {
+ _int_vector_val.push_back(std::stoi(t));
+ }
+ break;
}
- default:
- UHD_THROW_INVALID_CODE_PATH();
+ default:
+ UHD_THROW_INVALID_CODE_PATH();
}
}
expression_literal::expression_literal(bool b)
- : _bool_val(b)
- , _int_val(0)
- , _double_val(0.0)
- , _val("")
- , _type(expression::TYPE_BOOL)
+ : _bool_val(b), _int_val(0), _double_val(0.0), _val(""), _type(expression::TYPE_BOOL)
{
// nop
}
expression_literal::expression_literal(int i)
- : _bool_val(false)
- , _int_val(i)
- , _double_val(0.0)
- , _val("")
- , _type(expression::TYPE_INT)
+ : _bool_val(false)
+ , _int_val(i)
+ , _double_val(0.0)
+ , _val("")
+ , _type(expression::TYPE_INT)
{
// nop
}
expression_literal::expression_literal(double d)
- : _bool_val(false)
- , _int_val(0)
- , _double_val(d)
- , _val("")
- , _type(expression::TYPE_DOUBLE)
+ : _bool_val(false)
+ , _int_val(0)
+ , _double_val(d)
+ , _val("")
+ , _type(expression::TYPE_DOUBLE)
{
// nop
}
-expression_literal::expression_literal(const std::string &s)
- : _bool_val(false)
- , _int_val(0)
- , _double_val(0.0)
- , _val(s)
- , _type(expression::TYPE_STRING)
+expression_literal::expression_literal(const std::string& s)
+ : _bool_val(false)
+ , _int_val(0)
+ , _double_val(0.0)
+ , _val(s)
+ , _type(expression::TYPE_STRING)
{
// nop
}
expression_literal::expression_literal(const std::vector<int> v)
- : _bool_val(false)
- , _int_val(0)
- , _double_val(0.0)
- , _int_vector_val(v)
- , _val("")
- , _type(expression::TYPE_INT_VECTOR)
+ : _bool_val(false)
+ , _int_val(0)
+ , _double_val(0.0)
+ , _int_vector_val(v)
+ , _val("")
+ , _type(expression::TYPE_INT_VECTOR)
{
// nop
}
@@ -201,8 +190,7 @@ std::string expression_literal::repr() const
return std::to_string(_double_val);
case TYPE_BOOL:
return _bool_val ? "TRUE" : "FALSE";
- case TYPE_INT_VECTOR:
- {
+ case TYPE_INT_VECTOR: {
std::stringstream sstr;
sstr << "[";
for (size_t i = 0; i < _int_vector_val.size(); i++) {
@@ -213,13 +201,13 @@ std::string expression_literal::repr() const
}
sstr << "]";
return sstr.str();
- }
+ }
default:
UHD_THROW_INVALID_CODE_PATH();
}
}
-bool expression_literal::operator==(const expression_literal &rhs) const
+bool expression_literal::operator==(const expression_literal& rhs) const
{
if (rhs.infer_type() != _type) {
return false;
@@ -287,7 +275,7 @@ expression_literal expression_container::eval()
}
expression_literal ret_val;
- for(const expression::sptr &sub_expr: _sub_exprs) {
+ for (const expression::sptr& sub_expr : _sub_exprs) {
ret_val = sub_expr->eval();
if (_combiner == COMBINE_AND and ret_val.to_bool() == false) {
return ret_val;
@@ -303,11 +291,12 @@ expression_literal expression_container::eval()
/********************************************************************
* Functions
*******************************************************************/
-std::string expression_function::to_string(const std::string &name, const argtype_list_type &types)
+std::string expression_function::to_string(
+ const std::string& name, const argtype_list_type& types)
{
std::string s = name;
int arg_count = 0;
- for(const expression::type_t type: types) {
+ for (const expression::type_t type : types) {
if (arg_count == 0) {
s += "(";
} else {
@@ -322,17 +311,12 @@ std::string expression_function::to_string(const std::string &name, const argtyp
}
expression_function::expression_function(
- const std::string &name,
- const function_table::sptr func_table
-) : _name(name)
- , _func_table(func_table)
+ const std::string& name, const function_table::sptr func_table)
+ : _name(name), _func_table(func_table)
{
_combiner = COMBINE_ALL;
if (not _func_table->function_exists(_name)) {
- throw uhd::syntax_error(str(
- boost::format("Unknown function: %s")
- % _name
- ));
+ throw uhd::syntax_error(str(boost::format("Unknown function: %s") % _name));
}
}
@@ -359,21 +343,18 @@ std::string expression_function::repr() const
}
expression_function::sptr expression_function::make(
- const std::string &name,
- const function_table::sptr func_table
-) {
+ const std::string& name, const function_table::sptr func_table)
+{
return sptr(new expression_function(name, func_table));
}
/********************************************************************
* Variables
*******************************************************************/
-expression_variable::expression_variable(
- const std::string &token_val,
+expression_variable::expression_variable(const std::string& token_val,
type_getter_type type_getter,
- value_getter_type value_getter
-) : _type_getter(type_getter)
- , _value_getter(value_getter)
+ value_getter_type value_getter)
+ : _type_getter(type_getter), _value_getter(value_getter)
{
// We can assume this is true because otherwise, it's not a valid token:
UHD_ASSERT_THROW(not token_val.empty() and token_val[0] == '$');
@@ -391,11 +372,9 @@ expression_literal expression_variable::eval()
return _value_getter(_varname);
}
-expression_variable::sptr expression_variable::make(
- const std::string &token_val,
- type_getter_type type_getter,
- value_getter_type value_getter
-) {
+expression_variable::sptr expression_variable::make(const std::string& token_val,
+ type_getter_type type_getter,
+ value_getter_type value_getter)
+{
return sptr(new expression_variable(token_val, type_getter, value_getter));
}
-
diff --git a/host/lib/rfnoc/nocscript/expression.hpp b/host/lib/rfnoc/nocscript/expression.hpp
index 69b5198bb..becc329f0 100644
--- a/host/lib/rfnoc/nocscript/expression.hpp
+++ b/host/lib/rfnoc/nocscript/expression.hpp
@@ -6,14 +6,14 @@
//
#include <uhd/exception.hpp>
-#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>
#include <boost/make_shared.hpp>
-#include <vector>
+#include <boost/shared_ptr.hpp>
#include <map>
+#include <vector>
#ifndef INCLUDED_LIBUHD_RFNOC_NOCSCRIPT_EXPR_HPP
-#define INCLUDED_LIBUHD_RFNOC_NOCSCRIPT_EXPR_HPP
+# define INCLUDED_LIBUHD_RFNOC_NOCSCRIPT_EXPR_HPP
namespace uhd { namespace rfnoc { namespace nocscript {
@@ -24,17 +24,11 @@ class expression_literal;
*/
class expression
{
- public:
+public:
typedef boost::shared_ptr<expression> sptr;
//! All the possible return types for expressions within Noc-Script
- enum type_t {
- TYPE_INT,
- TYPE_DOUBLE,
- TYPE_STRING,
- TYPE_BOOL,
- TYPE_INT_VECTOR
- };
+ enum type_t { TYPE_INT, TYPE_DOUBLE, TYPE_STRING, TYPE_BOOL, TYPE_INT_VECTOR };
// TODO make this a const and fix the [] usage
static std::map<type_t, std::string> type_repr;
@@ -53,29 +47,28 @@ class expression
*/
class expression_literal : public expression
{
- public:
+public:
typedef boost::shared_ptr<expression_literal> sptr;
- template <typename expr_type>
- static sptr make(expr_type x) { return boost::make_shared<expression_literal>(x); };
+ template <typename expr_type> static sptr make(expr_type x)
+ {
+ return boost::make_shared<expression_literal>(x);
+ };
/*! Generate the literal expression from its token string representation.
* This includes markup, e.g. a string would still have the quotes, and
* a hex value would still have leading 0x.
*/
- expression_literal(
- const std::string token_val,
- expression::type_t type
- );
+ expression_literal(const std::string token_val, expression::type_t type);
//! Create a boolean literal expression from a C++ bool.
- expression_literal(bool b=false);
+ expression_literal(bool b = false);
//! Create an integer literal expression from a C++ int.
expression_literal(int i);
//! Create a double literal expression from a C++ double.
expression_literal(double d);
//! Create a string literal expression from a C++ string.
- expression_literal(const std::string &s);
+ expression_literal(const std::string& s);
//! Create an int vector literal expression from a C++ vector<int>.
expression_literal(std::vector<int> v);
@@ -149,9 +142,9 @@ class expression_literal : public expression
//! String representation
std::string repr() const;
- bool operator==(const expression_literal &rhs) const;
+ bool operator==(const expression_literal& rhs) const;
- private:
+private:
//! For TYPE_BOOL
bool _bool_val;
@@ -171,13 +164,13 @@ class expression_literal : public expression
expression::type_t _type;
};
-UHD_INLINE std::ostream& operator<< (std::ostream& out, const expression_literal &l)
+UHD_INLINE std::ostream& operator<<(std::ostream& out, const expression_literal& l)
{
out << l.repr();
return out;
}
-UHD_INLINE std::ostream& operator<< (std::ostream& out, const expression_literal::sptr &l)
+UHD_INLINE std::ostream& operator<<(std::ostream& out, const expression_literal::sptr& l)
{
out << l->repr();
return out;
@@ -187,7 +180,7 @@ UHD_INLINE std::ostream& operator<< (std::ostream& out, const expression_literal
*/
class expression_container : public expression
{
- public:
+public:
typedef boost::shared_ptr<expression_container> sptr;
typedef std::vector<expression::sptr> expr_list_type;
@@ -195,15 +188,10 @@ class expression_container : public expression
static sptr make();
//! List of valid combination types (see expression_container::eval()).
- enum combiner_type {
- COMBINE_ALL,
- COMBINE_AND,
- COMBINE_OR,
- COMBINE_NOTSET
- };
+ enum combiner_type { COMBINE_ALL, COMBINE_AND, COMBINE_OR, COMBINE_NOTSET };
//! Create an empty container
- expression_container() : _combiner(COMBINE_NOTSET) {};
+ expression_container() : _combiner(COMBINE_NOTSET){};
virtual ~expression_container(){};
/*! Type-deduction rules for containers are:
@@ -222,9 +210,15 @@ class expression_container : public expression
void set_combiner_safe(const combiner_type c);
- void set_combiner(const combiner_type c) { _combiner = c; };
+ void set_combiner(const combiner_type c)
+ {
+ _combiner = c;
+ };
- combiner_type get_combiner() const { return _combiner; };
+ combiner_type get_combiner() const
+ {
+ return _combiner;
+ };
/*! Evaluate a container by evaluating its sub-expressions.
*
@@ -243,7 +237,7 @@ class expression_container : public expression
*/
virtual expression_literal eval();
- protected:
+protected:
//! Store all the sub-expressions, in order
expr_list_type _sub_exprs;
combiner_type _combiner;
@@ -273,23 +267,19 @@ class function_table;
*/
class expression_function : public expression_container
{
- public:
+public:
typedef boost::shared_ptr<expression_function> sptr;
typedef std::vector<expression::type_t> argtype_list_type;
//! Return an sptr to a function object without args
static sptr make(
- const std::string &name,
- const boost::shared_ptr<function_table> func_table
- );
+ const std::string& name, const boost::shared_ptr<function_table> func_table);
- static std::string to_string(const std::string &name, const argtype_list_type &types);
+ static std::string to_string(const std::string& name, const argtype_list_type& types);
expression_function(
- const std::string &name,
- const boost::shared_ptr<function_table> func_table
- );
- ~expression_function(){}
+ const std::string& name, const boost::shared_ptr<function_table> func_table);
+ ~expression_function() {}
//! Add an argument expression
virtual void add(expression::sptr new_expr);
@@ -309,7 +299,7 @@ class expression_function : public expression_container
//! String representation
std::string repr() const;
- private:
+private:
std::string _name;
const boost::shared_ptr<function_table> _func_table;
std::vector<expression::type_t> _arg_types;
@@ -324,42 +314,38 @@ class expression_function : public expression_container
*/
class expression_variable : public expression
{
- public:
+public:
typedef boost::shared_ptr<expression_variable> sptr;
- typedef boost::function<expression::type_t(const std::string &)> type_getter_type;
- typedef boost::function<expression_literal(const std::string &)> value_getter_type;
+ typedef boost::function<expression::type_t(const std::string&)> type_getter_type;
+ typedef boost::function<expression_literal(const std::string&)> value_getter_type;
- static sptr make(
- const std::string &token_val,
- type_getter_type type_getter,
- value_getter_type value_getter
- );
+ static sptr make(const std::string& token_val,
+ type_getter_type type_getter,
+ value_getter_type value_getter);
/*! Create a variable object from its token value
* (e.g. '$spp', i.e. including the '$' symbol). The variable
* does not have to exist at this point.
*/
- expression_variable(
- const std::string &token_val,
- type_getter_type type_getter,
- value_getter_type value_getter
- );
+ expression_variable(const std::string& token_val,
+ type_getter_type type_getter,
+ value_getter_type value_getter);
/*! Looks up the variable type in the variable table.
*
- * \throws Depending on \p type_getter, this may throw when the variable does not exist.
- * Recommended behaviour is to throw uhd::syntax_error.
+ * \throws Depending on \p type_getter, this may throw when the variable does not
+ * exist. Recommended behaviour is to throw uhd::syntax_error.
*/
expression::type_t infer_type() const;
/*! Look up a variable's value in the variable table.
*
- * \throws Depending on \p value_getter, this may throw when the variable does not exist.
- * Recommended behaviour is to throw uhd::syntax_error.
+ * \throws Depending on \p value_getter, this may throw when the variable does not
+ * exist. Recommended behaviour is to throw uhd::syntax_error.
*/
expression_literal eval();
- private:
+private:
std::string _varname;
type_getter_type _type_getter;
value_getter_type _value_getter;
diff --git a/host/lib/rfnoc/nocscript/function_table.cpp b/host/lib/rfnoc/nocscript/function_table.cpp
index 621cd5809..57e32363d 100644
--- a/host/lib/rfnoc/nocscript/function_table.cpp
+++ b/host/lib/rfnoc/nocscript/function_table.cpp
@@ -15,18 +15,21 @@ using namespace uhd::rfnoc::nocscript;
class function_table_impl : public function_table
{
- public:
- struct function_info {
+public:
+ struct function_info
+ {
expression::type_t return_type;
function_ptr function;
- function_info(): return_type(expression::TYPE_INT) {};
- function_info(const expression::type_t return_type_, const function_ptr &function_)
- : return_type(return_type_), function(function_)
- {};
+ function_info() : return_type(expression::TYPE_INT){};
+ function_info(
+ const expression::type_t return_type_, const function_ptr& function_)
+ : return_type(return_type_), function(function_){};
};
// Should be an unordered_map... sigh, we'll get to C++11 someday.
- typedef std::map<std::string, std::map<expression_function::argtype_list_type, function_info> > table_type;
+ typedef std::map<std::string,
+ std::map<expression_function::argtype_list_type, function_info>>
+ table_type;
/************************************************************************
* Structors
@@ -36,63 +39,58 @@ class function_table_impl : public function_table
_REGISTER_ALL_FUNCS();
}
- ~function_table_impl() {};
+ ~function_table_impl(){};
/************************************************************************
* Interface implementation
***********************************************************************/
- bool function_exists(const std::string &name) const {
+ bool function_exists(const std::string& name) const
+ {
return bool(_table.count(name));
}
- bool function_exists(
- const std::string &name,
- const expression_function::argtype_list_type &arg_types
- ) const {
+ bool function_exists(const std::string& name,
+ const expression_function::argtype_list_type& arg_types) const
+ {
table_type::const_iterator it = _table.find(name);
return (it != _table.end()) and bool(it->second.count(arg_types));
}
- expression::type_t get_type(
- const std::string &name,
- const expression_function::argtype_list_type &arg_types
- ) const {
+ expression::type_t get_type(const std::string& name,
+ const expression_function::argtype_list_type& arg_types) const
+ {
table_type::const_iterator it = _table.find(name);
if (it == _table.end() or (it->second.find(arg_types) == it->second.end())) {
- throw uhd::syntax_error(str(
- boost::format("Unable to retrieve return value for function %s")
- % expression_function::to_string(name, arg_types)
- ));
+ throw uhd::syntax_error(
+ str(boost::format("Unable to retrieve return value for function %s")
+ % expression_function::to_string(name, arg_types)));
}
return it->second.find(arg_types)->second.return_type;
}
- expression_literal eval(
- const std::string &name,
- const expression_function::argtype_list_type &arg_types,
- expression_container::expr_list_type &arguments
- ) {
+ expression_literal eval(const std::string& name,
+ const expression_function::argtype_list_type& arg_types,
+ expression_container::expr_list_type& arguments)
+ {
if (not function_exists(name, arg_types)) {
- throw uhd::syntax_error(str(
- boost::format("Cannot eval() function %s, not a known signature")
- % expression_function::to_string(name, arg_types)
- ));
+ throw uhd::syntax_error(
+ str(boost::format("Cannot eval() function %s, not a known signature")
+ % expression_function::to_string(name, arg_types)));
}
return _table[name][arg_types].function(arguments);
}
- void register_function(
- const std::string &name,
- const function_table::function_ptr &ptr,
- const expression::type_t return_type,
- const expression_function::argtype_list_type &sig
- ) {
+ void register_function(const std::string& name,
+ const function_table::function_ptr& ptr,
+ const expression::type_t return_type,
+ const expression_function::argtype_list_type& sig)
+ {
_table[name][sig] = function_info(return_type, ptr);
}
- private:
+private:
table_type _table;
};
diff --git a/host/lib/rfnoc/nocscript/function_table.hpp b/host/lib/rfnoc/nocscript/function_table.hpp
index 6d7ef4202..63125ab1b 100644
--- a/host/lib/rfnoc/nocscript/function_table.hpp
+++ b/host/lib/rfnoc/nocscript/function_table.hpp
@@ -6,48 +6,45 @@
//
#include "expression.hpp"
-#include <boost/shared_ptr.hpp>
#include <boost/function.hpp>
+#include <boost/shared_ptr.hpp>
#include <vector>
#ifndef INCLUDED_LIBUHD_RFNOC_NOCSCRIPT_FUNCTABLE_HPP
-#define INCLUDED_LIBUHD_RFNOC_NOCSCRIPT_FUNCTABLE_HPP
+# define INCLUDED_LIBUHD_RFNOC_NOCSCRIPT_FUNCTABLE_HPP
namespace uhd { namespace rfnoc { namespace nocscript {
class function_table
{
- public:
+public:
typedef boost::shared_ptr<function_table> sptr;
- typedef boost::function<expression_literal(expression_container::expr_list_type&)> function_ptr;
+ typedef boost::function<expression_literal(expression_container::expr_list_type&)>
+ function_ptr;
static sptr make();
- virtual ~function_table() {};
+ virtual ~function_table(){};
/*! Check if any function with a given name exists
*
* \returns True, if any function with name \p name is registered.
*/
- virtual bool function_exists(const std::string &name) const = 0;
+ virtual bool function_exists(const std::string& name) const = 0;
/*! Check if a function with a given name and list of argument types exists
*
* \returns True, if such a function is registered.
*/
- virtual bool function_exists(
- const std::string &name,
- const expression_function::argtype_list_type &arg_types
- ) const = 0;
+ virtual bool function_exists(const std::string& name,
+ const expression_function::argtype_list_type& arg_types) const = 0;
/*! Get the return type of a function with given name and argument type list
*
* \returns The function's return type
* \throws uhd::syntax_error if no such function is registered
*/
- virtual expression::type_t get_type(
- const std::string &name,
- const expression_function::argtype_list_type &arg_types
- ) const = 0;
+ virtual expression::type_t get_type(const std::string& name,
+ const expression_function::argtype_list_type& arg_types) const = 0;
/*! Calls the function \p name with the argument list \p arguments
*
@@ -56,11 +53,9 @@ class function_table
* \returns The return value of the called function
* \throws uhd::syntax_error if no such function is found
*/
- virtual expression_literal eval(
- const std::string &name,
- const expression_function::argtype_list_type &arg_types,
- expression_container::expr_list_type &arguments
- ) = 0;
+ virtual expression_literal eval(const std::string& name,
+ const expression_function::argtype_list_type& arg_types,
+ expression_container::expr_list_type& arguments) = 0;
/*! Register a new function
*
@@ -69,12 +64,10 @@ class function_table
* \param return_type The function's return value
* \param sig The function signature (list of argument types)
*/
- virtual void register_function(
- const std::string &name,
- const function_ptr &ptr,
- const expression::type_t return_type,
- const expression_function::argtype_list_type &sig
- ) = 0;
+ virtual void register_function(const std::string& name,
+ const function_ptr& ptr,
+ const expression::type_t return_type,
+ const expression_function::argtype_list_type& sig) = 0;
};
}}} /* namespace uhd::rfnoc::nocscript */
diff --git a/host/lib/rfnoc/nocscript/parser.cpp b/host/lib/rfnoc/nocscript/parser.cpp
index 71bb7b028..f34d475ba 100644
--- a/host/lib/rfnoc/nocscript/parser.cpp
+++ b/host/lib/rfnoc/nocscript/parser.cpp
@@ -7,11 +7,11 @@
#include "parser.hpp"
#include <uhd/utils/cast.hpp>
-#include <boost/spirit/include/lex_lexertl.hpp>
-#include <boost/format.hpp>
-#include <boost/bind.hpp>
#include <boost/assign.hpp>
+#include <boost/bind.hpp>
+#include <boost/format.hpp>
#include <boost/make_shared.hpp>
+#include <boost/spirit/include/lex_lexertl.hpp>
#include <sstream>
#include <stack>
@@ -20,30 +20,28 @@ namespace lex = boost::spirit::lex;
class parser_impl : public parser
{
- public:
+public:
/******************************************************************
* Structors TODO make them protected
*****************************************************************/
- parser_impl(
- function_table::sptr ftable,
+ parser_impl(function_table::sptr ftable,
expression_variable::type_getter_type var_type_getter,
- expression_variable::value_getter_type var_value_getter
- ) : _ftable(ftable)
- , _var_type_getter(var_type_getter)
- , _var_value_getter(var_value_getter)
+ expression_variable::value_getter_type var_value_getter)
+ : _ftable(ftable)
+ , _var_type_getter(var_type_getter)
+ , _var_value_getter(var_value_getter)
{
// nop
}
- ~parser_impl() {};
+ ~parser_impl(){};
/******************************************************************
* Parsing
*****************************************************************/
//! List of parser tokens
- enum token_ids
- {
+ enum token_ids {
ID_WHITESPACE = lex::min_token_id + 42,
ID_KEYWORD,
ID_ARG_SEP,
@@ -58,29 +56,21 @@ class parser_impl : public parser
};
//! The Lexer object used for NocScript
- template <typename Lexer>
- struct ns_lexer : lex::lexer<Lexer>
+ template <typename Lexer> struct ns_lexer : lex::lexer<Lexer>
{
ns_lexer()
{
- this->self.add
- ("\\s+", ID_WHITESPACE)
- (",", ID_ARG_SEP)
- ("[A-Z][A-Z0-9_]*", ID_KEYWORD)
- ("\\(", ID_PARENS_OPEN)
- ("\\)", ID_PARENS_CLOSE)
- ("\\$[a-z][a-z0-9_]*", ID_VARIABLE)
- ("-?\\d+\\.\\d+", ID_LITERAL_DOUBLE)
- ("-?\\d+", ID_LITERAL_INT)
- ("0x[0-9A-F]+", ID_LITERAL_HEX)
- ("\\\"[^\\\"]*\\\"", ID_LITERAL_STR)
- ("'[^']*'", ID_LITERAL_STR) // both work
- ("\\[[0-9]\\]", ID_LITERAL_VECTOR_INT)
- ;
+ this->self.add("\\s+", ID_WHITESPACE)(",", ID_ARG_SEP)(
+ "[A-Z][A-Z0-9_]*", ID_KEYWORD)("\\(", ID_PARENS_OPEN)(
+ "\\)", ID_PARENS_CLOSE)("\\$[a-z][a-z0-9_]*", ID_VARIABLE)(
+ "-?\\d+\\.\\d+", ID_LITERAL_DOUBLE)("-?\\d+", ID_LITERAL_INT)(
+ "0x[0-9A-F]+", ID_LITERAL_HEX)("\\\"[^\\\"]*\\\"", ID_LITERAL_STR)(
+ "'[^']*'", ID_LITERAL_STR) // both work
+ ("\\[[0-9]\\]", ID_LITERAL_VECTOR_INT);
}
};
- private:
+private:
struct grammar_props
{
function_table::sptr ftable;
@@ -92,12 +82,13 @@ class parser_impl : public parser
std::string error;
std::stack<expression_container::sptr> expr_stack;
- grammar_props(
- function_table::sptr ftable_,
+ grammar_props(function_table::sptr ftable_,
expression_variable::type_getter_type var_type_getter_,
- expression_variable::value_getter_type var_value_getter_
- ) : ftable(ftable_), var_type_getter(var_type_getter_), var_value_getter(var_value_getter_),
- function_name("")
+ expression_variable::value_getter_type var_value_getter_)
+ : ftable(ftable_)
+ , var_type_getter(var_type_getter_)
+ , var_value_getter(var_value_getter_)
+ , function_name("")
{
UHD_ASSERT_THROW(expr_stack.empty());
// Push an empty container to the stack to hold the result
@@ -124,11 +115,11 @@ class parser_impl : public parser
static const int VALID_PARENS_OPEN = 0x2;
static const int VALID_PARENS_CLOSE = 0x4;
static const int VALID_EXPRESSION = 0x8 + 0x02;
- static const int VALID_OPERATOR = 0x10;
+ static const int VALID_OPERATOR = 0x10;
// !This function operator gets called for each of the matched tokens.
template <typename Token>
- bool operator()(Token const& t, grammar_props &P, int &next_valid_state) const
+ bool operator()(Token const& t, grammar_props& P, int& next_valid_state) const
{
//! This is totally not how Boost::Spirit is meant to be used,
// as there's token types etc. But for now let's just convert
@@ -136,218 +127,231 @@ class parser_impl : public parser
std::stringstream sstr;
sstr << t.value();
std::string val = sstr.str();
- //std::cout << "VAL: " << val << std::endl;
- //std::cout << "Next valid states:\n"
- //<< boost::format("VALID_COMMA [%s]\n") % ((next_valid_state & 0x1) ? "x" : " ")
- //<< boost::format("VALID_PARENS_OPEN [%s]\n") % ((next_valid_state & 0x2) ? "x" : " ")
- //<< boost::format("VALID_PARENS_CLOSE [%s]\n") % ((next_valid_state & 0x4) ? "x" : " ")
- //<< boost::format("VALID_EXPRESSION [%s]\n") % ((next_valid_state & (0x8 + 0x02)) ? "x" : " ")
- //<< boost::format("VALID_OPERATOR [%s]\n") % ((next_valid_state & 0x10) ? "x" : " ")
- //<< std::endl;
+ // std::cout << "VAL: " << val << std::endl;
+ // std::cout << "Next valid states:\n"
+ //<< boost::format("VALID_COMMA [%s]\n") % ((next_valid_state & 0x1) ?
+ //"x" : " ")
+ //<< boost::format("VALID_PARENS_OPEN [%s]\n") % ((next_valid_state & 0x2) ?
+ //"x" : " ")
+ //<< boost::format("VALID_PARENS_CLOSE [%s]\n") % ((next_valid_state & 0x4) ?
+ //"x" : " ")
+ //<< boost::format("VALID_EXPRESSION [%s]\n") % ((next_valid_state & (0x8 +
+ //0x02)) ? "x" : " ")
+ //<< boost::format("VALID_OPERATOR [%s]\n") % ((next_valid_state & 0x10)
+ //? "x" : " ")
+ //<< std::endl;
switch (t.id()) {
+ case ID_WHITESPACE:
+ // Ignore
+ break;
- case ID_WHITESPACE:
- // Ignore
- break;
-
- case ID_KEYWORD:
- // Ambiguous, could be an operator (AND, OR) or a function name (ADD, MULT...).
- // So first, check which it is:
- if (val == "AND" or val == "OR") {
- if (not (next_valid_state & VALID_OPERATOR)) {
- P.error = str(boost::format("Unexpected operator: %s") % val);
+ case ID_KEYWORD:
+ // Ambiguous, could be an operator (AND, OR) or a function name (ADD,
+ // MULT...). So first, check which it is:
+ if (val == "AND" or val == "OR") {
+ if (not(next_valid_state & VALID_OPERATOR)) {
+ P.error = str(boost::format("Unexpected operator: %s") % val);
+ return false;
+ }
+ next_valid_state = VALID_EXPRESSION;
+ try {
+ if (val == "AND") {
+ P.expr_stack.top()->set_combiner_safe(
+ expression_container::COMBINE_AND);
+ } else if (val == "OR") {
+ P.expr_stack.top()->set_combiner_safe(
+ expression_container::COMBINE_OR);
+ }
+ } catch (const uhd::syntax_error& e) {
+ P.error = str(boost::format("Operator %s is mixing operator "
+ "types within this container.")
+ % val);
+ }
+ // Right now, we can't have multiple operator types within a
+ // container. We might be able to change that, if there's enough
+ // demand. Either we keep track of multiple operators, or we open
+ // a new container. In the latter case, we'd need a way of keeping
+ // track of those containers, so it's a bit tricky.
+ break;
+ }
+ // If it's not a keyword, it has to be a function, so check the
+ // function table:
+ if (not(next_valid_state & VALID_EXPRESSION)) {
+ P.error = str(boost::format("Unexpected expression: %s") % val);
return false;
}
- next_valid_state = VALID_EXPRESSION;
- try {
- if (val == "AND") {
- P.expr_stack.top()->set_combiner_safe(expression_container::COMBINE_AND);
- } else if (val == "OR") {
- P.expr_stack.top()->set_combiner_safe(expression_container::COMBINE_OR);
- }
- } catch (const uhd::syntax_error &e) {
- P.error = str(boost::format("Operator %s is mixing operator types within this container.") % val);
+ if (not P.ftable->function_exists(val)) {
+ P.error = str(boost::format("Unknown function: %s") % val);
+ return false;
}
- // Right now, we can't have multiple operator types within a container.
- // We might be able to change that, if there's enough demand. Either
- // we keep track of multiple operators, or we open a new container.
- // In the latter case, we'd need a way of keeping track of those containers,
- // so it's a bit tricky.
+ P.function_name = val;
+ next_valid_state = VALID_PARENS_OPEN;
break;
- }
- // If it's not a keyword, it has to be a function, so check the
- // function table:
- if (not (next_valid_state & VALID_EXPRESSION)) {
- P.error = str(boost::format("Unexpected expression: %s") % val);
- return false;
- }
- if (not P.ftable->function_exists(val)) {
- P.error = str(boost::format("Unknown function: %s") % val);
- return false;
- }
- P.function_name = val;
- next_valid_state = VALID_PARENS_OPEN;
- break;
- // Every () creates a new container, either a raw container or
- // a function.
- case ID_PARENS_OPEN:
- if (not (next_valid_state & VALID_PARENS_OPEN)) {
- P.error = str(boost::format("Unexpected parentheses."));
- return false;
- }
- if (not P.function_name.empty()) {
- // We've already checked the function name exists
- P.expr_stack.push(expression_function::make(P.function_name, P.ftable));
- P.function_name.clear();
- } else {
+ // Every () creates a new container, either a raw container or
+ // a function.
+ case ID_PARENS_OPEN:
+ if (not(next_valid_state & VALID_PARENS_OPEN)) {
+ P.error = str(boost::format("Unexpected parentheses."));
+ return false;
+ }
+ if (not P.function_name.empty()) {
+ // We've already checked the function name exists
+ P.expr_stack.push(
+ expression_function::make(P.function_name, P.ftable));
+ P.function_name.clear();
+ } else {
+ P.expr_stack.push(expression_container::make());
+ }
+ // Push another empty container to hold the first element/argument
+ // in this container:
P.expr_stack.push(expression_container::make());
- }
- // Push another empty container to hold the first element/argument
- // in this container:
- P.expr_stack.push(expression_container::make());
- next_valid_state = VALID_EXPRESSION | VALID_PARENS_CLOSE;
- break;
-
- case ID_PARENS_CLOSE:
- {
- if (not (next_valid_state & VALID_PARENS_CLOSE)) {
- P.error = str(boost::format("Unexpected parentheses."));
- return false;
- }
- if (P.expr_stack.size() < 2) {
- P.error = str(boost::format("Unbalanced closing parentheses."));
- return false;
- }
- // First pop the last expression inside the parentheses,
- // if it's not empty, add it to the top container (this also avoids
- // adding arguments to functions if none were provided):
- expression_container::sptr c = P.expr_stack.top();
- P.expr_stack.pop();
- if (not c->empty()) {
- P.expr_stack.top()->add(c);
- }
- // At the end of (), either a function or container is complete,
- // so pop that and add it to its top container:
- expression_container::sptr c2 = P.expr_stack.top();
- P.expr_stack.pop();
- P.expr_stack.top()->add(c2);
- next_valid_state = VALID_OPERATOR | VALID_COMMA | VALID_PARENS_CLOSE;
- }
- break;
-
- case ID_ARG_SEP:
- {
- if (not (next_valid_state & VALID_COMMA)) {
- P.error = str(boost::format("Unexpected comma."));
- return false;
- }
- next_valid_state = VALID_EXPRESSION;
- // If stack size is 1, we're on the base container, which means we
- // simply string stuff.
- if (P.expr_stack.size() == 1) {
+ next_valid_state = VALID_EXPRESSION | VALID_PARENS_CLOSE;
break;
- }
- // Otherwise, a ',' always means we add the previous expression to
- // the current container:
- expression_container::sptr c = P.expr_stack.top();
- P.expr_stack.pop();
- P.expr_stack.top()->add(c);
- // It also means another expression is following, so create another
- // empty container for that:
- P.expr_stack.push(expression_container::make());
- }
- break;
- // All the atomic expressions just get added to the current container:
+ case ID_PARENS_CLOSE: {
+ if (not(next_valid_state & VALID_PARENS_CLOSE)) {
+ P.error = str(boost::format("Unexpected parentheses."));
+ return false;
+ }
+ if (P.expr_stack.size() < 2) {
+ P.error = str(boost::format("Unbalanced closing parentheses."));
+ return false;
+ }
+ // First pop the last expression inside the parentheses,
+ // if it's not empty, add it to the top container (this also avoids
+ // adding arguments to functions if none were provided):
+ expression_container::sptr c = P.expr_stack.top();
+ P.expr_stack.pop();
+ if (not c->empty()) {
+ P.expr_stack.top()->add(c);
+ }
+ // At the end of (), either a function or container is complete,
+ // so pop that and add it to its top container:
+ expression_container::sptr c2 = P.expr_stack.top();
+ P.expr_stack.pop();
+ P.expr_stack.top()->add(c2);
+ next_valid_state = VALID_OPERATOR | VALID_COMMA | VALID_PARENS_CLOSE;
+ } break;
+
+ case ID_ARG_SEP: {
+ if (not(next_valid_state & VALID_COMMA)) {
+ P.error = str(boost::format("Unexpected comma."));
+ return false;
+ }
+ next_valid_state = VALID_EXPRESSION;
+ // If stack size is 1, we're on the base container, which means we
+ // simply string stuff.
+ if (P.expr_stack.size() == 1) {
+ break;
+ }
+ // Otherwise, a ',' always means we add the previous expression to
+ // the current container:
+ expression_container::sptr c = P.expr_stack.top();
+ P.expr_stack.pop();
+ P.expr_stack.top()->add(c);
+ // It also means another expression is following, so create another
+ // empty container for that:
+ P.expr_stack.push(expression_container::make());
+ } break;
- case ID_VARIABLE:
- {
- if (not (next_valid_state & VALID_EXPRESSION)) {
- P.error = str(boost::format("Unexpected expression."));
- return false;
- }
- expression_variable::sptr v = expression_variable::make(val, P.var_type_getter, P.var_value_getter);
- P.expr_stack.top()->add(v);
- next_valid_state = VALID_OPERATOR | VALID_COMMA | VALID_PARENS_CLOSE;
- }
- break;
+ // All the atomic expressions just get added to the current container:
- default:
- // If we get here, we assume it's a literal expression
- {
- if (not (next_valid_state & VALID_EXPRESSION)) {
- P.error = str(boost::format("Unexpected expression."));
- return false;
- }
- expression::type_t token_type;
- switch (t.id()) { // A map lookup would be more elegant, but we'd need a nicer C++ for that
- case ID_LITERAL_DOUBLE: token_type = expression::TYPE_DOUBLE; break;
- case ID_LITERAL_INT: token_type = expression::TYPE_INT; break;
- case ID_LITERAL_HEX: token_type = expression::TYPE_INT; break;
- case ID_LITERAL_STR: token_type = expression::TYPE_STRING; break;
- case ID_LITERAL_VECTOR_INT: token_type = expression::TYPE_INT_VECTOR; break;
- default: UHD_THROW_INVALID_CODE_PATH();
- }
- P.expr_stack.top()->add(boost::make_shared<expression_literal>(val, token_type));
- next_valid_state = VALID_OPERATOR | VALID_COMMA | VALID_PARENS_CLOSE;
- break;
- }
+ case ID_VARIABLE: {
+ if (not(next_valid_state & VALID_EXPRESSION)) {
+ P.error = str(boost::format("Unexpected expression."));
+ return false;
+ }
+ expression_variable::sptr v = expression_variable::make(
+ val, P.var_type_getter, P.var_value_getter);
+ P.expr_stack.top()->add(v);
+ next_valid_state = VALID_OPERATOR | VALID_COMMA | VALID_PARENS_CLOSE;
+ } break;
+
+ default:
+ // If we get here, we assume it's a literal expression
+ {
+ if (not(next_valid_state & VALID_EXPRESSION)) {
+ P.error = str(boost::format("Unexpected expression."));
+ return false;
+ }
+ expression::type_t token_type;
+ switch (t.id()) { // A map lookup would be more elegant, but we'd
+ // need a nicer C++ for that
+ case ID_LITERAL_DOUBLE:
+ token_type = expression::TYPE_DOUBLE;
+ break;
+ case ID_LITERAL_INT:
+ token_type = expression::TYPE_INT;
+ break;
+ case ID_LITERAL_HEX:
+ token_type = expression::TYPE_INT;
+ break;
+ case ID_LITERAL_STR:
+ token_type = expression::TYPE_STRING;
+ break;
+ case ID_LITERAL_VECTOR_INT:
+ token_type = expression::TYPE_INT_VECTOR;
+ break;
+ default:
+ UHD_THROW_INVALID_CODE_PATH();
+ }
+ P.expr_stack.top()->add(
+ boost::make_shared<expression_literal>(val, token_type));
+ next_valid_state = VALID_OPERATOR | VALID_COMMA
+ | VALID_PARENS_CLOSE;
+ break;
+ }
} // end switch
return true;
}
};
- public:
- expression::sptr create_expr_tree(const std::string &code)
+public:
+ expression::sptr create_expr_tree(const std::string& code)
{
// Create empty stack and keyword states
grammar_props P(_ftable, _var_type_getter, _var_value_getter);
int next_valid_state = grammar::VALID_EXPRESSION;
// Create a lexer instance
- ns_lexer<lex::lexertl::lexer<> > lexer_functor;
+ ns_lexer<lex::lexertl::lexer<>> lexer_functor;
// Tokenize the string
char const* first = code.c_str();
- char const* last = &first[code.size()];
- bool r = lex::tokenize(
- first, last, // Iterators
+ char const* last = &first[code.size()];
+ bool r = lex::tokenize(first,
+ last, // Iterators
lexer_functor, // Lexer
- boost::bind(grammar(), _1, boost::ref(P), boost::ref(next_valid_state)) // Function object
+ boost::bind(grammar(),
+ _1,
+ boost::ref(P),
+ boost::ref(next_valid_state)) // Function object
);
// Check the parsing worked:
if (not r or P.expr_stack.size() != 1) {
std::string rest(first, last);
- throw uhd::syntax_error(str(
- boost::format("Parsing stopped at: %s\nError message: %s")
- % rest % P.error
- ));
+ throw uhd::syntax_error(
+ str(boost::format("Parsing stopped at: %s\nError message: %s") % rest
+ % P.error));
}
// Clear stack and return result
return P.get_result();
}
- private:
-
+private:
function_table::sptr _ftable;
expression_variable::type_getter_type _var_type_getter;
expression_variable::value_getter_type _var_value_getter;
};
-parser::sptr parser::make(
- function_table::sptr ftable,
+parser::sptr parser::make(function_table::sptr ftable,
expression_variable::type_getter_type var_type_getter,
- expression_variable::value_getter_type var_value_getter
-) {
- return sptr(new parser_impl(
- ftable,
- var_type_getter,
- var_value_getter
- ));
+ expression_variable::value_getter_type var_value_getter)
+{
+ return sptr(new parser_impl(ftable, var_type_getter, var_value_getter));
}
-
diff --git a/host/lib/rfnoc/nocscript/parser.hpp b/host/lib/rfnoc/nocscript/parser.hpp
index 139082515..e9d9f0820 100644
--- a/host/lib/rfnoc/nocscript/parser.hpp
+++ b/host/lib/rfnoc/nocscript/parser.hpp
@@ -10,20 +10,18 @@
#include <boost/shared_ptr.hpp>
#ifndef INCLUDED_LIBUHD_RFNOC_NOCSCRIPT_PARSER_HPP
-#define INCLUDED_LIBUHD_RFNOC_NOCSCRIPT_PARSER_HPP
+# define INCLUDED_LIBUHD_RFNOC_NOCSCRIPT_PARSER_HPP
namespace uhd { namespace rfnoc { namespace nocscript {
class parser
{
- public:
+public:
typedef boost::shared_ptr<parser> sptr;
- static sptr make(
- function_table::sptr ftable,
+ static sptr make(function_table::sptr ftable,
expression_variable::type_getter_type var_type_getter,
- expression_variable::value_getter_type var_value_getter
- );
+ expression_variable::value_getter_type var_value_getter);
/*! The main parsing call: Turn a string of code into an expression tree.
*
@@ -31,7 +29,7 @@ class parser
*
* \throws uhd::syntax_error if \p code contains syntax errors
*/
- virtual expression::sptr create_expr_tree(const std::string &code) = 0;
+ virtual expression::sptr create_expr_tree(const std::string& code) = 0;
};
}}} /* namespace uhd::rfnoc::nocscript */
--
cgit v1.2.3