dep/ACE_wrappers/ace/SString.cpp

   1 // $Id: SString.cpp 80826 2008-03-04 14:51:23Z wotte $
   2
   3 #include "ace/Malloc_T.h"
   4 #include "ace/OS_Memory.h"
   5 #if !defined (ACE_HAS_WINCE)
   6 //# include "ace/Service_Config.h"
   7 #endif /* !ACE_HAS_WINCE */
   8 #include "ace/SString.h"
   9 #include "ace/Auto_Ptr.h"
  10 #include "ace/OS_NS_string.h"
  11 #include "ace/Numeric_Limits.h"
  12
  13 #if !defined (ACE_LACKS_IOSTREAM_TOTALLY)
  14 // FUZZ: disable check_for_streams_include
  15 # include "ace/streams.h"
  16 #endif /* ! ACE_LACKS_IOSTREAM_TOTALLY */
  17
  18 #if !defined (__ACE_INLINE__)
  19 #include "ace/SString.inl"
  20 #endif /* __ACE_INLINE__ */
  21
  22
  23 ACE_RCSID (ace,
  24            SString,
  25            "SString.cpp,v 4.61 2001/03/04 00:55:30 brunsch Exp")
  26
  27
  28 // ************************************************************
  29
  30 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  31
  32 #if !defined (ACE_LACKS_IOSTREAM_TOTALLY)
  33 ACE_OSTREAM_TYPE &
  34 operator<< (ACE_OSTREAM_TYPE &os, const ACE_CString &cs)
  35 {
  36   if (cs.fast_rep () != 0)
  37     os << cs.fast_rep ();
  38   return os;
  39 }
  40
  41 ACE_OSTREAM_TYPE &
  42 operator<< (ACE_OSTREAM_TYPE &os, const ACE_WString &ws)
  43 {
  44   // @@ Need to figure out how to print the "wide" string
  45   //    on platforms that don't support "wide" strings.
  46 #if defined (ACE_HAS_WCHAR)
  47   os << ACE_Wide_To_Ascii (ws.fast_rep ()).char_rep ();
  48 #else
  49   ACE_UNUSED_ARG (ws);
  50   os << "(*non-printable string*)";
  51 #endif
  52   return os;
  53 }
  54
  55 ACE_OSTREAM_TYPE &
  56 operator<< (ACE_OSTREAM_TYPE &os, const ACE_SString &ss)
  57 {
  58   if (ss.fast_rep () != 0)
  59     os << ss.fast_rep ();
  60   return os;
  61 }
  62 #endif /* !ACE_LACKS_IOSTREAM_TOTALLY */
  63
  64 // *****************************************************************
  65
  66 char *
  67 ACE_NS_WString::char_rep (void) const
  68 {
  69   ACE_TRACE ("ACE_NS_WString::char_rep");
  70   if (this->len_ == 0)
  71     return 0;
  72   else
  73     {
  74       char *t = 0;
  75
  76       ACE_NEW_RETURN (t,
  77                       char[this->len_ + 1],
  78                       0);
  79
  80       for (size_type i = 0; i < this->len_; ++i)
  81         // Note that this cast may lose data if wide chars are
  82         // actually used!
  83         t[i] = char (this->rep_[i]);
  84
  85       t[this->len_] = '\0';
  86       return t;
  87     }
  88 }
  89
  90 ACE_USHORT16 *
  91 ACE_NS_WString::ushort_rep (void) const
  92 {
  93   ACE_TRACE ("ACE_NS_WString::ushort_rep");
  94   if (this->len_ <= 0)
  95     return 0;
  96   else
  97     {
  98       ACE_USHORT16 *t = 0;
  99
 100       ACE_NEW_RETURN (t,
 101                       ACE_USHORT16[this->len_ + 1],
 102                       0);
 103
 104       for (size_type i = 0; i < this->len_; ++i)
 105         // Note that this cast may lose data if wide chars are
 106         // actually used!
 107         t[i] = (ACE_USHORT16)this->rep_[i];
 108
 109       t[this->len_] = 0;
 110       return t;
 111     }
 112 }
 113
 114 ACE_NS_WString::ACE_NS_WString (const char *s,
 115                                 ACE_Allocator *alloc)
 116   : ACE_WString (alloc)
 117 {
 118   if (s == 0)
 119     return;
 120
 121   this->len_ = this->buf_len_ = ACE_OS::strlen (s);
 122
 123   if (this->buf_len_ == 0)
 124     return;
 125
 126   ACE_ALLOCATOR (this->rep_,
 127                  (ACE_WSTRING_TYPE *)
 128                  this->allocator_->malloc ((this->buf_len_ + 1) *
 129                                            sizeof (ACE_WSTRING_TYPE)));
 130   this->release_ = 1;
 131   for (size_type i = 0; i <= this->buf_len_; ++i)
 132     this->rep_[i] = s[i];
 133 }
 134
 135 #if defined (ACE_WSTRING_HAS_USHORT_SUPPORT)
 136 ACE_NS_WString::ACE_NS_WString (const ACE_USHORT16 *s,
 137                                 size_type len,
 138                                 ACE_Allocator *alloc)
 139   : ACE_WString (alloc)
 140 {
 141   if (s == 0)
 142     return;
 143
 144   this->buf_len_ = len;
 145
 146   if (this->buf_len_ == 0)
 147     return;
 148
 149   ACE_ALLOCATOR (this->rep_,
 150                  (ACE_WSTRING_TYPE *)
 151                  this->allocator_->malloc ((this->buf_len_) *
 152                                            sizeof (ACE_WSTRING_TYPE)));
 153   this->release_ = 1;
 154   for (size_type i = 0; i < this->buf_len_; ++i)
 155     this->rep_[i] = s[i];
 156 }
 157 #endif /* ACE_WSTRING_HAS_USHORT_SUPPORT */
 158
 159 // *****************************************************************
 160
 161 ACE_SString::size_type const ACE_SString::npos =
 162   ACE_Numeric_Limits<ACE_SString::size_type>::max ();
 163
 164 ACE_ALLOC_HOOK_DEFINE(ACE_SString)
 165
 166 void
 167 ACE_SString::dump (void) const
 168 {
 169 #if defined (ACE_HAS_DUMP)
 170   ACE_TRACE ("ACE_SString::dump");
 171 #endif /* ACE_HAS_DUMP */
 172 }
 173
 174 // Copy constructor.
 175
 176 ACE_SString::ACE_SString (const ACE_SString &s)
 177   : allocator_ (s.allocator_),
 178     len_ (s.len_)
 179 {
 180   ACE_TRACE ("ACE_SString::ACE_SString");
 181
 182   if (this->allocator_ == 0)
 183     this->allocator_ = ACE_Allocator::instance ();
 184
 185   this->rep_ = (char *) this->allocator_->malloc (s.len_ + 1);
 186   ACE_OS::memcpy ((void *) this->rep_,
 187                   (const void *) s.rep_,
 188                   this->len_);
 189   this->rep_[this->len_] = '\0';
 190 }
 191
 192 // Default constructor.
 193
 194 ACE_SString::ACE_SString (ACE_Allocator *alloc)
 195   : allocator_ (alloc),
 196     len_ (0),
 197     rep_ (0)
 198
 199 {
 200   ACE_TRACE ("ACE_SString::ACE_SString");
 201
 202   if (this->allocator_ == 0)
 203     this->allocator_ = ACE_Allocator::instance ();
 204
 205   this->len_ = 0;
 206   this->rep_ = (char *) this->allocator_->malloc (this->len_ + 1);
 207   this->rep_[this->len_] = '\0';
 208 }
 209
 210 // Set the underlying pointer (does not copy memory).
 211
 212 void
 213 ACE_SString::rep (char *s)
 214 {
 215   ACE_TRACE ("ACE_SString::rep");
 216
 217   this->rep_ = s;
 218
 219   if (s == 0)
 220     this->len_ = 0;
 221   else
 222     this->len_ = ACE_OS::strlen (s);
 223 }
 224
 225 // Constructor that actually copies memory.
 226
 227 ACE_SString::ACE_SString (const char *s,
 228                           ACE_Allocator *alloc)
 229   : allocator_ (alloc)
 230 {
 231   ACE_TRACE ("ACE_SString::ACE_SString");
 232
 233   if (this->allocator_ == 0)
 234     this->allocator_ = ACE_Allocator::instance ();
 235
 236   if (s == 0)
 237     {
 238       this->len_ = 0;
 239       this->rep_ = (char *) this->allocator_->malloc (this->len_ + 1);
 240       this->rep_[this->len_] = '\0';
 241     }
 242   else
 243     {
 244       this->len_ = ACE_OS::strlen (s);
 245       this->rep_ = (char *) this->allocator_->malloc (this->len_ + 1);
 246       ACE_OS::strcpy (this->rep_, s);
 247     }
 248 }
 249
 250 ACE_SString::ACE_SString (char c,
 251                           ACE_Allocator *alloc)
 252   : allocator_ (alloc)
 253 {
 254   ACE_TRACE ("ACE_SString::ACE_SString");
 255
 256   if (this->allocator_ == 0)
 257     this->allocator_ = ACE_Allocator::instance ();
 258
 259   this->len_ = 1;
 260   this->rep_ = (char *) this->allocator_->malloc (this->len_ + 1);
 261   this->rep_[0] = c;
 262   this->rep_[this->len_] = '\0';
 263 }
 264
 265 // Constructor that actually copies memory.
 266
 267 ACE_SString::ACE_SString (const char *s,
 268                           size_type len,
 269                           ACE_Allocator *alloc)
 270   : allocator_ (alloc)
 271 {
 272   ACE_TRACE ("ACE_SString::ACE_SString");
 273
 274   if (this->allocator_ == 0)
 275     this->allocator_ = ACE_Allocator::instance ();
 276
 277   if (s == 0)
 278     {
 279       this->len_ = 0;
 280       this->rep_ = (char *) this->allocator_->malloc (this->len_ + 1);
 281       this->rep_[this->len_] = '\0';
 282     }
 283   else
 284     {
 285       this->len_ = len;
 286       this->rep_ = (char *) this->allocator_->malloc (this->len_ + 1);
 287       ACE_OS::memcpy (this->rep_, s, len);
 288       this->rep_[len] = '\0'; // Make sure to NUL terminate this!
 289     }
 290 }
 291
 292 // Assignment operator (does copy memory).
 293
 294 ACE_SString &
 295 ACE_SString::operator= (const ACE_SString &s)
 296 {
 297   ACE_TRACE ("ACE_SString::operator=");
 298   // Check for identify.
 299
 300   if (this != &s)
 301     {
 302       // Only reallocate if we don't have enough space...
 303       if (this->len_ < s.len_)
 304         {
 305           this->allocator_->free (this->rep_);
 306           this->rep_ = (char *) this->allocator_->malloc (s.len_ + 1);
 307         }
 308       this->len_ = s.len_;
 309       ACE_OS::strcpy (this->rep_, s.rep_);
 310     }
 311
 312   return *this;
 313 }
 314
 315 // Return substring.
 316 ACE_SString
 317 ACE_SString::substring (size_type offset,
 318                         size_type length) const
 319 {
 320   size_t count = length;
 321
 322   // case 1. empty string
 323   if (len_ == 0)
 324     return ACE_SString ();
 325
 326   // case 2. start pos l
 327   if (offset >= len_)
 328     return ACE_SString ();
 329
 330   // get all remaining bytes
 331   if (length == npos || count > (this->len_ - offset))
 332     count = len_ - offset;
 333
 334   return ACE_SString (&rep_[offset], count, this->allocator_);
 335 }
 336
 337 // ************************************************************
 338
 339 ACE_Tokenizer::ACE_Tokenizer (ACE_TCHAR *buffer)
 340   : buffer_ (buffer),
 341     index_ (0),
 342     preserves_index_ (0),
 343     delimiter_index_ (0)
 344 {
 345 }
 346
 347 int
 348 ACE_Tokenizer::delimiter (ACE_TCHAR d)
 349 {
 350   if (delimiter_index_ == MAX_DELIMITERS)
 351     return -1;
 352
 353   delimiters_[delimiter_index_].delimiter_ = d;
 354   delimiters_[delimiter_index_].replace_ = 0;
 355   delimiter_index_++;
 356   return 0;
 357 }
 358
 359 int
 360 ACE_Tokenizer::delimiter_replace (ACE_TCHAR d,
 361                                   ACE_TCHAR replacement)
 362 {
 363   // Make it possible to replace delimiters on-the-fly, e.g., parse
 364   // string until certain token count and then copy rest of the
 365   // original string.
 366   for (int i = 0; i < delimiter_index_; i++)
 367     if (delimiters_[i].delimiter_ == d)
 368       {
 369         delimiters_[i].replacement_ = replacement;
 370         delimiters_[i].replace_ = 1;
 371         return 0;
 372       }
 373
 374   if (delimiter_index_ >= MAX_DELIMITERS)
 375     return -1;
 376
 377   delimiters_[delimiter_index_].delimiter_ = d;
 378   delimiters_[delimiter_index_].replacement_ = replacement;
 379   delimiters_[delimiter_index_].replace_ = 1;
 380   delimiter_index_++;
 381   return 0;
 382 }
 383
 384 int
 385 ACE_Tokenizer::preserve_designators (ACE_TCHAR start,
 386                                      ACE_TCHAR stop,
 387                                      int strip)
 388 {
 389   if (preserves_index_ == MAX_PRESERVES)
 390     return -1;
 391
 392   preserves_[preserves_index_].start_ = start;
 393   preserves_[preserves_index_].stop_ = stop;
 394   preserves_[preserves_index_].strip_ = strip;
 395   preserves_index_++;
 396   return 0;
 397 }
 398
 399 int
 400 ACE_Tokenizer::is_delimiter (ACE_TCHAR d,
 401                              int &replace,
 402                              ACE_TCHAR &r)
 403 {
 404   replace = 0;
 405
 406   for (int x = 0; x < delimiter_index_; x++)
 407     if (delimiters_[x].delimiter_ == d)
 408       {
 409         if (delimiters_[x].replace_)
 410           {
 411             r = delimiters_[x].replacement_;
 412             replace = 1;
 413           }
 414         return 1;
 415       }
 416
 417   return 0;
 418 }
 419
 420 int
 421 ACE_Tokenizer::is_preserve_designator (ACE_TCHAR start,
 422                                        ACE_TCHAR &stop,
 423                                        int &strip)
 424 {
 425   for (int x = 0; x < preserves_index_; x++)
 426     if (preserves_[x].start_ == start)
 427       {
 428         stop = preserves_[x].stop_;
 429         strip = preserves_[x].strip_;
 430         return 1;
 431       }
 432
 433   return 0;
 434 }
 435
 436 ACE_TCHAR *
 437 ACE_Tokenizer::next (void)
 438 {
 439   // Check if the previous pass was the last one in the buffer.
 440   if (index_ == -1)
 441     {
 442       index_ = 0;
 443       return 0;
 444     }
 445
 446   ACE_TCHAR replacement = 0;
 447   int replace;
 448   ACE_TCHAR *next_token;
 449
 450   // Skip all leading delimiters.
 451   for (;;)
 452     {
 453       // Check for end of string.
 454       if (buffer_[index_] == '\0')
 455         {
 456           // If we hit EOS at the start, return 0.
 457           index_ = 0;
 458           return 0;
 459         }
 460
 461       if (this->is_delimiter (buffer_[index_],
 462                               replace,
 463                               replacement))
 464         index_++;
 465       else
 466         break;
 467     }
 468
 469   // When we reach this point, buffer_[index_] is a non-delimiter and
 470   // not EOS - the start of our next_token.
 471   next_token = buffer_ + index_;
 472
 473   // A preserved region is it's own token.
 474   ACE_TCHAR stop;
 475   int strip;
 476   if (this->is_preserve_designator (buffer_[index_],
 477                                     stop,
 478                                     strip))
 479     {
 480       while (++index_)
 481         {
 482           if (buffer_[index_] == '\0')
 483             {
 484               index_ = -1;
 485               goto EXIT_LABEL;
 486             }
 487
 488           if (buffer_[index_] == stop)
 489             break;
 490         }
 491
 492       if (strip)
 493         {
 494           // Skip start preserve designator.
 495           next_token += 1;
 496           // Zap the stop preserve designator.
 497           buffer_[index_] = '\0';
 498           // Increment to the next token.
 499           index_++;
 500         }
 501
 502       goto EXIT_LABEL;
 503     }
 504
 505   // Step through finding the next delimiter or EOS.
 506   for (;;)
 507     {
 508       // Advance pointer.
 509       index_++;
 510
 511       // Check for delimiter.
 512       if (this->is_delimiter (buffer_[index_],
 513                               replace,
 514                               replacement))
 515         {
 516           // Replace the delimiter.
 517           if (replace != 0)
 518             buffer_[index_] = replacement;
 519
 520           // Move the pointer up and return.
 521           index_++;
 522           goto EXIT_LABEL;
 523         }
 524
 525       // A preserve designator signifies the end of this token.
 526       if (this->is_preserve_designator (buffer_[index_],
 527                                         stop,
 528                                         strip))
 529         goto EXIT_LABEL;
 530
 531       // Check for end of string.
 532       if (buffer_[index_] == '\0')
 533         {
 534           index_ = -1;
 535           goto EXIT_LABEL;
 536         }
 537     }
 538
 539 EXIT_LABEL:
 540   return next_token;
 541 }
 542
 543 // *************************************************************
 544
 545 #if defined (ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION)
 546 template char ACE_String_Base<char>::NULL_String_;
 547 template ACE_WSTRING_TYPE ACE_String_Base<ACE_WSTRING_TYPE>::NULL_String_;
 548 #endif /* ACE_HAS_EXPLICIT_STATIC_TEMPLATE_MEMBER_INSTANTIATION */
 549
 550 ACE_END_VERSIONED_NAMESPACE_DECL