Use UHD_INLINE macro instead of inline

6 files changed, 54 insertions, 54 deletions

diff --git a/host/include/uhd/types/filters.hpp b/host/include/uhd/types/filters.hpp
index 976ae233d..2c30c1007 100644
--- a/host/include/uhd/types/filters.hpp
+++ b/host/include/uhd/types/filters.hpp
@@ -55,12 +55,12 @@ namespace uhd{
             //NOP
         }
 
-        inline virtual bool is_bypassed()
+        UHD_INLINE virtual bool is_bypassed()
         {
             return _bypass;
         }
 
-        inline filter_type get_type()
+        UHD_INLINE filter_type get_type()
         {
             return _type;
         }
@@ -98,7 +98,7 @@ namespace uhd{
                 //NOP
             }
 
-            inline const std::string& get_analog_type()
+            UHD_INLINE const std::string& get_analog_type()
             {
                 return _analog_type;
             }
@@ -128,17 +128,17 @@ namespace uhd{
             //NOP
         }
 
-        inline double get_cutoff()
+        UHD_INLINE double get_cutoff()
         {
             return _cutoff;
         }
 
-        inline double get_rolloff()
+        UHD_INLINE double get_rolloff()
         {
             return _cutoff;
         }
 
-        inline void set_cutoff(const double cutoff)
+        UHD_INLINE void set_cutoff(const double cutoff)
         {
             _cutoff = cutoff;
         }
@@ -181,32 +181,32 @@ namespace uhd{
             //NOP
         }
 
-        inline double get_output_rate()
+        UHD_INLINE double get_output_rate()
         {
             return (_bypass ? _rate : (_rate / _decimation * _interpolation));
         }
 
-        inline double get_input_rate()
+        UHD_INLINE double get_input_rate()
         {
             return _rate;
         }
 
-        inline double get_interpolation()
+        UHD_INLINE double get_interpolation()
         {
             return _interpolation;
         }
 
-        inline double get_decimation()
+        UHD_INLINE double get_decimation()
         {
             return _decimation;
         }
 
-        inline double get_tap_full_scale()
+        UHD_INLINE double get_tap_full_scale()
         {
             return _tap_full_scale;
         }
 
-        inline std::vector<tap_t>& get_taps()
+        UHD_INLINE std::vector<tap_t>& get_taps()
         {
             return _taps;
         }
diff --git a/host/include/uhd/utils/algorithm.hpp b/host/include/uhd/utils/algorithm.hpp
index 704d745d9..6c6cdf033 100644
--- a/host/include/uhd/utils/algorithm.hpp
+++ b/host/include/uhd/utils/algorithm.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2010-2014 Ettus Research LLC
+// Copyright 2010-2015 Ettus Research LLC
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -39,7 +39,7 @@ namespace uhd{
      * \param range the range of elements to be sorted
      * \return a new range with the elements sorted
      */
-    template<typename Range> inline Range sorted(const Range &range){
+    template<typename Range> UHD_INLINE Range sorted(const Range &range){
         Range r(range); std::sort(boost::begin(r), boost::end(r)); return r;
     }
 
@@ -53,7 +53,7 @@ namespace uhd{
      * \param range the range of elements to be reversed
      * \return a new range with the elements reversed
      */
-    template<typename Range> inline Range reversed(const Range &range){
+    template<typename Range> UHD_INLINE Range reversed(const Range &range){
         Range r(range); std::reverse(boost::begin(r), boost::end(r)); return r;
     }
 
@@ -66,7 +66,7 @@ namespace uhd{
      * \param value the match to look for in the range
      * \return true when the value is found in the range
      */
-    template<typename Range, typename T> inline
+    template<typename Range, typename T> UHD_INLINE
     bool has(const Range &range, const T &value){
         return boost::end(range) != std::find(boost::begin(range), boost::end(range), value);
     }
@@ -78,7 +78,7 @@ namespace uhd{
      * \param bound2 the upper or lower bound
      * \return the value clipped at the bounds
      */
-    template<typename T> inline T clip(const T &val, const T &bound1, const T &bound2){
+    template<typename T> UHD_INLINE T clip(const T &val, const T &bound1, const T &bound2){
         const T minimum = std::min(bound1, bound2);
         if (val < minimum) return minimum;
         const T maximum = std::max(bound1, bound2);
diff --git a/host/include/uhd/utils/cast.hpp b/host/include/uhd/utils/cast.hpp
index 9db92c526..869d53053 100644
--- a/host/include/uhd/utils/cast.hpp
+++ b/host/include/uhd/utils/cast.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2014 Ettus Research LLC
+// Copyright 2014-2015 Ettus Research LLC
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -28,7 +28,7 @@ namespace uhd{ namespace cast{
     // Example:
     //     boost::uint16_t x = hexstr_cast<boost::uint16_t>("0xDEADBEEF");
     // Uses stringstream.
-    template<typename T> inline T hexstr_cast(const std::string &in)
+    template<typename T> UHD_INLINE T hexstr_cast(const std::string &in)
     {
         T x;
         std::stringstream ss;
diff --git a/host/include/uhd/utils/dirty_tracked.hpp b/host/include/uhd/utils/dirty_tracked.hpp
index d228a9e65..561beec9b 100644
--- a/host/include/uhd/utils/dirty_tracked.hpp
+++ b/host/include/uhd/utils/dirty_tracked.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2010-2014 Ettus Research LLC
+// Copyright 2010-2015 Ettus Research LLC
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -60,7 +60,7 @@ namespace uhd{
         /*!
          * Get underlying data
          */
-        inline const data_t& get() const {
+        UHD_INLINE const data_t& get() const {
             return _data;
         }
 
@@ -68,21 +68,21 @@ namespace uhd{
          * Has the underlying data changed since the last
          * time it was cleaned?
          */
-        inline bool is_dirty() const {
+        UHD_INLINE bool is_dirty() const {
             return _dirty;
         }
 
         /*!
          * Mark the underlying data as clean
          */
-        inline void mark_clean() {
+        UHD_INLINE void mark_clean() {
             _dirty = false;
         }
 
         /*!
          * Mark the underlying data as dirty
          */
-        inline void force_dirty() {
+        UHD_INLINE void force_dirty() {
             _dirty = true;
         }
 
@@ -91,7 +91,7 @@ namespace uhd{
          * Store the specified value and mark it as dirty
          * if it is not equal to the underlying data.
          */
-        inline dirty_tracked& operator=(const data_t& value)
+        UHD_INLINE dirty_tracked& operator=(const data_t& value)
         {
             if(!(_data == value)) {    //data_t must have an equality operator
                 _dirty = true;
@@ -107,7 +107,7 @@ namespace uhd{
          * This exists to optimize out an implicit cast from dirty_tracked
          * type to data type.
          */
-        inline dirty_tracked& operator=(const dirty_tracked& source) {
+        UHD_INLINE dirty_tracked& operator=(const dirty_tracked& source) {
             if (!(_data == source._data)) {
                 _dirty = true;
                 _data = source._data;
@@ -118,7 +118,7 @@ namespace uhd{
         /*!
          * Explicit conversion from this type to data_t
          */
-        inline operator const data_t&() const {
+        UHD_INLINE operator const data_t&() const {
             return get();
         }
 
diff --git a/host/include/uhd/utils/msg_task.hpp b/host/include/uhd/utils/msg_task.hpp
index d46fdd69e..8ae789d72 100644
--- a/host/include/uhd/utils/msg_task.hpp
+++ b/host/include/uhd/utils/msg_task.hpp
@@ -1,5 +1,5 @@
 //
-// Copyright 2011-2014 Ettus Research LLC
+// Copyright 2011-2015 Ettus Research LLC
 //
 // This program is free software: you can redistribute it and/or modify
 // it under the terms of the GNU General Public License as published by
@@ -42,7 +42,7 @@ namespace uhd{
              */
             virtual msg_payload_t get_msg_from_dump_queue(boost::uint32_t sid) = 0;
 
-            inline static std::vector<boost::uint8_t> buff_to_vector(boost::uint8_t* p, size_t n) {
+            UHD_INLINE static std::vector<boost::uint8_t> buff_to_vector(boost::uint8_t* p, size_t n) {
                 if(p and n > 0){
                     std::vector<boost::uint8_t> v(n);
                     memcpy(&v.front(), p, n);
diff --git a/host/include/uhd/utils/soft_register.hpp b/host/include/uhd/utils/soft_register.hpp
index 665876e73..a6184bbb9 100644
--- a/host/include/uhd/utils/soft_register.hpp
+++ b/host/include/uhd/utils/soft_register.hpp
@@ -57,7 +57,7 @@ namespace uhd {
 //TODO: These hints were added to boost 1.53.
 
 /** \brief hint for the branch prediction */
-inline bool likely(bool expr)
+UHD_INLINE bool likely(bool expr)
 {
 #ifdef __GNUC__
     return __builtin_expect(expr, true);
@@ -67,7 +67,7 @@ inline bool likely(bool expr)
     }
 
 /** \brief hint for the branch prediction */
-inline bool unlikely(bool expr)
+UHD_INLINE bool unlikely(bool expr)
 {
 #ifdef __GNUC__
     return __builtin_expect(expr, false);
@@ -86,16 +86,16 @@ inline bool unlikely(bool expr)
 typedef boost::uint32_t soft_reg_field_t;
 
 namespace soft_reg_field {
-    inline size_t width(const soft_reg_field_t field) {
+    UHD_INLINE size_t width(const soft_reg_field_t field) {
         return (field & 0xFF);
     }
 
-    inline size_t shift(const soft_reg_field_t field) {
+    UHD_INLINE size_t shift(const soft_reg_field_t field) {
         return ((field >> 8) & 0xFF);
     }
 
     template<typename data_t>
-    inline size_t mask(const soft_reg_field_t field) {
+    UHD_INLINE size_t mask(const soft_reg_field_t field) {
         static const data_t ONE = static_cast<data_t>(1);
         //Behavior for the left shift operation is undefined in C++
         //if the shift amount is >= bitwidth of the datatype
@@ -122,7 +122,7 @@ public:
      * Cast the soft_register generic reference to a more specific type
      */
     template <typename soft_reg_t>
-    inline static soft_reg_t& cast(soft_register_base& reg) {
+    UHD_INLINE static soft_reg_t& cast(soft_register_base& reg) {
         soft_reg_t* ptr = dynamic_cast<soft_reg_t*>(&reg);
         if (ptr) {
             return *ptr;
@@ -172,7 +172,7 @@ public:
      * Can be optionally synced with hardware.
      * NOTE: Memory management of the iface is up to the caller
      */
-    inline void initialize(wb_iface& iface, bool sync = false)
+    UHD_INLINE void initialize(wb_iface& iface, bool sync = false)
     {
         _iface = &iface;
 
@@ -186,7 +186,7 @@ public:
      * Performs a read-modify-write operation so all other field are preserved.
      * NOTE: This does not write the value to hardware.
      */
-    inline void set(const soft_reg_field_t field, const reg_data_t value)
+    UHD_INLINE void set(const soft_reg_field_t field, const reg_data_t value)
     {
         _soft_copy = (_soft_copy & ~soft_reg_field::mask<reg_data_t>(field)) |
                      ((value << soft_reg_field::shift(field)) & soft_reg_field::mask<reg_data_t>(field));
@@ -196,7 +196,7 @@ public:
      * Get the value of the specified field from the soft-copy.
      * NOTE: This does not read anything from hardware.
      */
-    inline reg_data_t get(const soft_reg_field_t field)
+    UHD_INLINE reg_data_t get(const soft_reg_field_t field)
     {
         return (_soft_copy & soft_reg_field::mask<reg_data_t>(field)) >> soft_reg_field::shift(field);
     }
@@ -204,7 +204,7 @@ public:
     /*!
      * Write the contents of the soft-copy to hardware.
      */
-    inline void flush()
+    UHD_INLINE void flush()
     {
         if (writable && _iface) {
             //If optimized flush then poke only if soft copy is dirty
@@ -230,7 +230,7 @@ public:
     /*!
      * Read the contents of the register from hardware and update the soft copy.
      */
-    inline void refresh()
+    UHD_INLINE void refresh()
     {
         if (readable && _iface) {
             if (get_bitwidth() <= 16) {
@@ -251,7 +251,7 @@ public:
     /*!
      * Shortcut for a set and a flush.
      */
-    inline void write(const soft_reg_field_t field, const reg_data_t value)
+    UHD_INLINE void write(const soft_reg_field_t field, const reg_data_t value)
     {
         set(field, value);
         flush();
@@ -260,7 +260,7 @@ public:
     /*!
      * Shortcut for refresh and get
      */
-    inline reg_data_t read(const soft_reg_field_t field)
+    UHD_INLINE reg_data_t read(const soft_reg_field_t field)
     {
         refresh();
         return get(field);
@@ -269,7 +269,7 @@ public:
     /*!
      * Get bitwidth for this register
      */
-    inline size_t get_bitwidth()
+    UHD_INLINE size_t get_bitwidth()
     {
         static const size_t BITS_IN_BYTE = 8;
         return sizeof(reg_data_t) * BITS_IN_BYTE;
@@ -278,7 +278,7 @@ public:
     /*!
      * Is the register readable?
      */
-    inline bool is_readable()
+    UHD_INLINE bool is_readable()
     {
         return readable;
     }
@@ -286,7 +286,7 @@ public:
     /*!
      * Is the register writable?
      */
-    inline bool is_writable()
+    UHD_INLINE bool is_writable()
     {
         return writable;
     }
@@ -321,43 +321,43 @@ public:
         soft_register_t<reg_data_t, readable, writable>(addr, mode), _mutex()
     {}
 
-    inline void initialize(wb_iface& iface, bool sync = false)
+    UHD_INLINE void initialize(wb_iface& iface, bool sync = false)
     {
         boost::lock_guard<boost::mutex> lock(_mutex);
         soft_register_t<reg_data_t, readable, writable>::initialize(iface, sync);
     }
 
-    inline void set(const soft_reg_field_t field, const reg_data_t value)
+    UHD_INLINE void set(const soft_reg_field_t field, const reg_data_t value)
     {
         boost::lock_guard<boost::mutex> lock(_mutex);
         soft_register_t<reg_data_t, readable, writable>::set(field, value);
     }
 
-    inline reg_data_t get(const soft_reg_field_t field)
+    UHD_INLINE reg_data_t get(const soft_reg_field_t field)
     {
         boost::lock_guard<boost::mutex> lock(_mutex);
         return soft_register_t<reg_data_t, readable, writable>::get(field);
     }
 
-    inline void flush()
+    UHD_INLINE void flush()
     {
         boost::lock_guard<boost::mutex> lock(_mutex);
         soft_register_t<reg_data_t, readable, writable>::flush();
     }
 
-    inline void refresh()
+    UHD_INLINE void refresh()
     {
         boost::lock_guard<boost::mutex> lock(_mutex);
         soft_register_t<reg_data_t, readable, writable>::refresh();
     }
 
-    inline void write(const soft_reg_field_t field, const reg_data_t value)
+    UHD_INLINE void write(const soft_reg_field_t field, const reg_data_t value)
     {
         boost::lock_guard<boost::mutex> lock(_mutex);
         soft_register_t<reg_data_t, readable, writable>::write(field, value);
     }
 
-    inline reg_data_t read(const soft_reg_field_t field)
+    UHD_INLINE reg_data_t read(const soft_reg_field_t field)
     {
         boost::lock_guard<boost::mutex> lock(_mutex);
         return soft_register_t<reg_data_t, readable, writable>::read(field);
@@ -469,7 +469,7 @@ public:
     /*!
      * Get the name of this register map
      */
-    virtual inline const std::string& get_name() const { return _name; }
+    virtual UHD_INLINE const std::string& get_name() const { return _name; }
 
     /*!
      * Initialize all registers in this register map using a bus.
@@ -542,7 +542,7 @@ protected:
     /*!
      * Add a register to this map with an identifier "name" and visibility
      */
-    inline void add_to_map(soft_register_base& reg, const std::string& name, const visibility_t visible = PRIVATE) {
+    UHD_INLINE void add_to_map(soft_register_base& reg, const std::string& name, const visibility_t visible = PRIVATE) {
         boost::lock_guard<boost::mutex> lock(_mutex);
         if (visible == PUBLIC) {
             //Only add to the map if this register is publicly visible