granicus.if.org Git - imagemagick/blob - MagickCore/string.c

   1 /*
   2 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
   3 %                                                                             %
   4 %                                                                             %
   5 %                                                                             %
   6 %                  SSSSS   TTTTT  RRRR   IIIII  N   N   GGGG                  %
   7 %                  SS        T    R   R    I    NN  N  G                      %
   8 %                   SSS      T    RRRR     I    N N N  G GGG                  %
   9 %                     SS     T    R R      I    N  NN  G   G                  %
  10 %                  SSSSS     T    R  R   IIIII  N   N   GGGG                  %
  11 %                                                                             %
  12 %                                                                             %
  13 %                        MagickCore String Methods                            %
  14 %                                                                             %
  15 %                             Software Design                                 %
  16 %                               John Cristy                                   %
  17 %                               August 2003                                   %
  18 %                                                                             %
  19 %                                                                             %
  20 %  Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization      %
  21 %  dedicated to making software imaging solutions freely available.           %
  22 %                                                                             %
  23 %  You may not use this file except in compliance with the License.  You may  %
  24 %  obtain a copy of the License at                                            %
  25 %                                                                             %
  26 %    http://www.imagemagick.org/script/license.php                            %
  27 %                                                                             %
  28 %  Unless required by applicable law or agreed to in writing, software        %
  29 %  distributed under the License is distributed on an "AS IS" BASIS,          %
  30 %  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   %
  31 %  See the License for the specific language governing permissions and        %
  32 %  limitations under the License.                                             %
  33 %                                                                             %
  34 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  35 %
  36 %
  37 */
  38 \f
  39 /*
  40   Include declarations.
  41 */
  42 #include "MagickCore/studio.h"
  43 #include "MagickCore/blob.h"
  44 #include "MagickCore/blob-private.h"
  45 #include "MagickCore/exception.h"
  46 #include "MagickCore/exception-private.h"
  47 #include "MagickCore/list.h"
  48 #include "MagickCore/locale_.h"
  49 #include "MagickCore/log.h"
  50 #include "MagickCore/memory_.h"
  51 #include "MagickCore/property.h"
  52 #include "MagickCore/resource_.h"
  53 #include "MagickCore/signature-private.h"
  54 #include "MagickCore/string_.h"
  55 #include "MagickCore/utility-private.h"
  56 \f
  57 /*
  58   Static declarations.
  59 */
  60 #if !defined(MAGICKCORE_HAVE_STRCASECMP) || !defined(MAGICKCORE_HAVE_STRNCASECMP)
  61 static const unsigned char
  62   AsciiMap[] =
  63   {
  64     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
  65     0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
  66     0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
  67     0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
  68     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
  69     0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
  70     0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73,
  71     0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
  72     0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
  73     0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
  74     0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83,
  75     0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
  76     0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
  77     0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
  78     0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
  79     0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
  80     0xc0, 0xe1, 0xe2, 0xe3, 0xe4, 0xc5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb,
  81     0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
  82     0xf8, 0xf9, 0xfa, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3,
  83     0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
  84     0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb,
  85     0xfc, 0xfd, 0xfe, 0xff,
  86   };
  87 #endif
  88 \f
  89 /*
  90 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  91 %                                                                             %
  92 %                                                                             %
  93 %                                                                             %
  94 %   A c q u i r e S t r i n g                                                 %
  95 %                                                                             %
  96 %                                                                             %
  97 %                                                                             %
  98 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
  99 %
 100 %  AcquireString() allocates memory for a string and copies the source string
 101 %  to that memory location (and returns it).
 102 %
 103 %  The format of the AcquireString method is:
 104 %
 105 %      char *AcquireString(const char *source)
 106 %
 107 %  A description of each parameter follows:
 108 %
 109 %    o source: A character string.
 110 %
 111 */
 112 MagickExport char *AcquireString(const char *source)
 113 {
 114   char
 115     *destination;
 116
 117   size_t
 118     length;
 119
 120   length=0;
 121   if (source != (char *) NULL)
 122     length+=strlen(source);
 123   if (~length < MaxTextExtent)
 124     ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
 125   destination=(char *) AcquireQuantumMemory(length+MaxTextExtent,
 126     sizeof(*destination));
 127   if (destination == (char *) NULL)
 128     ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
 129   *destination='\0';
 130   if (source != (char *) NULL)
 131     (void) memcpy(destination,source,length*sizeof(*destination));
 132   destination[length]='\0';
 133   return(destination);
 134 }
 135 \f
 136 /*
 137 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 138 %                                                                             %
 139 %                                                                             %
 140 %                                                                             %
 141 %   A c q u i r e S t r i n g I n f o                                         %
 142 %                                                                             %
 143 %                                                                             %
 144 %                                                                             %
 145 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 146 %
 147 %  AcquireStringInfo() allocates the StringInfo structure.
 148 %
 149 %  The format of the AcquireStringInfo method is:
 150 %
 151 %      StringInfo *AcquireStringInfo(const size_t length)
 152 %
 153 %  A description of each parameter follows:
 154 %
 155 %    o length: the string length.
 156 %
 157 */
 158 MagickExport StringInfo *AcquireStringInfo(const size_t length)
 159 {
 160   StringInfo
 161     *string_info;
 162
 163   string_info=(StringInfo *) AcquireMagickMemory(sizeof(*string_info));
 164   if (string_info == (StringInfo *) NULL)
 165     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
 166   (void) ResetMagickMemory(string_info,0,sizeof(*string_info));
 167   string_info->signature=MagickSignature;
 168   string_info->length=length;
 169   if (string_info->length != 0)
 170     {
 171       string_info->datum=(unsigned char *) NULL;
 172       if (~string_info->length >= (MaxTextExtent-1))
 173         string_info->datum=(unsigned char *) AcquireQuantumMemory(
 174           string_info->length+MaxTextExtent,sizeof(*string_info->datum));
 175       if (string_info->datum == (unsigned char *) NULL)
 176         ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
 177     }
 178   return(string_info);
 179 }
 180 \f
 181 /*
 182 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 183 %                                                                             %
 184 %                                                                             %
 185 %                                                                             %
 186 %   B l o b T o S t r i n g I n f o                                           %
 187 %                                                                             %
 188 %                                                                             %
 189 %                                                                             %
 190 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 191 %
 192 %  BlobToStringInfo() returns the contents of a blob as a string.
 193 %
 194 %  The format of the BlobToStringInfo method is:
 195 %
 196 %      StringInfo *BlobToStringInfo(const void *blob,const size_t length)
 197 %
 198 %  A description of each parameter follows:
 199 %
 200 %    o blob: the blob.
 201 %
 202 %    o length: the length of the blob.
 203 %
 204 */
 205 MagickExport StringInfo *BlobToStringInfo(const void *blob,const size_t length)
 206 {
 207   StringInfo
 208     *string_info;
 209
 210   string_info=AcquireStringInfo(0);
 211   string_info->length=length;
 212   if (~string_info->length >= (MaxTextExtent-1))
 213     string_info->datum=(unsigned char *) AcquireQuantumMemory(
 214       string_info->length+MaxTextExtent,sizeof(*string_info->datum));
 215   if (string_info->datum == (unsigned char *) NULL)
 216     {
 217       string_info=DestroyStringInfo(string_info);
 218       return((StringInfo *) NULL);
 219     }
 220   if (blob != (const void *) NULL)
 221     (void) memcpy(string_info->datum,blob,length);
 222   return(string_info);
 223 }
 224 \f
 225 /*
 226 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 227 %                                                                             %
 228 %                                                                             %
 229 %                                                                             %
 230 %   C l o n e S t r i n g                                                     %
 231 %                                                                             %
 232 %                                                                             %
 233 %                                                                             %
 234 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 235 %
 236 %  CloneString() allocates memory for the destination string and copies
 237 %  the source string to that memory location.
 238 %
 239 %  The format of the CloneString method is:
 240 %
 241 %      char *CloneString(char **destination,const char *source)
 242 %
 243 %  A description of each parameter follows:
 244 %
 245 %    o destination:  A pointer to a character string.
 246 %
 247 %    o source: A character string.
 248 %
 249 */
 250 MagickExport char *CloneString(char **destination,const char *source)
 251 {
 252   size_t
 253     length;
 254
 255   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 256   assert(destination != (char **) NULL);
 257   if (source == (const char *) NULL)
 258     {
 259       if (*destination != (char *) NULL)
 260         *destination=DestroyString(*destination);
 261       return(*destination);
 262     }
 263   if (*destination == (char *) NULL)
 264     {
 265       *destination=AcquireString(source);
 266       return(*destination);
 267     }
 268   length=strlen(source);
 269   if (~length < MaxTextExtent)
 270     ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
 271   *destination=(char *) ResizeQuantumMemory(*destination,length+MaxTextExtent,
 272     sizeof(**destination));
 273   if (*destination == (char *) NULL)
 274     ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
 275   if (length != 0)
 276     (void) memcpy(*destination,source,length*sizeof(**destination));
 277   (*destination)[length]='\0';
 278   return(*destination);
 279 }
 280 \f
 281 /*
 282 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 283 %                                                                             %
 284 %                                                                             %
 285 %                                                                             %
 286 %   C l o n e S t r i n g I n f o                                             %
 287 %                                                                             %
 288 %                                                                             %
 289 %                                                                             %
 290 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 291 %
 292 %  CloneStringInfo() clones a copy of the StringInfo structure.
 293 %
 294 %  The format of the CloneStringInfo method is:
 295 %
 296 %      StringInfo *CloneStringInfo(const StringInfo *string_info)
 297 %
 298 %  A description of each parameter follows:
 299 %
 300 %    o string_info: the string info.
 301 %
 302 */
 303 MagickExport StringInfo *CloneStringInfo(const StringInfo *string_info)
 304 {
 305   StringInfo
 306     *clone_info;
 307
 308   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 309   assert(string_info != (StringInfo *) NULL);
 310   assert(string_info->signature == MagickSignature);
 311   clone_info=AcquireStringInfo(string_info->length);
 312   if (string_info->length != 0)
 313     (void) memcpy(clone_info->datum,string_info->datum,string_info->length+1);
 314   return(clone_info);
 315 }
 316 \f
 317 /*
 318 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 319 %                                                                             %
 320 %                                                                             %
 321 %                                                                             %
 322 %   C o m p a r e S t r i n g I n f o                                         %
 323 %                                                                             %
 324 %                                                                             %
 325 %                                                                             %
 326 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 327 %
 328 %  CompareStringInfo() compares the two datums target and source.  It returns
 329 %  an integer less than, equal to, or greater than zero if target is found,
 330 %  respectively, to be less than, to match, or be greater than source.
 331 %
 332 %  The format of the CompareStringInfo method is:
 333 %
 334 %      int CompareStringInfo(const StringInfo *target,const StringInfo *source)
 335 %
 336 %  A description of each parameter follows:
 337 %
 338 %    o target: the target string.
 339 %
 340 %    o source: the source string.
 341 %
 342 */
 343
 344 static inline size_t MagickMin(const size_t x,const size_t y)
 345 {
 346   if (x < y)
 347     return(x);
 348   return(y);
 349 }
 350
 351 MagickExport int CompareStringInfo(const StringInfo *target,
 352   const StringInfo *source)
 353 {
 354   int
 355     status;
 356
 357   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 358   assert(target != (StringInfo *) NULL);
 359   assert(target->signature == MagickSignature);
 360   assert(source != (StringInfo *) NULL);
 361   assert(source->signature == MagickSignature);
 362   status=memcmp(target->datum,source->datum,MagickMin(target->length,
 363     source->length));
 364   if (status != 0)
 365     return(status);
 366   if (target->length == source->length)
 367     return(0);
 368   return(target->length < source->length ? -1 : 1);
 369 }
 370 \f
 371 /*
 372 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 373 %                                                                             %
 374 %                                                                             %
 375 %                                                                             %
 376 %   C o n c a t e n a t e M a g i c k S t r i n g                             %
 377 %                                                                             %
 378 %                                                                             %
 379 %                                                                             %
 380 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 381 %
 382 %  ConcatenateMagickString() concatenates the source string to the destination
 383 %  string.  The destination buffer is always null-terminated even if the
 384 %  string must be truncated.
 385 %
 386 %  The format of the ConcatenateMagickString method is:
 387 %
 388 %      size_t ConcatenateMagickString(char *destination,const char *source,
 389 %        const size_t length)
 390 %
 391 %  A description of each parameter follows:
 392 %
 393 %    o destination: the destination string.
 394 %
 395 %    o source: the source string.
 396 %
 397 %    o length: the length of the destination string.
 398 %
 399 */
 400 MagickExport size_t ConcatenateMagickString(char *destination,
 401   const char *source,const size_t length)
 402 {
 403   register char
 404     *q;
 405
 406   register const char
 407     *p;
 408
 409   register size_t
 410     i;
 411
 412   size_t
 413     count;
 414
 415   assert(destination != (char *) NULL);
 416   assert(source != (const char *) NULL);
 417   assert(length >= 1);
 418   p=source;
 419   q=destination;
 420   i=length;
 421   while ((i-- != 0) && (*q != '\0'))
 422     q++;
 423   count=(size_t) (q-destination);
 424   i=length-count;
 425   if (i == 0)
 426     return(count+strlen(p));
 427   while (*p != '\0')
 428   {
 429     if (i != 1)
 430       {
 431         *q++=(*p);
 432         i--;
 433       }
 434     p++;
 435   }
 436   *q='\0';
 437   return(count+(p-source));
 438 }
 439 \f
 440 /*
 441 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 442 %                                                                             %
 443 %                                                                             %
 444 %                                                                             %
 445 %   C o n c a t e n a t e S t r i n g                                         %
 446 %                                                                             %
 447 %                                                                             %
 448 %                                                                             %
 449 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 450 %
 451 %  ConcatenateString() appends a copy of string source, including the
 452 %  terminating null character, to the end of string destination.
 453 %
 454 %  The format of the ConcatenateString method is:
 455 %
 456 %      MagickBooleanType ConcatenateString(char **destination,
 457 %        const char *source)
 458 %
 459 %  A description of each parameter follows:
 460 %
 461 %    o destination:  A pointer to a character string.
 462 %
 463 %    o source: A character string.
 464 %
 465 */
 466 MagickExport MagickBooleanType ConcatenateString(char **destination,
 467   const char *source)
 468 {
 469   size_t
 470     destination_length,
 471     length,
 472     source_length;
 473
 474   assert(destination != (char **) NULL);
 475   if (source == (const char *) NULL)
 476     return(MagickTrue);
 477   if (*destination == (char *) NULL)
 478     {
 479       *destination=AcquireString(source);
 480       return(MagickTrue);
 481     }
 482   destination_length=strlen(*destination);
 483   source_length=strlen(source);
 484   length=destination_length;
 485   if (~length < source_length)
 486     ThrowFatalException(ResourceLimitFatalError,"UnableToConcatenateString");
 487   length+=source_length;
 488   if (~length < MaxTextExtent)
 489     ThrowFatalException(ResourceLimitFatalError,"UnableToConcatenateString");
 490   *destination=(char *) ResizeQuantumMemory(*destination,length+MaxTextExtent,
 491     sizeof(**destination));
 492   if (*destination == (char *) NULL)
 493     ThrowFatalException(ResourceLimitFatalError,"UnableToConcatenateString");
 494   if (source_length != 0)
 495     (void) memcpy((*destination)+destination_length,source,source_length);
 496   (*destination)[length]='\0';
 497   return(MagickTrue);
 498 }
 499 \f
 500 /*
 501 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 502 %                                                                             %
 503 %                                                                             %
 504 %                                                                             %
 505 %   C o n c a t e n a t e S t r i n g I n f o                                 %
 506 %                                                                             %
 507 %                                                                             %
 508 %                                                                             %
 509 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 510 %
 511 %  ConcatenateStringInfo() concatenates the source string to the destination
 512 %  string.
 513 %
 514 %  The format of the ConcatenateStringInfo method is:
 515 %
 516 %      void ConcatenateStringInfo(StringInfo *string_info,
 517 %        const StringInfo *source)
 518 %
 519 %  A description of each parameter follows:
 520 %
 521 %    o string_info: the string info.
 522 %
 523 %    o source: the source string.
 524 %
 525 */
 526 MagickExport void ConcatenateStringInfo(StringInfo *string_info,
 527   const StringInfo *source)
 528 {
 529   size_t
 530     length;
 531
 532   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 533   assert(string_info != (StringInfo *) NULL);
 534   assert(string_info->signature == MagickSignature);
 535   assert(source != (const StringInfo *) NULL);
 536   length=string_info->length;
 537   if (~length < source->length)
 538     ThrowFatalException(ResourceLimitFatalError,"UnableToConcatenateString");
 539   SetStringInfoLength(string_info,length+source->length);
 540   (void) memcpy(string_info->datum+length,source->datum,source->length);
 541 }
 542 \f
 543 /*
 544 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 545 %                                                                             %
 546 %                                                                             %
 547 %                                                                             %
 548 %   C o n f i g u r e F i l e T o S t r i n g I n f o                         %
 549 %                                                                             %
 550 %                                                                             %
 551 %                                                                             %
 552 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 553 %
 554 %  ConfigureFileToStringInfo() returns the contents of a configure file as a
 555 %  string.
 556 %
 557 %  The format of the ConfigureFileToStringInfo method is:
 558 %
 559 %      StringInfo *ConfigureFileToStringInfo(const char *filename)
 560 %        ExceptionInfo *exception)
 561 %
 562 %  A description of each parameter follows:
 563 %
 564 %    o filename: the filename.
 565 %
 566 */
 567 MagickPrivate StringInfo *ConfigureFileToStringInfo(const char *filename)
 568 {
 569   char
 570     *string;
 571
 572   int
 573     file;
 574
 575   MagickOffsetType
 576     offset;
 577
 578   size_t
 579     length;
 580
 581   StringInfo
 582     *string_info;
 583
 584   void
 585     *map;
 586
 587   assert(filename != (const char *) NULL);
 588   file=open_utf8(filename,O_RDONLY | O_BINARY,0);
 589   if (file == -1)
 590     return((StringInfo *) NULL);
 591   offset=(MagickOffsetType) lseek(file,0,SEEK_END);
 592   if ((offset < 0) || (offset != (MagickOffsetType) ((ssize_t) offset)))
 593     {
 594       file=close(file)-1;
 595       return((StringInfo *) NULL);
 596     }
 597   length=(size_t) offset;
 598   string=(char *) NULL;
 599   if (~length >= (MaxTextExtent-1))
 600     string=(char *) AcquireQuantumMemory(length+MaxTextExtent,sizeof(*string));
 601   if (string == (char *) NULL)
 602     {
 603       file=close(file)-1;
 604       return((StringInfo *) NULL);
 605     }
 606   map=MapBlob(file,ReadMode,0,length);
 607   if (map != (void *) NULL)
 608     {
 609       (void) memcpy(string,map,length);
 610       (void) UnmapBlob(map,length);
 611     }
 612   else
 613     {
 614       register size_t
 615         i;
 616
 617       ssize_t
 618         count;
 619
 620       (void) lseek(file,0,SEEK_SET);
 621       for (i=0; i < length; i+=count)
 622       {
 623         count=read(file,string+i,(size_t) MagickMin(length-i,(size_t)
 624           SSIZE_MAX));
 625         if (count <= 0)
 626           {
 627             count=0;
 628             if (errno != EINTR)
 629               break;
 630           }
 631       }
 632       if (i < length)
 633         {
 634           file=close(file)-1;
 635           string=DestroyString(string);
 636           return((StringInfo *) NULL);
 637         }
 638     }
 639   string[length]='\0';
 640   file=close(file)-1;
 641   string_info=AcquireStringInfo(0);
 642   (void) CopyMagickString(string_info->path,filename,MaxTextExtent);
 643   string_info->length=length;
 644   string_info->datum=(unsigned char *) string;
 645   return(string_info);
 646 }
 647 \f
 648 /*
 649 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 650 %                                                                             %
 651 %                                                                             %
 652 %                                                                             %
 653 %   C o n s t a n t S t r i n g                                               %
 654 %                                                                             %
 655 %                                                                             %
 656 %                                                                             %
 657 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 658 %
 659 %  ConstantString() allocates memory for a string and copies the source string
 660 %  to that memory location (and returns it).  Use it for strings that you do
 661 %  do not expect to change over its lifetime.
 662 %
 663 %  The format of the ConstantString method is:
 664 %
 665 %      char *ConstantString(const char *source)
 666 %
 667 %  A description of each parameter follows:
 668 %
 669 %    o source: A character string.
 670 %
 671 */
 672 MagickExport char *ConstantString(const char *source)
 673 {
 674   char
 675     *destination;
 676
 677   size_t
 678     length;
 679
 680   length=0;
 681   if (source != (char *) NULL)
 682     length+=strlen(source);
 683   destination=(char *) NULL;
 684   if (~length >= 1UL)
 685     destination=(char *) AcquireQuantumMemory(length+1UL,sizeof(*destination));
 686   if (destination == (char *) NULL)
 687     ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
 688   *destination='\0';
 689   if (source != (char *) NULL)
 690     (void) memcpy(destination,source,length*sizeof(*destination));
 691   destination[length]='\0';
 692   return(destination);
 693 }
 694 \f
 695 /*
 696 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 697 %                                                                             %
 698 %                                                                             %
 699 %                                                                             %
 700 %   C o p y M a g i c k S t r i n g                                           %
 701 %                                                                             %
 702 %                                                                             %
 703 %                                                                             %
 704 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 705 %
 706 %  CopyMagickString() copies the source string to the destination string.  The
 707 %  destination buffer is always null-terminated even if the string must be
 708 %  truncated.  The return value is the minimum of the source string length
 709 %  or the length parameter.
 710 %
 711 %  The format of the CopyMagickString method is:
 712 %
 713 %      size_t CopyMagickString(const char *destination,char *source,
 714 %        const size_t length)
 715 %
 716 %  A description of each parameter follows:
 717 %
 718 %    o destination: the destination string.
 719 %
 720 %    o source: the source string.
 721 %
 722 %    o length: the length of the destination string.
 723 %
 724 */
 725 MagickExport size_t CopyMagickString(char *destination,const char *source,
 726   const size_t length)
 727 {
 728   register char
 729     *q;
 730
 731   register const char
 732     *p;
 733
 734   register size_t
 735     n;
 736
 737   p=source;
 738   q=destination;
 739   for (n=length; n > 4; n-=4)
 740   {
 741     *q=(*p++);
 742     if (*q == '\0')
 743       return((size_t) (p-source-1));
 744     q++;
 745     *q=(*p++);
 746     if (*q == '\0')
 747       return((size_t) (p-source-1));
 748     q++;
 749     *q=(*p++);
 750     if (*q == '\0')
 751       return((size_t) (p-source-1));
 752     q++;
 753     *q=(*p++);
 754     if (*q == '\0')
 755       return((size_t) (p-source-1));
 756     q++;
 757   }
 758   if (n != 0)
 759     for (n--; n != 0; n--)
 760     {
 761       *q=(*p++);
 762       if (*q == '\0')
 763         return((size_t) (p-source-1));
 764       q++;
 765     }
 766   if (length != 0)
 767     *q='\0';
 768   return((size_t) (p-source-1));
 769 }
 770 \f
 771 /*
 772 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 773 %                                                                             %
 774 %                                                                             %
 775 %                                                                             %
 776 %   D e s t r o y S t r i n g                                                 %
 777 %                                                                             %
 778 %                                                                             %
 779 %                                                                             %
 780 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 781 %
 782 %  DestroyString() destroys memory associated with a string.
 783 %
 784 %  The format of the DestroyString method is:
 785 %
 786 %      char *DestroyString(char *string)
 787 %
 788 %  A description of each parameter follows:
 789 %
 790 %    o string: the string.
 791 %
 792 */
 793 MagickExport char *DestroyString(char *string)
 794 {
 795   return((char *) RelinquishMagickMemory(string));
 796 }
 797 \f
 798 /*
 799 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 800 %                                                                             %
 801 %                                                                             %
 802 %                                                                             %
 803 %   D e s t r o y S t r i n g I n f o                                         %
 804 %                                                                             %
 805 %                                                                             %
 806 %                                                                             %
 807 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 808 %
 809 %  DestroyStringInfo() destroys memory associated with the StringInfo structure.
 810 %
 811 %  The format of the DestroyStringInfo method is:
 812 %
 813 %      StringInfo *DestroyStringInfo(StringInfo *string_info)
 814 %
 815 %  A description of each parameter follows:
 816 %
 817 %    o string_info: the string info.
 818 %
 819 */
 820 MagickExport StringInfo *DestroyStringInfo(StringInfo *string_info)
 821 {
 822   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 823   assert(string_info != (StringInfo *) NULL);
 824   assert(string_info->signature == MagickSignature);
 825   if (string_info->datum != (unsigned char *) NULL)
 826     string_info->datum=(unsigned char *) RelinquishMagickMemory(
 827       string_info->datum);
 828   string_info->signature=(~MagickSignature);
 829   string_info=(StringInfo *) RelinquishMagickMemory(string_info);
 830   return(string_info);
 831 }
 832 \f
 833 /*
 834 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 835 %                                                                             %
 836 %                                                                             %
 837 %                                                                             %
 838 %   D e s t r o y S t r i n g L i s t                                         %
 839 %                                                                             %
 840 %                                                                             %
 841 %                                                                             %
 842 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 843 %
 844 %  DestroyStringList() zeros memory associated with a string list.
 845 %
 846 %  The format of the DestroyStringList method is:
 847 %
 848 %      char **DestroyStringList(char **list)
 849 %
 850 %  A description of each parameter follows:
 851 %
 852 %    o list: the string list.
 853 %
 854 */
 855 MagickExport char **DestroyStringList(char **list)
 856 {
 857   register ssize_t
 858     i;
 859
 860   assert(list != (char **) NULL);
 861   for (i=0; list[i] != (char *) NULL; i++)
 862     list[i]=DestroyString(list[i]);
 863   list=(char **) RelinquishMagickMemory(list);
 864   return(list);
 865 }
 866 \f
 867 /*
 868 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 869 %                                                                             %
 870 %                                                                             %
 871 %                                                                             %
 872 %   E s c a p e S t r i n g                                                   %
 873 %                                                                             %
 874 %                                                                             %
 875 %                                                                             %
 876 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 877 %
 878 %  EscapeString() allocates memory for a backslash-escaped version of a
 879 %  source text string, copies the escaped version of the text to that
 880 %  memory location while adding backslash characters, and returns the
 881 %  escaped string.
 882 %
 883 %  The format of the EscapeString method is:
 884 %
 885 %      char *EscapeString(const char *source,const char escape)
 886 %
 887 %  A description of each parameter follows:
 888 %
 889 %    o allocate_string:  Method EscapeString returns the escaped string.
 890 %
 891 %    o source: A character string.
 892 %
 893 %    o escape: the quoted string termination character to escape (e.g. '"').
 894 %
 895 */
 896 MagickExport char *EscapeString(const char *source,const char escape)
 897 {
 898   char
 899     *destination;
 900
 901   register char
 902     *q;
 903
 904   register const char
 905     *p;
 906
 907   size_t
 908     length;
 909
 910   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
 911   assert(source != (const char *) NULL);
 912   length=strlen(source);
 913   for (p=source; *p != '\0'; p++)
 914     if ((*p == '\\') || (*p == escape))
 915       {
 916         if (~length < 1)
 917           ThrowFatalException(ResourceLimitFatalError,"UnableToEscapeString");
 918         length++;
 919       }
 920   destination=(char *) NULL;
 921   if (~length >= (MaxTextExtent-1))
 922     destination=(char *) AcquireQuantumMemory(length+MaxTextExtent,
 923       sizeof(*destination));
 924   if (destination == (char *) NULL)
 925     ThrowFatalException(ResourceLimitFatalError,"UnableToEscapeString");
 926   *destination='\0';
 927   if (source != (char *) NULL)
 928     {
 929       q=destination;
 930       for (p=source; *p != '\0'; p++)
 931       {
 932         if ((*p == '\\') || (*p == escape))
 933           *q++='\\';
 934         *q++=(*p);
 935       }
 936       *q='\0';
 937     }
 938   return(destination);
 939 }
 940 \f
 941 /*
 942 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 943 %                                                                             %
 944 %                                                                             %
 945 %                                                                             %
 946 %   F i l e T o S t r i n g                                                   %
 947 %                                                                             %
 948 %                                                                             %
 949 %                                                                             %
 950 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 951 %
 952 %  FileToString() returns the contents of a file as a string.
 953 %
 954 %  The format of the FileToString method is:
 955 %
 956 %      char *FileToString(const char *filename,const size_t extent,
 957 %        ExceptionInfo *exception)
 958 %
 959 %  A description of each parameter follows:
 960 %
 961 %    o filename: the filename.
 962 %
 963 %    o extent: Maximum length of the string.
 964 %
 965 %    o exception: return any errors or warnings in this structure.
 966 %
 967 */
 968 MagickExport char *FileToString(const char *filename,const size_t extent,
 969   ExceptionInfo *exception)
 970 {
 971   size_t
 972     length;
 973
 974   assert(filename != (const char *) NULL);
 975   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",filename);
 976   assert(exception != (ExceptionInfo *) NULL);
 977   return((char *) FileToBlob(filename,extent,&length,exception));
 978 }
 979 \f
 980 /*
 981 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 982 %                                                                             %
 983 %                                                                             %
 984 %                                                                             %
 985 %   F i l e T o S t r i n g I n f o                                           %
 986 %                                                                             %
 987 %                                                                             %
 988 %                                                                             %
 989 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 990 %
 991 %  FileToStringInfo() returns the contents of a file as a string.
 992 %
 993 %  The format of the FileToStringInfo method is:
 994 %
 995 %      StringInfo *FileToStringInfo(const char *filename,const size_t extent,
 996 %        ExceptionInfo *exception)
 997 %
 998 %  A description of each parameter follows:
 999 %
1000 %    o filename: the filename.
1001 %
1002 %    o extent: Maximum length of the string.
1003 %
1004 %    o exception: return any errors or warnings in this structure.
1005 %
1006 */
1007 MagickExport StringInfo *FileToStringInfo(const char *filename,
1008   const size_t extent,ExceptionInfo *exception)
1009 {
1010   StringInfo
1011     *string_info;
1012
1013   assert(filename != (const char *) NULL);
1014   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",filename);
1015   assert(exception != (ExceptionInfo *) NULL);
1016   string_info=AcquireStringInfo(0);
1017   (void) CopyMagickString(string_info->path,filename,MaxTextExtent);
1018   string_info->datum=FileToBlob(filename,extent,&string_info->length,exception);
1019   if (string_info->datum == (unsigned char *) NULL)
1020     {
1021       string_info=DestroyStringInfo(string_info);
1022       return((StringInfo *) NULL);
1023     }
1024   return(string_info);
1025 }
1026 \f
1027 /*
1028 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1029 %                                                                             %
1030 %                                                                             %
1031 %                                                                             %
1032 %  F o r m a t M a g i c k S i z e                                            %
1033 %                                                                             %
1034 %                                                                             %
1035 %                                                                             %
1036 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1037 %
1038 %  FormatMagickSize() converts a size to a human readable format, for example,
1039 %  14k, 234m, 2.7g, or 3.0t.  Scaling is done by repetitively dividing by
1040 %  1000.
1041 %
1042 %  The format of the FormatMagickSize method is:
1043 %
1044 %      ssize_t FormatMagickSize(const MagickSizeType size,char *format)
1045 %
1046 %  A description of each parameter follows:
1047 %
1048 %    o size:  convert this size to a human readable format.
1049 %
1050 %    o bi:  use power of two rather than power of ten.
1051 %
1052 %    o format:  human readable format.
1053 %
1054 */
1055 MagickPrivate ssize_t FormatMagickSize(const MagickSizeType size,
1056   const MagickBooleanType bi,char *format)
1057 {
1058   const char
1059     **units;
1060
1061   double
1062     bytes,
1063     length;
1064
1065   register ssize_t
1066     i,
1067     j;
1068
1069   ssize_t
1070     count;
1071
1072   static const char
1073     *bi_units[] =
1074     {
1075       "", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi", (char *) NULL
1076     },
1077     *traditional_units[] =
1078     {
1079       "", "K", "M", "G", "T", "P", "E", "Z", "Y", (char *) NULL
1080     };
1081
1082   bytes=1000.0;
1083   units=traditional_units;
1084   if (bi != MagickFalse)
1085     {
1086       bytes=1024.0;
1087       units=bi_units;
1088     }
1089 #if defined(_MSC_VER) && (_MSC_VER == 1200)
1090   length=(double) ((MagickOffsetType) size);
1091 #else
1092   length=(double) size;
1093 #endif
1094   for (i=0; (length >= bytes) && (units[i+1] != (const char *) NULL); i++)
1095     length/=bytes;
1096   for (j=2; j < 12; j++)
1097   {
1098     count=FormatLocaleString(format,MaxTextExtent,"%.*g%sB",(int) (i+j),length,
1099       units[i]);
1100     if (strchr(format,'+') == (char *) NULL)
1101       break;
1102   }
1103   return(count);
1104 }
1105 \f
1106 /*
1107 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1108 %                                                                             %
1109 %                                                                             %
1110 %                                                                             %
1111 %  F o r m a t M a g i c k T i m e                                            %
1112 %                                                                             %
1113 %                                                                             %
1114 %                                                                             %
1115 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1116 %
1117 %  FormatMagickTime() returns the specified time in the Internet date/time
1118 %  format and the length of the timestamp.
1119 %
1120 %  The format of the FormatMagickTime method is:
1121 %
1122 %      ssize_t FormatMagickTime(const time_t time,const size_t length,
1123 %        char *timestamp)
1124 %
1125 %  A description of each parameter follows.
1126 %
1127 %   o time:  the time since the Epoch (00:00:00 UTC, January 1, 1970),
1128 %     measured in seconds.
1129 %
1130 %   o length: the maximum length of the string.
1131 %
1132 %   o timestamp:  Return the Internet date/time here.
1133 %
1134 */
1135 MagickExport ssize_t FormatMagickTime(const time_t time,const size_t length,
1136   char *timestamp)
1137 {
1138   ssize_t
1139     count;
1140
1141   struct tm
1142     gm_time,
1143     local_time;
1144
1145   time_t
1146     timezone;
1147
1148   assert(timestamp != (char *) NULL);
1149   (void) ResetMagickMemory(&local_time,0,sizeof(local_time));
1150   (void) ResetMagickMemory(&gm_time,0,sizeof(gm_time));
1151 #if defined(MAGICKCORE_HAVE_LOCALTIME_R)
1152   (void) localtime_r(&time,&local_time);
1153 #else
1154   {
1155     struct tm
1156       *my_time;
1157
1158     my_time=localtime(&time);
1159     if (my_time != (struct tm *) NULL)
1160       (void) memcpy(&local_time,my_time,sizeof(local_time));
1161   }
1162 #endif
1163 #if defined(MAGICKCORE_HAVE_GMTIME_R)
1164   (void) gmtime_r(&time,&gm_time);
1165 #else
1166   {
1167     struct tm
1168       *my_time;
1169
1170     my_time=gmtime(&time);
1171     if (my_time != (struct tm *) NULL)
1172       (void) memcpy(&gm_time,my_time,sizeof(gm_time));
1173   }
1174 #endif
1175   timezone=(time_t) ((local_time.tm_min-gm_time.tm_min)/60+
1176     local_time.tm_hour-gm_time.tm_hour+24*((local_time.tm_year-
1177     gm_time.tm_year) != 0 ? (local_time.tm_year-gm_time.tm_year) :
1178     (local_time.tm_yday-gm_time.tm_yday)));
1179   count=FormatLocaleString(timestamp,length,
1180     "%04d-%02d-%02dT%02d:%02d:%02d%+03ld:00",local_time.tm_year+1900,
1181     local_time.tm_mon+1,local_time.tm_mday,local_time.tm_hour,
1182     local_time.tm_min,local_time.tm_sec,(long) timezone);
1183   return(count);
1184 }
1185 \f
1186 /*
1187 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1188 %                                                                             %
1189 %                                                                             %
1190 %                                                                             %
1191 %   G e t E n v i r o n m e n t V a l u e                                     %
1192 %                                                                             %
1193 %                                                                             %
1194 %                                                                             %
1195 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1196 %
1197 %  GetEnvironmentValue() returns the environment string that matches the
1198 %  specified name.
1199 %
1200 %  The format of the GetEnvironmentValue method is:
1201 %
1202 %      char *GetEnvironmentValue(const char *name)
1203 %
1204 %  A description of each parameter follows:
1205 %
1206 %    o name: the environment name.
1207 %
1208 */
1209 MagickPrivate char *GetEnvironmentValue(const char *name)
1210 {
1211   const char
1212     *environment;
1213
1214   environment=getenv(name);
1215   if (environment == (const char *) NULL)
1216     return((char *) NULL);
1217   return(ConstantString(environment));
1218 }
1219 \f
1220 /*
1221 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1222 %                                                                             %
1223 %                                                                             %
1224 %                                                                             %
1225 %   G e t S t r i n g I n f o D a t u m                                       %
1226 %                                                                             %
1227 %                                                                             %
1228 %                                                                             %
1229 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1230 %
1231 %  GetStringInfoDatum() returns the datum associated with the string.
1232 %
1233 %  The format of the GetStringInfoDatum method is:
1234 %
1235 %      unsigned char *GetStringInfoDatum(const StringInfo *string_info)
1236 %
1237 %  A description of each parameter follows:
1238 %
1239 %    o string_info: the string info.
1240 %
1241 */
1242 MagickExport unsigned char *GetStringInfoDatum(const StringInfo *string_info)
1243 {
1244   assert(string_info != (StringInfo *) NULL);
1245   assert(string_info->signature == MagickSignature);
1246   return(string_info->datum);
1247 }
1248 \f
1249 /*
1250 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1251 %                                                                             %
1252 %                                                                             %
1253 %                                                                             %
1254 %   G e t S t r i n g I n f o L e n g t h                                     %
1255 %                                                                             %
1256 %                                                                             %
1257 %                                                                             %
1258 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1259 %
1260 %  GetStringInfoLength() returns the string length.
1261 %
1262 %  The format of the GetStringInfoLength method is:
1263 %
1264 %      size_t GetStringInfoLength(const StringInfo *string_info)
1265 %
1266 %  A description of each parameter follows:
1267 %
1268 %    o string_info: the string info.
1269 %
1270 */
1271 MagickExport size_t GetStringInfoLength(const StringInfo *string_info)
1272 {
1273   assert(string_info != (StringInfo *) NULL);
1274   assert(string_info->signature == MagickSignature);
1275   return(string_info->length);
1276 }
1277 \f
1278 /*
1279 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1280 %                                                                             %
1281 %                                                                             %
1282 %                                                                             %
1283 %   G e t S t r i n g I n f o P a t h                                         %
1284 %                                                                             %
1285 %                                                                             %
1286 %                                                                             %
1287 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1288 %
1289 %  GetStringInfoPath() returns the path associated with the string.
1290 %
1291 %  The format of the GetStringInfoPath method is:
1292 %
1293 %      const char *GetStringInfoPath(const StringInfo *string_info)
1294 %
1295 %  A description of each parameter follows:
1296 %
1297 %    o string_info: the string info.
1298 %
1299 */
1300 MagickExport const char *GetStringInfoPath(const StringInfo *string_info)
1301 {
1302   assert(string_info != (StringInfo *) NULL);
1303   assert(string_info->signature == MagickSignature);
1304   return(string_info->path);
1305 }
1306 \f
1307 /*
1308 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1309 %                                                                             %
1310 %                                                                             %
1311 %                                                                             %
1312 %   L o c a l e C o m p a r e                                                 %
1313 %                                                                             %
1314 %                                                                             %
1315 %                                                                             %
1316 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1317 %
1318 %  LocaleCompare() performs a case-insensitive comparison of two strings
1319 %  byte-by-byte, according to the ordering of the current locale encoding.
1320 %  LocaleCompare returns an integer greater than, equal to, or less than 0,
1321 %  if the string pointed to by p is greater than, equal to, or less than the
1322 %  string pointed to by q respectively.  The sign of a non-zero return value
1323 %  is determined by the sign of the difference between the values of the first
1324 %  pair of bytes that differ in the strings being compared.
1325 %
1326 %  The format of the LocaleCompare method is:
1327 %
1328 %      int LocaleCompare(const char *p,const char *q)
1329 %
1330 %  A description of each parameter follows:
1331 %
1332 %    o p: A pointer to a character string.
1333 %
1334 %    o q: A pointer to a character string to compare to p.
1335 %
1336 */
1337 MagickExport int LocaleCompare(const char *p,const char *q)
1338 {
1339   if ((p == (char *) NULL) && (q == (char *) NULL))
1340     return(0);
1341   if (p == (char *) NULL)
1342     return(-1);
1343   if (q == (char *) NULL)
1344     return(1);
1345 #if defined(MAGICKCORE_HAVE_STRCASECMP)
1346   return(strcasecmp(p,q));
1347 #else
1348   {
1349     register int
1350       c,
1351       d;
1352
1353     for ( ; ; )
1354     {
1355       c=(int) *((unsigned char *) p);
1356       d=(int) *((unsigned char *) q);
1357       if ((c == 0) || (AsciiMap[c] != AsciiMap[d]))
1358         break;
1359       p++;
1360       q++;
1361     }
1362     return(AsciiMap[c]-(int) AsciiMap[d]);
1363   }
1364 #endif
1365 }
1366 \f
1367 /*
1368 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1369 %                                                                             %
1370 %                                                                             %
1371 %                                                                             %
1372 %   L o c a l e L o w e r                                                     %
1373 %                                                                             %
1374 %                                                                             %
1375 %                                                                             %
1376 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1377 %
1378 %  LocaleLower() transforms all of the characters in the supplied
1379 %  null-terminated string, changing all uppercase letters to lowercase.
1380 %
1381 %  The format of the LocaleLower method is:
1382 %
1383 %      void LocaleLower(char *string)
1384 %
1385 %  A description of each parameter follows:
1386 %
1387 %    o string: A pointer to the string to convert to lower-case Locale.
1388 %
1389 */
1390 MagickExport void LocaleLower(char *string)
1391 {
1392   register char
1393     *q;
1394
1395   assert(string != (char *) NULL);
1396   for (q=string; *q != '\0'; q++)
1397     *q=(char) tolower((int) *q);
1398 }
1399 \f
1400 /*
1401 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1402 %                                                                             %
1403 %                                                                             %
1404 %                                                                             %
1405 %   L o c a l e N C o m p a r e                                               %
1406 %                                                                             %
1407 %                                                                             %
1408 %                                                                             %
1409 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1410 %
1411 %  LocaleNCompare() performs a case-insensitive comparison of two
1412 %  strings byte-by-byte, according to the ordering of the current locale
1413 %  encoding. LocaleNCompare returns an integer greater than, equal to, or
1414 %  less than 0, if the string pointed to by p is greater than, equal to, or
1415 %  less than the string pointed to by q respectively.  The sign of a non-zero
1416 %  return value is determined by the sign of the difference between the
1417 %  values of the first pair of bytes that differ in the strings being
1418 %  compared.  The LocaleNCompare method makes the same comparison as
1419 %  LocaleCompare but looks at a maximum of n bytes.  Bytes following a
1420 %  null byte are not compared.
1421 %
1422 %  The format of the LocaleNCompare method is:
1423 %
1424 %      int LocaleNCompare(const char *p,const char *q,const size_t n)
1425 %
1426 %  A description of each parameter follows:
1427 %
1428 %    o p: A pointer to a character string.
1429 %
1430 %    o q: A pointer to a character string to compare to p.
1431 %
1432 %    o length: the number of characters to compare in strings p and q.
1433 %
1434 */
1435 MagickExport int LocaleNCompare(const char *p,const char *q,const size_t length)
1436 {
1437   if (p == (char *) NULL)
1438     return(-1);
1439   if (q == (char *) NULL)
1440     return(1);
1441 #if defined(MAGICKCORE_HAVE_STRNCASECMP)
1442   return(strncasecmp(p,q,length));
1443 #else
1444   {
1445     register int
1446       c,
1447       d;
1448
1449     register size_t
1450       i;
1451
1452     for (i=length; i != 0; i--)
1453     {
1454       c=(int) *((unsigned char *) p);
1455       d=(int) *((unsigned char *) q);
1456       if (AsciiMap[c] != AsciiMap[d])
1457         return(AsciiMap[c]-(int) AsciiMap[d]);
1458       if (c == 0)
1459         return(0);
1460       p++;
1461       q++;
1462     }
1463     return(0);
1464   }
1465 #endif
1466 }
1467 \f
1468 /*
1469 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1470 %                                                                             %
1471 %                                                                             %
1472 %                                                                             %
1473 %   L o c a l e U p p e r                                                     %
1474 %                                                                             %
1475 %                                                                             %
1476 %                                                                             %
1477 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1478 %
1479 %  LocaleUpper() transforms all of the characters in the supplied
1480 %  null-terminated string, changing all lowercase letters to uppercase.
1481 %
1482 %  The format of the LocaleUpper method is:
1483 %
1484 %      void LocaleUpper(char *string)
1485 %
1486 %  A description of each parameter follows:
1487 %
1488 %    o string: A pointer to the string to convert to upper-case Locale.
1489 %
1490 */
1491 MagickExport void LocaleUpper(char *string)
1492 {
1493   register char
1494     *q;
1495
1496   assert(string != (char *) NULL);
1497   for (q=string; *q != '\0'; q++)
1498     *q=(char) toupper((int) *q);
1499 }
1500 \f
1501 /*
1502 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1503 %                                                                             %
1504 %                                                                             %
1505 %                                                                             %
1506 %   P r i n t S t r i n g I n f o                                             %
1507 %                                                                             %
1508 %                                                                             %
1509 %                                                                             %
1510 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1511 %
1512 %  PrintStringInfo() prints the string.
1513 %
1514 %  The format of the PrintStringInfo method is:
1515 %
1516 %      void PrintStringInfo(FILE *file,const char *id,
1517 %        const StringInfo *string_info)
1518 %
1519 %  A description of each parameter follows:
1520 %
1521 %    o file: the file, typically stdout.
1522 %
1523 %    o id: the string id.
1524 %
1525 %    o string_info: the string info.
1526 %
1527 */
1528 MagickExport void PrintStringInfo(FILE *file,const char *id,
1529   const StringInfo *string_info)
1530 {
1531   register const char
1532     *p;
1533
1534   register size_t
1535     i,
1536     j;
1537
1538   assert(id != (const char *) NULL);
1539   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",id);
1540   assert(string_info != (StringInfo *) NULL);
1541   assert(string_info->signature == MagickSignature);
1542   p=(char *) string_info->datum;
1543   for (i=0; i < string_info->length; i++)
1544   {
1545     if (((int) ((unsigned char) *p) < 32) &&
1546         (isspace((int) ((unsigned char) *p)) == 0))
1547       break;
1548     p++;
1549   }
1550   if (i == string_info->length)
1551     {
1552       (void) fputs((char *) string_info->datum,file);
1553       (void) fputc('\n',file);
1554       return;
1555     }
1556   /*
1557     Convert string to a HEX list.
1558   */
1559   p=(char *) string_info->datum;
1560   for (i=0; i < string_info->length; i+=0x14)
1561   {
1562     (void) FormatLocaleFile(file,"0x%08lx: ",(unsigned long) (0x14*i));
1563     for (j=1; j <= MagickMin(string_info->length-i,0x14); j++)
1564     {
1565       (void) FormatLocaleFile(file,"%02lx",(unsigned long) (*(p+j)) & 0xff);
1566       if ((j % 0x04) == 0)
1567         (void) fputc(' ',file);
1568     }
1569     for ( ; j <= 0x14; j++)
1570     {
1571       (void) fputc(' ',file);
1572       (void) fputc(' ',file);
1573       if ((j % 0x04) == 0)
1574         (void) fputc(' ',file);
1575     }
1576     (void) fputc(' ',file);
1577     for (j=1; j <= MagickMin(string_info->length-i,0x14); j++)
1578     {
1579       if (isprint((int) ((unsigned char) *p)) != 0)
1580         (void) fputc(*p,file);
1581       else
1582         (void) fputc('-',file);
1583       p++;
1584     }
1585     (void) fputc('\n',file);
1586   }
1587 }
1588 \f
1589 /*
1590 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1591 %                                                                             %
1592 %                                                                             %
1593 %                                                                             %
1594 %   R e s e t S t r i n g I n f o                                             %
1595 %                                                                             %
1596 %                                                                             %
1597 %                                                                             %
1598 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1599 %
1600 %  ResetStringInfo() reset the string to all null bytes.
1601 %
1602 %  The format of the ResetStringInfo method is:
1603 %
1604 %      void ResetStringInfo(StringInfo *string_info)
1605 %
1606 %  A description of each parameter follows:
1607 %
1608 %    o string_info: the string info.
1609 %
1610 */
1611 MagickExport void ResetStringInfo(StringInfo *string_info)
1612 {
1613   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1614   assert(string_info != (StringInfo *) NULL);
1615   assert(string_info->signature == MagickSignature);
1616   (void) ResetMagickMemory(string_info->datum,0,string_info->length);
1617 }
1618 \f
1619 /*
1620 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1621 %                                                                             %
1622 %                                                                             %
1623 %                                                                             %
1624 %   S e t S t r i n g I n f o                                                 %
1625 %                                                                             %
1626 %                                                                             %
1627 %                                                                             %
1628 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1629 %
1630 %  SetStringInfo() copies the source string to the destination string.
1631 %
1632 %  The format of the SetStringInfo method is:
1633 %
1634 %      void SetStringInfo(StringInfo *string_info,const StringInfo *source)
1635 %
1636 %  A description of each parameter follows:
1637 %
1638 %    o string_info: the string info.
1639 %
1640 %    o source: the source string.
1641 %
1642 */
1643 MagickExport void SetStringInfo(StringInfo *string_info,
1644   const StringInfo *source)
1645 {
1646   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1647   assert(string_info != (StringInfo *) NULL);
1648   assert(string_info->signature == MagickSignature);
1649   assert(source != (StringInfo *) NULL);
1650   assert(source->signature == MagickSignature);
1651   if (string_info->length == 0)
1652     return;
1653   (void) ResetMagickMemory(string_info->datum,0,string_info->length);
1654   (void) memcpy(string_info->datum,source->datum,MagickMin(string_info->length,
1655     source->length));
1656 }
1657 \f
1658 /*
1659 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1660 %                                                                             %
1661 %                                                                             %
1662 %                                                                             %
1663 %   S e t S t r i n g I n f o D a t u m                                       %
1664 %                                                                             %
1665 %                                                                             %
1666 %                                                                             %
1667 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1668 %
1669 %  SetStringInfoDatum() copies bytes from the source string for the length of
1670 %  the destination string.
1671 %
1672 %  The format of the SetStringInfoDatum method is:
1673 %
1674 %      void SetStringInfoDatum(StringInfo *string_info,
1675 %        const unsigned char *source)
1676 %
1677 %  A description of each parameter follows:
1678 %
1679 %    o string_info: the string info.
1680 %
1681 %    o source: the source string.
1682 %
1683 */
1684 MagickExport void SetStringInfoDatum(StringInfo *string_info,
1685   const unsigned char *source)
1686 {
1687   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1688   assert(string_info != (StringInfo *) NULL);
1689   assert(string_info->signature == MagickSignature);
1690   if (string_info->length != 0)
1691     (void) memcpy(string_info->datum,source,string_info->length);
1692 }
1693 \f
1694 /*
1695 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1696 %                                                                             %
1697 %                                                                             %
1698 %                                                                             %
1699 %   S e t S t r i n g I n f o L e n g t h                                     %
1700 %                                                                             %
1701 %                                                                             %
1702 %                                                                             %
1703 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1704 %
1705 %  SetStringInfoLength() set the string length to the specified value.
1706 %
1707 %  The format of the SetStringInfoLength method is:
1708 %
1709 %      void SetStringInfoLength(StringInfo *string_info,const size_t length)
1710 %
1711 %  A description of each parameter follows:
1712 %
1713 %    o string_info: the string info.
1714 %
1715 %    o length: the string length.
1716 %
1717 */
1718 MagickExport void SetStringInfoLength(StringInfo *string_info,
1719   const size_t length)
1720 {
1721   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1722   assert(string_info != (StringInfo *) NULL);
1723   assert(string_info->signature == MagickSignature);
1724   if (~length < MaxTextExtent)
1725     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
1726   string_info->length=length;
1727   if (string_info->datum == (unsigned char *) NULL)
1728     string_info->datum=(unsigned char *) AcquireQuantumMemory(length+
1729       MaxTextExtent,sizeof(*string_info->datum));
1730   else
1731     string_info->datum=(unsigned char *) ResizeQuantumMemory(string_info->datum,
1732       length+MaxTextExtent,sizeof(*string_info->datum));
1733   if (string_info->datum == (unsigned char *) NULL)
1734     ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
1735 }
1736 \f
1737 /*
1738 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1739 %                                                                             %
1740 %                                                                             %
1741 %                                                                             %
1742 %   S e t S t r i n g I n f o D a t u m                                       %
1743 %                                                                             %
1744 %                                                                             %
1745 %                                                                             %
1746 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1747 %
1748 %  SetStringInfoPath() sets the path associated with the string.
1749 %
1750 %  The format of the SetStringInfoPath method is:
1751 %
1752 %      void SetStringInfoPath(StringInfo *string_info,const char *path)
1753 %
1754 %  A description of each parameter follows:
1755 %
1756 %    o string_info: the string info.
1757 %
1758 %    o path: the path.
1759 %
1760 */
1761 MagickExport void SetStringInfoPath(StringInfo *string_info,const char *path)
1762 {
1763   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1764   assert(string_info != (StringInfo *) NULL);
1765   assert(string_info->signature == MagickSignature);
1766   assert(path != (const char *) NULL);
1767   (void) CopyMagickString(string_info->path,path,MaxTextExtent);
1768 }
1769 \f
1770 /*
1771 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1772 %                                                                             %
1773 %                                                                             %
1774 %                                                                             %
1775 %   S p l i t S t r i n g I n f o                                             %
1776 %                                                                             %
1777 %                                                                             %
1778 %                                                                             %
1779 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1780 %
1781 %  SplitStringInfo() splits a string into two and returns it.
1782 %
1783 %  The format of the SplitStringInfo method is:
1784 %
1785 %      StringInfo *SplitStringInfo(StringInfo *string_info,const size_t offset)
1786 %
1787 %  A description of each parameter follows:
1788 %
1789 %    o string_info: the string info.
1790 %
1791 */
1792 MagickExport StringInfo *SplitStringInfo(StringInfo *string_info,
1793   const size_t offset)
1794 {
1795   StringInfo
1796     *split_info;
1797
1798   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
1799   assert(string_info != (StringInfo *) NULL);
1800   assert(string_info->signature == MagickSignature);
1801   if (offset > string_info->length)
1802     return((StringInfo *) NULL);
1803   split_info=AcquireStringInfo(offset);
1804   SetStringInfo(split_info,string_info);
1805   (void) memmove(string_info->datum,string_info->datum+offset,
1806     string_info->length-offset+MaxTextExtent);
1807   SetStringInfoLength(string_info,string_info->length-offset);
1808   return(split_info);
1809 }
1810 \f
1811 /*
1812 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1813 %                                                                             %
1814 %                                                                             %
1815 %                                                                             %
1816 %   S t r i n g I n f o T o S t r i n g                                       %
1817 %                                                                             %
1818 %                                                                             %
1819 %                                                                             %
1820 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1821 %
1822 %  StringInfoToString() converts a string info string to a C string.
1823 %
1824 %  The format of the StringInfoToString method is:
1825 %
1826 %      char *StringInfoToString(const StringInfo *string_info)
1827 %
1828 %  A description of each parameter follows:
1829 %
1830 %    o string_info: the string.
1831 %
1832 */
1833 MagickExport char *StringInfoToString(const StringInfo *string_info)
1834 {
1835   char
1836     *string;
1837
1838   size_t
1839     length;
1840
1841   string=(char *) NULL;
1842   length=string_info->length;
1843   if (~length >= (MaxTextExtent-1))
1844     string=(char *) AcquireQuantumMemory(length+MaxTextExtent,sizeof(*string));
1845   if (string == (char *) NULL)
1846     return((char *) NULL);
1847   (void) memcpy(string,(char *) string_info->datum,length*sizeof(*string));
1848   string[length]='\0';
1849   return(string);
1850 }
1851 \f
1852 /*
1853 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1854 %                                                                             %
1855 %                                                                             %
1856 %                                                                             %
1857 %  S t r i n g T o A r g v                                                    %
1858 %                                                                             %
1859 %                                                                             %
1860 %                                                                             %
1861 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1862 %
1863 %  StringToArgv() converts a text string into command line arguments.
1864 %
1865 %  The format of the StringToArgv method is:
1866 %
1867 %      char **StringToArgv(const char *text,int *argc)
1868 %
1869 %  A description of each parameter follows:
1870 %
1871 %    o argv:  Method StringToArgv returns the string list unless an error
1872 %      occurs, otherwise NULL.
1873 %
1874 %    o text:  Specifies the string to segment into a list.
1875 %
1876 %    o argc:  This integer pointer returns the number of arguments in the
1877 %      list.
1878 %
1879 */
1880 MagickExport char **StringToArgv(const char *text,int *argc)
1881 {
1882   char
1883     **argv;
1884
1885   register const char
1886     *p,
1887     *q;
1888
1889   register ssize_t
1890     i;
1891
1892   *argc=0;
1893   if (text == (char *) NULL)
1894     return((char **) NULL);
1895   /*
1896     Determine the number of arguments.
1897   */
1898   for (p=text; *p != '\0'; )
1899   {
1900     while (isspace((int) ((unsigned char) *p)) != 0)
1901       p++;
1902     if (*p == '\0')
1903       break;
1904     (*argc)++;
1905     if (*p == '"')
1906       for (p++; (*p != '"') && (*p != '\0'); p++) ;
1907     if (*p == '\'')
1908       for (p++; (*p != '\'') && (*p != '\0'); p++) ;
1909     while ((isspace((int) ((unsigned char) *p)) == 0) && (*p != '\0'))
1910       p++;
1911   }
1912   (*argc)++;
1913   argv=(char **) AcquireQuantumMemory((size_t) (*argc+1UL),sizeof(*argv));
1914   if (argv == (char **) NULL)
1915     ThrowFatalException(ResourceLimitFatalError,"UnableToConvertStringToARGV");
1916   /*
1917     Convert string to an ASCII list.
1918   */
1919   argv[0]=AcquireString("magick");
1920   p=text;
1921   for (i=1; i < (ssize_t) *argc; i++)
1922   {
1923     while (isspace((int) ((unsigned char) *p)) != 0)
1924       p++;
1925     q=p;
1926     if (*q == '"')
1927       {
1928         p++;
1929         for (q++; (*q != '"') && (*q != '\0'); q++) ;
1930       }
1931     else
1932       if (*q == '\'')
1933         {
1934           p++;
1935           for (q++; (*q != '\'') && (*q != '\0'); q++) ;
1936         }
1937       else
1938         while ((isspace((int) ((unsigned char) *q)) == 0) && (*q != '\0'))
1939           q++;
1940     argv[i]=(char *) AcquireQuantumMemory((size_t) (q-p)+MaxTextExtent,
1941       sizeof(**argv));
1942     if (argv[i] == (char *) NULL)
1943       {
1944         for (i--; i >= 0; i--)
1945           argv[i]=DestroyString(argv[i]);
1946         argv=(char **) RelinquishMagickMemory(argv);
1947         ThrowFatalException(ResourceLimitFatalError,
1948           "UnableToConvertStringToARGV");
1949       }
1950     (void) memcpy(argv[i],p,(size_t) (q-p));
1951     argv[i][q-p]='\0';
1952     p=q;
1953     while ((isspace((int) ((unsigned char) *p)) == 0) && (*p != '\0'))
1954       p++;
1955   }
1956   argv[i]=(char *) NULL;
1957   return(argv);
1958 }
1959 \f
1960 /*
1961 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1962 %                                                                             %
1963 %                                                                             %
1964 %                                                                             %
1965 %   S t r i n g I n f o T o H e x S t r i n g                                 %
1966 %                                                                             %
1967 %                                                                             %
1968 %                                                                             %
1969 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1970 %
1971 %  StringInfoToHexString() converts a string info string to a C string.
1972 %
1973 %  The format of the StringInfoToHexString method is:
1974 %
1975 %      char *StringInfoToHexString(const StringInfo *string_info)
1976 %
1977 %  A description of each parameter follows:
1978 %
1979 %    o string_info: the string.
1980 %
1981 */
1982 MagickExport char *StringInfoToHexString(const StringInfo *string_info)
1983 {
1984   char
1985     *string;
1986
1987   register const unsigned char
1988     *p;
1989
1990   register ssize_t
1991     i;
1992
1993   register unsigned char
1994     *q;
1995
1996   size_t
1997     length;
1998
1999   unsigned char
2000     hex_digits[16];
2001
2002   length=string_info->length;
2003   if (~length < MaxTextExtent)
2004     ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
2005   string=(char *) AcquireQuantumMemory(length+MaxTextExtent,2*sizeof(*string));
2006   if (string == (char *) NULL)
2007     ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
2008   hex_digits[0]='0';
2009   hex_digits[1]='1';
2010   hex_digits[2]='2';
2011   hex_digits[3]='3';
2012   hex_digits[4]='4';
2013   hex_digits[5]='5';
2014   hex_digits[6]='6';
2015   hex_digits[7]='7';
2016   hex_digits[8]='8';
2017   hex_digits[9]='9';
2018   hex_digits[10]='a';
2019   hex_digits[11]='b';
2020   hex_digits[12]='c';
2021   hex_digits[13]='d';
2022   hex_digits[14]='e';
2023   hex_digits[15]='f';
2024   p=string_info->datum;
2025   q=(unsigned char *) string;
2026   for (i=0; i < (ssize_t) string_info->length; i++)
2027   {
2028     *q++=hex_digits[(*p >> 4) & 0x0f];
2029     *q++=hex_digits[*p & 0x0f];
2030     p++;
2031   }
2032   *q='\0';
2033   return(string);
2034 }
2035 \f
2036 /*
2037 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2038 %                                                                             %
2039 %                                                                             %
2040 %                                                                             %
2041 %   S t r i n g T o k e n                                                     %
2042 %                                                                             %
2043 %                                                                             %
2044 %                                                                             %
2045 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2046 %
2047 %  StringToken() extracts a token a from the string.
2048 %
2049 %  The format of the StringToken method is:
2050 %
2051 %      char *StringToken(const char *delimiters,char **string)
2052 %
2053 %  A description of each parameter follows:
2054 %
2055 %    o delimiters: one or more delimiters.
2056 %
2057 %    o string: return the first token in the string.  If none is found, return
2058 %      NULL.
2059 %
2060 */
2061 MagickExport char *StringToken(const char *delimiters,char **string)
2062 {
2063   char
2064     *q;
2065
2066   register char
2067     *p;
2068
2069   register const char
2070     *r;
2071
2072   register int
2073     c,
2074     d;
2075
2076   p=(*string);
2077   if (p == (char *) NULL)
2078     return((char *) NULL);
2079   for (q=p; ; )
2080   {
2081     c=(*p++);
2082     r=delimiters;
2083     do
2084     {
2085       d=(*r++);
2086       if (c == d)
2087         {
2088           if (c == '\0')
2089             p=(char *) NULL;
2090           else
2091             p[-1]='\0';
2092           *string=p;
2093           return(q);
2094         }
2095     } while (d != '\0');
2096   }
2097 }
2098 \f
2099 /*
2100 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2101 %                                                                             %
2102 %                                                                             %
2103 %                                                                             %
2104 %  S t r i n g T o L i s t                                                    %
2105 %                                                                             %
2106 %                                                                             %
2107 %                                                                             %
2108 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2109 %
2110 %  StringToList() converts a text string into a list by segmenting the text
2111 %  string at each carriage return discovered.  The list is converted to HEX
2112 %  characters if any control characters are discovered within the text string.
2113 %
2114 %  The format of the StringToList method is:
2115 %
2116 %      char **StringToList(const char *text)
2117 %
2118 %  A description of each parameter follows:
2119 %
2120 %    o text:  Specifies the string to segment into a list.
2121 %
2122 */
2123 MagickExport char **StringToList(const char *text)
2124 {
2125   char
2126     **textlist;
2127
2128   register const char
2129     *p;
2130
2131   register ssize_t
2132     i;
2133
2134   size_t
2135     lines;
2136
2137   if (text == (char *) NULL)
2138     return((char **) NULL);
2139   for (p=text; *p != '\0'; p++)
2140     if (((int) ((unsigned char) *p) < 32) &&
2141         (isspace((int) ((unsigned char) *p)) == 0))
2142       break;
2143   if (*p == '\0')
2144     {
2145       register const char
2146         *q;
2147
2148       /*
2149         Convert string to an ASCII list.
2150       */
2151       lines=1;
2152       for (p=text; *p != '\0'; p++)
2153         if (*p == '\n')
2154           lines++;
2155       textlist=(char **) AcquireQuantumMemory((size_t) lines+1UL,
2156         sizeof(*textlist));
2157       if (textlist == (char **) NULL)
2158         ThrowFatalException(ResourceLimitFatalError,"UnableToConvertText");
2159       p=text;
2160       for (i=0; i < (ssize_t) lines; i++)
2161       {
2162         for (q=p; *q != '\0'; q++)
2163           if ((*q == '\r') || (*q == '\n'))
2164             break;
2165         textlist[i]=(char *) AcquireQuantumMemory((size_t) (q-p)+MaxTextExtent,
2166           sizeof(**textlist));
2167         if (textlist[i] == (char *) NULL)
2168           ThrowFatalException(ResourceLimitFatalError,"UnableToConvertText");
2169         (void) memcpy(textlist[i],p,(size_t) (q-p));
2170         textlist[i][q-p]='\0';
2171         if (*q == '\r')
2172           q++;
2173         p=q+1;
2174       }
2175     }
2176   else
2177     {
2178       char
2179         hex_string[MaxTextExtent];
2180
2181       register char
2182         *q;
2183
2184       register ssize_t
2185         j;
2186
2187       /*
2188         Convert string to a HEX list.
2189       */
2190       lines=(size_t) (strlen(text)/0x14)+1;
2191       textlist=(char **) AcquireQuantumMemory((size_t) lines+1UL,
2192         sizeof(*textlist));
2193       if (textlist == (char **) NULL)
2194         ThrowFatalException(ResourceLimitFatalError,"UnableToConvertText");
2195       p=text;
2196       for (i=0; i < (ssize_t) lines; i++)
2197       {
2198         textlist[i]=(char *) AcquireQuantumMemory(2UL*MaxTextExtent,
2199           sizeof(**textlist));
2200         if (textlist[i] == (char *) NULL)
2201           ThrowFatalException(ResourceLimitFatalError,"UnableToConvertText");
2202         (void) FormatLocaleString(textlist[i],MaxTextExtent,"0x%08lx: ",
2203           (long) (0x14*i));
2204         q=textlist[i]+strlen(textlist[i]);
2205         for (j=1; j <= (ssize_t) MagickMin(strlen(p),0x14); j++)
2206         {
2207           (void) FormatLocaleString(hex_string,MaxTextExtent,"%02x",*(p+j));
2208           (void) CopyMagickString(q,hex_string,MaxTextExtent);
2209           q+=2;
2210           if ((j % 0x04) == 0)
2211             *q++=' ';
2212         }
2213         for ( ; j <= 0x14; j++)
2214         {
2215           *q++=' ';
2216           *q++=' ';
2217           if ((j % 0x04) == 0)
2218             *q++=' ';
2219         }
2220         *q++=' ';
2221         for (j=1; j <= (ssize_t) MagickMin(strlen(p),0x14); j++)
2222         {
2223           if (isprint((int) ((unsigned char) *p)) != 0)
2224             *q++=(*p);
2225           else
2226             *q++='-';
2227           p++;
2228         }
2229         *q='\0';
2230       }
2231     }
2232   textlist[i]=(char *) NULL;
2233   return(textlist);
2234 }
2235 \f
2236 /*
2237 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2238 %                                                                             %
2239 %                                                                             %
2240 %                                                                             %
2241 %   S t r i n g T o S t r i n g I n f o                                       %
2242 %                                                                             %
2243 %                                                                             %
2244 %                                                                             %
2245 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2246 %
2247 %  StringToStringInfo() converts a string to a StringInfo type.
2248 %
2249 %  The format of the StringToStringInfo method is:
2250 %
2251 %      StringInfo *StringToStringInfo(const char *string)
2252 %
2253 %  A description of each parameter follows:
2254 %
2255 %    o string:  The string.
2256 %
2257 */
2258 MagickExport StringInfo *StringToStringInfo(const char *string)
2259 {
2260   StringInfo
2261     *string_info;
2262
2263   (void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
2264   assert(string != (const char *) NULL);
2265   string_info=AcquireStringInfo(strlen(string));
2266   SetStringInfoDatum(string_info,(const unsigned char *) string);
2267   return(string_info);
2268 }
2269 \f
2270 /*
2271 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2272 %                                                                             %
2273 %                                                                             %
2274 %                                                                             %
2275 %   S t r i p S t r i n g                                                     %
2276 %                                                                             %
2277 %                                                                             %
2278 %                                                                             %
2279 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2280 %
2281 %  StripString() strips any whitespace or quotes from the beginning and end of
2282 %  a string of characters.
2283 %
2284 %  The format of the StripString method is:
2285 %
2286 %      void StripString(char *message)
2287 %
2288 %  A description of each parameter follows:
2289 %
2290 %    o message: Specifies an array of characters.
2291 %
2292 */
2293 MagickExport void StripString(char *message)
2294 {
2295   register char
2296     *p,
2297     *q;
2298
2299   size_t
2300     length;
2301
2302   assert(message != (char *) NULL);
2303   if (*message == '\0')
2304     return;
2305   length=strlen(message);
2306   p=message;
2307   while (isspace((int) ((unsigned char) *p)) != 0)
2308     p++;
2309   if ((*p == '\'') || (*p == '"'))
2310     p++;
2311   q=message+length-1;
2312   while ((isspace((int) ((unsigned char) *q)) != 0) && (q > p))
2313     q--;
2314   if (q > p)
2315     if ((*q == '\'') || (*q == '"'))
2316       q--;
2317   (void) memmove(message,p,(size_t) (q-p+1));
2318   message[q-p+1]='\0';
2319   for (p=message; *p != '\0'; p++)
2320     if (*p == '\n')
2321       *p=' ';
2322 }
2323 \f
2324 /*
2325 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2326 %                                                                             %
2327 %                                                                             %
2328 %                                                                             %
2329 %   S u b s t i t u t e S t r i n g                                           %
2330 %                                                                             %
2331 %                                                                             %
2332 %                                                                             %
2333 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2334 %
2335 %  SubstituteString() performs string substitution on a string, replacing the
2336 %  string with the substituted version. Buffer must be allocated from the heap.
2337 %  If the string is matched and status, MagickTrue is returned otherwise
2338 %  MagickFalse.
2339 %
2340 %  The format of the SubstituteString method is:
2341 %
2342 %      MagickBooleanType SubstituteString(char **string,const char *search,
2343 %        const char *replace)
2344 %
2345 %  A description of each parameter follows:
2346 %
2347 %    o string: the string to perform replacements on;  replaced with new
2348 %      allocation if a replacement is made.
2349 %
2350 %    o search: search for this string.
2351 %
2352 %    o replace: replace any matches with this string.
2353 %
2354 */
2355 MagickExport MagickBooleanType SubstituteString(char **string,
2356   const char *search,const char *replace)
2357 {
2358   MagickBooleanType
2359     status;
2360
2361   register char
2362     *p;
2363
2364   size_t
2365     extent,
2366     replace_extent,
2367     search_extent;
2368
2369   ssize_t
2370     offset;
2371
2372   status=MagickFalse;
2373   search_extent=0,
2374   replace_extent=0;
2375   for (p=strchr(*string,*search); p != (char *) NULL; p=strchr(p+1,*search))
2376   {
2377     if (search_extent == 0)
2378       search_extent=strlen(search);
2379     if (strncmp(p,search,search_extent) != 0)
2380       continue;
2381     /*
2382       We found a match.
2383     */
2384     status=MagickTrue;
2385     if (replace_extent == 0)
2386       replace_extent=strlen(replace);
2387     if (replace_extent > search_extent)
2388       {
2389         /*
2390           Make room for the replacement string.
2391         */
2392         offset=(ssize_t) (p-(*string));
2393         extent=strlen(*string)+replace_extent-search_extent+1;
2394         *string=(char *) ResizeQuantumMemory(*string,extent+MaxTextExtent,
2395           sizeof(*p));
2396         if (*string == (char *) NULL)
2397           ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
2398         p=(*string)+offset;
2399       }
2400     /*
2401       Replace string.
2402     */
2403     if (search_extent != replace_extent)
2404       (void) CopyMagickMemory(p+replace_extent,p+search_extent,
2405         strlen(p+search_extent)+1);
2406     (void) CopyMagickMemory(p,replace,replace_extent);
2407     p+=replace_extent-1;
2408   }
2409   return(status);
2410 }