A few 'constexpr' and 'noexcept' added to some obvious places.

tamlin-mike · Xottab-DUTY · commit 7a9e2c3babdd · 2018-01-29T22:54:00.000+05:00
diff --git a/src/xrCommon/math_funcs_inline.h b/src/xrCommon/math_funcs_inline.h
@@ -4,14 +4,14 @@
 #include "xrCommon/inlining_macros.h"
 #include "xrCore/_bitwise.h" // iFloor
 
-inline float _abs(float x) { return fabsf(x); }
-inline float _sqrt(float x) { return sqrtf(x); }
-inline float _sin(float x) { return sinf(x); }
-inline float _cos(float x) { return cosf(x); }
-inline double _abs(double x) { return fabs(x); }
-inline double _sqrt(double x) { return sqrt(x); }
-inline double _sin(double x) { return sin(x); }
-inline double _cos(double x) { return cos(x); }
+inline float _abs(float x) noexcept { return fabsf(x); }
+inline float _sqrt(float x) noexcept { return sqrtf(x); }
+inline float _sin(float x) noexcept { return sinf(x); }
+inline float _cos(float x) noexcept { return cosf(x); }
+inline double _abs(double x) noexcept { return fabs(x); }
+inline double _sqrt(double x) noexcept { return sqrt(x); }
+inline double _sin(double x) noexcept { return sin(x); }
+inline double _cos(double x) noexcept { return cos(x); }
 
 // comparisions
 inline bool fsimilar(float a, float b, float cmp = EPS) { return _abs(a-b)<cmp; }
@@ -21,32 +21,33 @@ inline bool fis_zero(float val, float cmp = EPS_S) noexcept { return _abs(val) <
 inline bool dis_zero(double val, double cmp = EPS_S) noexcept { return _abs(val) < cmp; }
 
 // degree to radians and vice-versa
-ICF float  deg2rad(float  val) { return val*M_PI / 180; }
-ICF double deg2rad(double val) { return val*M_PI / 180; }
-ICF float  rad2deg(float  val) { return val*180 / M_PI; }
-ICF double rad2deg(double val) { return val*180 / M_PI;}
+constexpr float  deg2rad(float  val) noexcept { return val*M_PI / 180; }
+constexpr double deg2rad(double val) noexcept { return val*M_PI / 180; }
+constexpr float  rad2deg(float  val) noexcept { return val*180 / M_PI; }
+constexpr double rad2deg(double val) noexcept { return val*180 / M_PI;}
 
 // clamping/snapping
 template <class T>
-IC void clamp(T& val, const T& _low, const T& _high)
+constexpr void clamp(T& val, const T& _low, const T& _high)
 {
     if (val<_low)
         val = _low;
     else if (val>_high)
         val = _high;
 }
 
+// XXX: Check usages and provide overloads for native types where arguments are NOT references.
 template <class T>
-IC T clampr(const T& val, const T& _low, const T& _high)
+constexpr T clampr(const T& val, const T& _low, const T& _high)
 {
-    if (val<_low)
+    if (val < _low)
         return _low;
-    if (val>_high)
+    if (val > _high)
         return _high;
     return val;
 }
 
-IC float snapto(float value, float snap)
+inline float snapto(float value, float snap)
 {
     if (snap <= 0.f)
         return value;
diff --git a/src/xrCore/FTimer.h b/src/xrCore/FTimer.h
@@ -39,7 +39,7 @@ class XRCORE_API CTimerBase
     bool paused;
 
 public:
-    CTimerBase() : startTime(), pauseDuration(), pauseAccum(), paused(false) {}
+    constexpr CTimerBase() noexcept : startTime(), pauseDuration(), pauseAccum(), paused(false) {}
 
     void Start()
     {
@@ -88,18 +88,18 @@ class XRCORE_API CTimer : public CTimerBase
     }
 
 public:
-    CTimer() : m_time_factor(1.f), realTime(), time() {}
+    constexpr CTimer() noexcept : m_time_factor(1.f), realTime(), time() {}
 
-    void Start()
+    void Start() noexcept
     {
         if (paused) return;
 
         super::Start();
     }
 
-    float time_factor() const { return m_time_factor; }
+    float time_factor() const noexcept { return m_time_factor; }
 
-    void time_factor(const float time_factor)
+    void time_factor(const float time_factor) noexcept
     {
         const auto current = super::getElapsedTime();
         time = getElapsedTime(current);
@@ -118,11 +118,11 @@ class XRCORE_API CTimer_paused_ex : public CTimer
     Time save_clock;
 
 public:
-    CTimer_paused_ex() : save_clock() {}
+    CTimer_paused_ex() noexcept : save_clock() {}
     virtual ~CTimer_paused_ex() {}
-    bool Paused() const { return paused; }
+    bool Paused() const noexcept { return paused; }
 
-    void Pause(const bool b)
+    void Pause(const bool b) noexcept
     {
         if (paused == b) return;
 
diff --git a/src/xrCore/_math.cpp b/src/xrCore/_math.cpp
@@ -159,7 +159,7 @@ XRCORE_API u32 qpc_counter = 0;
 
 XRCORE_API processor_info ID;
 
-XRCORE_API u64 QPC()
+XRCORE_API u64 QPC() noexcept
 {
     u64 _dest;
     QueryPerformanceCounter((PLARGE_INTEGER)&_dest);
diff --git a/src/xrCore/_math.h b/src/xrCore/_math.h
@@ -24,7 +24,7 @@ XRCORE_API extern u64 qpc_freq;
 XRCORE_API extern u32 qpc_counter;
 
 XRCORE_API extern processor_info ID;
-XRCORE_API extern u64 QPC();
+XRCORE_API extern u64 QPC() noexcept;
 
 #ifdef _MSC_VER
 // XXX: Stale checks. All MS' x86&x64 compilers cabable of compiling XRay-16 have __rdtsc
diff --git a/src/xrCore/_vector3d.h b/src/xrCore/_vector3d.h
@@ -21,167 +21,168 @@ struct _vector3
     ICF T& operator[](int i) { return *((T*)this + i); }
     ICF T& operator[](int i) const { return *((T*)this + i); }
 
-    ICF SelfRef set(T _x, T _y, T _z)
+    ICF SelfRef set(T _x, T _y, T _z) noexcept
     {
         x = _x;
         y = _y;
         z = _z;
         return *this;
     }
 
-    ICF SelfRef set(const _vector3<float>& v)
+    ICF SelfRef set(const _vector3<float>& v) noexcept
     {
         x = T(v.x);
         y = T(v.y);
         z = T(v.z);
         return *this;
     }
 
-    ICF SelfRef set(const _vector3<double>& v)
+    ICF SelfRef set(const _vector3<double>& v) noexcept
     {
         x = T(v.x);
         y = T(v.y);
         z = T(v.z);
         return *this;
     }
 
-    ICF SelfRef set(float* p)
+    ICF SelfRef set(float* p) noexcept
     {
         x = p[0];
         y = p[1];
         z = p[2];
         return *this;
     }
 
-    ICF SelfRef set(double* p)
+    ICF SelfRef set(double* p) noexcept
     {
         x = p[0];
         y = p[1];
         z = p[2];
         return *this;
     }
 
-    ICF SelfRef add(const Self& v)
+    // XXX: The vast majority of these basic math operations can be expressed as non-class functions.
+    ICF SelfRef add(const Self& v) noexcept
     {
         x += v.x;
         y += v.y;
         z += v.z;
         return *this;
     }
 
-    ICF SelfRef add(T s)
+    ICF SelfRef add(T s) noexcept
     {
         x += s;
         y += s;
         z += s;
         return *this;
     }
 
-    ICF SelfRef add(const Self& a, const Self& v)
+    ICF SelfRef add(const Self& a, const Self& v) noexcept
     {
         x = a.x + v.x;
         y = a.y + v.y;
         z = a.z + v.z;
         return *this;
     }
 
-    ICF SelfRef add(const Self& a, T s)
+    ICF SelfRef add(const Self& a, T s) noexcept
     {
         x = a.x + s;
         y = a.y + s;
         z = a.z + s;
         return *this;
     }
 
-    ICF SelfRef sub(const Self& v)
+    ICF SelfRef sub(const Self& v) noexcept
     {
         x -= v.x;
         y -= v.y;
         z -= v.z;
         return *this;
     }
 
-    ICF SelfRef sub(T s)
+    ICF SelfRef sub(T s) noexcept
     {
         x -= s;
         y -= s;
         z -= s;
         return *this;
     }
 
-    ICF SelfRef sub(const Self& a, const Self& v)
+    ICF SelfRef sub(const Self& a, const Self& v) noexcept
     {
         x = a.x - v.x;
         y = a.y - v.y;
         z = a.z - v.z;
         return *this;
     }
 
-    ICF SelfRef sub(const Self& a, T s)
+    ICF SelfRef sub(const Self& a, T s) noexcept
     {
         x = a.x - s;
         y = a.y - s;
         z = a.z - s;
         return *this;
     }
 
-    ICF SelfRef mul(const Self& v)
+    ICF SelfRef mul(const Self& v) noexcept
     {
         x *= v.x;
         y *= v.y;
         z *= v.z;
         return *this;
     }
 
-    ICF SelfRef mul(T s)
+    ICF SelfRef mul(T s) noexcept
     {
         x *= s;
         y *= s;
         z *= s;
         return *this;
     }
 
-    ICF SelfRef mul(const Self& a, const Self& v)
+    ICF SelfRef mul(const Self& a, const Self& v) noexcept
     {
         x = a.x * v.x;
         y = a.y * v.y;
         z = a.z * v.z;
         return *this;
     }
 
-    ICF SelfRef mul(const Self& a, T s)
+    ICF SelfRef mul(const Self& a, T s) noexcept
     {
         x = a.x * s;
         y = a.y * s;
         z = a.z * s;
         return *this;
     }
 
-    ICF SelfRef div(const Self& v)
+    ICF SelfRef div(const Self& v) noexcept
     {
         x /= v.x;
         y /= v.y;
         z /= v.z;
         return *this;
     }
 
-    ICF SelfRef div(T s)
+    ICF SelfRef div(T s) noexcept
     {
         x /= s;
         y /= s;
         z /= s;
         return *this;
     }
 
-    ICF SelfRef div(const Self& a, const Self& v)
+    ICF SelfRef div(const Self& a, const Self& v) noexcept
     {
         x = a.x / v.x;
         y = a.y / v.y;
         z = a.z / v.z;
         return *this;
     }
 
-    ICF SelfRef div(const Self& a, T s)
+    ICF SelfRef div(const Self& a, T s) noexcept
     {
         x = a.x / s;
         y = a.y / s;
diff --git a/src/xrGame/alife_switch_manager.h b/src/xrGame/alife_switch_manager.h
@@ -7,9 +7,9 @@
 ////////////////////////////////////////////////////////////////////////////
 
 #pragma once
-
 #include "alife_simulator_base.h"
 
+// XXX: WTF is this? CALifeSwitchManager IS-A CRandom??? I think NOT! CRandom should be aggregated, NOT inherited from!
 class CALifeSwitchManager : public virtual CALifeSimulatorBase, CRandom
 {
 protected:
@@ -40,11 +40,11 @@ class CALifeSwitchManager : public virtual CALifeSimulatorBase, CRandom
     IC CALifeSwitchManager(IPureServer* server, LPCSTR section);
     virtual ~CALifeSwitchManager();
     void switch_object(CSE_ALifeDynamicObject* object);
-    IC float online_distance() const;
-    IC float offline_distance() const;
-    IC float switch_distance() const;
-    IC void set_switch_distance(float switch_distance);
-    IC void set_switch_factor(float switch_factor);
+    IC float online_distance() const noexcept;
+    IC float offline_distance() const noexcept;
+    IC float switch_distance() const noexcept;
+    IC void set_switch_distance(float switch_distance) noexcept;
+    IC void set_switch_factor(float switch_factor) noexcept;
 };
 
 #include "alife_switch_manager_inline.h"
diff --git a/src/xrGame/alife_switch_manager_inline.h b/src/xrGame/alife_switch_manager_inline.h
@@ -16,17 +16,17 @@ IC CALifeSwitchManager::CALifeSwitchManager(IPureServer* server, LPCSTR section)
     seed(u32(CPU::QPC() & 0xffffffff));
 }
 
-IC float CALifeSwitchManager::online_distance() const { return (m_online_distance); }
-IC float CALifeSwitchManager::offline_distance() const { return (m_offline_distance); }
-IC float CALifeSwitchManager::switch_distance() const { return (m_switch_distance); }
-IC void CALifeSwitchManager::set_switch_distance(float switch_distance)
+IC float CALifeSwitchManager::online_distance() const noexcept { return (m_online_distance); }
+IC float CALifeSwitchManager::offline_distance() const noexcept { return (m_offline_distance); }
+IC float CALifeSwitchManager::switch_distance() const noexcept { return (m_switch_distance); }
+IC void CALifeSwitchManager::set_switch_distance(float switch_distance) noexcept
 {
     m_switch_distance = switch_distance;
     m_online_distance = m_switch_distance * (1.f - m_switch_factor);
     m_offline_distance = m_switch_distance * (1.f + m_switch_factor);
 }
 
-IC void CALifeSwitchManager::set_switch_factor(float switch_factor)
+IC void CALifeSwitchManager::set_switch_factor(float switch_factor) noexcept
 {
     m_switch_factor = switch_factor;
     set_switch_distance(switch_distance());
diff --git a/src/xrServerEntities/script_token_list.h b/src/xrServerEntities/script_token_list.h
@@ -23,7 +23,7 @@ class CScriptTokenList
     {
         pcstr m_name;
 
-        CTokenPredicateName(pcstr name) noexcept : m_name(name) {}
+        constexpr CTokenPredicateName(pcstr name) noexcept : m_name(name) {}
         IC bool operator()(const xr_token& token) const noexcept { return token.name && !xr_strcmp(token.name, m_name); }
     };
 

Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,7 @@ XRCORE_API u32 qpc_counter = 0;`
`159`	`159`
`160`	`160`	`XRCORE_API processor_info ID;`
`161`	`161`
`162`		`-XRCORE_API u64 QPC()`
	`162`	`+XRCORE_API u64 QPC() noexcept`
`163`	`163`	`{`
`164`	`164`	`u64 _dest;`
`165`	`165`	`QueryPerformanceCounter((PLARGE_INTEGER)&_dest);`
Original file line number	Diff line number	Diff line change
`@@ -21,167 +21,168 @@ struct _vector3`
`21`	`21`	`ICF T& operator[](int i) { return ((T)this + i); }`
`22`	`22`	`ICF T& operator[](int i) const { return ((T)this + i); }`
`23`	`23`
`24`		`- ICF SelfRef set(T _x, T _y, T _z)`
	`24`	`+ ICF SelfRef set(T _x, T _y, T _z) noexcept`
`25`	`25`	`{`
`26`	`26`	`x = _x;`
`27`	`27`	`y = _y;`
`28`	`28`	`z = _z;`
`29`	`29`	`return *this;`
`30`	`30`	`}`
`31`	`31`
`32`		`- ICF SelfRef set(const _vector3<float>& v)`
	`32`	`+ ICF SelfRef set(const _vector3<float>& v) noexcept`
`33`	`33`	`{`
`34`	`34`	`x = T(v.x);`
`35`	`35`	`y = T(v.y);`
`36`	`36`	`z = T(v.z);`
`37`	`37`	`return *this;`
`38`	`38`	`}`
`39`	`39`
`40`		`- ICF SelfRef set(const _vector3<double>& v)`
	`40`	`+ ICF SelfRef set(const _vector3<double>& v) noexcept`
`41`	`41`	`{`
`42`	`42`	`x = T(v.x);`
`43`	`43`	`y = T(v.y);`
`44`	`44`	`z = T(v.z);`
`45`	`45`	`return *this;`
`46`	`46`	`}`
`47`	`47`
`48`		`- ICF SelfRef set(float* p)`
	`48`	`+ ICF SelfRef set(float* p) noexcept`
`49`	`49`	`{`
`50`	`50`	`x = p[0];`
`51`	`51`	`y = p[1];`
`52`	`52`	`z = p[2];`
`53`	`53`	`return *this;`
`54`	`54`	`}`
`55`	`55`
`56`		`- ICF SelfRef set(double* p)`
	`56`	`+ ICF SelfRef set(double* p) noexcept`
`57`	`57`	`{`
`58`	`58`	`x = p[0];`
`59`	`59`	`y = p[1];`
`60`	`60`	`z = p[2];`
`61`	`61`	`return *this;`
`62`	`62`	`}`
`63`	`63`
`64`		`- ICF SelfRef add(const Self& v)`
	`64`	`+ // XXX: The vast majority of these basic math operations can be expressed as non-class functions.`
	`65`	`+ ICF SelfRef add(const Self& v) noexcept`
`65`	`66`	`{`
`66`	`67`	`x += v.x;`
`67`	`68`	`y += v.y;`
`68`	`69`	`z += v.z;`
`69`	`70`	`return *this;`
`70`	`71`	`}`
`71`	`72`
`72`		`- ICF SelfRef add(T s)`
	`73`	`+ ICF SelfRef add(T s) noexcept`
`73`	`74`	`{`
`74`	`75`	`x += s;`
`75`	`76`	`y += s;`
`76`	`77`	`z += s;`
`77`	`78`	`return *this;`
`78`	`79`	`}`
`79`	`80`
`80`		`- ICF SelfRef add(const Self& a, const Self& v)`
	`81`	`+ ICF SelfRef add(const Self& a, const Self& v) noexcept`
`81`	`82`	`{`
`82`	`83`	`x = a.x + v.x;`
`83`	`84`	`y = a.y + v.y;`
`84`	`85`	`z = a.z + v.z;`
`85`	`86`	`return *this;`
`86`	`87`	`}`
`87`	`88`
`88`		`- ICF SelfRef add(const Self& a, T s)`
	`89`	`+ ICF SelfRef add(const Self& a, T s) noexcept`
`89`	`90`	`{`
`90`	`91`	`x = a.x + s;`
`91`	`92`	`y = a.y + s;`
`92`	`93`	`z = a.z + s;`
`93`	`94`	`return *this;`
`94`	`95`	`}`
`95`	`96`
`96`		`- ICF SelfRef sub(const Self& v)`
	`97`	`+ ICF SelfRef sub(const Self& v) noexcept`
`97`	`98`	`{`
`98`	`99`	`x -= v.x;`
`99`	`100`	`y -= v.y;`
`100`	`101`	`z -= v.z;`
`101`	`102`	`return *this;`
`102`	`103`	`}`
`103`	`104`
`104`		`- ICF SelfRef sub(T s)`
	`105`	`+ ICF SelfRef sub(T s) noexcept`
`105`	`106`	`{`
`106`	`107`	`x -= s;`
`107`	`108`	`y -= s;`
`108`	`109`	`z -= s;`
`109`	`110`	`return *this;`
`110`	`111`	`}`
`111`	`112`
`112`		`- ICF SelfRef sub(const Self& a, const Self& v)`
	`113`	`+ ICF SelfRef sub(const Self& a, const Self& v) noexcept`
`113`	`114`	`{`
`114`	`115`	`x = a.x - v.x;`
`115`	`116`	`y = a.y - v.y;`
`116`	`117`	`z = a.z - v.z;`
`117`	`118`	`return *this;`
`118`	`119`	`}`
`119`	`120`
`120`		`- ICF SelfRef sub(const Self& a, T s)`
	`121`	`+ ICF SelfRef sub(const Self& a, T s) noexcept`
`121`	`122`	`{`
`122`	`123`	`x = a.x - s;`
`123`	`124`	`y = a.y - s;`
`124`	`125`	`z = a.z - s;`
`125`	`126`	`return *this;`
`126`	`127`	`}`
`127`	`128`
`128`		`- ICF SelfRef mul(const Self& v)`
	`129`	`+ ICF SelfRef mul(const Self& v) noexcept`
`129`	`130`	`{`
`130`	`131`	`x *= v.x;`
`131`	`132`	`y *= v.y;`
`132`	`133`	`z *= v.z;`
`133`	`134`	`return *this;`
`134`	`135`	`}`
`135`	`136`
`136`		`- ICF SelfRef mul(T s)`
	`137`	`+ ICF SelfRef mul(T s) noexcept`
`137`	`138`	`{`
`138`	`139`	`x *= s;`
`139`	`140`	`y *= s;`
`140`	`141`	`z *= s;`
`141`	`142`	`return *this;`
`142`	`143`	`}`
`143`	`144`
`144`		`- ICF SelfRef mul(const Self& a, const Self& v)`
	`145`	`+ ICF SelfRef mul(const Self& a, const Self& v) noexcept`
`145`	`146`	`{`
`146`	`147`	`x = a.x * v.x;`
`147`	`148`	`y = a.y * v.y;`
`148`	`149`	`z = a.z * v.z;`
`149`	`150`	`return *this;`
`150`	`151`	`}`
`151`	`152`
`152`		`- ICF SelfRef mul(const Self& a, T s)`
	`153`	`+ ICF SelfRef mul(const Self& a, T s) noexcept`
`153`	`154`	`{`
`154`	`155`	`x = a.x * s;`
`155`	`156`	`y = a.y * s;`
`156`	`157`	`z = a.z * s;`
`157`	`158`	`return *this;`
`158`	`159`	`}`
`159`	`160`
`160`		`- ICF SelfRef div(const Self& v)`
	`161`	`+ ICF SelfRef div(const Self& v) noexcept`
`161`	`162`	`{`
`162`	`163`	`x /= v.x;`
`163`	`164`	`y /= v.y;`
`164`	`165`	`z /= v.z;`
`165`	`166`	`return *this;`
`166`	`167`	`}`
`167`	`168`
`168`		`- ICF SelfRef div(T s)`
	`169`	`+ ICF SelfRef div(T s) noexcept`
`169`	`170`	`{`
`170`	`171`	`x /= s;`
`171`	`172`	`y /= s;`
`172`	`173`	`z /= s;`
`173`	`174`	`return *this;`
`174`	`175`	`}`
`175`	`176`
`176`		`- ICF SelfRef div(const Self& a, const Self& v)`
	`177`	`+ ICF SelfRef div(const Self& a, const Self& v) noexcept`
`177`	`178`	`{`
`178`	`179`	`x = a.x / v.x;`
`179`	`180`	`y = a.y / v.y;`
`180`	`181`	`z = a.z / v.z;`
`181`	`182`	`return *this;`
`182`	`183`	`}`
`183`	`184`
`184`		`- ICF SelfRef div(const Self& a, T s)`
	`185`	`+ ICF SelfRef div(const Self& a, T s) noexcept`
`185`	`186`	`{`
`186`	`187`	`x = a.x / s;`
`187`	`188`	`y = a.y / s;`
Original file line number	Diff line number	Diff line change
`@@ -16,17 +16,17 @@ IC CALifeSwitchManager::CALifeSwitchManager(IPureServer* server, LPCSTR section)`
`16`	`16`	`seed(u32(CPU::QPC() & 0xffffffff));`
`17`	`17`	`}`
`18`	`18`
`19`		`-IC float CALifeSwitchManager::online_distance() const { return (m_online_distance); }`
`20`		`-IC float CALifeSwitchManager::offline_distance() const { return (m_offline_distance); }`
`21`		`-IC float CALifeSwitchManager::switch_distance() const { return (m_switch_distance); }`
`22`		`-IC void CALifeSwitchManager::set_switch_distance(float switch_distance)`
	`19`	`+IC float CALifeSwitchManager::online_distance() const noexcept { return (m_online_distance); }`
	`20`	`+IC float CALifeSwitchManager::offline_distance() const noexcept { return (m_offline_distance); }`
	`21`	`+IC float CALifeSwitchManager::switch_distance() const noexcept { return (m_switch_distance); }`
	`22`	`+IC void CALifeSwitchManager::set_switch_distance(float switch_distance) noexcept`
`23`	`23`	`{`
`24`	`24`	`m_switch_distance = switch_distance;`
`25`	`25`	`m_online_distance = m_switch_distance * (1.f - m_switch_factor);`
`26`	`26`	`m_offline_distance = m_switch_distance * (1.f + m_switch_factor);`
`27`	`27`	`}`
`28`	`28`
`29`		`-IC void CALifeSwitchManager::set_switch_factor(float switch_factor)`
	`29`	`+IC void CALifeSwitchManager::set_switch_factor(float switch_factor) noexcept`
`30`	`30`	`{`
`31`	`31`	`m_switch_factor = switch_factor;`
`32`	`32`	`set_switch_distance(switch_distance());`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ class CScriptTokenList`
`23`	`23`	`{`
`24`	`24`	`pcstr m_name;`
`25`	`25`
`26`		`- CTokenPredicateName(pcstr name) noexcept : m_name(name) {}`
	`26`	`+ constexpr CTokenPredicateName(pcstr name) noexcept : m_name(name) {}`
`27`	`27`	`IC bool operator()(const xr_token& token) const noexcept { return token.name && !xr_strcmp(token.name, m_name); }`
`28`	`28`	`};`
`29`	`29`