Fixed variable shadowing.

include/bx/ringbuffer.h

@@ -201,11 +201,11 @@ namespace bx
 
 		void read(char* _data, uint32_t _len)
 		{
-			const uint32_t end = (m_read + _len) % m_control.m_size;
+			const uint32_t eof = (m_read + _len) % m_control.m_size;
 			uint32_t wrap = 0;
 			const char* from = &m_buffer[m_read];
 
-			if (end < m_read)
+			if (eof < m_read)
 			{
 				wrap = m_control.m_size - m_read;
 				memcpy(_data, from, wrap);
@@ -215,7 +215,7 @@ namespace bx
 
 			memcpy(_data, from, _len-wrap);
 
-			m_read = end;
+			m_read = eof;
 		}
 
 		void skip(uint32_t _len)
@@ -271,11 +271,11 @@ namespace bx
 
 		void write(const char* _data, uint32_t _len)
 		{
-			const uint32_t end = (m_write + _len) % m_control.m_size;
+			const uint32_t eof = (m_write + _len) % m_control.m_size;
 			uint32_t wrap = 0;
 			char* to = &m_buffer[m_write];
 
-			if (end < m_write)
+			if (eof < m_write)
 			{
 				wrap = m_control.m_size - m_write;
 				memcpy(to, _data, wrap);
@@ -285,16 +285,16 @@ namespace bx
 
 			memcpy(to, _data, _len-wrap);
 
-			m_write = end;
+			m_write = eof;
 		}
 
 		void write(ReadRingBufferT<Control>& _read, uint32_t _len)
 		{
-			const uint32_t end = (_read.m_read + _len) % _read.m_control.m_size;
+			const uint32_t eof = (_read.m_read + _len) % _read.m_control.m_size;
 			uint32_t wrap = 0;
 			const char* from = &_read.m_buffer[_read.m_read];
 
-			if (end < _read.m_read)
+			if (eof < _read.m_read)
 			{
 				wrap = _read.m_control.m_size - _read.m_read;
 				write(from, wrap);
@@ -303,7 +303,7 @@ namespace bx
 
 			write(from, _len-wrap);
 
-			_read.m_read = end;
+			_read.m_read = eof;
 		}
 
 		void skip(uint32_t _len)

include/tinystl/string.h

@@ -47,8 +47,8 @@ namespace tinystl {
 		size_t size() const;
 		bool empty() const;
 
-		void reserve(size_t size);
-		void resize(size_t size);
+		void reserve(size_t _size);
+		void resize(size_t _size);
 
 		void append(const char* first, const char* last);
 		void append(const char* str);
@@ -145,7 +145,7 @@ namespace tinystl {
 			return;
 		}
 
-		const size_t size = (size_t)(m_last - m_first);
+		const size_t _size = (size_t)(m_last - m_first);
 
 		pointer newfirst = (pointer)Alloc::static_allocate(capacity + 1);
 		for (pointer it = m_first, newit = newfirst, end = m_last; it != end; ++it, ++newit) {
@@ -157,17 +157,17 @@ namespace tinystl {
 		}
 
 		m_first = newfirst;
-		m_last = newfirst + size;
+		m_last = newfirst + _size;
 		m_capacity = m_first + capacity;
 	}
 
 	template<typename Alloc>
-	inline void stringT<Alloc>::resize(size_t size) {
-		reserve(size);
-		for (pointer it = m_last, end = m_first + size + 1; it < end; ++it)
+	inline void stringT<Alloc>::resize(size_t _size) {
+		reserve(_size);
+		for (pointer it = m_last, end = m_first + _size + 1; it < end; ++it)
 			*it = 0;
 
-		m_last += size;
+		m_last += _size;
 	}
 
 	template<typename Alloc>

include/tinystl/vector.h

@@ -38,8 +38,8 @@ namespace tinystl {
 	public:
 		vector();
 		vector(const vector& other);
-		vector(size_t size);
-		vector(size_t size, const T& value);
+		vector(size_t _size);
+		vector(size_t _size, const T& value);
 		vector(const T* first, const T* last);
 		~vector();
 
@@ -62,7 +62,7 @@ namespace tinystl {
 		void resize(size_t size);
 		void resize(size_t size, const T& value);
 		void clear();
-		void reserve(size_t capacity);
+		void reserve(size_t _capacity);
 
 		void push_back(const T& t);
 		void pop_back();
@@ -107,15 +107,15 @@ namespace tinystl {
 	}
 
 	template<typename T, typename Alloc>
-	inline vector<T, Alloc>::vector(size_t size) {
+	inline vector<T, Alloc>::vector(size_t _size) {
 		buffer_init(&m_buffer);
-		buffer_resize(&m_buffer, size, T());
+		buffer_resize(&m_buffer, _size, T());
 	}
 
 	template<typename T, typename Alloc>
-	inline vector<T, Alloc>::vector(size_t size, const T& value) {
+	inline vector<T, Alloc>::vector(size_t _size, const T& value) {
 		buffer_init(&m_buffer);
-		buffer_resize(&m_buffer, size, value);
+		buffer_resize(&m_buffer, _size, value);
 	}
 
 	template<typename T, typename Alloc>
@@ -187,13 +187,13 @@ namespace tinystl {
 	}
 
 	template<typename T, typename Alloc>
-	inline void vector<T, Alloc>::resize(size_t size) {
-		buffer_resize(&m_buffer, size, T());
+	inline void vector<T, Alloc>::resize(size_t _size) {
+		buffer_resize(&m_buffer, _size, T());
 	}
 
 	template<typename T, typename Alloc>
-	inline void vector<T, Alloc>::resize(size_t size, const T& value) {
-		buffer_resize(&m_buffer, size, value);
+	inline void vector<T, Alloc>::resize(size_t _size, const T& value) {
+		buffer_resize(&m_buffer, _size, value);
 	}
 
 	template<typename T, typename Alloc>
@@ -202,8 +202,8 @@ namespace tinystl {
 	}
 
 	template<typename T, typename Alloc>
-	inline void vector<T, Alloc>::reserve(size_t capacity) {
-		buffer_reserve(&m_buffer, capacity);
+	inline void vector<T, Alloc>::reserve(size_t _capacity) {
+		buffer_reserve(&m_buffer, _capacity);
 	}
 
 	template<typename T, typename Alloc>
@@ -277,4 +277,4 @@ namespace tinystl {
 	}
 }
 
-#endif 
+#endif