argv_wildcards.cpp File Reference

#include <corecrt_internal.h>
#include <ctype.h>
#include <corecrt_internal_traits.h>
#include <limits.h>
#include <mbstring.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include <wrl/wrappers/corewrappers.h>

Include dependency graph for argv_wildcards.cpp:

Go to the source code of this file.

Classes
class	anonymous_namespace{argv_wildcards.cpp}::argument_list< Character >

Namespaces
namespace	anonymous_namespace{argv_wildcards.cpp}

Functions
static _Check_return_ char *	previous_character (_In_reads_z_(current - first+1) char *const first, _In_z_ char *const current) throw ()
static wchar_t *	previous_character (_In_reads_(0) wchar_t *, _In_reads_(0) wchar_t *const current) throw ()
template<typename Character >
static errno_t	copy_and_add_argument_to_buffer (_In_z_ Character const *const file_name, _In_z_ Character const *const directory, size_t const directory_length, argument_list< Character > &buffer) throw ()
static wchar_t *	get_wide (__crt_internal_win32_buffer< wchar_t > *const dest, char *const source)
static wchar_t *	get_wide (__crt_internal_win32_buffer< wchar_t > *, wchar_t *const source)
static char *	get_file_name (__crt_internal_win32_buffer< char > *const dest, wchar_t *const source)
static wchar_t *	get_file_name (__crt_internal_win32_buffer< wchar_t > *, wchar_t *const source)
template<typename Character >
static errno_t	expand_argument_wildcards (Character *const argument, Character *const wildcard, argument_list< Character > &buffer) throw ()
template<typename Character >
static errno_t	common_expand_argv_wildcards (Character **const argv, Character ***const result) throw ()
errno_t	__acrt_expand_narrow_argv_wildcards (char **const argv, char ***const result)
errno_t	__acrt_expand_wide_argv_wildcards (wchar_t **const argv, wchar_t ***const result)

Function Documentation

__acrt_expand_narrow_argv_wildcards()

errno_t __acrt_expand_narrow_argv_wildcards	(	char **const	argv,
		char ***const	result
	)

Definition at line 383 of file argv_wildcards.cpp.

{
    return common_expand_argv_wildcards(argv, result);
}

Referenced by expand_argv_wildcards().

__acrt_expand_wide_argv_wildcards()

errno_t __acrt_expand_wide_argv_wildcards	(	wchar_t **const	argv,
		wchar_t ***const	result
	)

Definition at line 388 of file argv_wildcards.cpp.

{
    return common_expand_argv_wildcards(argv, result);
}

Referenced by expand_argv_wildcards().

common_expand_argv_wildcards()

template<typename Character >

static errno_t common_expand_argv_wildcards ( Character **const  argv, Character ***const  result  ) throw ( )

static

Definition at line 308 of file argv_wildcards.cpp.

{
    typedef __crt_char_traits<Character> traits;
 
    _VALIDATE_RETURN_ERRCODE(result != nullptr, EINVAL);
    *result = nullptr;
 
    argument_list<Character> expansion_buffer;
    for (Character** it = argv; *it != nullptr; ++it)
    {
        Character const wildcard_characters[] = { '*', '?', '\0' };
        Character* const wildcard = traits::tcspbrk(*it, wildcard_characters);
 
        // If no wildcard characters were found in the argument string, just
        // append it to the list and continue on.  Otherwise, do the expansion:
        if (!wildcard)
        {
            errno_t const append_status = copy_and_add_argument_to_buffer(
                *it,
                static_cast<Character*>(nullptr),
                0,
                expansion_buffer);
 
            if (append_status != 0)
                return append_status;
        }
        else
        {
            errno_t const expand_status = expand_argument_wildcards(*it, wildcard, expansion_buffer);
            if (expand_status != 0)
                return expand_status;
        }
    }
 
    // Now that we've accumulated the expanded arguments into the expansion
    // buffer, we want to re-pack them in the form used by the argv parser,
    // in a single array, with everything "concatenated" together.
    size_t const argument_count  = expansion_buffer.size() + 1;
    size_t       character_count = 0;
    for (auto it = expansion_buffer.begin(); it != expansion_buffer.end(); ++it)
        character_count += traits::tcslen(*it) + 1;
 
    __crt_unique_heap_ptr<unsigned char> expanded_argv(__acrt_allocate_buffer_for_argv(
        argument_count,
        character_count,
        sizeof(Character)));
 
    if (!expanded_argv)
        return -1;
 
    Character** const argument_first  = reinterpret_cast<Character**>(expanded_argv.get());
    Character*  const character_first = reinterpret_cast<Character*>(
        expanded_argv.get() +
        argument_count * sizeof(Character*));
 
    Character** argument_it  = argument_first;
    Character*  character_it = character_first;
    for (auto it = expansion_buffer.begin(); it != expansion_buffer.end(); ++it)
    {
        size_t const count = traits::tcslen(*it) + 1;
 
        _ERRCHECK(traits::tcsncpy_s(
            character_it,
            character_count - (character_it - character_first),
            *it,
            count));
 
        *argument_it++ = character_it;
        character_it += count;
    }
 
    *result = reinterpret_cast<Character**>(expanded_argv.detach());
    return 0;
}

Referenced by __acrt_expand_narrow_argv_wildcards(), and __acrt_expand_wide_argv_wildcards().

copy_and_add_argument_to_buffer()

template<typename Character >

static errno_t copy_and_add_argument_to_buffer ( _In_z_ Character const *const  file_name, _In_z_ Character const *const  directory, size_t const  directory_length, argument_list< Character > &  buffer  ) throw ( )

static

Definition at line 138 of file argv_wildcards.cpp.

{
    typedef __crt_char_traits<Character> traits;
 
    size_t const file_name_count = traits::tcslen(file_name) + 1;
    if (file_name_count > SIZE_MAX - directory_length)
        return ENOMEM;
 
    size_t const required_count = directory_length + file_name_count + 1;
    __crt_unique_heap_ptr<Character> argument_buffer(_calloc_crt_t(Character, required_count));
 
    if (directory_length > 0)
    {
        _ERRCHECK(traits::tcsncpy_s(argument_buffer.get(), required_count, directory, directory_length));
    }
 
    _ERRCHECK(traits::tcsncpy_s(
        argument_buffer.get() + directory_length,
        required_count        - directory_length,
        file_name,
        file_name_count));
 
    return buffer.append(argument_buffer.detach());
}

Referenced by common_expand_argv_wildcards(), and expand_argument_wildcards().

expand_argument_wildcards()

template<typename Character >

static errno_t expand_argument_wildcards ( Character *const  argument, Character *const  wildcard, argument_list< Character > &  buffer  ) throw ( )

static

Definition at line 212 of file argv_wildcards.cpp.

{
    typedef __crt_char_traits<Character>          traits;
    typedef typename traits::win32_find_data_type find_data_type;
 
    auto const is_directory_separator = [](Character const c) { return c == '/' || c == '\\' || c == ':'; };
 
    // Find the first slash or colon before the wildcard:
    Character* it = wildcard;
    while (it != argument && !is_directory_separator(*it))
    {
        it = previous_character(argument, it);
    }
 
    // If we found a colon that can't form a drive name (e.g. it can't be 'D:'),
    // then just add the argument as-is (we don't know how to expand it):
    if (*it == ':' && it != argument + 1)
    {
        return copy_and_add_argument_to_buffer(argument, static_cast<Character*>(nullptr), 0, buffer);
    }
 
    size_t const directory_length = is_directory_separator(*it)
        ? it - argument + 1 // it points to the separator, so add 1 to include it.
        : 0;
 
    // Try to begin the find operation:
    WIN32_FIND_DATAW findFileDataW;
    __crt_internal_win32_buffer<wchar_t> wide_file_name;
 
    __crt_findfile_handle const find_handle(::FindFirstFileExW(
        get_wide(&wide_file_name, argument),
        FindExInfoStandard,
        &findFileDataW,
        FindExSearchNameMatch,
        nullptr,
        0));
 
    // If the find operation failed, there was no match, so just add the argument:
    if (find_handle.get() == INVALID_HANDLE_VALUE)
    {
        return copy_and_add_argument_to_buffer(argument, static_cast<Character*>(nullptr), 0, buffer);
    }
 
    size_t const old_argument_count = buffer.size();
 
    do
    {
        __crt_internal_win32_buffer<Character> character_buffer;
        Character* const file_name = get_file_name(&character_buffer, findFileDataW.cFileName);
        // Skip . and ..:
        if (file_name[0] == '.' && file_name[1] == '\0')
        {
            continue;
        }
 
        if (file_name[0] == '.' && file_name[1] == '.' && file_name[2] == '\0')
        {
            continue;
        }
 
        errno_t const add_status = copy_and_add_argument_to_buffer(file_name, argument, directory_length, buffer);
        if (add_status != 0)
        {
            return add_status;
        }
    }
    while (::FindNextFileW(find_handle.get(), &findFileDataW));
 
    // If we didn't add any arguments to the buffer, then we're done:
    size_t const new_argument_count = buffer.size();
    if (old_argument_count == new_argument_count)
    {
        return 0;
    }
 
    // If we did add new arguments, let's helpfully sort them:
    qsort(
        buffer.begin()     + old_argument_count,
        new_argument_count - old_argument_count,
        sizeof(Character*),
        [](void const* lhs, void const* rhs) -> int
        {
            if (lhs < rhs) { return -1; }
            if (lhs > rhs) { return  1; }
            return 0;
        });
 
    return 0;
}

Referenced by common_expand_argv_wildcards().

get_file_name() [1/2]

static char * get_file_name ( __crt_internal_win32_buffer< char > *const  dest, wchar_t *const  source  )

static

Definition at line 190 of file argv_wildcards.cpp.

{
    errno_t const cvt = __acrt_wcs_to_mbs_cp(
        source,
        *dest,
        __acrt_get_utf8_acp_compatibility_codepage()
    );
 
    if (cvt != 0)
    {
        return nullptr;
    }
 
    return dest->data();
}

get_file_name() [2/2]

static wchar_t * get_file_name ( __crt_internal_win32_buffer< wchar_t > *  , wchar_t *const  source  )

static

Definition at line 206 of file argv_wildcards.cpp.

{
    return source;
}

get_wide() [1/2]

static wchar_t * get_wide ( __crt_internal_win32_buffer< wchar_t > *  , wchar_t *const  source  )

static

Definition at line 185 of file argv_wildcards.cpp.

{
    return source;
}

get_wide() [2/2]

static wchar_t * get_wide ( __crt_internal_win32_buffer< wchar_t > *const  dest, char *const  source  )

static

Definition at line 169 of file argv_wildcards.cpp.

{
    errno_t const cvt1 = __acrt_mbs_to_wcs_cp(
        source,
        *dest,
        __acrt_get_utf8_acp_compatibility_codepage()
    );
 
    if (cvt1 != 0)
    {
        return nullptr;
    }
 
    return dest->data();
};

Referenced by expand_argument_wildcards().

previous_character() [1/2]

static wchar_t * previous_character ( _In_reads_(0) wchar_t *  , _In_reads_(0) wchar_t *const  current  ) throw ( )

static

Definition at line 130 of file argv_wildcards.cpp.

{
    return current - 1;
}

previous_character() [2/2]

static _Check_return_ char * previous_character ( _In_reads_z_(current - first+1) char *const  first, _In_z_ char *const  current  ) throw ( )

static

Definition at line 122 of file argv_wildcards.cpp.

{
    return reinterpret_cast<char*>(_mbsdec(
        reinterpret_cast<unsigned char*>(first),
        reinterpret_cast<unsigned char*>(current)));
}

Referenced by expand_argument_wildcards().