ACE/ace/ARGV.cpp

   1 #ifndef ACE_ARGV_CPP
   2 #define ACE_ARGV_CPP
   3
   4 #include "ace/Log_Category.h"
   5 #include "ace/OS_NS_unistd.h"
   6 #include "ace/OS_NS_string.h"
   7 #include "ace/OS_Memory.h"
   8
   9 #if !defined (__ACE_INLINE__)
  10 #include "ace/ARGV.inl"
  11 #endif /* __ACE_INLINE__ */
  12
  13 // Open versioned namespace, if enabled by the user.
  14 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
  15
  16 ACE_ALLOC_HOOK_DEFINE_Tt (ACE_ARGV_Queue_Entry_T)
  17 ACE_ALLOC_HOOK_DEFINE_Tt (ACE_ARGV_T)
  18
  19 template <typename CHAR_TYPE>
  20 void
  21 ACE_ARGV_Queue_Entry_T<CHAR_TYPE>::dump () const
  22 {
  23 #if defined (ACE_HAS_DUMP)
  24   ACE_TRACE ("ACE_ARGV_Queue_Entry_T::dump");
  25
  26   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
  27   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("arg_ = %s"), this->arg_));
  28   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("quote_arg_ = %d"), (int)this->quote_arg_));
  29   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
  30 #endif /* ACE_HAS_DUMP */
  31 }
  32
  33 template <typename CHAR_TYPE>
  34 void
  35 ACE_ARGV_T<CHAR_TYPE>::dump () const
  36 {
  37 #if defined (ACE_HAS_DUMP)
  38   ACE_TRACE ("ACE_ARGV_T::dump");
  39
  40   ACELIB_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
  41   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("argc_ = %d"), this->argc_));
  42
  43   ACE_ARGV *this_obj = const_cast<ACE_ARGV *> (this);
  44
  45   for (int i = 0; i < this->argc_; i++)
  46     ACELIB_DEBUG ((LM_DEBUG,
  47                 ACE_TEXT ("\nargv_[%i] = %s"),
  48                 i,
  49                 this_obj->argv ()[i]));
  50
  51   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("\nbuf = %s\n"), this->buf_));
  52   ACELIB_DEBUG ((LM_DEBUG,  ACE_TEXT ("\n")));
  53   ACELIB_DEBUG ((LM_DEBUG, ACE_END_DUMP));
  54 #endif /* ACE_HAS_DUMP */
  55 }
  56
  57 // Creates this->argv_ out of this->buf_.  New memory is allocated for
  58 // each element of the array.  This is used by the array-to-string
  59 // style constructor and for creating this->argv_ when in iterative
  60 // mode.
  61
  62 template <typename CHAR_TYPE>
  63 int
  64 ACE_ARGV_T<CHAR_TYPE>::string_to_argv ()
  65 {
  66   ACE_TRACE ("ACE_ARGV_T::string_to_argv");
  67
  68   return ACE_OS::string_to_argv (this->buf_,
  69                                  this->argc_,
  70                                  this->argv_,
  71                                  this->substitute_env_args_);
  72 }
  73
  74 template <typename CHAR_TYPE>
  75 ACE_ARGV_T<CHAR_TYPE>::ACE_ARGV_T (const CHAR_TYPE buf[],
  76                                    bool substitute_env_args)
  77   : substitute_env_args_ (substitute_env_args),
  78     iterative_ (false),
  79     argc_ (0),
  80     argv_ (0),
  81     buf_ (0),
  82     length_ (0),
  83     queue_ ()
  84 {
  85   ACE_TRACE ("ACE_ARGV_T::ACE_ARGV_T CHAR_TYPE[] to CHAR_TYPE *[]");
  86
  87   if (buf == 0 || buf[0] == 0)
  88     return;
  89
  90   // Make an internal copy of the string.
  91 #if defined (ACE_HAS_ALLOC_HOOKS)
  92   ACE_ALLOCATOR(this->buf_,
  93                           static_cast<char*> (ACE_Allocator::instance()->malloc(sizeof (CHAR_TYPE) * (ACE_OS::strlen (buf) + 1))));
  94 #else
  95   ACE_NEW (this->buf_,
  96            CHAR_TYPE[ACE_OS::strlen (buf) + 1]);
  97 #endif /* ACE_HAS_ALLOC_HOOKS */
  98
  99   ACE_OS::strcpy (this->buf_, buf);
 100
 101   // Create this->argv_.
 102   if (this->string_to_argv () == -1)
 103     ACELIB_ERROR ((LM_ERROR,
 104                 ACE_TEXT ("%p\n"),
 105                 ACE_TEXT ("string_to_argv")));
 106 }
 107
 108 template <typename CHAR_TYPE>
 109 ACE_ARGV_T<CHAR_TYPE>::ACE_ARGV_T (CHAR_TYPE *argv[],
 110                                    bool substitute_env_args,
 111                                    bool quote_arg)
 112   : substitute_env_args_ (substitute_env_args),
 113     iterative_ (false),
 114     argc_ (0),
 115     argv_ (0),
 116     buf_ (0),
 117     length_ (0),
 118     queue_ ()
 119 {
 120   ACE_TRACE ("ACE_ARGV_T::ACE_ARGV_T CHAR_TYPE*[] to CHAR_TYPE[]");
 121
 122   if (argv == 0 || argv[0] == 0)
 123     return;
 124
 125   this->argc_ = ACE_OS::argv_to_string (argv,
 126                                         this->buf_,
 127                                         substitute_env_args,
 128                                         quote_arg);
 129 }
 130
 131 template <typename CHAR_TYPE>
 132 ACE_ARGV_T<CHAR_TYPE>::ACE_ARGV_T (int argc,
 133                                    CHAR_TYPE *argv[],
 134                                    bool substitute_env_args,
 135                                    bool quote_arg)
 136   : substitute_env_args_ (substitute_env_args),
 137     iterative_ (false),
 138     argc_ (0),
 139     argv_ (0),
 140     buf_ (0),
 141     length_ (0),
 142     queue_ ()
 143 {
 144   ACE_TRACE ("ACE_ARGV_T::ACE_ARGV_T int,CHAR_TYPE*[] to CHAR_TYPE[]");
 145
 146   this->argc_ = ACE_OS::argv_to_string (argc,
 147                                         argv,
 148                                         this->buf_,
 149                                         substitute_env_args,
 150                                         quote_arg);
 151 }
 152
 153
 154 template <typename CHAR_TYPE>
 155 ACE_ARGV_T<CHAR_TYPE>::ACE_ARGV_T (CHAR_TYPE *first_argv[],
 156                                    CHAR_TYPE *second_argv[],
 157                                    bool substitute_env_args,
 158                                    bool quote_args)
 159   : substitute_env_args_ (substitute_env_args),
 160     iterative_ (false),
 161     argc_ (0),
 162     argv_ (0),
 163     buf_ (0),
 164     length_ (0),
 165     queue_ ()
 166 {
 167   ACE_TRACE ("ACE_ARGV_T::ACE_ARGV_T CHAR_TYPE*[] + CHAR_TYPE *[] to CHAR_TYPE[]");
 168
 169   int first_argc = 0;
 170   int second_argc = 0;
 171
 172   CHAR_TYPE *first_buf = 0;
 173   CHAR_TYPE *second_buf = 0;
 174   size_t buf_len = 1;
 175
 176   // convert the first argv to a string
 177   if (first_argv != 0 && first_argv[0] != 0)
 178     {
 179       first_argc = ACE_OS::argv_to_string (first_argv,
 180                                            first_buf,
 181                                            substitute_env_args,
 182                                            quote_args);
 183       buf_len += ACE_OS::strlen (first_buf);
 184     }
 185
 186   // convert the second argv to a string
 187   if (second_argv != 0 && second_argv[0] != 0)
 188     {
 189       second_argc = ACE_OS::argv_to_string (second_argv,
 190                                             second_buf,
 191                                             substitute_env_args,
 192                                             quote_args);
 193       buf_len += ACE_OS::strlen (second_buf);
 194     }
 195
 196   // Add the number of arguments in both the argvs.
 197   this->argc_ = first_argc + second_argc;
 198
 199   // Allocate memory to the lenght of the combined argv string.
 200   ACE_NEW (this->buf_,
 201            CHAR_TYPE[buf_len + 1]);
 202
 203   // copy the first argv string to the buffer
 204   ACE_OS::strcpy (this->buf_, first_buf);
 205
 206   // concatenate the second argv string to the buffer
 207   ACE_OS::strcat (this->buf_, second_buf);
 208
 209   //   Delete the first and second buffers
 210 #if defined (ACE_HAS_ALLOC_HOOKS)
 211   ACE_Allocator::instance()->free (first_buf);
 212   ACE_Allocator::instance()->free (second_buf);
 213 #else
 214   delete [] first_buf;
 215   delete [] second_buf;
 216 #endif /* ACE_HAS_ALLOC_HOOKS */
 217 }
 218
 219 template <typename CHAR_TYPE>
 220 ACE_ARGV_T<CHAR_TYPE>::ACE_ARGV_T (bool substitute_env_args)
 221   : substitute_env_args_ (substitute_env_args),
 222     iterative_ (true),
 223     argc_ (0),
 224     argv_ (0),
 225     buf_ (0),
 226     length_ (0),
 227     queue_ ()
 228 {
 229   ACE_TRACE ("ACE_ARGV_T::ACE_ARGV_T Iterative");
 230
 231   // Nothing to do yet -- the user puts in arguments via add ()
 232 }
 233
 234 template <typename CHAR_TYPE>
 235 int
 236 ACE_ARGV_T<CHAR_TYPE>::add (const CHAR_TYPE *next_arg, bool quote_arg)
 237 {
 238   // Only allow this to work in the "iterative" verion -- the
 239   // ACE_ARGVs created with the one argument constructor.
 240   if (!this->iterative_)
 241     {
 242       errno = EINVAL;
 243       return -1;
 244     }
 245
 246   this->length_ += ACE_OS::strlen (next_arg);
 247   if (quote_arg && ACE_OS::strchr (next_arg, ' ') != 0)
 248     {
 249       this->length_ += 2;
 250       if (ACE_OS::strchr (next_arg, '"') != 0)
 251         for (const CHAR_TYPE * p = next_arg; *p != '\0'; ++p)
 252           if (*p == '"') ++this->length_;
 253     }
 254   else
 255     {
 256       quote_arg = false;
 257     }
 258
 259   // Put the new argument at the end of the queue.
 260   if (this->queue_.enqueue_tail (ACE_ARGV_Queue_Entry_T<CHAR_TYPE> (next_arg, quote_arg)) == -1)
 261     ACELIB_ERROR_RETURN ((LM_ERROR,
 262                        ACE_TEXT ("Can't add more to ARGV queue")),
 263                       -1);
 264
 265   ++this->argc_;
 266
 267   // Wipe argv_ and buf_ away so that they will be recreated if the
 268   // user calls argv () or buf ().
 269   if (this->argv_ != 0)
 270     {
 271       for (int i = 0; this->argv_[i] != 0; i++)
 272         ACE_OS::free ((void *) this->argv_[i]);
 273
 274 #if defined (ACE_HAS_ALLOC_HOOKS)
 275       ACE_Allocator::instance()->free (this->argv_);
 276 #else
 277       delete [] this->argv_;
 278 #endif /* ACE_HAS_ALLOC_HOOKS */
 279       this->argv_ = 0;
 280     }
 281
 282 #if defined (ACE_HAS_ALLOC_HOOKS)
 283   ACE_Allocator::instance()->free (this->buf_);
 284 #else
 285   delete [] this->buf_;
 286 #endif /* ACE_HAS_ALLOC_HOOKS */
 287   this->buf_ = 0;
 288
 289   return 0;
 290 }
 291
 292 template <typename CHAR_TYPE>
 293 int
 294 ACE_ARGV_T<CHAR_TYPE>::add (CHAR_TYPE *argv[], bool quote_args)
 295 {
 296   for (int i = 0; argv[i] != 0; i++)
 297     if (this->add (argv[i], quote_args) == -1)
 298       return -1;
 299
 300   return 0;
 301 }
 302
 303 // Free up argv_ and buf_
 304 template <typename CHAR_TYPE>
 305 ACE_ARGV_T<CHAR_TYPE>::~ACE_ARGV_T ()
 306 {
 307   ACE_TRACE ("ACE_ARGV_T::~ACE_ARGV_T");
 308
 309   if (this->argv_ != 0)
 310     for (int i = 0; this->argv_[i] != 0; i++)
 311 #if defined (ACE_HAS_ALLOC_HOOKS)
 312       ACE_Allocator::instance()->free ((void *) this->argv_[i]);
 313 #else
 314       ACE_OS::free ((void *) this->argv_[i]);
 315 #endif /* ACE_HAS_ALLOC_HOOKS */
 316
 317
 318 #if defined (ACE_HAS_ALLOC_HOOKS)
 319   ACE_Allocator::instance()->free (this->argv_);
 320   ACE_Allocator::instance()->free (this->buf_);
 321 #else
 322   delete [] this->argv_;
 323   delete [] this->buf_;
 324 #endif /* ACE_HAS_ALLOC_HOOKS */
 325 }
 326
 327 // Create buf_ out of the queue_.  This is only used in the
 328 // "iterative" mode.
 329
 330 template <typename CHAR_TYPE>
 331 int
 332 ACE_ARGV_T<CHAR_TYPE>::create_buf_from_queue ()
 333 {
 334   ACE_TRACE ("ACE_ARGV_T::create_buf_from_queue");
 335
 336   // If the are no arguments, don't do anything
 337   if (this->argc_ <= 0)
 338     return -1;
 339
 340 #if defined (ACE_HAS_ALLOC_HOOKS)
 341   ACE_Allocator::instance()->free (this->buf_);
 342 #else
 343   delete [] this->buf_;
 344 #endif /* ACE_HAS_ALLOC_HOOKS */
 345
 346 #if defined (ACE_HAS_ALLOC_HOOKS)
 347   ACE_ALLOCATOR_RETURN (this->buf_,
 348                         static_cast<char*> (ACE_Allocator::instance()->malloc(sizeof (CHAR_TYPE) * (this->length_ + this->argc_))),
 349                         -1);
 350 #else
 351   ACE_NEW_RETURN (this->buf_,
 352                   CHAR_TYPE[this->length_ + this->argc_],
 353                   -1);
 354 #endif /* ACE_HAS_ALLOC_HOOKS */
 355
 356   // Get an iterator over the queue
 357   ACE_Unbounded_Queue_Iterator<ACE_ARGV_Queue_Entry_T<CHAR_TYPE> > iter (this->queue_);
 358
 359   ACE_ARGV_Queue_Entry_T<CHAR_TYPE> *arg = 0;
 360   CHAR_TYPE *ptr = this->buf_;
 361   size_t len;
 362
 363   while (!iter.done ())
 364     {
 365       // Get next argument from the queue.
 366       iter.next (arg);
 367       iter.advance ();
 368
 369       if (arg->quote_arg_)
 370         {
 371           *ptr++ = '"';
 372           if (ACE_OS::strchr (arg->arg_, '"') != 0)
 373             {
 374               CHAR_TYPE prev = 0;
 375               for (const CHAR_TYPE * p = arg->arg_; *p != '\0'; ++p)
 376                 {
 377                   if (*p == '"' && prev != '\\') *ptr++ = '\\';
 378                   prev = *ptr++ = *p;
 379                 }
 380             }
 381           else
 382             {
 383               len = ACE_OS::strlen (arg->arg_);
 384               // Copy the argument into buf_
 385               ACE_OS::memcpy ((void *) ptr,
 386                               (const void *) (arg->arg_),
 387                               len * sizeof (CHAR_TYPE));
 388               // Move the pointer down.
 389               ptr += len;
 390             }
 391           *ptr++ = '"';
 392         }
 393       else
 394         {
 395           len = ACE_OS::strlen (arg->arg_);
 396           // Copy the argument into buf_
 397           ACE_OS::memcpy ((void *) ptr,
 398                           (const void *) (arg->arg_),
 399                           len * sizeof (CHAR_TYPE));
 400           // Move the pointer down.
 401           ptr += len;
 402         }
 403
 404       // Put in an argument separating space.
 405       *ptr++ = ' ';
 406     }
 407
 408   // Put in the NUL terminator
 409   ptr[-1] = '\0';
 410
 411   return 0;
 412 }
 413
 414 // Close versioned namespace, if enabled by the user.
 415 ACE_END_VERSIONED_NAMESPACE_DECL
 416
 417 #endif /* ACE_ARGV_CPP */