diff options
Diffstat (limited to 'src/include/util')
-rw-r--r-- | src/include/util/functor.H | 100 | ||||
-rw-r--r-- | src/include/util/locked/list.H | 1 | ||||
-rw-r--r-- | src/include/util/sprintf.H | 323 |
3 files changed, 424 insertions, 0 deletions
diff --git a/src/include/util/functor.H b/src/include/util/functor.H new file mode 100644 index 000000000..a9320f292 --- /dev/null +++ b/src/include/util/functor.H @@ -0,0 +1,100 @@ +#ifndef __UTIL_FUNCTOR_H +#define __UTIL_FUNCTOR_H + +#include <builtins.h> + +namespace Util +{ + template <typename _ARG, typename _RESULT> + class unary_functor + { + public: + typedef _ARG argument_type; + typedef _RESULT result_type; + + public: + virtual ~unary_functor() {}; + virtual result_type operator()(argument_type) = 0; + }; + + template <typename _ARG1, typename _ARG2, typename _RESULT> + class binary_functor + { + public: + typedef _ARG1 first_argument_type; + typedef _ARG2 second_argument_type; + typedef _RESULT result_type; + + public: + virtual ~binary_functor() {}; + virtual result_type operator() + (first_argument_type, second_argument_type) = 0; + }; + + // Function pointer wrappers for functors. + + template <typename _ARG, typename _RESULT> + class ptr_to_unary_function : public unary_functor<_ARG, _RESULT> + { + public: + typedef _RESULT(*function_type)(_ARG); + + private: + function_type function; + + public: + ptr_to_unary_function(function_type f) : function(f) {}; + + + _RESULT operator()(_ARG t) + { + return function(t); + } + }; + + template <typename _ARG, typename _RESULT> + ALWAYS_INLINE + ptr_to_unary_function<_ARG, _RESULT> ptr_fun(_RESULT (*f)(_ARG)) + { + return ptr_to_unary_function<_ARG,_RESULT>(f); + } + +#define PTR_FUN1_T(ARG_T, RESULT_T) \ + ptr_to_unary_function<_ARG, _RESULT> + + + template <typename _ARG, typename _RESULT, typename _CLASS> + class mem_ptr_to_unary_function : public unary_functor<_ARG, _RESULT> + { + public: + typedef _CLASS member_type; + typedef _RESULT(member_type::*function_type)(_ARG); + + private: + member_type& object; + function_type function; + + public: + mem_ptr_to_unary_function(member_type& o, function_type f) + : object(o), function(f) {}; + + _RESULT operator()(_ARG t) + { + return (object.*function)(t); + } + }; + + template <typename _ARG, typename _RESULT, typename _CLASS> + ALWAYS_INLINE + mem_ptr_to_unary_function<_ARG, _RESULT, _CLASS> + mem_ptr_fun(_CLASS& o, _RESULT (_CLASS::*f)(_ARG)) + { + return mem_ptr_to_unary_function<_ARG,_RESULT,_CLASS>(o, f); + } + +#define MEM_PTR_FUN1_T(CLASS_T, ARG_T, RESULT_T) \ + mem_ptr_to_unary_function<ARG_T, RESULT_T, CLASS_T> + +}; + +#endif diff --git a/src/include/util/locked/list.H b/src/include/util/locked/list.H index e4bc0f99c..ad5b06a3b 100644 --- a/src/include/util/locked/list.H +++ b/src/include/util/locked/list.H @@ -1,6 +1,7 @@ #ifndef __UTIL_LOCKED_LIST_H #define __UTIL_LOCKED_LIST_H +#include <stddef.h> #include <util/locked/lock.H> namespace Util diff --git a/src/include/util/sprintf.H b/src/include/util/sprintf.H new file mode 100644 index 000000000..6246b72a0 --- /dev/null +++ b/src/include/util/sprintf.H @@ -0,0 +1,323 @@ +#ifndef __UTIL_SPRINTF_H +#define __UTIL_SPRINTF_H + +#include <stdarg.h> +#include <stdint.h> +#include <builtins.h> + +class Console; + +namespace Util +{ + + class ConsoleTraits + { + public: + enum trait { NONE, HEX, DEC, }; + }; + + template <typename _T, ConsoleTraits::trait _S = ConsoleTraits::NONE> + class ConsoleDisplay + { + public: + template <typename _F> + ALWAYS_INLINE + static size_t display(_F& c, _T value) { return 0; }; + }; + + template <ConsoleTraits::trait _S> + class ConsoleDisplay<char*, _S> + { + public: + template <typename _F> + ALWAYS_INLINE + static size_t display(_F& c, char* value) + { + size_t count = 0; + while(*value != '\0') + { + c(*value); + value++; + count++; + } + return count; + } + }; + + template <> + class ConsoleDisplay<char, ConsoleTraits::NONE> + { + public: + template <typename _F> + ALWAYS_INLINE + static size_t display(_F& c, char value) + { + c(value); + return 1; + } + }; + + template <typename _T> + class ConsoleDisplay<_T, ConsoleTraits::DEC> + { + public: + template <typename _F> + ALWAYS_INLINE + static size_t display(_F& c, _T value) + { + size_t count = 0; + if (value == 0) + { + c('0'); count++; + } + else if (value < 0) + { + c('-'); count++; + value *= -1; + count += subdisplay(c, value); + } + else + count += subdisplay(c, value); + return count; + } + + template <typename _F> + static size_t subdisplay(_F& c, _T value) + { + size_t count = 0; + if (value != 0) + { + count += subdisplay(c, value / 10); + c('0' + (value % 10)); + count++; + } + return count; + } + }; + + template<typename _T> + class ConsoleDisplay<_T, ConsoleTraits::HEX> + { + public: + template <typename _F> + ALWAYS_INLINE + static size_t display(_F& c, _T value) + { + size_t length = sizeof(_T) * 2; + subdisplay(c, value, length); + return length; + } + + template <typename _F> + static void subdisplay(_F& c, _T value, size_t length) + { + if (length == 0) return; + subdisplay(c, value / 16, length-1); + char nibble = value % 16; + if (nibble >= 0x0a) + c('A' + (nibble - 0x0a)); + else + c('0' + nibble); + } + }; + + template<typename _F> + size_t vasprintf(_F output_func, const char* fmt_str, va_list& args) + { + size_t count = 0; + + bool format = false; + int size = 0; + + while('\0' != *fmt_str) + { + if (('%' == *fmt_str) || (format)) + switch (*fmt_str) + { + case '%': + { + if (format) + { + count += + ConsoleDisplay<char>::display(output_func, + '%'); + format = false; + } + else + { + format = true; + size = 2; + } + break; + } + case 'c': + { + format = false; + count += ConsoleDisplay<char> + ::display(output_func, (char)va_arg(args,int)); + break; + } + case 'h': + { + size--; + break; + } + case 'l': + { + size++; + break; + } + case 'z': // size_t or ssize_t + { + size = 4; + break; + } + case 'd': // decimal + { + format = false; + switch(size) + { + case 0: + count += ConsoleDisplay<char, + ConsoleTraits::DEC> + ::display(output_func, + (char)va_arg(args,int)); + break; + + case 1: + count += ConsoleDisplay<short, + ConsoleTraits::DEC> + ::display(output_func, + (short)va_arg(args,int)); + break; + + case 2: + count += ConsoleDisplay<int, + ConsoleTraits::DEC> + ::display(output_func, + va_arg(args,int)); + break; + + case 3: + case 4: + count += ConsoleDisplay<long, + ConsoleTraits::DEC> + ::display(output_func, + va_arg(args,long)); + break; + } + break; + } + case 'u': // unsigned decimal + { + format = false; + switch(size) + { + case 0: + count += ConsoleDisplay<unsigned char, + ConsoleTraits::DEC> + ::display(output_func, + (unsigned char) + va_arg(args,unsigned int)); + break; + + case 1: + count += ConsoleDisplay<unsigned short, + ConsoleTraits::DEC> + ::display(output_func, + (unsigned short) + va_arg(args,unsigned int)); + break; + + case 2: + count += ConsoleDisplay<unsigned int, + ConsoleTraits::DEC> + ::display(output_func, + va_arg(args,unsigned int)); + break; + + case 3: + case 4: + count += ConsoleDisplay<unsigned long, + ConsoleTraits::DEC> + ::display(output_func, + va_arg(args,unsigned long)); + break; + } + break; + } + case 'x': // unsigned hex + case 'X': + { + format = false; + switch(size) + { + case 0: + count += ConsoleDisplay<unsigned char, + ConsoleTraits::HEX> + ::display(output_func, + (unsigned char) + va_arg(args,unsigned int)); + break; + + case 1: + count += ConsoleDisplay<unsigned short, + ConsoleTraits::HEX> + ::display(output_func, + (unsigned short) + va_arg(args,unsigned int)); + break; + + case 2: + count += ConsoleDisplay<unsigned int, + ConsoleTraits::HEX> + ::display(output_func, + va_arg(args,unsigned int)); + break; + + case 3: + case 4: + count += ConsoleDisplay<unsigned long, + ConsoleTraits::HEX> + ::display(output_func, + va_arg(args,unsigned long)); + break; + } + break; + } + case 's': // string + { + format = false; + count += ConsoleDisplay<char*> + ::display(output_func, + (char*) va_arg(args,void*)); + break; + } + case 'p': // pointer + { + format = false; + count += ConsoleDisplay<char> + ::display(output_func, + '0'); + count += ConsoleDisplay<char> + ::display(output_func, + 'x'); + count += ConsoleDisplay<unsigned long, + ConsoleTraits::HEX> + ::display(output_func, + va_arg(args,unsigned long)); + break; + } + } + else + count += ConsoleDisplay<char>::display(output_func, *fmt_str); + + fmt_str++; + } + + return count; + } + +}; + +#endif |