1  /************************************************************************

     2  *

     3  * any.cpp - definitions of the rw_any_t class members

     4  *

     5  * $Id: any.cpp 345524 2005-11-18 17:08:11Z sebor $

     6  *

     7  ************************************************************************

     8  *

     9  * Copyright (c) 1994-2005 Quovadx,  Inc., acting through its  Rogue Wave

    10  * Software division. Licensed under the Apache License, Version 2.0 (the

    11  * "License");  you may  not use this file except  in compliance with the

    12  * License.    You    may   obtain   a   copy   of    the   License    at

    13  * http://www.apache.org/licenses/LICENSE-2.0.    Unless   required    by

    14  * applicable law  or agreed to  in writing,  software  distributed under

    15  * the License is distributed on an "AS IS" BASIS,  WITHOUT WARRANTIES OR

    16  * CONDITIONS OF  ANY KIND, either  express or implied.  See  the License

    17  * for the specific language governing permissions  and limitations under

    18  * the License.

    19  *

    20  **************************************************************************/

    21 

    22 // expand _TEST_EXPORT macros

    23 #define _RWSTD_TEST_SRC

    24 

    25 #include <any.h>

    26 

    27 #include <printf.h>   // for rw_sprintfa()

    28 #include <stdlib.h>   // for free()

    29 #include <string.h>   // for memset()

    30 

    31 

    32 #ifndef _RWSTD_NO_BOOL

    33 

    34 _TEST_EXPORT rw_any_t::rw_any_t (bool value)

    35     : str_ (0), tid_ (t_bool)

    36 {

    37     // using memset instead of default-initialization in the ctor

    38     // initializer list here and in all other ctors to work around

    39     // a SunPro -xarch=v9 bug (PR #28328) that causes the following:

    40     // Warning (Anachronism): Assigning int to __BIT_BLAST_16_16.

    41     // Error: Cannot cast from int to __BIT_BLAST_16_16

    42     

    43     memset (&val_, 0, sizeof val_);

    44     val_.bool_ = value;

    45 }

    46 

    47 #endif   // _RWSTD_NO_BOOL

    48 

    49 _TEST_EXPORT rw_any_t::rw_any_t (char value)

    50     : str_ (0), tid_ (t_char)

    51 {

    52     memset (&val_, 0, sizeof val_);

    53     val_.char_ = value;

    54 }

    55 

    56 

    57 _TEST_EXPORT rw_any_t::rw_any_t (signed char value)

    58     : str_ (0), tid_ (t_schar)

    59 {

    60     memset (&val_, 0, sizeof val_);

    61     val_.schar_ = value;

    62 }

    63 

    64 

    65 _TEST_EXPORT rw_any_t::rw_any_t (unsigned char value)

    66     : str_ (0), tid_ (t_uchar)

    67 {

    68     memset (&val_, 0, sizeof val_);

    69     val_.uchar_ = value;

    70 }

    71 

    72 

    73 _TEST_EXPORT rw_any_t::rw_any_t (signed short value)

    74     : str_ (0), tid_ (t_sshrt)

    75 {

    76     memset (&val_, 0, sizeof val_);

    77     val_.sshrt_ = value;

    78 }

    79 

    80 

    81 _TEST_EXPORT rw_any_t::rw_any_t (unsigned short value)

    82     : str_ (0), tid_ (t_ushrt)

    83 {

    84     memset (&val_, 0, sizeof val_);

    85     val_.ushrt_ = value;

    86 }

    87 

    88 

    89 _TEST_EXPORT rw_any_t::rw_any_t (signed int value)

    90     : str_ (0), tid_ (t_sint)

    91 {

    92     memset (&val_, 0, sizeof val_);

    93     val_.sint_ = value;

    94 }

    95 

    96 

    97 _TEST_EXPORT rw_any_t::rw_any_t (unsigned int value)

    98     : str_ (0), tid_ (t_uint)

    99 {

   100     memset (&val_, 0, sizeof val_);

   101     val_.uint_ = value;

   102 }

   103 

   104 

   105 _TEST_EXPORT rw_any_t::rw_any_t (signed long value)

   106     : str_ (0), tid_ (t_slong)

   107 {

   108     memset (&val_, 0, sizeof val_);

   109     val_.slong_ = value;

   110 }

   111 

   112 

   113 _TEST_EXPORT rw_any_t::rw_any_t (unsigned long value)

   114     : str_ (0), tid_ (t_ulong)

   115 {

   116     memset (&val_, 0, sizeof val_);

   117     val_.ulong_ = value;

   118 }

   119 

   120 

   121 #ifdef _RWSTD_LONG_LONG

   122 

   123 _TEST_EXPORT rw_any_t::rw_any_t (signed _RWSTD_LONG_LONG value)

   124     : str_ (0), tid_ (t_sllong)

   125 {

   126     memset (&val_, 0, sizeof val_);

   127     val_.sllong_ = value;

   128 }

   129 

   130 

   131 _TEST_EXPORT rw_any_t::rw_any_t (unsigned _RWSTD_LONG_LONG value)

   132     : str_ (0), tid_ (t_ullong)

   133 {

   134     memset (&val_, 0, sizeof val_);

   135     val_.ullong_ = value;

   136 }

   137 

   138 #endif   // _RWSTD_LONG_LONG

   139 

   140 

   141 _TEST_EXPORT rw_any_t::rw_any_t (float value)

   142     : str_ (0), tid_ (t_flt)

   143 {

   144     memset (&val_, 0, sizeof val_);

   145     val_.flt_ = value;

   146 }

   147 

   148 

   149 _TEST_EXPORT rw_any_t::rw_any_t (double value)

   150     : str_ (0), tid_ (t_dbl)

   151 {

   152     memset (&val_, 0, sizeof val_);

   153     val_.dbl_ = value;

   154 }

   155 

   156 

   157 #ifndef _RWSTD_NO_LONG_DOUBLE

   158 

   159 _TEST_EXPORT rw_any_t::rw_any_t (long double value)

   160     : str_ (0), tid_ (t_ldbl)

   161 {

   162     memset (&val_, 0, sizeof val_);

   163     val_.ldbl_ = value;

   164 }

   165 

   166 #endif   // _RWSTD_NO_LONG_DOUBLE

   167 

   168 

   169 _TEST_EXPORT rw_any_t::rw_any_t (const void* value)

   170     : str_ (0), tid_ (t_pvoid)

   171 {

   172     memset (&val_, 0, sizeof val_);

   173     val_.pvoid_ = value;

   174 }

   175 

   176 

   177 _TEST_EXPORT rw_any_t::rw_any_t (const char* value)

   178     : str_ (0), tid_ (t_str)

   179 {

   180     memset (&val_, 0, sizeof val_);

   181     val_.pvoid_ = value;

   182 }

   183 

   184 

   185 #ifndef _RWSTD_NO_NATIVE_WCHAR_T

   186 

   187 _TEST_EXPORT rw_any_t::rw_any_t (wchar_t value)

   188     : str_ (0), tid_ (t_wchar)

   189 {

   190     memset (&val_, 0, sizeof val_);

   191     val_.wchar_ = value;

   192 }

   193 

   194 #endif   // _RWSTD_NO_NATIVE_WCHAR_T

   195 

   196 

   197 #ifndef _RWSTD_NO_WCHAR_T

   198 

   199 _TEST_EXPORT rw_any_t::rw_any_t (const wchar_t* value)

   200     : str_ (0), tid_ (t_wstr)

   201 {

   202     memset (&val_, 0, sizeof val_);

   203     val_.pvoid_ = value;

   204 }

   205 

   206 #endif   // _RWSTD_NO_WCHAR_T

   207 

   208 

   209 _TEST_EXPORT rw_any_t::rw_any_t (const rw_any_t &rhs)

   210     : val_ (rhs.val_), str_ (0), tid_ (rhs.tid_)

   211 {

   212 }

   213 

   214 

   215 _TEST_EXPORT rw_any_t& rw_any_t::operator= (const rw_any_t &rhs)

   216 {

   217     // free string allocated by tostr() (via a call to sprintfa())

   218     free (str_);

   219 

   220     val_ = rhs.val_;

   221     str_ = 0;

   222     tid_ = rhs.tid_;

   223 

   224     return *this;

   225 }

   226 

   227 

   228 _TEST_EXPORT rw_any_t::~rw_any_t ()

   229 {

   230     // free string allocated by tostr() (via a call to sprintfa())

   231     free (str_);

   232 

   233     memset (&val_, 0, sizeof val_);

   234 

   235     str_ = 0;

   236     tid_ = type_id_t ();

   237 }

   238 

   239 

   240 _TEST_EXPORT const char*

   241 rw_any_t::type_name () const

   242 {

   243     static const char* const names[] = {

   244         "<no type>",

   245         "bool", "signed char", "unsigned char", "char",

   246         "short", "unsigned short", "int", "unsigned int",

   247         "long", "unsigned long",

   248         "long long", "unsigned long long",

   249         "float", "double", "long double",

   250         "wchar_t", "void*",

   251         "const char*", "const wchar_t*"

   252     };

   253 

   254     // the liftime of the returned string must extend

   255     // to the end of the program

   256     return names [tid_];

   257 }

   258 

   259 

   260 _TEST_EXPORT const char*

   261 rw_any_t::tostr (const char *fmt /* = 0 */)

   262 {

   263     // free the previously allocated string

   264     free (str_);

   265     str_ = 0;

   266 

   267     switch (tid_) {

   268     case t_none:

   269         return 0;

   270 

   271     case t_bool:

   272         return val_.bool_ ? "true" : "false";

   273 

   274     case t_char:

   275         if (0 == fmt)

   276             fmt = "%c";

   277         str_ = rw_sprintfa (fmt, val_.char_);

   278         break;

   279 

   280     case t_schar:

   281         if (0 == fmt)

   282             fmt = "%hhi";

   283         str_ = rw_sprintfa (fmt, val_.schar_);

   284         break;

   285 

   286     case t_uchar:

   287         if (0 == fmt)

   288             fmt = "%hhu";

   289         str_ = rw_sprintfa (fmt, val_.uchar_);

   290         break;

   291 

   292     case t_sshrt:

   293         if (0 == fmt)

   294             fmt = "%hi";

   295         str_ = rw_sprintfa (fmt, val_.sshrt_);

   296         break;

   297 

   298     case t_ushrt:

   299         if (0 == fmt)

   300             fmt = "%hu";

   301         str_ = rw_sprintfa (fmt, val_.ushrt_);

   302         break;

   303 

   304     case t_sint:

   305         if (0 == fmt)

   306             fmt = "%i";

   307         str_ = rw_sprintfa (fmt, val_.sint_);

   308         break;

   309 

   310     case t_uint:

   311         if (0 == fmt)

   312             fmt = "%u";

   313         str_ = rw_sprintfa (fmt, val_.uint_);

   314         break;

   315 

   316     case t_slong:

   317         if (0 == fmt)

   318             fmt = "%li";

   319         str_ = rw_sprintfa (fmt, val_.slong_);

   320         break;

   321 

   322     case t_ulong:

   323         if (0 == fmt)

   324             fmt = "%lu";

   325         str_ = rw_sprintfa (fmt, val_.ulong_);

   326         break;

   327 

   328 #ifdef _RWSTD_LONG_LONG

   329 

   330     case t_sllong:

   331         if (0 == fmt)

   332             fmt = "%lli";

   333         str_ = rw_sprintfa (fmt, val_.sllong_);

   334         break;

   335 

   336     case t_ullong:

   337         if (0 == fmt)

   338             fmt = "%llu";

   339         str_ = rw_sprintfa (fmt, val_.ullong_);

   340         break;

   341 

   342 #endif   // _RWSTD_LONG_LONG

   343 

   344     case t_flt:

   345         if (0 == fmt)

   346             fmt = "%g";

   347         str_ = rw_sprintfa (fmt, val_.flt_);

   348         break;

   349 

   350     case t_dbl:

   351         if (0 == fmt)

   352             fmt = "%g";

   353         str_ = rw_sprintfa (fmt, val_.dbl_);

   354         break;

   355 

   356 #ifndef _RWSTD_NO_LONG_DOUBLE

   357 

   358     case t_ldbl:

   359         if (0 == fmt)

   360             fmt = "%Lg";

   361         str_ = rw_sprintfa (fmt, val_.ldbl_);

   362         break;

   363 

   364 #endif   // _RWSTD_NO_LONG_DOUBLE

   365 

   366     case t_pvoid:

   367         if (0 == fmt)

   368             fmt = "%p";

   369         str_ = rw_sprintfa (fmt, val_.pvoid_);

   370         break;

   371 

   372 #ifndef _RWSTD_NO_NATIVE_WCHAR_T

   373 

   374     case t_wchar:

   375         if (0 == fmt)

   376             fmt = "%lc";

   377         str_ = rw_sprintfa (fmt, val_.wchar_);

   378         break;

   379 

   380 #endif   // _RWSTD_NO_NATIVE_WCHAR_T

   381 

   382     case t_str:

   383         if (0 == fmt)

   384             fmt = "%s";

   385         str_ = rw_sprintfa (fmt, val_.pvoid_);

   386         break;

   387 

   388 #ifndef _RWSTD_NO_WCHAR_T

   389 

   390     case t_wstr:

   391         if (0 == fmt)

   392             fmt = "%ls";

   393         str_ = rw_sprintfa (fmt, val_.pvoid_);

   394         break;

   395 

   396 #endif   // _RWSTD_NO_WCHAR_T

   397 

   398     }

   399 

   400     return str_;

   401 }