CMake/Source/kwsys/System.c

302 lines
7.9 KiB
C

/*============================================================================
KWSys - Kitware System Library
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#include "kwsysPrivate.h"
#include KWSYS_HEADER(System.h)
/* Work-around CMake dependency scanning limitation. This must
duplicate the above list of headers. */
#if 0
# include "System.h.in"
#endif
#include <stddef.h> /* ptrdiff_t */
#include <stdlib.h> /* malloc, free */
#include <string.h> /* memcpy */
#include <ctype.h> /* isspace */
#include <stdio.h>
#if defined(KWSYS_C_HAS_PTRDIFF_T) && KWSYS_C_HAS_PTRDIFF_T
typedef ptrdiff_t kwsysSystem_ptrdiff_t;
#else
typedef int kwsysSystem_ptrdiff_t;
#endif
/*--------------------------------------------------------------------------*/
static int kwsysSystem__AppendByte(char* local,
char** begin, char** end,
int* size, char c)
{
/* Allocate space for the character. */
if((*end - *begin) >= *size)
{
kwsysSystem_ptrdiff_t length = *end - *begin;
char* newBuffer = (char*)malloc((size_t)(*size*2));
if(!newBuffer)
{
return 0;
}
memcpy(newBuffer, *begin, (size_t)(length)*sizeof(char));
if(*begin != local)
{
free(*begin);
}
*begin = newBuffer;
*end = *begin + length;
*size *= 2;
}
/* Store the character. */
*(*end)++ = c;
return 1;
}
/*--------------------------------------------------------------------------*/
static int kwsysSystem__AppendArgument(char** local,
char*** begin, char*** end,
int* size,
char* arg_local,
char** arg_begin, char** arg_end,
int* arg_size)
{
/* Append a null-terminator to the argument string. */
if(!kwsysSystem__AppendByte(arg_local, arg_begin, arg_end, arg_size, '\0'))
{
return 0;
}
/* Allocate space for the argument pointer. */
if((*end - *begin) >= *size)
{
kwsysSystem_ptrdiff_t length = *end - *begin;
char** newPointers = (char**)malloc((size_t)(*size)*2*sizeof(char*));
if(!newPointers)
{
return 0;
}
memcpy(newPointers, *begin, (size_t)(length)*sizeof(char*));
if(*begin != local)
{
free(*begin);
}
*begin = newPointers;
*end = *begin + length;
*size *= 2;
}
/* Allocate space for the argument string. */
**end = (char*)malloc((size_t)(*arg_end - *arg_begin));
if(!**end)
{
return 0;
}
/* Store the argument in the command array. */
memcpy(**end, *arg_begin,(size_t)(*arg_end - *arg_begin));
++(*end);
/* Reset the argument to be empty. */
*arg_end = *arg_begin;
return 1;
}
/*--------------------------------------------------------------------------*/
#define KWSYSPE_LOCAL_BYTE_COUNT 1024
#define KWSYSPE_LOCAL_ARGS_COUNT 32
static char** kwsysSystem__ParseUnixCommand(const char* command, int flags)
{
/* Create a buffer for argument pointers during parsing. */
char* local_pointers[KWSYSPE_LOCAL_ARGS_COUNT];
int pointers_size = KWSYSPE_LOCAL_ARGS_COUNT;
char** pointer_begin = local_pointers;
char** pointer_end = pointer_begin;
/* Create a buffer for argument strings during parsing. */
char local_buffer[KWSYSPE_LOCAL_BYTE_COUNT];
int buffer_size = KWSYSPE_LOCAL_BYTE_COUNT;
char* buffer_begin = local_buffer;
char* buffer_end = buffer_begin;
/* Parse the command string. Try to behave like a UNIX shell. */
char** newCommand = 0;
const char* c = command;
int in_argument = 0;
int in_escape = 0;
int in_single = 0;
int in_double = 0;
int failed = 0;
for(;*c; ++c)
{
if(in_escape)
{
/* This character is escaped so do no special handling. */
if(!in_argument)
{
in_argument = 1;
}
if(!kwsysSystem__AppendByte(local_buffer, &buffer_begin,
&buffer_end, &buffer_size, *c))
{
failed = 1;
break;
}
in_escape = 0;
}
else if(*c == '\\')
{
/* The next character should be escaped. */
in_escape = 1;
}
else if(*c == '\'' && !in_double)
{
/* Enter or exit single-quote state. */
if(in_single)
{
in_single = 0;
}
else
{
in_single = 1;
if(!in_argument)
{
in_argument = 1;
}
}
}
else if(*c == '"' && !in_single)
{
/* Enter or exit double-quote state. */
if(in_double)
{
in_double = 0;
}
else
{
in_double = 1;
if(!in_argument)
{
in_argument = 1;
}
}
}
else if(isspace((unsigned char) *c))
{
if(in_argument)
{
if(in_single || in_double)
{
/* This space belongs to a quoted argument. */
if(!kwsysSystem__AppendByte(local_buffer, &buffer_begin,
&buffer_end, &buffer_size, *c))
{
failed = 1;
break;
}
}
else
{
/* This argument has been terminated by whitespace. */
if(!kwsysSystem__AppendArgument(local_pointers, &pointer_begin,
&pointer_end, &pointers_size,
local_buffer, &buffer_begin,
&buffer_end, &buffer_size))
{
failed = 1;
break;
}
in_argument = 0;
}
}
}
else
{
/* This character belong to an argument. */
if(!in_argument)
{
in_argument = 1;
}
if(!kwsysSystem__AppendByte(local_buffer, &buffer_begin,
&buffer_end, &buffer_size, *c))
{
failed = 1;
break;
}
}
}
/* Finish the last argument. */
if(in_argument)
{
if(!kwsysSystem__AppendArgument(local_pointers, &pointer_begin,
&pointer_end, &pointers_size,
local_buffer, &buffer_begin,
&buffer_end, &buffer_size))
{
failed = 1;
}
}
/* If we still have memory allocate space for the new command
buffer. */
if(!failed)
{
kwsysSystem_ptrdiff_t n = pointer_end - pointer_begin;
newCommand = (char**)malloc((size_t)(n+1)*sizeof(char*));
}
if(newCommand)
{
/* Copy the arguments into the new command buffer. */
kwsysSystem_ptrdiff_t n = pointer_end - pointer_begin;
memcpy(newCommand, pointer_begin, sizeof(char*)*(size_t)(n));
newCommand[n] = 0;
}
else
{
/* Free arguments already allocated. */
while(pointer_end != pointer_begin)
{
free(*(--pointer_end));
}
}
/* Free temporary buffers. */
if(pointer_begin != local_pointers)
{
free(pointer_begin);
}
if(buffer_begin != local_buffer)
{
free(buffer_begin);
}
/* The flags argument is currently unused. */
(void)flags;
/* Return the final command buffer. */
return newCommand;
}
/*--------------------------------------------------------------------------*/
char** kwsysSystem_Parse_CommandForUnix(const char* command, int flags)
{
/* Validate the flags. */
if(flags != 0)
{
return 0;
}
/* Forward to our internal implementation. */
return kwsysSystem__ParseUnixCommand(command, flags);
}