/* [<][>][^][v][top][bottom][index][help] */
DEFINITIONS
This source file includes following definitions.
- AcquireString
- AcquireStringInfo
- CloneString
- CloneStringInfo
- MagickMin
- CompareStringInfo
- ConcatenateMagickString
- ConcatenateString
- ConcatenateStringInfo
- ConfigureFileToStringInfo
- ConstantString
- CopyMagickString
- DestroyString
- DestroyStringInfo
- DestroyStringList
- EscapeString
- FileToString
- FileToStringInfo
- FormatMagickSize
- FormatMagickStringList
- FormatMagickString
- FormatMagickTime
- GetEnvironmentValue
- GetStringInfoDatum
- GetStringInfoLength
- GetStringInfoPath
- LocaleCompare
- LocaleLower
- LocaleNCompare
- LocaleUpper
- PrintStringInfo
- ResetStringInfo
- SetStringInfo
- SetStringInfoDatum
- SetStringInfoLength
- SetStringInfoPath
- SplitStringInfo
- StringInfoToString
- StringToArgv
- StringInfoToHexString
- StringToken
- StringToList
- StringToStringInfo
- StripString
- SubstituteString
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% SSSSS TTTTT RRRR IIIII N N GGGG %
% SS T R R I NN N G %
% SSS T RRRR I N N N G GGG %
% SS T R R I N NN G G %
% SSSSS T R R IIIII N N GGGG %
% %
% %
% MagickCore String Methods %
% %
% Software Design %
% John Cristy %
% August 2003 %
% %
% %
% Copyright 1999-2011 ImageMagick Studio LLC, a non-profit organization %
% dedicated to making software imaging solutions freely available. %
% %
% You may not use this file except in compliance with the License. You may %
% obtain a copy of the License at %
% %
% http://www.imagemagick.org/script/license.php %
% %
% Unless required by applicable law or agreed to in writing, software %
% distributed under the License is distributed on an "AS IS" BASIS, %
% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %
% See the License for the specific language governing permissions and %
% limitations under the License. %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
%
*/
/*
Include declarations.
*/
#include "magick/studio.h"
#include "magick/blob.h"
#include "magick/blob-private.h"
#include "magick/exception.h"
#include "magick/exception-private.h"
#include "magick/list.h"
#include "magick/log.h"
#include "magick/memory_.h"
#include "magick/property.h"
#include "magick/resource_.h"
#include "magick/signature-private.h"
#include "magick/string_.h"
/*
Static declarations.
*/
#if !defined(MAGICKCORE_HAVE_STRCASECMP) || !defined(MAGICKCORE_HAVE_STRNCASECMP)
static const unsigned char
AsciiMap[] =
{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b,
0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23,
0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f,
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b,
0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67,
0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73,
0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x5b, 0x5c, 0x5d, 0x5e, 0x5f,
0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b,
0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77,
0x78, 0x79, 0x7a, 0x7b, 0x7c, 0x7d, 0x7e, 0x7f, 0x80, 0x81, 0x82, 0x83,
0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f,
0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b,
0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, 0xb0, 0xb1, 0xb2, 0xb3,
0xb4, 0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf,
0xc0, 0xe1, 0xe2, 0xe3, 0xe4, 0xc5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb,
0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7,
0xf8, 0xf9, 0xfa, 0xdb, 0xdc, 0xdd, 0xde, 0xdf, 0xe0, 0xe1, 0xe2, 0xe3,
0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef,
0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa, 0xfb,
0xfc, 0xfd, 0xfe, 0xff,
};
#endif
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% A c q u i r e S t r i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% AcquireString() allocates memory for a string and copies the source string
% to that memory location (and returns it).
%
% The format of the AcquireString method is:
%
% char *AcquireString(const char *source)
%
% A description of each parameter follows:
%
% o source: A character string.
%
*/
MagickExport char *AcquireString(const char *source)
{
char
*destination;
size_t
length;
length=0;
if (source != (char *) NULL)
length+=strlen(source);
if (~length < MaxTextExtent)
ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
destination=(char *) AcquireQuantumMemory(length+MaxTextExtent,
sizeof(*destination));
if (destination == (char *) NULL)
ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
*destination='\0';
if (source != (char *) NULL)
(void) memcpy(destination,source,length*sizeof(*destination));
destination[length]='\0';
return(destination);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% A c q u i r e S t r i n g I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% AcquireStringInfo() allocates the StringInfo structure.
%
% The format of the AcquireStringInfo method is:
%
% StringInfo *AcquireStringInfo(const size_t length)
%
% A description of each parameter follows:
%
% o length: the string length.
%
*/
MagickExport StringInfo *AcquireStringInfo(const size_t length)
{
StringInfo
*string_info;
string_info=(StringInfo *) AcquireMagickMemory(sizeof(*string_info));
if (string_info == (StringInfo *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
(void) ResetMagickMemory(string_info,0,sizeof(*string_info));
string_info->signature=MagickSignature;
string_info->length=length;
if (string_info->length != 0)
{
string_info->datum=(unsigned char *) NULL;
if (~string_info->length >= MaxTextExtent)
string_info->datum=(unsigned char *) AcquireQuantumMemory(
string_info->length+MaxTextExtent,sizeof(*string_info->datum));
if (string_info->datum == (unsigned char *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
}
return(string_info);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% C l o n e S t r i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% CloneString() allocates memory for the destination string and copies
% the source string to that memory location.
%
% The format of the CloneString method is:
%
% char *CloneString(char **destination,const char *source)
%
% A description of each parameter follows:
%
% o destination: A pointer to a character string.
%
% o source: A character string.
%
*/
MagickExport char *CloneString(char **destination,const char *source)
{
size_t
length;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(destination != (char **) NULL);
if (source == (const char *) NULL)
{
if (*destination != (char *) NULL)
*destination=DestroyString(*destination);
return(*destination);
}
if (*destination == (char *) NULL)
{
*destination=AcquireString(source);
return(*destination);
}
length=strlen(source);
if (~length < MaxTextExtent)
ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
*destination=(char *) ResizeQuantumMemory(*destination,length+MaxTextExtent,
sizeof(**destination));
if (*destination == (char *) NULL)
ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
if (length != 0)
(void) memcpy(*destination,source,length*sizeof(**destination));
(*destination)[length]='\0';
return(*destination);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% C l o n e S t r i n g I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% CloneStringInfo() clones a copy of the StringInfo structure.
%
% The format of the CloneStringInfo method is:
%
% StringInfo *CloneStringInfo(const StringInfo *string_info)
%
% A description of each parameter follows:
%
% o string_info: the string info.
%
*/
MagickExport StringInfo *CloneStringInfo(const StringInfo *string_info)
{
StringInfo
*clone_info;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(string_info != (StringInfo *) NULL);
assert(string_info->signature == MagickSignature);
clone_info=AcquireStringInfo(string_info->length);
if (string_info->length != 0)
(void) memcpy(clone_info->datum,string_info->datum,string_info->length+1);
return(clone_info);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% C o m p a r e S t r i n g I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% CompareStringInfo() compares the two datums target and source. It returns
% an integer less than, equal to, or greater than zero if target is found,
% respectively, to be less than, to match, or be greater than source.
%
% The format of the CompareStringInfo method is:
%
% int CompareStringInfo(const StringInfo *target,const StringInfo *source)
%
% A description of each parameter follows:
%
% o target: the target string.
%
% o source: the source string.
%
*/
static inline size_t MagickMin(const size_t x,const size_t y)
{
if (x < y)
return(x);
return(y);
}
MagickExport int CompareStringInfo(const StringInfo *target,
const StringInfo *source)
{
int
status;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(target != (StringInfo *) NULL);
assert(target->signature == MagickSignature);
assert(source != (StringInfo *) NULL);
assert(source->signature == MagickSignature);
status=memcmp(target->datum,source->datum,MagickMin(target->length,
source->length));
if (status != 0)
return(status);
if (target->length == source->length)
return(0);
return(target->length < source->length ? -1 : 1);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% C o n c a t e n a t e M a g i c k S t r i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ConcatenateMagickString() concatenates the source string to the destination
% string. The destination buffer is always null-terminated even if the
% string must be truncated.
%
% The format of the ConcatenateMagickString method is:
%
% size_t ConcatenateMagickString(char *destination,const char *source,
% const size_t length)
%
% A description of each parameter follows:
%
% o destination: the destination string.
%
% o source: the source string.
%
% o length: the length of the destination string.
%
*/
MagickExport size_t ConcatenateMagickString(char *destination,
const char *source,const size_t length)
{
register char
*q;
register const char
*p;
register size_t
i;
size_t
count;
assert(destination != (char *) NULL);
assert(source != (const char *) NULL);
assert(length >= 1);
p=source;
q=destination;
i=length;
while ((i-- != 0) && (*q != '\0'))
q++;
count=(size_t) (q-destination);
i=length-count;
if (i == 0)
return(count+strlen(p));
while (*p != '\0')
{
if (i != 1)
{
*q++=(*p);
i--;
}
p++;
}
*q='\0';
return(count+(p-source));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% C o n c a t e n a t e S t r i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ConcatenateString() appends a copy of string source, including the
% terminating null character, to the end of string destination.
%
% The format of the ConcatenateString method is:
%
% MagickBooleanType ConcatenateString(char **destination,
% const char *source)
%
% A description of each parameter follows:
%
% o destination: A pointer to a character string.
%
% o source: A character string.
%
*/
MagickExport MagickBooleanType ConcatenateString(char **destination,
const char *source)
{
size_t
destination_length,
length,
source_length;
assert(destination != (char **) NULL);
if (source == (const char *) NULL)
return(MagickTrue);
if (*destination == (char *) NULL)
{
*destination=AcquireString(source);
return(MagickTrue);
}
destination_length=strlen(*destination);
source_length=strlen(source);
length=destination_length;
if (~length < source_length)
ThrowFatalException(ResourceLimitFatalError,"UnableToConcatenateString");
length+=source_length;
if (~length < MaxTextExtent)
ThrowFatalException(ResourceLimitFatalError,"UnableToConcatenateString");
*destination=(char *) ResizeQuantumMemory(*destination,length+MaxTextExtent,
sizeof(**destination));
if (*destination == (char *) NULL)
ThrowFatalException(ResourceLimitFatalError,"UnableToConcatenateString");
if (source_length != 0)
(void) memcpy((*destination)+destination_length,source,source_length);
(*destination)[length]='\0';
return(MagickTrue);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% C o n c a t e n a t e S t r i n g I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ConcatenateStringInfo() concatenates the source string to the destination
% string.
%
% The format of the ConcatenateStringInfo method is:
%
% void ConcatenateStringInfo(StringInfo *string_info,
% const StringInfo *source)
%
% A description of each parameter follows:
%
% o string_info: the string info.
%
% o source: the source string.
%
*/
MagickExport void ConcatenateStringInfo(StringInfo *string_info,
const StringInfo *source)
{
size_t
length;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(string_info != (StringInfo *) NULL);
assert(string_info->signature == MagickSignature);
assert(source != (const StringInfo *) NULL);
length=string_info->length;
if (~length < source->length)
ThrowFatalException(ResourceLimitFatalError,"UnableToConcatenateString");
SetStringInfoLength(string_info,length+source->length);
(void) memcpy(string_info->datum+length,source->datum,source->length);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% 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 %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ConfigureFileToStringInfo() returns the contents of a configure file as a
% string.
%
% The format of the ConfigureFileToStringInfo method is:
%
% StringInfo *ConfigureFileToStringInfo(const char *filename)
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o filename: the filename.
%
*/
MagickExport StringInfo *ConfigureFileToStringInfo(const char *filename)
{
char
*string;
int
file;
MagickOffsetType
offset;
size_t
length;
StringInfo
*string_info;
void
*map;
assert(filename != (const char *) NULL);
file=open(filename,O_RDONLY | O_BINARY);
if (file == -1)
return((StringInfo *) NULL);
offset=(MagickOffsetType) lseek(file,0,SEEK_END);
if ((offset < 0) || (offset != (MagickOffsetType) ((ssize_t) offset)))
{
file=close(file)-1;
return((StringInfo *) NULL);
}
length=(size_t) offset;
string=(char *) NULL;
if (~length > MaxTextExtent)
string=(char *) AcquireQuantumMemory(length+MaxTextExtent,sizeof(*string));
if (string == (char *) NULL)
{
file=close(file)-1;
return((StringInfo *) NULL);
}
map=MapBlob(file,ReadMode,0,length);
if (map != (void *) NULL)
{
(void) memcpy(string,map,length);
(void) UnmapBlob(map,length);
}
else
{
register size_t
i;
ssize_t
count;
(void) lseek(file,0,SEEK_SET);
for (i=0; i < length; i+=count)
{
count=read(file,string+i,(size_t) MagickMin(length-i,(size_t)
SSIZE_MAX));
if (count <= 0)
{
count=0;
if (errno != EINTR)
break;
}
}
if (i < length)
{
file=close(file)-1;
string=DestroyString(string);
return((StringInfo *) NULL);
}
}
string[length]='\0';
file=close(file)-1;
string_info=AcquireStringInfo(0);
(void) CopyMagickString(string_info->path,filename,MaxTextExtent);
string_info->length=length;
string_info->datum=(unsigned char *) string;
return(string_info);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% C o n s t a n t S t r i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ConstantString() allocates memory for a string and copies the source string
% to that memory location (and returns it). Use it for strings that you do
% do not expect to change over its lifetime.
%
% The format of the ConstantString method is:
%
% char *ConstantString(const char *source)
%
% A description of each parameter follows:
%
% o source: A character string.
%
*/
MagickExport char *ConstantString(const char *source)
{
char
*destination;
size_t
length;
length=0;
if (source != (char *) NULL)
length+=strlen(source);
destination=(char *) NULL;
if (~length >= 1UL)
destination=(char *) AcquireQuantumMemory(length+1UL,sizeof(*destination));
if (destination == (char *) NULL)
ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
*destination='\0';
if (source != (char *) NULL)
(void) memcpy(destination,source,length*sizeof(*destination));
destination[length]='\0';
return(destination);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% C o p y M a g i c k S t r i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% CopyMagickString() copies the source string to the destination string. The
% destination buffer is always null-terminated even if the string must be
% truncated. The return value is the minimum of the source string length
% or the length parameter.
%
% The format of the CopyMagickString method is:
%
% size_t CopyMagickString(const char *destination,char *source,
% const size_t length)
%
% A description of each parameter follows:
%
% o destination: the destination string.
%
% o source: the source string.
%
% o length: the length of the destination string.
%
*/
MagickExport size_t CopyMagickString(char *destination,const char *source,
const size_t length)
{
register char
*q;
register const char
*p;
register size_t
n;
p=source;
q=destination;
for (n=length; n > 4; n-=4)
{
*q=(*p++);
if (*q == '\0')
return((size_t) (p-source-1));
q++;
*q=(*p++);
if (*q == '\0')
return((size_t) (p-source-1));
q++;
*q=(*p++);
if (*q == '\0')
return((size_t) (p-source-1));
q++;
*q=(*p++);
if (*q == '\0')
return((size_t) (p-source-1));
q++;
}
if (n != 0)
for (n--; n != 0; n--)
{
*q=(*p++);
if (*q == '\0')
return((size_t) (p-source-1));
q++;
}
if (length != 0)
*q='\0';
return((size_t) (p-source-1));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% D e s t r o y S t r i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% DestroyString() destroys memory associated with a string.
%
% The format of the DestroyString method is:
%
% char *DestroyString(char *string)
%
% A description of each parameter follows:
%
% o string: the string.
%
*/
MagickExport char *DestroyString(char *string)
{
return((char *) RelinquishMagickMemory(string));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% D e s t r o y S t r i n g I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% DestroyStringInfo() destroys memory associated with the StringInfo structure.
%
% The format of the DestroyStringInfo method is:
%
% StringInfo *DestroyStringInfo(StringInfo *string_info)
%
% A description of each parameter follows:
%
% o string_info: the string info.
%
*/
MagickExport StringInfo *DestroyStringInfo(StringInfo *string_info)
{
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(string_info != (StringInfo *) NULL);
assert(string_info->signature == MagickSignature);
if (string_info->datum != (unsigned char *) NULL)
string_info->datum=(unsigned char *) RelinquishMagickMemory(
string_info->datum);
string_info->signature=(~MagickSignature);
string_info=(StringInfo *) RelinquishMagickMemory(string_info);
return(string_info);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% D e s t r o y S t r i n g L i s t %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% DestroyStringList() zeros memory associated with a string list.
%
% The format of the DestroyStringList method is:
%
% char **DestroyStringList(char **list)
%
% A description of each parameter follows:
%
% o list: the string list.
%
*/
MagickExport char **DestroyStringList(char **list)
{
register ssize_t
i;
assert(list != (char **) NULL);
for (i=0; list[i] != (char *) NULL; i++)
list[i]=DestroyString(list[i]);
list=(char **) RelinquishMagickMemory(list);
return(list);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% E s c a p e S t r i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% EscapeString() allocates memory for a backslash-escaped version of a
% source text string, copies the escaped version of the text to that
% memory location while adding backslash characters, and returns the
% escaped string.
%
% The format of the EscapeString method is:
%
% char *EscapeString(const char *source,const char escape)
%
% A description of each parameter follows:
%
% o allocate_string: Method EscapeString returns the escaped string.
%
% o source: A character string.
%
% o escape: the quoted string termination character to escape (e.g. '"').
%
*/
MagickExport char *EscapeString(const char *source,const char escape)
{
char
*destination;
register char
*q;
register const char
*p;
size_t
length;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(source != (const char *) NULL);
length=strlen(source);
for (p=source; *p != '\0'; p++)
if ((*p == '\\') || (*p == escape))
{
if (~length < 1)
ThrowFatalException(ResourceLimitFatalError,"UnableToEscapeString");
length++;
}
destination=(char *) NULL;
if (~length >= MaxTextExtent)
destination=(char *) AcquireQuantumMemory(length+MaxTextExtent,
sizeof(*destination));
if (destination == (char *) NULL)
ThrowFatalException(ResourceLimitFatalError,"UnableToEscapeString");
*destination='\0';
if (source != (char *) NULL)
{
q=destination;
for (p=source; *p != '\0'; p++)
{
if ((*p == '\\') || (*p == escape))
*q++='\\';
*q++=(*p);
}
*q='\0';
}
return(destination);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% F i l e T o S t r i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% FileToString() returns the contents of a file as a string.
%
% The format of the FileToString method is:
%
% char *FileToString(const char *filename,const size_t extent,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o filename: the filename.
%
% o extent: Maximum length of the string.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport char *FileToString(const char *filename,const size_t extent,
ExceptionInfo *exception)
{
size_t
length;
assert(filename != (const char *) NULL);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",filename);
assert(exception != (ExceptionInfo *) NULL);
return((char *) FileToBlob(filename,extent,&length,exception));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% F i l e T o S t r i n g I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% FileToStringInfo() returns the contents of a file as a string.
%
% The format of the FileToStringInfo method is:
%
% StringInfo *FileToStringInfo(const char *filename,const size_t extent,
% ExceptionInfo *exception)
%
% A description of each parameter follows:
%
% o filename: the filename.
%
% o extent: Maximum length of the string.
%
% o exception: return any errors or warnings in this structure.
%
*/
MagickExport StringInfo *FileToStringInfo(const char *filename,
const size_t extent,ExceptionInfo *exception)
{
StringInfo
*string_info;
assert(filename != (const char *) NULL);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",filename);
assert(exception != (ExceptionInfo *) NULL);
string_info=AcquireStringInfo(0);
(void) CopyMagickString(string_info->path,filename,MaxTextExtent);
string_info->datum=FileToBlob(filename,extent,&string_info->length,exception);
if (string_info->datum == (unsigned char *) NULL)
{
string_info=DestroyStringInfo(string_info);
return((StringInfo *) NULL);
}
return(string_info);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% F o r m a t M a g i c k S i z e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% FormatMagickSize() converts a size to a human readable format, for example,
% 14k, 234m, 2.7g, or 3.0t. Scaling is done by repetitively dividing by
% 1000.
%
% The format of the FormatMagickSize method is:
%
% ssize_t FormatMagickSize(const MagickSizeType size,char *format)
%
% A description of each parameter follows:
%
% o size: convert this size to a human readable format.
%
% o bi: use power of two rather than power of ten.
%
% o format: human readable format.
%
*/
MagickExport ssize_t FormatMagickSize(const MagickSizeType size,
const MagickBooleanType bi,char *format)
{
const char
**units;
double
bytes,
length;
register ssize_t
i,
j;
ssize_t
count;
static const char
*bi_units[] =
{
"", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi", "Yi", (char *) NULL
},
*traditional_units[] =
{
"", "K", "M", "G", "T", "P", "E", "Z", "Y", (char *) NULL
};
bytes=1000.0;
units=traditional_units;
if (bi != MagickFalse)
{
bytes=1024.0;
units=bi_units;
}
#if defined(_MSC_VER) && (_MSC_VER == 1200)
length=(double) ((MagickOffsetType) size);
#else
length=(double) size;
#endif
for (i=0; (length >= bytes) && (units[i+1] != (const char *) NULL); i++)
length/=bytes;
for (j=2; j < 12; j++)
{
count=FormatMagickString(format,MaxTextExtent,"%.*g%sB",(int) (i+j),length,
units[i]);
if (strchr(format,'+') == (char *) NULL)
break;
}
return(count);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% F o r m a t M a g i c k S t r i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% FormatMagickString() prints formatted output of a variable argument list.
%
% The format of the FormatMagickString method is:
%
% ssize_t FormatMagickString(char *string,const size_t length,
% const char *format,...)
%
% A description of each parameter follows.
%
% o string: FormatMagickString() returns the formatted string in this
% character buffer.
%
% o length: the maximum length of the string.
%
% o format: A string describing the format to use to write the remaining
% arguments.
%
*/
MagickExport ssize_t FormatMagickStringList(char *string,const size_t length,
const char *format,va_list operands)
{
int
n;
#if defined(MAGICKCORE_HAVE_VSNPRINTF)
n=vsnprintf(string,length,format,operands);
#else
n=vsprintf(string,format,operands);
#endif
if (n < 0)
string[length-1]='\0';
return((ssize_t) n);
}
MagickExport ssize_t FormatMagickString(char *string,const size_t length,
const char *format,...)
{
ssize_t
n;
va_list
operands;
va_start(operands,format);
n=(ssize_t) FormatMagickStringList(string,length,format,operands);
va_end(operands);
return(n);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% F o r m a t M a g i c k T i m e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% FormatMagickTime() returns the specified time in the Internet date/time
% format and the length of the timestamp.
%
% The format of the FormatMagickTime method is:
%
% ssize_t FormatMagickTime(const time_t time,const size_t length,
% char *timestamp)
%
% A description of each parameter follows.
%
% o time: the time since the Epoch (00:00:00 UTC, January 1, 1970),
% measured in seconds.
%
% o length: the maximum length of the string.
%
% o timestamp: Return the Internet date/time here.
%
*/
MagickExport ssize_t FormatMagickTime(const time_t time,const size_t length,
char *timestamp)
{
ssize_t
count;
struct tm
gm_time,
local_time;
time_t
timezone;
assert(timestamp != (char *) NULL);
(void) ResetMagickMemory(&local_time,0,sizeof(local_time));
(void) ResetMagickMemory(&gm_time,0,sizeof(gm_time));
#if defined(MAGICKCORE_HAVE_LOCALTIME_R)
(void) localtime_r(&time,&local_time);
#else
{
struct tm
*my_time;
my_time=localtime(&time);
if (my_time != (struct tm *) NULL)
(void) memcpy(&local_time,my_time,sizeof(local_time));
}
#endif
#if defined(MAGICKCORE_HAVE_GMTIME_R)
(void) gmtime_r(&time,&gm_time);
#else
{
struct tm
*my_time;
my_time=gmtime(&time);
if (my_time != (struct tm *) NULL)
(void) memcpy(&gm_time,my_time,sizeof(gm_time));
}
#endif
timezone=(time_t) ((local_time.tm_min-gm_time.tm_min)/60+
local_time.tm_hour-gm_time.tm_hour+24*((local_time.tm_year-
gm_time.tm_year) != 0 ? (local_time.tm_year-gm_time.tm_year) :
(local_time.tm_yday-gm_time.tm_yday)));
count=FormatMagickString(timestamp,length,
"%04d-%02d-%02dT%02d:%02d:%02d%+03ld:00",local_time.tm_year+1900,
local_time.tm_mon+1,local_time.tm_mday,local_time.tm_hour,
local_time.tm_min,local_time.tm_sec,(long) timezone);
return(count);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% G e t E n v i r o n m e n t V a l u e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% GetEnvironmentValue() returns the environment string that matches the
% specified name.
%
% The format of the GetEnvironmentValue method is:
%
% char *GetEnvironmentValue(const char *name)
%
% A description of each parameter follows:
%
% o name: the environment name.
%
*/
MagickExport char *GetEnvironmentValue(const char *name)
{
const char
*environment;
environment=getenv(name);
if (environment == (const char *) NULL)
return((char *) NULL);
return(ConstantString(environment));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% G e t S t r i n g I n f o D a t u m %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% GetStringInfoDatum() returns the datum associated with the string.
%
% The format of the GetStringInfoDatum method is:
%
% unsigned char *GetStringInfoDatum(const StringInfo *string_info)
%
% A description of each parameter follows:
%
% o string_info: the string info.
%
*/
MagickExport unsigned char *GetStringInfoDatum(const StringInfo *string_info)
{
assert(string_info != (StringInfo *) NULL);
assert(string_info->signature == MagickSignature);
return(string_info->datum);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% G e t S t r i n g I n f o L e n g t h %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% GetStringInfoLength() returns the string length.
%
% The format of the GetStringInfoLength method is:
%
% size_t GetStringInfoLength(const StringInfo *string_info)
%
% A description of each parameter follows:
%
% o string_info: the string info.
%
*/
MagickExport size_t GetStringInfoLength(const StringInfo *string_info)
{
assert(string_info != (StringInfo *) NULL);
assert(string_info->signature == MagickSignature);
return(string_info->length);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% G e t S t r i n g I n f o P a t h %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% GetStringInfoPath() returns the path associated with the string.
%
% The format of the GetStringInfoPath method is:
%
% const char *GetStringInfoPath(const StringInfo *string_info)
%
% A description of each parameter follows:
%
% o string_info: the string info.
%
*/
MagickExport const char *GetStringInfoPath(const StringInfo *string_info)
{
assert(string_info != (StringInfo *) NULL);
assert(string_info->signature == MagickSignature);
return(string_info->path);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% L o c a l e C o m p a r e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% LocaleCompare() performs a case-insensitive comparison of two strings
% byte-by-byte, according to the ordering of the current locale encoding.
% LocaleCompare returns an integer greater than, equal to, or less than 0,
% if the string pointed to by p is greater than, equal to, or less than the
% string pointed to by q respectively. The sign of a non-zero return value
% is determined by the sign of the difference between the values of the first
% pair of bytes that differ in the strings being compared.
%
% The format of the LocaleCompare method is:
%
% int LocaleCompare(const char *p,const char *q)
%
% A description of each parameter follows:
%
% o p: A pointer to a character string.
%
% o q: A pointer to a character string to compare to p.
%
*/
MagickExport int LocaleCompare(const char *p,const char *q)
{
if ((p == (char *) NULL) && (q == (char *) NULL))
return(0);
if (p == (char *) NULL)
return(-1);
if (q == (char *) NULL)
return(1);
#if defined(MAGICKCORE_HAVE_STRCASECMP)
return(strcasecmp(p,q));
#else
{
register int
c,
d;
for ( ; ; )
{
c=(int) *((unsigned char *) p);
d=(int) *((unsigned char *) q);
if ((c == 0) || (AsciiMap[c] != AsciiMap[d]))
break;
p++;
q++;
}
return(AsciiMap[c]-(int) AsciiMap[d]);
}
#endif
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% L o c a l e L o w e r %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% LocaleLower() transforms all of the characters in the supplied
% null-terminated string, changing all uppercase letters to lowercase.
%
% The format of the LocaleLower method is:
%
% void LocaleLower(char *string)
%
% A description of each parameter follows:
%
% o string: A pointer to the string to convert to lower-case Locale.
%
*/
MagickExport void LocaleLower(char *string)
{
register char
*q;
assert(string != (char *) NULL);
for (q=string; *q != '\0'; q++)
*q=(char) tolower((int) *q);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% L o c a l e N C o m p a r e %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% LocaleNCompare() performs a case-insensitive comparison of two
% strings byte-by-byte, according to the ordering of the current locale
% encoding. LocaleNCompare returns an integer greater than, equal to, or
% less than 0, if the string pointed to by p is greater than, equal to, or
% less than the string pointed to by q respectively. The sign of a non-zero
% return value is determined by the sign of the difference between the
% values of the first pair of bytes that differ in the strings being
% compared. The LocaleNCompare method makes the same comparison as
% LocaleCompare but looks at a maximum of n bytes. Bytes following a
% null byte are not compared.
%
% The format of the LocaleNCompare method is:
%
% int LocaleNCompare(const char *p,const char *q,const size_t n)
%
% A description of each parameter follows:
%
% o p: A pointer to a character string.
%
% o q: A pointer to a character string to compare to p.
%
% o length: the number of characters to compare in strings p and q.
%
*/
MagickExport int LocaleNCompare(const char *p,const char *q,const size_t length)
{
if (p == (char *) NULL)
return(-1);
if (q == (char *) NULL)
return(1);
#if defined(MAGICKCORE_HAVE_STRNCASECMP)
return(strncasecmp(p,q,length));
#else
{
register int
c,
d;
register size_t
i;
for (i=length; i != 0; i--)
{
c=(int) *((unsigned char *) p);
d=(int) *((unsigned char *) q);
if (AsciiMap[c] != AsciiMap[d])
return(AsciiMap[c]-(int) AsciiMap[d]);
if (c == 0)
return(0);
p++;
q++;
}
return(0);
}
#endif
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% L o c a l e U p p e r %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% LocaleUpper() transforms all of the characters in the supplied
% null-terminated string, changing all lowercase letters to uppercase.
%
% The format of the LocaleUpper method is:
%
% void LocaleUpper(char *string)
%
% A description of each parameter follows:
%
% o string: A pointer to the string to convert to upper-case Locale.
%
*/
MagickExport void LocaleUpper(char *string)
{
register char
*q;
assert(string != (char *) NULL);
for (q=string; *q != '\0'; q++)
*q=(char) toupper((int) *q);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% P r i n t S t r i n g I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% PrintStringInfo() prints the string.
%
% The format of the PrintStringInfo method is:
%
% void PrintStringInfo(FILE *file,const char *id,
% const StringInfo *string_info)
%
% A description of each parameter follows:
%
% o file: the file, typically stdout.
%
% o id: the string id.
%
% o string_info: the string info.
%
*/
MagickExport void PrintStringInfo(FILE *file,const char *id,
const StringInfo *string_info)
{
register const char
*p;
register size_t
i,
j;
assert(id != (const char *) NULL);
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"%s",id);
assert(string_info != (StringInfo *) NULL);
assert(string_info->signature == MagickSignature);
p=(char *) string_info->datum;
for (i=0; i < string_info->length; i++)
{
if (((int) ((unsigned char) *p) < 32) &&
(isspace((int) ((unsigned char) *p)) == 0))
break;
p++;
}
if (i == string_info->length)
{
(void) fputs((char *) string_info->datum,file);
(void) fputc('\n',file);
return;
}
/*
Convert string to a HEX list.
*/
p=(char *) string_info->datum;
for (i=0; i < string_info->length; i+=0x14)
{
(void) fprintf(file,"0x%08lx: ",(unsigned long) (0x14*i));
for (j=1; j <= MagickMin(string_info->length-i,0x14); j++)
{
(void) fprintf(file,"%02lx",(unsigned long) (*(p+j)) & 0xff);
if ((j % 0x04) == 0)
(void) fputc(' ',file);
}
for ( ; j <= 0x14; j++)
{
(void) fputc(' ',file);
(void) fputc(' ',file);
if ((j % 0x04) == 0)
(void) fputc(' ',file);
}
(void) fputc(' ',file);
for (j=1; j <= MagickMin(string_info->length-i,0x14); j++)
{
if (isprint((int) ((unsigned char) *p)) != 0)
(void) fputc(*p,file);
else
(void) fputc('-',file);
p++;
}
(void) fputc('\n',file);
}
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% R e s e t S t r i n g I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% ResetStringInfo() reset the string to all null bytes.
%
% The format of the ResetStringInfo method is:
%
% void ResetStringInfo(StringInfo *string_info)
%
% A description of each parameter follows:
%
% o string_info: the string info.
%
*/
MagickExport void ResetStringInfo(StringInfo *string_info)
{
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(string_info != (StringInfo *) NULL);
assert(string_info->signature == MagickSignature);
(void) ResetMagickMemory(string_info->datum,0,string_info->length);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S e t S t r i n g I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% SetStringInfo() copies the source string to the destination string.
%
% The format of the SetStringInfo method is:
%
% void SetStringInfo(StringInfo *string_info,const StringInfo *source)
%
% A description of each parameter follows:
%
% o string_info: the string info.
%
% o source: the source string.
%
*/
MagickExport void SetStringInfo(StringInfo *string_info,
const StringInfo *source)
{
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(string_info != (StringInfo *) NULL);
assert(string_info->signature == MagickSignature);
assert(source != (StringInfo *) NULL);
assert(source->signature == MagickSignature);
if (string_info->length == 0)
return;
(void) ResetMagickMemory(string_info->datum,0,string_info->length);
(void) memcpy(string_info->datum,source->datum,MagickMin(string_info->length,
source->length));
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S e t S t r i n g I n f o D a t u m %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% SetStringInfoDatum() copies bytes from the source string for the length of
% the destination string.
%
% The format of the SetStringInfoDatum method is:
%
% void SetStringInfoDatum(StringInfo *string_info,
% const unsigned char *source)
%
% A description of each parameter follows:
%
% o string_info: the string info.
%
% o source: the source string.
%
*/
MagickExport void SetStringInfoDatum(StringInfo *string_info,
const unsigned char *source)
{
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(string_info != (StringInfo *) NULL);
assert(string_info->signature == MagickSignature);
if (string_info->length != 0)
(void) memcpy(string_info->datum,source,string_info->length);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S e t S t r i n g I n f o L e n g t h %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% SetStringInfoLength() set the string length to the specified value.
%
% The format of the SetStringInfoLength method is:
%
% void SetStringInfoLength(StringInfo *string_info,const size_t length)
%
% A description of each parameter follows:
%
% o string_info: the string info.
%
% o length: the string length.
%
*/
MagickExport void SetStringInfoLength(StringInfo *string_info,
const size_t length)
{
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(string_info != (StringInfo *) NULL);
assert(string_info->signature == MagickSignature);
if (~length < MaxTextExtent)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
string_info->length=length;
if (string_info->datum == (unsigned char *) NULL)
string_info->datum=(unsigned char *) AcquireQuantumMemory(length+
MaxTextExtent,sizeof(*string_info->datum));
else
string_info->datum=(unsigned char *) ResizeQuantumMemory(string_info->datum,
length+MaxTextExtent,sizeof(*string_info->datum));
if (string_info->datum == (unsigned char *) NULL)
ThrowFatalException(ResourceLimitFatalError,"MemoryAllocationFailed");
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S e t S t r i n g I n f o D a t u m %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% SetStringInfoPath() sets the path associated with the string.
%
% The format of the SetStringInfoPath method is:
%
% void SetStringInfoPath(StringInfo *string_info,const char *path)
%
% A description of each parameter follows:
%
% o string_info: the string info.
%
% o path: the path.
%
*/
MagickExport void SetStringInfoPath(StringInfo *string_info,const char *path)
{
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(string_info != (StringInfo *) NULL);
assert(string_info->signature == MagickSignature);
assert(path != (const char *) NULL);
(void) CopyMagickString(string_info->path,path,MaxTextExtent);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S p l i t S t r i n g I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% SplitStringInfo() splits a string into two and returns it.
%
% The format of the SplitStringInfo method is:
%
% StringInfo *SplitStringInfo(StringInfo *string_info,const size_t offset)
%
% A description of each parameter follows:
%
% o string_info: the string info.
%
*/
MagickExport StringInfo *SplitStringInfo(StringInfo *string_info,
const size_t offset)
{
StringInfo
*split_info;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(string_info != (StringInfo *) NULL);
assert(string_info->signature == MagickSignature);
if (offset > string_info->length)
return((StringInfo *) NULL);
split_info=AcquireStringInfo(offset);
SetStringInfo(split_info,string_info);
(void) memcpy(string_info->datum,string_info->datum+offset,
string_info->length-offset+MaxTextExtent);
SetStringInfoLength(string_info,string_info->length-offset);
return(split_info);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S t r i n g I n f o T o S t r i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% StringInfoToString() converts a string info string to a C string.
%
% The format of the StringInfoToString method is:
%
% char *StringInfoToString(const StringInfo *string_info)
%
% A description of each parameter follows:
%
% o string_info: the string.
%
*/
MagickExport char *StringInfoToString(const StringInfo *string_info)
{
char
*string;
size_t
length;
string=(char *) NULL;
length=string_info->length;
if (~length >= MaxTextExtent)
string=(char *) AcquireQuantumMemory(length+MaxTextExtent,sizeof(*string));
if (string == (char *) NULL)
return((char *) NULL);
(void) memcpy(string,(char *) string_info->datum,length*sizeof(*string));
string[length]='\0';
return(string);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S t r i n g T o A r g v %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% StringToArgv() converts a text string into command line arguments.
%
% The format of the StringToArgv method is:
%
% char **StringToArgv(const char *text,int *argc)
%
% A description of each parameter follows:
%
% o argv: Method StringToArgv returns the string list unless an error
% occurs, otherwise NULL.
%
% o text: Specifies the string to segment into a list.
%
% o argc: This integer pointer returns the number of arguments in the
% list.
%
*/
MagickExport char **StringToArgv(const char *text,int *argc)
{
char
**argv;
register const char
*p,
*q;
register ssize_t
i;
*argc=0;
if (text == (char *) NULL)
return((char **) NULL);
/*
Determine the number of arguments.
*/
for (p=text; *p != '\0'; )
{
while (isspace((int) ((unsigned char) *p)) != 0)
p++;
if (*p == '\0')
break;
(*argc)++;
if (*p == '"')
for (p++; (*p != '"') && (*p != '\0'); p++) ;
if (*p == '\'')
for (p++; (*p != '\'') && (*p != '\0'); p++) ;
while ((isspace((int) ((unsigned char) *p)) == 0) && (*p != '\0'))
p++;
}
(*argc)++;
argv=(char **) AcquireQuantumMemory((size_t) (*argc+1UL),sizeof(*argv));
if (argv == (char **) NULL)
ThrowFatalException(ResourceLimitFatalError,"UnableToConvertStringToARGV");
/*
Convert string to an ASCII list.
*/
argv[0]=AcquireString("magick");
p=text;
for (i=1; i < (ssize_t) *argc; i++)
{
while (isspace((int) ((unsigned char) *p)) != 0)
p++;
q=p;
if (*q == '"')
{
p++;
for (q++; (*q != '"') && (*q != '\0'); q++) ;
}
else
if (*q == '\'')
{
p++;
for (q++; (*q != '\'') && (*q != '\0'); q++) ;
}
else
while ((isspace((int) ((unsigned char) *q)) == 0) && (*q != '\0'))
q++;
argv[i]=(char *) AcquireQuantumMemory((size_t) (q-p)+MaxTextExtent,
sizeof(**argv));
if (argv[i] == (char *) NULL)
{
for (i--; i >= 0; i--)
argv[i]=DestroyString(argv[i]);
argv=(char **) RelinquishMagickMemory(argv);
ThrowFatalException(ResourceLimitFatalError,
"UnableToConvertStringToARGV");
}
(void) memcpy(argv[i],p,(size_t) (q-p));
argv[i][q-p]='\0';
p=q;
while ((isspace((int) ((unsigned char) *p)) == 0) && (*p != '\0'))
p++;
}
argv[i]=(char *) NULL;
return(argv);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S t r i n g I n f o T o H e x S t r i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% StringInfoToHexString() converts a string info string to a C string.
%
% The format of the StringInfoToHexString method is:
%
% char *StringInfoToHexString(const StringInfo *string_info)
%
% A description of each parameter follows:
%
% o string_info: the string.
%
*/
MagickExport char *StringInfoToHexString(const StringInfo *string_info)
{
char
*string;
register const unsigned char
*p;
register ssize_t
i;
register unsigned char
*q;
size_t
length;
unsigned char
hex_digits[16];
length=string_info->length;
if (~length < MaxTextExtent)
ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
string=(char *) AcquireQuantumMemory(length+MaxTextExtent,2*sizeof(*string));
if (string == (char *) NULL)
ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
hex_digits[0]='0';
hex_digits[1]='1';
hex_digits[2]='2';
hex_digits[3]='3';
hex_digits[4]='4';
hex_digits[5]='5';
hex_digits[6]='6';
hex_digits[7]='7';
hex_digits[8]='8';
hex_digits[9]='9';
hex_digits[10]='a';
hex_digits[11]='b';
hex_digits[12]='c';
hex_digits[13]='d';
hex_digits[14]='e';
hex_digits[15]='f';
p=string_info->datum;
q=(unsigned char *) string;
for (i=0; i < (ssize_t) string_info->length; i++)
{
*q++=hex_digits[(*p >> 4) & 0x0f];
*q++=hex_digits[*p & 0x0f];
p++;
}
*q='\0';
return(string);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S t r i n g T o k e n %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% StringToken() extracts a token a from the string.
%
% The format of the StringToken method is:
%
% char *StringToken(const char *delimiters,char **string)
%
% A description of each parameter follows:
%
% o delimiters: one or more delimiters.
%
% o string: return the first token in the string. If none is found, return
% NULL.
%
*/
MagickExport char *StringToken(const char *delimiters,char **string)
{
char
*q;
register char
*p;
register const char
*r;
register int
c,
d;
p=(*string);
if (p == (char *) NULL)
return((char *) NULL);
for (q=p; ; )
{
c=(*p++);
r=delimiters;
do
{
d=(*r++);
if (c == d)
{
if (c == '\0')
p=(char *) NULL;
else
p[-1]='\0';
*string=p;
return(q);
}
} while (d != '\0');
}
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S t r i n g T o L i s t %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% StringToList() converts a text string into a list by segmenting the text
% string at each carriage return discovered. The list is converted to HEX
% characters if any control characters are discovered within the text string.
%
% The format of the StringToList method is:
%
% char **StringToList(const char *text)
%
% A description of each parameter follows:
%
% o text: Specifies the string to segment into a list.
%
*/
MagickExport char **StringToList(const char *text)
{
char
**textlist;
register const char
*p;
register ssize_t
i;
size_t
lines;
if (text == (char *) NULL)
return((char **) NULL);
for (p=text; *p != '\0'; p++)
if (((int) ((unsigned char) *p) < 32) &&
(isspace((int) ((unsigned char) *p)) == 0))
break;
if (*p == '\0')
{
register const char
*q;
/*
Convert string to an ASCII list.
*/
lines=1;
for (p=text; *p != '\0'; p++)
if (*p == '\n')
lines++;
textlist=(char **) AcquireQuantumMemory((size_t) lines+1UL,
sizeof(*textlist));
if (textlist == (char **) NULL)
ThrowFatalException(ResourceLimitFatalError,"UnableToConvertText");
p=text;
for (i=0; i < (ssize_t) lines; i++)
{
for (q=p; *q != '\0'; q++)
if ((*q == '\r') || (*q == '\n'))
break;
textlist[i]=(char *) AcquireQuantumMemory((size_t) (q-p)+MaxTextExtent,
sizeof(**textlist));
if (textlist[i] == (char *) NULL)
ThrowFatalException(ResourceLimitFatalError,"UnableToConvertText");
(void) memcpy(textlist[i],p,(size_t) (q-p));
textlist[i][q-p]='\0';
if (*q == '\r')
q++;
p=q+1;
}
}
else
{
char
hex_string[MaxTextExtent];
register char
*q;
register ssize_t
j;
/*
Convert string to a HEX list.
*/
lines=(size_t) (strlen(text)/0x14)+1;
textlist=(char **) AcquireQuantumMemory((size_t) lines+1UL,
sizeof(*textlist));
if (textlist == (char **) NULL)
ThrowFatalException(ResourceLimitFatalError,"UnableToConvertText");
p=text;
for (i=0; i < (ssize_t) lines; i++)
{
textlist[i]=(char *) AcquireQuantumMemory(2UL*MaxTextExtent,
sizeof(**textlist));
if (textlist[i] == (char *) NULL)
ThrowFatalException(ResourceLimitFatalError,"UnableToConvertText");
(void) FormatMagickString(textlist[i],MaxTextExtent,"0x%08lx: ",
(long) (0x14*i));
q=textlist[i]+strlen(textlist[i]);
for (j=1; j <= (ssize_t) MagickMin(strlen(p),0x14); j++)
{
(void) FormatMagickString(hex_string,MaxTextExtent,"%02x",*(p+j));
(void) CopyMagickString(q,hex_string,MaxTextExtent);
q+=2;
if ((j % 0x04) == 0)
*q++=' ';
}
for ( ; j <= 0x14; j++)
{
*q++=' ';
*q++=' ';
if ((j % 0x04) == 0)
*q++=' ';
}
*q++=' ';
for (j=1; j <= (ssize_t) MagickMin(strlen(p),0x14); j++)
{
if (isprint((int) ((unsigned char) *p)) != 0)
*q++=(*p);
else
*q++='-';
p++;
}
*q='\0';
}
}
textlist[i]=(char *) NULL;
return(textlist);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S t r i n g T o S t r i n g I n f o %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% StringToStringInfo() returns the contents of a file as a string.
%
% The format of the StringToStringInfo method is:
%
% StringInfo *StringToStringInfo(const char *string)
%
% A description of each parameter follows:
%
% o string: The string.
%
*/
MagickExport StringInfo *StringToStringInfo(const char *string)
{
StringInfo
*string_info;
(void) LogMagickEvent(TraceEvent,GetMagickModule(),"...");
assert(string != (const char *) NULL);
string_info=AcquireStringInfo(strlen(string)+1);
SetStringInfoDatum(string_info,(const unsigned char *) string);
return(string_info);
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S t r i p S t r i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% StripString() strips any whitespace or quotes from the beginning and end of
% a string of characters.
%
% The format of the StripString method is:
%
% void StripString(char *message)
%
% A description of each parameter follows:
%
% o message: Specifies an array of characters.
%
*/
MagickExport void StripString(char *message)
{
register char
*p,
*q;
size_t
length;
assert(message != (char *) NULL);
if (*message == '\0')
return;
length=strlen(message);
p=message;
while (isspace((int) ((unsigned char) *p)) != 0)
p++;
if ((*p == '\'') || (*p == '"'))
p++;
q=message+length-1;
while ((isspace((int) ((unsigned char) *q)) != 0) && (q > p))
q--;
if (q > p)
if ((*q == '\'') || (*q == '"'))
q--;
(void) memcpy(message,p,(size_t) (q-p+1));
message[q-p+1]='\0';
for (p=message; *p != '\0'; p++)
if (*p == '\n')
*p=' ';
}
/*
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% %
% %
% %
% S u b s t i t u t e S t r i n g %
% %
% %
% %
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
%
% SubstituteString() performs string substitution on a string, replacing the
% string with the substituted version. Buffer must be allocated from the heap.
% If the string is matched and status, MagickTrue is returned otherwise
% MagickFalse.
%
% The format of the SubstituteString method is:
%
% MagickBooleanType SubstituteString(char **string,const char *search,
% const char *replace)
%
% A description of each parameter follows:
%
% o string: the string to perform replacements on; replaced with new
% allocation if a replacement is made.
%
% o search: search for this string.
%
% o replace: replace any matches with this string.
%
*/
MagickExport MagickBooleanType SubstituteString(char **string,
const char *search,const char *replace)
{
MagickBooleanType
status;
register char
*p;
size_t
extent,
replace_extent,
search_extent;
ssize_t
offset;
status=MagickFalse;
search_extent=0,
replace_extent=0;
for (p=strchr(*string,*search); p != (char *) NULL; p=strchr(p+1,*search))
{
if (search_extent == 0)
search_extent=strlen(search);
if (strncmp(p,search,search_extent) != 0)
continue;
/*
We found a match.
*/
status=MagickTrue;
if (replace_extent == 0)
replace_extent=strlen(replace);
if (replace_extent > search_extent)
{
/*
Make room for the replacement string.
*/
offset=(ssize_t) (p-(*string));
extent=strlen(*string)+replace_extent-search_extent+1;
*string=(char *) ResizeQuantumMemory(*string,extent+MaxTextExtent,
sizeof(*p));
if (*string == (char *) NULL)
ThrowFatalException(ResourceLimitFatalError,"UnableToAcquireString");
p=(*string)+offset;
}
/*
Replace string.
*/
if (search_extent != replace_extent)
(void) CopyMagickMemory(p+replace_extent,p+search_extent,
strlen(p+search_extent)+1);
(void) CopyMagickMemory(p,replace,replace_extent);
p+=replace_extent-1;
}
return(status);
}