argv_parsing.cpp File Reference

#include <corecrt_internal.h>
#include <corecrt_internal_traits.h>
#include <limits.h>
#include <mbstring.h>
#include <stdlib.h>

Include dependency graph for argv_parsing.cpp:

Go to the source code of this file.

Functions
static void	do_locale_initialization (char) throw ()
static char *	get_command_line (char) throw ()
static wchar_t *	get_command_line (wchar_t) throw ()
static char **&	get_argv (char) throw ()
static wchar_t **&	get_argv (wchar_t) throw ()
static errno_t	expand_argv_wildcards (_In_z_ char **const argv, _Out_ _Deref_post_z_ char ***const expanded_argv) throw ()
static errno_t	expand_argv_wildcards (_In_z_ wchar_t **const argv, _Out_ _Deref_post_z_ wchar_t ***const expanded_argv) throw ()
static bool __cdecl	should_copy_another_character (char const c) throw ()
static bool __cdecl	should_copy_another_character (wchar_t) throw ()
template<typename Character >
static void __cdecl	parse_command_line (Character *cmdstart, Character **argv, Character *args, size_t *argument_count, size_t *character_count) throw ()
unsigned char *__cdecl	__acrt_allocate_buffer_for_argv (size_t const argument_count, size_t const character_count, size_t const character_size)
template<typename Character >
static errno_t __cdecl	common_configure_argv (_crt_argv_mode const mode) throw ()
errno_t __cdecl	_configure_narrow_argv (_crt_argv_mode const mode)
errno_t __cdecl	_configure_wide_argv (_crt_argv_mode const mode)

Variables
static void	do_locale_initialization (wchar_t)

Function Documentation

__acrt_allocate_buffer_for_argv()

unsigned char *__cdecl __acrt_allocate_buffer_for_argv	(	size_t const	argument_count,
		size_t const	character_count,
		size_t const	character_size
	)

Definition at line 266 of file argv_parsing.cpp.

{
    if (argument_count >= SIZE_MAX / sizeof(void*))
        return nullptr;
 
    if (character_count >= SIZE_MAX / character_size)
        return nullptr;
 
    size_t const argument_array_size  = argument_count  * sizeof(void*);
    size_t const character_array_size = character_count * character_size;
 
    if (SIZE_MAX - argument_array_size <= character_array_size)
        return nullptr;
 
    size_t const total_size = argument_array_size + character_array_size;
    __crt_unique_heap_ptr<unsigned char> buffer(_calloc_crt_t(unsigned char, total_size));
    if (!buffer)
        return nullptr;
 
    return buffer.detach();
}

Referenced by common_configure_argv(), and common_expand_argv_wildcards().

_configure_narrow_argv()

errno_t __cdecl _configure_narrow_argv

(

_crt_argv_mode const

mode

)

Definition at line 396 of file argv_parsing.cpp.

{
    return common_configure_argv<char>(mode);
}

_configure_wide_argv()

errno_t __cdecl _configure_wide_argv

(

_crt_argv_mode const

mode

)

Definition at line 401 of file argv_parsing.cpp.

{
    return common_configure_argv<wchar_t>(mode);
}

common_configure_argv()

template<typename Character >

static errno_t __cdecl common_configure_argv ( _crt_argv_mode const  mode ) throw ( )

static

Definition at line 319 of file argv_parsing.cpp.

{
    typedef __crt_char_traits<Character> traits;
 
    if (mode == _crt_argv_no_arguments)
    {
        return 0;
    }
 
    _VALIDATE_RETURN_ERRCODE(
        mode == _crt_argv_expanded_arguments ||
        mode == _crt_argv_unexpanded_arguments, EINVAL);
 
    do_locale_initialization(Character());
 
 
    static Character program_name[MAX_PATH + 1];
    traits::get_module_file_name(nullptr, program_name, MAX_PATH);
    traits::set_program_name(&program_name[0]);
 
    // If there's no command line at all, then use the program name as the
    // command line to parse, so that argv[0] is initialized with the program
    // name.  (This won't happen when the program is run by cmd.exe, but it
    // could happen if the program is spawned via some other means.)
    Character* const raw_command_line = get_command_line(Character());
    Character* const command_line = raw_command_line == nullptr || raw_command_line[0] == '\0'
        ? program_name
        : raw_command_line;
 
    size_t argument_count  = 0;
    size_t character_count = 0;
    parse_command_line(
        command_line,
        static_cast<Character**>(nullptr),
        static_cast<Character*>(nullptr),
        &argument_count,
        &character_count);
 
    __crt_unique_heap_ptr<unsigned char> buffer(__acrt_allocate_buffer_for_argv(
        argument_count,
        character_count,
        sizeof(Character)));
 
    _VALIDATE_RETURN_ERRCODE_NOEXC(buffer, ENOMEM);
 
    Character** const first_argument = reinterpret_cast<Character**>(buffer.get());
    Character*  const first_string   = reinterpret_cast<Character*>(buffer.get() + argument_count * sizeof(Character*));
 
    parse_command_line(command_line, first_argument, first_string, &argument_count, &character_count);
 
    // If we are not expanding wildcards, then we are done...
    if (mode == _crt_argv_unexpanded_arguments)
    {
        __argc = static_cast<int>(argument_count - 1);
        get_argv(Character()) = reinterpret_cast<Character**>(buffer.detach());
        return 0;
    }
 
    // ... otherwise, we try to do the wildcard expansion:
    __crt_unique_heap_ptr<Character*> expanded_argv;
    errno_t const argv_expansion_status = expand_argv_wildcards(first_argument, expanded_argv.get_address_of());
    if (argv_expansion_status != 0)
        return argv_expansion_status;
 
    __argc = [&]()
    {
        size_t n = 0;
        for (auto it = expanded_argv.get(); *it; ++it, ++n) { }
        return static_cast<int>(n);
    }();
 
    get_argv(Character()) = expanded_argv.detach();
    return 0;
}

do_locale_initialization()

static void do_locale_initialization ( char  ) throw ( )

static

Definition at line 21 of file argv_parsing.cpp.

{ __acrt_initialize_multibyte(); }

expand_argv_wildcards() [1/2]

static errno_t expand_argv_wildcards ( _In_z_ char **const  argv, _Out_ _Deref_post_z_ char ***const  expanded_argv  ) throw ( )

static

Definition at line 30 of file argv_parsing.cpp.

{
    return __acrt_expand_narrow_argv_wildcards(argv, expanded_argv);
}

Referenced by common_configure_argv().

expand_argv_wildcards() [2/2]

static errno_t expand_argv_wildcards ( _In_z_ wchar_t **const  argv, _Out_ _Deref_post_z_ wchar_t ***const  expanded_argv  ) throw ( )

static

Definition at line 37 of file argv_parsing.cpp.

{
    return __acrt_expand_wide_argv_wildcards(argv, expanded_argv);
}

get_argv() [1/2]

static char **& get_argv ( char  ) throw ( )

static

Definition at line 27 of file argv_parsing.cpp.

{ return __argv;  }

Referenced by common_configure_argv().

get_argv() [2/2]

static wchar_t **& get_argv ( wchar_t  ) throw ( )

static

Definition at line 28 of file argv_parsing.cpp.

{ return __wargv; }

get_command_line() [1/2]

static char * get_command_line ( char  ) throw ( )

static

Definition at line 24 of file argv_parsing.cpp.

{ return _acmdln; }

Referenced by common_configure_argv().

get_command_line() [2/2]

static wchar_t * get_command_line ( wchar_t  ) throw ( )

static

Definition at line 25 of file argv_parsing.cpp.

{ return _wcmdln; }

parse_command_line()

template<typename Character >

static void __cdecl parse_command_line ( Character *  cmdstart, Character **  argv, Character *  args, size_t *  argument_count, size_t *  character_count  ) throw ( )

static

Definition at line 95 of file argv_parsing.cpp.

{
    *character_count = 0;
    *argument_count  = 1; // We'll have at least the program name
 
    Character c;
    int copy_character;                   /* 1 = copy char to *args */
    unsigned numslash;              /* num of backslashes seen */
 
    /* first scan the program name, copy it, and count the bytes */
    Character* p = cmdstart;
    if (argv)
        *argv++ = args;
 
    // A quoted program name is handled here. The handling is much
    // simpler than for other arguments. Basically, whatever lies
    // between the leading double-quote and next one, or a terminal null
    // character is simply accepted. Fancier handling is not required
    // because the program name must be a legal NTFS/HPFS file name.
    // Note that the double-quote characters are not copied, nor do they
    // contribute to character_count.
    bool in_quotes = false;
    do
    {
        if (*p == '"')
        {
            in_quotes = !in_quotes;
            c = *p++;
            continue;
        }
 
        ++*character_count;
        if (args)
            *args++ = *p;
 
        c = *p++;
 
        if (should_copy_another_character(c))
        {
            ++*character_count;
            if (args)
                *args++ = *p; // Copy 2nd byte too
            ++p; // skip over trail byte
        }
    }
    while (c != '\0' && (in_quotes || (c != ' ' && c != '\t')));
 
    if (c == '\0')
    {
        p--;
    }
    else
    {
        if (args)
            *(args - 1) = '\0';
    }
 
    in_quotes = false;
 
    // Loop on each argument
    for (;;)
    {
        if (*p)
        {
            while (*p == ' ' || *p == '\t')
                ++p;
        }
 
        if (*p == '\0')
            break; // End of arguments
 
        // Scan an argument:
        if (argv)
            *argv++ = args;
 
        ++*argument_count;
 
        // Loop through scanning one argument:
        for (;;)
        {
            copy_character = 1;
 
            // Rules:
            // 2N     backslashes   + " ==> N backslashes and begin/end quote
            // 2N + 1 backslashes   + " ==> N backslashes + literal "
            // N      backslashes       ==> N backslashes
            numslash = 0;
 
            while (*p == '\\')
            {
                // Count number of backslashes for use below
                ++p;
                ++numslash;
            }
 
            if (*p == '"')
            {
                // if 2N backslashes before, start/end quote, otherwise
                // copy literally:
                if (numslash % 2 == 0)
                {
                    if (in_quotes && p[1] == '"')
                    {
                        p++; // Double quote inside quoted string
                    }
                    else
                    {
                        // Skip first quote char and copy second:
                        copy_character = 0; // Don't copy quote
                        in_quotes = !in_quotes;
                    }
                }
 
                numslash /= 2;
            }
 
            // Copy slashes:
            while (numslash--)
            {
                if (args)
                    *args++ = '\\';
                ++*character_count;
            }
 
            // If at end of arg, break loop:
            if (*p == '\0' || (!in_quotes && (*p == ' ' || *p == '\t')))
                break;
 
            // Copy character into argument:
            if (copy_character)
            {
                if (args)
                    *args++ = *p;
 
                if (should_copy_another_character(*p))
                {
                    ++p;
                    ++*character_count;
 
                    if (args)
                        *args++ = *p;
                }
 
                ++*character_count;
            }
 
            ++p;
        }
 
        // Null-terminate the argument:
        if (args)
            *args++ = '\0'; // Terminate the string
 
        ++*character_count;
    }
 
    // We put one last argument in -- a null pointer:
    if (argv)
        *argv++ = nullptr;
 
    ++*argument_count;
}

Referenced by common_configure_argv().

should_copy_another_character() [1/2]

static bool __cdecl should_copy_another_character ( char const  c ) throw ( )

static

Definition at line 82 of file argv_parsing.cpp.

{
    // This is OK for UTF-8 as a quote is never a trail byte.
    return _ismbblead(c) != 0;
}

Referenced by parse_command_line().

should_copy_another_character() [2/2]

static bool __cdecl should_copy_another_character ( wchar_t  ) throw ( )

static

Definition at line 88 of file argv_parsing.cpp.

{
    // This is OK for UTF-16 as a quote is never part of a surrogate pair.
    return false;
}

Variable Documentation

do_locale_initialization

void do_locale_initialization(wchar_t) ( wchar_t  )

static

Definition at line 22 of file argv_parsing.cpp.

{ /* no-op */                    }

Referenced by common_configure_argv().