+++ /dev/null
-////////////////////////////////////////////////////////////////////////////////
-
-// Author: Andy Rushton
-// Copyright: (c) Southampton University 1999-2004
-// (c) Andy Rushton 2004-2009
-// License: BSD License, see ../docs/license.html
-
-////////////////////////////////////////////////////////////////////////////////
-#include "string_int.hpp"
-#include <ctype.h>
-#include <stdlib.h>
-
-namespace stlplus
-{
-
- ////////////////////////////////////////////////////////////////////////////////
- // character mappings
-
- static char to_char [] = "0123456789abcdefghijklmnopqrstuvwxyz";
- static int from_char [] =
- {
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1,
- -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
- 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
- -1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
- 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1
- };
-
- ////////////////////////////////////////////////////////////////////////////////
- // Conversions to string
- // Local generic routines
-
- // signed version of the generic image generation function for all integer types
- template<typename T>
- static std::string simage (T i, unsigned radix, radix_display_t display, unsigned width)
- throw(std::invalid_argument)
- {
- if (radix < 2 || radix > 36)
- throw std::invalid_argument("invalid radix value " + unsigned_to_string(radix));
- // untangle all the options
- bool hashed = false;
- bool binary = false;
- bool octal = false;
- bool hex = false;
- switch(display)
- {
- case radix_none:
- break;
- case radix_hash_style:
- hashed = radix != 10;
- break;
- case radix_hash_style_all:
- hashed = true;
- break;
- case radix_c_style:
- if (radix == 16)
- hex = true;
- else if (radix == 8)
- octal = true;
- else if (radix == 2)
- binary = true;
- break;
- case radix_c_style_or_hash:
- if (radix == 16)
- hex = true;
- else if (radix == 8)
- octal = true;
- else if (radix == 2)
- binary = true;
- else if (radix != 10)
- hashed = true;
- break;
- default:
- throw std::invalid_argument("invalid radix display value");
- }
- // create constants of the same type as the template parameter to avoid type mismatches
- const T t_zero(0);
- const T t_radix(radix);
- // the C representations for binary, octal and hex use 2's-complement representation
- // all other represenations use sign-magnitude
- std::string result;
- if (hex || octal || binary)
- {
- // bit-pattern representation
- // this is the binary representation optionally shown in octal or hex
- // first generate the binary by masking the bits
- // ensure that it has at least one bit!
- for (T mask(1); ; mask <<= 1)
- {
- result.insert((std::string::size_type)0, 1, i & mask ? '1' : '0');
- if (mask == t_zero) break;
- }
- // the result is now the full width of the type - e.g. int will give a 32-bit result
- // now interpret this as either binary, octal or hex and add the prefix
- if (binary)
- {
- // the result is already binary - but the width may be wrong
- // if this is still smaller than the width field, sign extend
- // otherwise trim down to either the width or the smallest string that preserves the value
- while (result.size() < width)
- result.insert((std::string::size_type)0, 1, result[0]);
- while (result.size() > width)
- {
- // do not trim to less than 2 bits (sign plus 1-bit magnitude)
- if (result.size() <= 2) break;
- // only trim if it doesn't change the sign and therefore the value
- if (result[0] != result[1]) break;
- result.erase(0,1);
- }
- // add the prefix
- result.insert((std::string::size_type)0, "0b");
- }
- else if (octal)
- {
- // the result is currently binary - but before converting get the width right
- // the width is expressed in octal digits so make the binary 3 times this
- // if this is still smaller than the width field, sign extend
- // otherwise trim down to either the width or the smallest string that preserves the value
- // also ensure that the binary is a multiple of 3 bits to make the conversion to octal easier
- while (result.size() < 3*width)
- result.insert((std::string::size_type)0, 1, result[0]);
- while (result.size() > 3*width)
- {
- // do not trim to less than 2 bits (sign plus 1-bit magnitude)
- if (result.size() <= 2) break;
- // only trim if it doesn't change the sign and therefore the value
- if (result[0] != result[1]) break;
- result.erase(0,1);
- }
- while (result.size() % 3 != 0)
- result.insert((std::string::size_type)0, 1, result[0]);
- // now convert to octal
- std::string octal_result;
- for (unsigned i = 0; i < result.size()/3; i++)
- {
- // yuck - ugly or what?
- if (result[i*3] == '0')
- {
- if (result[i*3+1] == '0')
- {
- if (result[i*3+2] == '0')
- octal_result += '0';
- else
- octal_result += '1';
- }
- else
- {
- if (result[i*3+2] == '0')
- octal_result += '2';
- else
- octal_result += '3';
- }
- }
- else
- {
- if (result[i*3+1] == '0')
- {
- if (result[i*3+2] == '0')
- octal_result += '4';
- else
- octal_result += '5';
- }
- else
- {
- if (result[i*3+2] == '0')
- octal_result += '6';
- else
- octal_result += '7';
- }
- }
- }
- result = octal_result;
- // add the prefix
- result.insert((std::string::size_type)0, "0");
- }
- else
- {
- // hex - similar to octal
- while (result.size() < 4*width)
- result.insert((std::string::size_type)0, 1, result[0]);
- while (result.size() > 4*width)
- {
- // do not trim to less than 2 bits (sign plus 1-bit magnitude)
- if (result.size() <= 2) break;
- // only trim if it doesn't change the sign and therefore the value
- if (result[0] != result[1]) break;
- result.erase(0,1);
- }
- while (result.size() % 4 != 0)
- result.insert((std::string::size_type)0, 1, result[0]);
- // now convert to hex
- std::string hex_result;
- for (unsigned i = 0; i < result.size()/4; i++)
- {
- // yuck - ugly or what?
- if (result[i*4] == '0')
- {
- if (result[i*4+1] == '0')
- {
- if (result[i*4+2] == '0')
- {
- if (result[i*4+3] == '0')
- hex_result += '0';
- else
- hex_result += '1';
- }
- else
- {
- if (result[i*4+3] == '0')
- hex_result += '2';
- else
- hex_result += '3';
- }
- }
- else
- {
- if (result[i*4+2] == '0')
- {
- if (result[i*4+3] == '0')
- hex_result += '4';
- else
- hex_result += '5';
- }
- else
- {
- if (result[i*4+3] == '0')
- hex_result += '6';
- else
- hex_result += '7';
- }
- }
- }
- else
- {
- if (result[i*4+1] == '0')
- {
- if (result[i*4+2] == '0')
- {
- if (result[i*4+3] == '0')
- hex_result += '8';
- else
- hex_result += '9';
- }
- else
- {
- if (result[i*4+3] == '0')
- hex_result += 'a';
- else
- hex_result += 'b';
- }
- }
- else
- {
- if (result[i*4+2] == '0')
- {
- if (result[i*4+3] == '0')
- hex_result += 'c';
- else
- hex_result += 'd';
- }
- else
- {
- if (result[i*4+3] == '0')
- hex_result += 'e';
- else
- hex_result += 'f';
- }
- }
- }
- }
- result = hex_result;
- // add the prefix
- result.insert((std::string::size_type)0, "0x");
- }
- }
- else
- {
- // convert to sign-magnitude
- // the representation is:
- // [radix#][sign]magnitude
- bool negative = i < t_zero;
- // create a representation of the magnitude by successive division
- do
- {
- T ch = abs(i % t_radix);
- i /= t_radix;
- result.insert((std::string::size_type)0, 1, to_char[ch]);
- }
- while(i != t_zero || result.size() < width);
- // add the prefixes
- // add a sign only for negative values
- if (negative)
- result.insert((std::string::size_type)0, 1, '-');
- // then prefix everything with the radix if the hashed representation was requested
- if (hashed)
- result.insert((std::string::size_type)0, unsigned_to_string(radix) + "#");
- }
- return result;
- }
-
- // unsigned version
- template<typename T>
- static std::string uimage (T i, unsigned radix, radix_display_t display, unsigned width)
- throw(std::invalid_argument)
- {
- if (radix < 2 || radix > 36)
- throw std::invalid_argument("invalid radix value " + unsigned_to_string(radix));
- // untangle all the options
- bool hashed = false;
- bool binary = false;
- bool octal = false;
- bool hex = false;
- switch(display)
- {
- case radix_none:
- break;
- case radix_hash_style:
- hashed = radix != 10;
- break;
- case radix_hash_style_all:
- hashed = true;
- break;
- case radix_c_style:
- if (radix == 16)
- hex = true;
- else if (radix == 8)
- octal = true;
- else if (radix == 2)
- binary = true;
- break;
- case radix_c_style_or_hash:
- if (radix == 16)
- hex = true;
- else if (radix == 8)
- octal = true;
- else if (radix == 2)
- binary = true;
- else if (radix != 10)
- hashed = true;
- break;
- default:
- throw std::invalid_argument("invalid radix display value");
- }
- // create constants of the same type as the template parameter to avoid type mismatches
- const T t_zero(0);
- const T t_radix(radix);
- // the C representations for binary, octal and hex use 2's-complement representation
- // all other represenations use sign-magnitude
- std::string result;
- if (hex || octal || binary)
- {
- // bit-pattern representation
- // this is the binary representation optionally shown in octal or hex
- // first generate the binary by masking the bits
- // ensure at least one bit
- for (T mask(1); ; mask <<= 1)
- {
- result.insert((std::string::size_type)0, 1, i & mask ? '1' : '0');
- if (mask == t_zero) break;
- }
- // the result is now the full width of the type - e.g. int will give a 32-bit result
- // now interpret this as either binary, octal or hex and add the prefix
- if (binary)
- {
- // the result is already binary - but the width may be wrong
- // if this is still smaller than the width field, zero extend
- // otherwise trim down to either the width or the smallest string that preserves the value
- while (result.size() < width)
- result.insert((std::string::size_type)0, 1, '0');
- while (result.size() > width)
- {
- // do not trim to less than 1 bit (1-bit magnitude)
- if (result.size() <= 1) break;
- // only trim if it doesn't change the sign and therefore the value
- if (result[0] != '0') break;
- result.erase(0,1);
- }
- // add the prefix
- result.insert((std::string::size_type)0, "0b");
- }
- else if (octal)
- {
- // the result is currently binary - but before converting get the width right
- // the width is expressed in octal digits so make the binary 3 times this
- // if this is still smaller than the width field, sign extend
- // otherwise trim down to either the width or the smallest string that preserves the value
- // also ensure that the binary is a multiple of 3 bits to make the conversion to octal easier
- while (result.size() < 3*width)
- result.insert((std::string::size_type)0, 1, '0');
- while (result.size() > 3*width)
- {
- // do not trim to less than 1 bit (1-bit magnitude)
- if (result.size() <= 1) break;
- // only trim if it doesn't change the sign and therefore the value
- if (result[0] != '0') break;
- result.erase(0,1);
- }
- while (result.size() % 3 != 0)
- result.insert((std::string::size_type)0, 1, '0');
- // now convert to octal
- std::string octal_result;
- for (unsigned i = 0; i < result.size()/3; i++)
- {
- // yuck - ugly or what?
- if (result[i*3] == '0')
- {
- if (result[i*3+1] == '0')
- {
- if (result[i*3+2] == '0')
- octal_result += '0';
- else
- octal_result += '1';
- }
- else
- {
- if (result[i*3+2] == '0')
- octal_result += '2';
- else
- octal_result += '3';
- }
- }
- else
- {
- if (result[i*3+1] == '0')
- {
- if (result[i*3+2] == '0')
- octal_result += '4';
- else
- octal_result += '5';
- }
- else
- {
- if (result[i*3+2] == '0')
- octal_result += '6';
- else
- octal_result += '7';
- }
- }
- }
- result = octal_result;
- // add the prefix if the leading digit is not already 0
- if (result.empty() || result[0] != '0') result.insert((std::string::size_type)0, "0");
- }
- else
- {
- // similar to octal
- while (result.size() < 4*width)
- result.insert((std::string::size_type)0, 1, '0');
- while (result.size() > 4*width)
- {
- // do not trim to less than 1 bit (1-bit magnitude)
- if (result.size() <= 1) break;
- // only trim if it doesn't change the sign and therefore the value
- if (result[0] != '0') break;
- result.erase(0,1);
- }
- while (result.size() % 4 != 0)
- result.insert((std::string::size_type)0, 1, '0');
- // now convert to hex
- std::string hex_result;
- for (unsigned i = 0; i < result.size()/4; i++)
- {
- // yuck - ugly or what?
- if (result[i*4] == '0')
- {
- if (result[i*4+1] == '0')
- {
- if (result[i*4+2] == '0')
- {
- if (result[i*4+3] == '0')
- hex_result += '0';
- else
- hex_result += '1';
- }
- else
- {
- if (result[i*4+3] == '0')
- hex_result += '2';
- else
- hex_result += '3';
- }
- }
- else
- {
- if (result[i*4+2] == '0')
- {
- if (result[i*4+3] == '0')
- hex_result += '4';
- else
- hex_result += '5';
- }
- else
- {
- if (result[i*4+3] == '0')
- hex_result += '6';
- else
- hex_result += '7';
- }
- }
- }
- else
- {
- if (result[i*4+1] == '0')
- {
- if (result[i*4+2] == '0')
- {
- if (result[i*4+3] == '0')
- hex_result += '8';
- else
- hex_result += '9';
- }
- else
- {
- if (result[i*4+3] == '0')
- hex_result += 'a';
- else
- hex_result += 'b';
- }
- }
- else
- {
- if (result[i*4+2] == '0')
- {
- if (result[i*4+3] == '0')
- hex_result += 'c';
- else
- hex_result += 'd';
- }
- else
- {
- if (result[i*4+3] == '0')
- hex_result += 'e';
- else
- hex_result += 'f';
- }
- }
- }
- }
- result = hex_result;
- // add the prefix
- result.insert((std::string::size_type)0, "0x");
- }
- }
- else
- {
- // convert to sign-magnitude
- // the representation is:
- // [radix#]magnitude
- // create a representation of the magnitude by successive division
- do
- {
- T ch = i % t_radix;
- i /= t_radix;
- result.insert((std::string::size_type)0, 1, to_char[(int)ch]);
- }
- while(i != t_zero || result.size() < width);
- // prefix everything with the radix if the hashed representation was requested
- if (hashed)
- result.insert((std::string::size_type)0, unsigned_to_string(radix) + "#");
- }
- return result;
- }
-
- ////////////////////////////////////////////////////////////////////////////////
- // exported conversions to string
-
- std::string short_to_string(short i, unsigned radix, radix_display_t display, unsigned width)
- throw(std::invalid_argument)
- {
- return simage(i, radix, display, width);
- }
-
- std::string unsigned_short_to_string(unsigned short i, unsigned radix, radix_display_t display, unsigned width)
- throw(std::invalid_argument)
- {
- return uimage(i, radix, display, width);
- }
-
- std::string int_to_string(int i, unsigned radix, radix_display_t display, unsigned width)
- throw(std::invalid_argument)
- {
- return simage(i, radix, display, width);
- }
-
- std::string unsigned_to_string(unsigned i, unsigned radix, radix_display_t display, unsigned width)
- throw(std::invalid_argument)
- {
- return uimage(i, radix, display, width);
- }
-
- std::string long_to_string(long i, unsigned radix, radix_display_t display, unsigned width)
- throw(std::invalid_argument)
- {
- return simage(i, radix, display, width);
- }
-
- std::string unsigned_long_to_string(unsigned long i, unsigned radix, radix_display_t display, unsigned width)
- throw(std::invalid_argument)
- {
- return uimage(i, radix, display, width);
- }
-
- ////////////////////////////////////////////////////////////////////////////////
- // Conversions FROM string
- // local template function
- // Note: this has been copied and modified for the inf class - so any changes here must be made there too
-
- // signed version
- template<typename T>
- static T svalue(const std::string& str, unsigned radix)
- throw(std::invalid_argument)
- {
- if (radix != 0 && (radix < 2 || radix > 36))
- throw std::invalid_argument("invalid radix value " + unsigned_to_string(radix));
- std::string::size_type i = 0;
- // the radix passed as a parameter is just the default - it can be
- // overridden by either the C prefix or the hash prefix. Note: a leading zero
- // is the C-style prefix for octal - I only make this override the default
- // when the default prefix is not specified
- // First check for a C-style prefix
- bool c_style = false;
- if (i < str.size() && str[i] == '0')
- {
- // octal, binary or hex
- if (i+1 < str.size() && tolower(str[i+1]) == 'x')
- {
- radix = 16;
- i += 2;
- c_style = true;
- }
- else if (i+1 < str.size() && tolower(str[i+1]) == 'b')
- {
- radix = 2;
- i += 2;
- c_style = true;
- }
- else if (radix == 0)
- {
- radix = 8;
- i += 1;
- c_style = true;
- }
- }
- // now check for a hash-style prefix if a C-style prefix was not found
- if (i == 0)
- {
- // scan for the sequence {digits}#
- bool hash_found = false;
- std::string::size_type j = i;
- for (; j < str.size(); j++)
- {
- if (!isdigit(str[j]))
- {
- if (str[j] == '#')
- hash_found = true;
- break;
- }
- }
- if (hash_found)
- {
- // use the hash prefix to define the radix
- // i points to the start of the radix and j points to the # character
- std::string slice = str.substr(i, j-i);
- radix = string_to_unsigned(slice);
- i = j+1;
- }
- }
- if (radix == 0)
- radix = 10;
- if (radix < 2 || radix > 36)
- throw std::invalid_argument("invalid radix value " + unsigned_to_string(radix));
- T val(0);
- if (c_style)
- {
- // the C style formats are bit patterns not integer values - these need
- // to be sign-extended to get the right value
- std::string binary;
- if (radix == 2)
- {
- for (std::string::size_type j = i; j < str.size(); j++)
- {
- switch(str[j])
- {
- case '0':
- binary += '0';
- break;
- case '1':
- binary += '1';
- break;
- default:
- throw std::invalid_argument("invalid binary character in string " + str);
- break;
- }
- }
- }
- else if (radix == 8)
- {
- for (std::string::size_type j = i; j < str.size(); j++)
- {
- switch(str[j])
- {
- case '0':
- binary += "000";
- break;
- case '1':
- binary += "001";
- break;
- case '2':
- binary += "010";
- break;
- case '3':
- binary += "011";
- break;
- case '4':
- binary += "100";
- break;
- case '5':
- binary += "101";
- break;
- case '6':
- binary += "110";
- break;
- case '7':
- binary += "111";
- break;
- default:
- throw std::invalid_argument("invalid octal character in string " + str);
- break;
- }
- }
- }
- else
- {
- for (std::string::size_type j = i; j < str.size(); j++)
- {
- switch(tolower(str[j]))
- {
- case '0':
- binary += "0000";
- break;
- case '1':
- binary += "0001";
- break;
- case '2':
- binary += "0010";
- break;
- case '3':
- binary += "0011";
- break;
- case '4':
- binary += "0100";
- break;
- case '5':
- binary += "0101";
- break;
- case '6':
- binary += "0110";
- break;
- case '7':
- binary += "0111";
- break;
- case '8':
- binary += "1000";
- break;
- case '9':
- binary += "1001";
- break;
- case 'a':
- binary += "1010";
- break;
- case 'b':
- binary += "1011";
- break;
- case 'c':
- binary += "1100";
- break;
- case 'd':
- binary += "1101";
- break;
- case 'e':
- binary += "1110";
- break;
- case 'f':
- binary += "1111";
- break;
- default:
- throw std::invalid_argument("invalid hex character in string " + str);
- break;
- }
- }
- }
- // now sign-extend to the right number of bits for the type
- while (binary.size() < sizeof(T)*8)
- binary.insert((std::string::size_type)0, 1, binary.empty() ? '0' : binary[0]);
- // now convert the value
- for (std::string::size_type j = 0; j < binary.size(); j++)
- {
- val *= 2;
- int ch = from_char[(unsigned char)binary[j]] ;
- val += T(ch);
- }
- }
- else
- {
- // now scan for a sign and find whether this is a negative number
- bool negative = false;
- if (i < str.size())
- {
- switch (str[i])
- {
- case '-':
- negative = true;
- i++;
- break;
- case '+':
- i++;
- break;
- }
- }
- for (; i < str.size(); i++)
- {
- val *= T(radix);
- int ch = from_char[(unsigned char)str[i]] ;
- if (ch == -1 || (unsigned)ch >= radix)
- throw std::invalid_argument("invalid character in string " + str);
- val += T(ch);
- }
- if (negative)
- val = -val;
- }
- return val;
- }
-
- // unsigned version
- template<typename T>
- static T uvalue(const std::string& str, unsigned radix)
- throw(std::invalid_argument)
- {
- if (radix != 0 && (radix < 2 || radix > 36))
- throw std::invalid_argument("invalid radix value " + unsigned_to_string(radix));
- unsigned i = 0;
- // the radix passed as a parameter is just the default - it can be
- // overridden by either the C prefix or the hash prefix. Note: a leading
- // zero is the C-style prefix for octal - I only make this override the
- // default when the default prefix is not specified
- // First check for a C-style prefix
- bool c_style = false;
- if (i < str.size() && str[i] == '0')
- {
- // binary or hex
- if (i+1 < str.size() && tolower(str[i+1]) == 'x')
- {
- radix = 16;
- i += 2;
- c_style = true;
- }
- else if (i+1 < str.size() && tolower(str[i+1]) == 'b')
- {
- radix = 2;
- i += 2;
- c_style = true;
- }
- else if (radix == 0)
- {
- radix = 8;
- i += 1;
- c_style = true;
- }
- }
- // now check for a hash-style prefix if a C-style prefix was not found
- if (i == 0)
- {
- // scan for the sequence {digits}#
- bool hash_found = false;
- unsigned j = i;
- for (; j < str.size(); j++)
- {
- if (!isdigit(str[j]))
- {
- if (str[j] == '#')
- hash_found = true;
- break;
- }
- }
- if (hash_found)
- {
- // use the hash prefix to define the radix
- // i points to the start of the radix and j points to the # character
- std::string slice = str.substr(i, j-i);
- radix = string_to_unsigned(slice);
- i = j+1;
- }
- }
- if (radix == 0)
- radix = 10;
- if (radix < 2 || radix > 36)
- throw std::invalid_argument("invalid radix value " + unsigned_to_string(radix));
- T val(0);
- if (c_style)
- {
- // the C style formats are bit patterns not integer values - these need
- // to be sign-extended to get the right value
- std::string binary;
- if (radix == 2)
- {
- for (unsigned j = i; j < str.size(); j++)
- {
- switch(str[j])
- {
- case '0':
- binary += '0';
- break;
- case '1':
- binary += '1';
- break;
- default:
- throw std::invalid_argument("invalid hex character in string " + str);
- break;
- }
- }
- }
- else if (radix == 8)
- {
- for (unsigned j = i; j < str.size(); j++)
- {
- switch(str[j])
- {
- case '0':
- binary += "000";
- break;
- case '1':
- binary += "001";
- break;
- case '2':
- binary += "010";
- break;
- case '3':
- binary += "011";
- break;
- case '4':
- binary += "100";
- break;
- case '5':
- binary += "101";
- break;
- case '6':
- binary += "110";
- break;
- case '7':
- binary += "111";
- break;
- default:
- throw std::invalid_argument("invalid octal character in string " + str);
- break;
- }
- }
- }
- else
- {
- for (unsigned j = i; j < str.size(); j++)
- {
- switch(tolower(str[j]))
- {
- case '0':
- binary += "0000";
- break;
- case '1':
- binary += "0001";
- break;
- case '2':
- binary += "0010";
- break;
- case '3':
- binary += "0011";
- break;
- case '4':
- binary += "0100";
- break;
- case '5':
- binary += "0101";
- break;
- case '6':
- binary += "0110";
- break;
- case '7':
- binary += "0111";
- break;
- case '8':
- binary += "1000";
- break;
- case '9':
- binary += "1001";
- break;
- case 'a':
- binary += "1010";
- break;
- case 'b':
- binary += "1011";
- break;
- case 'c':
- binary += "1100";
- break;
- case 'd':
- binary += "1101";
- break;
- case 'e':
- binary += "1110";
- break;
- case 'f':
- binary += "1111";
- break;
- default:
- throw std::invalid_argument("invalid hex character in string " + str);
- break;
- }
- }
- }
- // now zero-extend to the right number of bits for the type
- while (binary.size() < sizeof(T)*8)
- binary.insert((std::string::size_type)0, 1, '0');
- // now convert the value
- for (unsigned j = 0; j < binary.size(); j++)
- {
- val *= 2;
- int ch = from_char[(unsigned char)binary[j]] ;
- val += T(ch);
- }
- }
- else
- {
- // now scan for a sign and find whether this is a negative number
- if (i < str.size())
- {
- switch (str[i])
- {
- case '-':
- throw std::invalid_argument("invalid sign character in string " + str + " for unsigned value");
- i++;
- break;
- case '+':
- i++;
- break;
- }
- }
- for (; i < str.size(); i++)
- {
- val *= T(radix);
- int ch = from_char[(unsigned char)str[i]] ;
- if (ch == -1 || (unsigned)ch >= radix)
- {
- throw std::invalid_argument("invalid character in string " + str);
- }
- val += T(ch);
- }
- }
- return val;
- }
-
- ////////////////////////////////////////////////////////////////////////////////
- // exported functions
-
- short string_to_short(const std::string& str, unsigned radix)
- throw(std::invalid_argument)
- {
- return svalue<short>(str, radix);
- }
-
- unsigned short string_to_unsigned_short(const std::string& str, unsigned radix)
- throw(std::invalid_argument)
- {
- return uvalue<unsigned short>(str, radix);
- }
-
- int string_to_int(const std::string& str, unsigned radix)
- throw(std::invalid_argument)
- {
- return svalue<int>(str, radix);
- }
-
- unsigned string_to_unsigned(const std::string& str, unsigned radix)
- throw(std::invalid_argument)
- {
- return uvalue<unsigned>(str, radix);
- }
-
- long string_to_long(const std::string& str, unsigned radix)
- throw(std::invalid_argument)
- {
- return svalue<long>(str, radix);
- }
-
- unsigned long string_to_unsigned_long(const std::string& str, unsigned radix)
- throw(std::invalid_argument)
- {
- return uvalue<unsigned long>(str, radix);
- }
-
- ////////////////////////////////////////////////////////////////////////////////
-
-} // end namespace stlplus
projects / chaz / yoink / blobdiff