/********************************************************/
/* ntapi: Native API core library */
/* Copyright (C) 2013,2014,2015 Z. Gilboa */
/* Released under GPLv2 and GPLv3; see COPYING.NTAPI. */
/********************************************************/
#include <psxtypes/psxtypes.h>
#include <ntapi/ntapi.h>
#include "ntapi_impl.h"
/**
* a simple facility for minimal programs or system libraries
* with no libc available at the time of invocation, as well
* as applications using the midipix free-standing development
* environment.
*
* the approach taken by this module to the support of short
* and long options reflects the above constraint, namely
* the absence of a callable libc at the time of invocation;
* there is no intent for interfaces in this module to
* be POSIXLY correct or otherwise portable. the sole
* purpose of all functions in this module is to serve
* internal or otherwise free-standing midipix applications,
* and their relevance otherwise is accordingly non-existent.
*
* all options are encoded in utf-16; note, however, that
* short options may only use code points that are located
* in the basic multilingual plane.
*
* option values are either required or not allowed altogether,
* and the first character of an option value may not be a hyphen.
* if you need the first character of an option value to be a
* hyphen, then make sure you escape it somehow (for instance by
* enclosing it in quotation marks).
*
* a short option and its value must reside in two separate
* argv[] elements (in other words: -ooutput is illegal).
*
* a long option and its value must reside in the same argv[]
* element and be separated by a single equal sign.
*
* Examples of valid options and option values:
* --------------------------------------------
* -o
* -o value
* --long-option-with-no-value
* --long-option=value
**/
#define HYPHEN 0x2D
#define EQUAL_SIGN 0x3D
static int __inline__ __fastcall __is_bmp_code_point(wchar16_t code_point)
{
return (((code_point >= 0x0000) && (code_point < 0xD800)) \
|| ((code_point >= 0xE000) && (code_point < 0x10000)));
}
static int __inline__ __fastcall __is_last_program_option(
__in nt_program_option * option)
{
return (!(option->short_name_code))
&& (!(option->long_name))
&& (!(option->long_name_hash));
}
static int __fastcall __is_short_option(wchar16_t * wch)
{
return ((wch) && (*wch == HYPHEN)
&& __is_bmp_code_point(*++wch)
&& (*++wch == 0));
}
static int __fastcall __is_long_option(wchar16_t * wch)
{
return ((wch) && (*wch == HYPHEN)
&& (++wch) && (*wch == HYPHEN)
&& (*++wch));
}
static int __fastcall __is_last_option_argument(wchar16_t * wch)
{
return ((wch) && (*wch == HYPHEN)
&& (*++wch == HYPHEN)
&& (*++wch == 0));
}
static uint32_t __fastcall __compute_crc32_utf16_str(
__in const uint32_t * crc32_table,
__in wchar16_t * wch)
{
uint32_t crc32;
unsigned char * byte_buffer;
/* crc32 hash... */
crc32 = 0 ^ 0xFFFFFFFF;
/* initialize byte_buffer */
byte_buffer = (unsigned char *)wch;
/* iterate */
while (*byte_buffer) {
/* two bytes at a time */
crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *byte_buffer) & 0xFF];
byte_buffer++;
crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *byte_buffer) & 0xFF];
byte_buffer++;
}
return crc32;
}
static uint32_t __fastcall __compute_crc32_long_option_name(
__in const uint32_t * crc32_table,
__in wchar16_t * wch_arg,
__in wchar16_t * wch_termination)
{
uint32_t crc32;
unsigned char * byte_buffer;
/* crc32 hash... */
crc32 = 0 ^ 0xFFFFFFFF;
/* initialize byte_buffer */
byte_buffer = (unsigned char *)wch_arg;
/* iterate */
while ((uintptr_t)byte_buffer < (uintptr_t)wch_termination) {
/* two bytes at a time */
crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *byte_buffer) & 0xFF];
byte_buffer++;
crc32 = (crc32 >> 8) ^ crc32_table[(crc32 ^ *byte_buffer) & 0xFF];
byte_buffer++;
}
return crc32;
}
static void __fastcall __init_cmd_option_meta_utf16(
__in nt_cmd_option_meta_utf16 * cmd_opt_meta)
{
cmd_opt_meta->short_name = (wchar16_t *)0;
cmd_opt_meta->short_name_code = 0;
cmd_opt_meta->long_name = (wchar16_t *)0;
cmd_opt_meta->long_name_hash = 0;
cmd_opt_meta->value = (wchar16_t *)0;
cmd_opt_meta->value_hash = 0;
cmd_opt_meta->argv_index = 0;
cmd_opt_meta->flags = 0;
return;
}
int32_t __stdcall __ntapi_tt_get_short_option_meta_utf16(
__in const uint32_t * crc32_table,
__in wchar16_t option_name,
__in wchar16_t * argv[],
__out nt_cmd_option_meta_utf16 * cmd_opt_meta)
{
int idx;
wchar16_t * wch;
if (!crc32_table)
return NT_STATUS_INVALID_PARAMETER_1;
else if (!option_name)
return NT_STATUS_INVALID_PARAMETER_2;
else if (!argv)
return NT_STATUS_INVALID_PARAMETER_3;
/* initialize cmd_opt_meta */
__init_cmd_option_meta_utf16(cmd_opt_meta);
/* step 1: attempt to find the short option in argv[] */
idx = 0;
while (argv[idx] && (!cmd_opt_meta->short_name_code)) {
wch = argv[idx];
/* is this our option? */
if ((*wch == HYPHEN)
&& (*++wch == option_name)
&& (*++wch == 0)) {
/* found it, get ready to hash the value */
cmd_opt_meta->short_name_code = option_name;
cmd_opt_meta->short_name = argv[idx];
cmd_opt_meta->argv_index = idx;
} else {
idx++;
}
}
/* if the next argument is also an option (or is null), just exit */
idx++;
if ((!argv[idx]) || (*argv[idx] == HYPHEN))
return NT_STATUS_SUCCESS;
/* step 2: hash the value */
cmd_opt_meta->value = argv[idx];
cmd_opt_meta->value_hash =
__compute_crc32_utf16_str(
crc32_table,
argv[idx]);
return NT_STATUS_SUCCESS;
}
int32_t __stdcall __ntapi_tt_get_long_option_meta_utf16(
__in const uint32_t * crc32_table,
__in wchar16_t * option_name,
__in uint32_t option_name_hash __optional,
__in wchar16_t * argv[],
__out nt_cmd_option_meta_utf16 * cmd_opt_meta)
{
/**
* option_name must always include the two-hyphen prefix;
* and the option value must be preceded by an equal sign.
*
* the only valid long option forms in argv[] are therefore:
* --long-option
* --long-option=value
**/
int idx;
uint32_t crc32;
wchar16_t * wch;
/* validation */
if (!crc32_table)
return NT_STATUS_INVALID_PARAMETER_1;
else if ((!option_name) && (!option_name_hash))
return NT_STATUS_INVALID_PARAMETER;
else if ((option_name) && (option_name_hash))
return NT_STATUS_INVALID_PARAMETER_MIX;
else if (!argv)
return NT_STATUS_INVALID_PARAMETER_4;
/* initialize cmd_opt_meta */
__init_cmd_option_meta_utf16(cmd_opt_meta);
/* step 1: crc32 of the target option_name */
if (option_name_hash)
crc32 = option_name_hash;
else
option_name_hash =
__compute_crc32_utf16_str(
crc32_table,
option_name);
/* step 2: attempt to find the long option in argv[] */
idx = 0;
while (argv[idx] && (!cmd_opt_meta->value)) {
wch = argv[idx];
if (__is_long_option(wch)) {
/* find the equal sign or null termination */
while ((*wch) && (*wch != EQUAL_SIGN))
wch++;
crc32 = __compute_crc32_long_option_name(
crc32_table,
argv[idx],
wch);
if (crc32 == option_name_hash) {
/* found it, get ready to hash the value */
cmd_opt_meta->long_name_hash = option_name_hash;
cmd_opt_meta->long_name = argv[idx];
cmd_opt_meta->argv_index = idx;
if (*wch)
/* skip the equal sign */
wch++;
cmd_opt_meta->value = wch;
} else
idx++;
}
}
if (cmd_opt_meta->value)
cmd_opt_meta->value_hash =
__compute_crc32_utf16_str(
crc32_table,
cmd_opt_meta->value);
return NT_STATUS_SUCCESS;
}
int32_t __stdcall __ntapi_tt_validate_program_options(
__in const uint32_t * crc32_table,
__in wchar16_t * argv[],
__in nt_program_option * options[],
__in nt_program_options_meta * options_meta)
{
int idx;
int idx_arg;
int idx_option;
int idx_max;
uint32_t crc32;
nt_program_option * option;
wchar16_t * parg;
wchar16_t * pvalue;
/* validation */
if (!crc32_table)
return NT_STATUS_INVALID_PARAMETER_1;
else if (!argv)
return NT_STATUS_INVALID_PARAMETER_2;
else if (!options)
return NT_STATUS_INVALID_PARAMETER_3;
else if (!options_meta)
return NT_STATUS_INVALID_PARAMETER_4;
/* step 1: validate options[] hash the long option names */
idx = 0;
idx_option = 0;
option = options[0];
pvalue = (wchar16_t *)0;
while (!__is_last_program_option(option)) {
if (option->short_name_code) {
if (!(__is_bmp_code_point(option->short_name_code))) {
options_meta->idx_invalid_short_name = idx;
return NT_STATUS_INVALID_PARAMETER;
}
}
if (option->long_name) {
if (!(__is_long_option(option->long_name))) {
options_meta->idx_invalid_long_name = idx;
return NT_STATUS_INVALID_PARAMETER;
}
/* update the long name hash (unconditionally) */
option->long_name_hash =
__compute_crc32_utf16_str(
crc32_table,
option->long_name);
}
idx++;
option++;
}
/* book keeping */
idx_max = idx;
/* step 2: validate argv[] */
parg = argv[0];
idx_arg = 0;
while ((parg) && (!(__is_last_option_argument(parg)))) {
if (__is_short_option(parg)) {
idx = 0;
idx_option = 0;
while ((idx < idx_max) && (!idx_option)) {
option = options[idx];
if (*(parg+1) == option->short_name_code)
idx_option = idx;
else
idx++;
}
if (idx == idx_max) {
options_meta->idx_invalid_argument = idx_arg;
return NT_STATUS_INVALID_PARAMETER;
} else {
/* get ready for the next element (or value) */
parg++;
idx_arg++;
pvalue = parg;
}
} else if (__is_long_option(parg)) {
idx = 0;
idx_option = 0;
/* find the equal sign or null termination */
pvalue = parg;
while ((*pvalue) && (*pvalue != EQUAL_SIGN))
pvalue++;
while ((idx < idx_max) && (!idx_option)) {
option = options[idx];
crc32 = __compute_crc32_long_option_name(
crc32_table,
parg,
pvalue);
if (crc32 == option->long_name_hash)
idx_option = idx;
else
idx++;
}
if (idx == idx_max) {
options_meta->idx_invalid_argument = idx_arg;
return NT_STATUS_INVALID_PARAMETER;
} else {
if (*pvalue != EQUAL_SIGN)
/* skip the equal sign */
pvalue++;
pvalue = (wchar16_t *)0;
}
}
/* validate the occurrence */
if (idx_option) {
if (option->flags && NT_OPTION_ALLOWED_ONCE) {
if (option->option_count) {
options_meta->idx_invalid_argument
= idx_arg;
return NT_STATUS_INVALID_PARAMETER;
} else {
option->option_count++;
}
}
if (option->flags && NT_OPTION_VALUE_REQUIRED) {
if ((!(*pvalue)) || (*pvalue == HYPHEN)) {
options_meta->idx_missing_option_value
= idx_arg;
return NT_STATUS_INVALID_PARAMETER;
} else {
option->value = pvalue;
option->value_hash =
__compute_crc32_utf16_str(
crc32_table,
option->value);
}
}
}
parg++;
idx_arg++;
}
return NT_STATUS_SUCCESS;
}