Revision: 9198 https://osdn.net/projects/ttssh2/scm/svn/commits/9198 Author: zmatsuo Date: 2021-03-13 23:43:03 +0900 (Sat, 13 Mar 2021) Log Message: ----------- lscom追加 - tools/lscom を追加 - list com ports - getopt移動 - tools/ttbroadcast/getopt_mb_uni_src/ -> tools/libs/getopt_mb_uni_src/ Modified Paths: -------------- trunk/tools/CMakeLists.txt trunk/tools/ttbroadcast/CMakeLists.txt Added Paths: ----------- trunk/tools/libs/ trunk/tools/libs/README.md trunk/tools/libs/getopt_mb_uni_src/ trunk/tools/libs/getopt_mb_uni_src/getopt.c trunk/tools/libs/getopt_mb_uni_src/getopt.h trunk/tools/lscom/ trunk/tools/lscom/CMakeLists.txt trunk/tools/lscom/iswindowsntkernel.c trunk/tools/lscom/main.cpp Removed Paths: ------------- trunk/tools/ttbroadcast/getopt.md trunk/tools/ttbroadcast/getopt_mb_uni_src/getopt.c trunk/tools/ttbroadcast/getopt_mb_uni_src/getopt.h -------------- next part -------------- Modified: trunk/tools/CMakeLists.txt =================================================================== --- trunk/tools/CMakeLists.txt 2021-03-13 14:42:48 UTC (rev 9197) +++ trunk/tools/CMakeLists.txt 2021-03-13 14:43:03 UTC (rev 9198) @@ -1,6 +1,11 @@ add_subdirectory(ttbroadcast) - set_target_properties( ttbroadcast PROPERTIES FOLDER tools ) + +add_subdirectory(lscom) +set_target_properties( + lscom + PROPERTIES FOLDER tools + ) Copied: trunk/tools/libs/README.md (from rev 9197, trunk/tools/ttbroadcast/getopt.md) =================================================================== --- trunk/tools/libs/README.md (rev 0) +++ trunk/tools/libs/README.md 2021-03-13 14:43:03 UTC (rev 9198) @@ -0,0 +1,3 @@ +# getopt + +https://www.codeproject.com/Articles/157001/Full-getopt-Port-for-Unicode-and-Multibyte-Microso Copied: trunk/tools/libs/getopt_mb_uni_src/getopt.c (from rev 9197, trunk/tools/ttbroadcast/getopt_mb_uni_src/getopt.c) =================================================================== --- trunk/tools/libs/getopt_mb_uni_src/getopt.c (rev 0) +++ trunk/tools/libs/getopt_mb_uni_src/getopt.c 2021-03-13 14:43:03 UTC (rev 9198) @@ -0,0 +1,973 @@ +/* Getopt for Microsoft C +This code is a modification of the Free Software Foundation, Inc. +Getopt library for parsing command line argument the purpose was +to provide a Microsoft Visual C friendly derivative. This code +provides functionality for both Unicode and Multibyte builds. + +Date: 02/03/2011 - Ludvik Jerabek - Initial Release +Version: 1.0 +Comment: Supports getopt, getopt_long, and getopt_long_only +and POSIXLY_CORRECT environment flag +License: LGPL + +Revisions: + +02/03/2011 - Ludvik Jerabek - Initial Release +02/20/2011 - Ludvik Jerabek - Fixed compiler warnings at Level 4 +07/05/2011 - Ludvik Jerabek - Added no_argument, required_argument, optional_argument defs +08/03/2011 - Ludvik Jerabek - Fixed non-argument runtime bug which caused runtime exception +08/09/2011 - Ludvik Jerabek - Added code to export functions for DLL and LIB +02/15/2012 - Ludvik Jerabek - Fixed _GETOPT_THROW definition missing in implementation file +08/01/2012 - Ludvik Jerabek - Created separate functions for char and wchar_t characters so single dll can do both unicode and ansi +10/15/2012 - Ludvik Jerabek - Modified to match latest GNU features +06/19/2015 - Ludvik Jerabek - Fixed maximum option limitation caused by option_a (255) and option_w (65535) structure val variable + +**DISCLAIMER** +THIS MATERIAL IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +EITHER EXPRESS OR IMPLIED, INCLUDING, BUT Not LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +PURPOSE, OR NON-INFRINGEMENT. SOME JURISDICTIONS DO NOT ALLOW THE +EXCLUSION OF IMPLIED WARRANTIES, SO THE ABOVE EXCLUSION MAY NOT +APPLY TO YOU. IN NO EVENT WILL I BE LIABLE TO ANY PARTY FOR ANY +DIRECT, INDIRECT, SPECIAL OR OTHER CONSEQUENTIAL DAMAGES FOR ANY +USE OF THIS MATERIAL INCLUDING, WITHOUT LIMITATION, ANY LOST +PROFITS, BUSINESS INTERRUPTION, LOSS OF PROGRAMS OR OTHER DATA ON +YOUR INFORMATION HANDLING SYSTEM OR OTHERWISE, EVEN If WE ARE +EXPRESSLY ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +*/ +#define _CRT_SECURE_NO_WARNINGS +#include <stdlib.h> +#include <stdio.h> +#include <malloc.h> +#include "getopt.h" + +#ifdef __cplusplus + #define _GETOPT_THROW throw() +#else + #define _GETOPT_THROW +#endif + +int optind = 1; +int opterr = 1; +int optopt = '?'; +enum ENUM_ORDERING { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER }; + +// +// +// Ansi structures and functions follow +// +// + +static struct _getopt_data_a +{ + int optind; + int opterr; + int optopt; + char *optarg; + int __initialized; + char *__nextchar; + enum ENUM_ORDERING __ordering; + int __posixly_correct; + int __first_nonopt; + int __last_nonopt; +} getopt_data_a; +char *optarg_a; + +static void exchange_a(char **argv, struct _getopt_data_a *d) +{ + int bottom = d->__first_nonopt; + int middle = d->__last_nonopt; + int top = d->optind; + char *tem; + while (top > middle && middle > bottom) + { + if (top - middle > middle - bottom) + { + int len = middle - bottom; + register int i; + for (i = 0; i < len; i++) + { + tem = argv[bottom + i]; + argv[bottom + i] = argv[top - (middle - bottom) + i]; + argv[top - (middle - bottom) + i] = tem; + } + top -= len; + } + else + { + int len = top - middle; + register int i; + for (i = 0; i < len; i++) + { + tem = argv[bottom + i]; + argv[bottom + i] = argv[middle + i]; + argv[middle + i] = tem; + } + bottom += len; + } + } + d->__first_nonopt += (d->optind - d->__last_nonopt); + d->__last_nonopt = d->optind; +} +static const char *_getopt_initialize_a (const char *optstring, struct _getopt_data_a *d, int posixly_correct) +{ + d->__first_nonopt = d->__last_nonopt = d->optind; + d->__nextchar = NULL; + d->__posixly_correct = posixly_correct | !!getenv("POSIXLY_CORRECT"); + if (optstring[0] == '-') + { + d->__ordering = RETURN_IN_ORDER; + ++optstring; + } + else if (optstring[0] == '+') + { + d->__ordering = REQUIRE_ORDER; + ++optstring; + } + else if (d->__posixly_correct) + d->__ordering = REQUIRE_ORDER; + else + d->__ordering = PERMUTE; + return optstring; +} +int _getopt_internal_r_a (int argc, char *const *argv, const char *optstring, const struct option_a *longopts, int *longind, int long_only, struct _getopt_data_a *d, int posixly_correct) +{ + int print_errors = d->opterr; + if (argc < 1) + return -1; + d->optarg = NULL; + if (d->optind == 0 || !d->__initialized) + { + if (d->optind == 0) + d->optind = 1; + optstring = _getopt_initialize_a (optstring, d, posixly_correct); + d->__initialized = 1; + } + else if (optstring[0] == '-' || optstring[0] == '+') + optstring++; + if (optstring[0] == ':') + print_errors = 0; + if (d->__nextchar == NULL || *d->__nextchar == '\0') + { + if (d->__last_nonopt > d->optind) + d->__last_nonopt = d->optind; + if (d->__first_nonopt > d->optind) + d->__first_nonopt = d->optind; + if (d->__ordering == PERMUTE) + { + if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind) + exchange_a ((char **) argv, d); + else if (d->__last_nonopt != d->optind) + d->__first_nonopt = d->optind; + while (d->optind < argc && (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')) + d->optind++; + d->__last_nonopt = d->optind; + } + if (d->optind != argc && !strcmp(argv[d->optind], "--")) + { + d->optind++; + if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind) + exchange_a((char **) argv, d); + else if (d->__first_nonopt == d->__last_nonopt) + d->__first_nonopt = d->optind; + d->__last_nonopt = argc; + d->optind = argc; + } + if (d->optind == argc) + { + if (d->__first_nonopt != d->__last_nonopt) + d->optind = d->__first_nonopt; + return -1; + } + if ((argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')) + { + if (d->__ordering == REQUIRE_ORDER) + return -1; + d->optarg = argv[d->optind++]; + return 1; + } + d->__nextchar = (argv[d->optind] + 1 + (longopts != NULL && argv[d->optind][1] == '-')); + } + if (longopts != NULL && (argv[d->optind][1] == '-' || (long_only && (argv[d->optind][2] || !strchr(optstring, argv[d->optind][1]))))) + { + char *nameend; + unsigned int namelen; + const struct option_a *p; + const struct option_a *pfound = NULL; + struct option_list + { + const struct option_a *p; + struct option_list *next; + } *ambig_list = NULL; + int exact = 0; + int indfound = -1; + int option_index; + for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++); + namelen = (unsigned int)(nameend - d->__nextchar); + for (p = longopts, option_index = 0; p->name; p++, option_index++) + if (!strncmp(p->name, d->__nextchar, namelen)) + { + if (namelen == (unsigned int)strlen(p->name)) + { + pfound = p; + indfound = option_index; + exact = 1; + break; + } + else if (pfound == NULL) + { + pfound = p; + indfound = option_index; + } + else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val) + { + struct option_list *newp = (struct option_list*)alloca(sizeof(*newp)); + newp->p = p; + newp->next = ambig_list; + ambig_list = newp; + } + } + if (ambig_list != NULL && !exact) + { + if (print_errors) + { + struct option_list first; + first.p = pfound; + first.next = ambig_list; + ambig_list = &first; + fprintf (stderr, "%s: option '%s' is ambiguous; possibilities:", argv[0], argv[d->optind]); + do + { + fprintf (stderr, " '--%s'", ambig_list->p->name); + ambig_list = ambig_list->next; + } + while (ambig_list != NULL); + fputc ('\n', stderr); + } + d->__nextchar += strlen(d->__nextchar); + d->optind++; + d->optopt = 0; + return '?'; + } + if (pfound != NULL) + { + option_index = indfound; + d->optind++; + if (*nameend) + { + if (pfound->has_arg) + d->optarg = nameend + 1; + else + { + if (print_errors) + { + if (argv[d->optind - 1][1] == '-') + { + fprintf(stderr, "%s: option '--%s' doesn't allow an argument\n",argv[0], pfound->name); + } + else + { + fprintf(stderr, "%s: option '%c%s' doesn't allow an argument\n",argv[0], argv[d->optind - 1][0],pfound->name); + } + } + d->__nextchar += strlen(d->__nextchar); + d->optopt = pfound->val; + return '?'; + } + } + else if (pfound->has_arg == 1) + { + if (d->optind < argc) + d->optarg = argv[d->optind++]; + else + { + if (print_errors) + { + fprintf(stderr,"%s: option '--%s' requires an argument\n",argv[0], pfound->name); + } + d->__nextchar += strlen(d->__nextchar); + d->optopt = pfound->val; + return optstring[0] == ':' ? ':' : '?'; + } + } + d->__nextchar += strlen(d->__nextchar); + if (longind != NULL) + *longind = option_index; + if (pfound->flag) + { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } + if (!long_only || argv[d->optind][1] == '-' || strchr(optstring, *d->__nextchar) == NULL) + { + if (print_errors) + { + if (argv[d->optind][1] == '-') + { + fprintf(stderr, "%s: unrecognized option '--%s'\n",argv[0], d->__nextchar); + } + else + { + fprintf(stderr, "%s: unrecognized option '%c%s'\n",argv[0], argv[d->optind][0], d->__nextchar); + } + } + d->__nextchar = (char *)""; + d->optind++; + d->optopt = 0; + return '?'; + } + } + { + char c = *d->__nextchar++; + char *temp = (char*)strchr(optstring, c); + if (*d->__nextchar == '\0') + ++d->optind; + if (temp == NULL || c == ':' || c == ';') + { + if (print_errors) + { + fprintf(stderr, "%s: invalid option -- '%c'\n", argv[0], c); + } + d->optopt = c; + return '?'; + } + if (temp[0] == 'W' && temp[1] == ';') + { + char *nameend; + const struct option_a *p; + const struct option_a *pfound = NULL; + int exact = 0; + int ambig = 0; + int indfound = 0; + int option_index; + if (longopts == NULL) + goto no_longs; + if (*d->__nextchar != '\0') + { + d->optarg = d->__nextchar; + d->optind++; + } + else if (d->optind == argc) + { + if (print_errors) + { + fprintf(stderr,"%s: option requires an argument -- '%c'\n",argv[0], c); + } + d->optopt = c; + if (optstring[0] == ':') + c = ':'; + else + c = '?'; + return c; + } + else + d->optarg = argv[d->optind++]; + for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '='; nameend++); + for (p = longopts, option_index = 0; p->name; p++, option_index++) + if (!strncmp(p->name, d->__nextchar, nameend - d->__nextchar)) + { + if ((unsigned int) (nameend - d->__nextchar) == strlen(p->name)) + { + pfound = p; + indfound = option_index; + exact = 1; + break; + } + else if (pfound == NULL) + { + pfound = p; + indfound = option_index; + } + else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val) + ambig = 1; + } + if (ambig && !exact) + { + if (print_errors) + { + fprintf(stderr, "%s: option '-W %s' is ambiguous\n",argv[0], d->optarg); + } + d->__nextchar += strlen(d->__nextchar); + d->optind++; + return '?'; + } + if (pfound != NULL) + { + option_index = indfound; + if (*nameend) + { + if (pfound->has_arg) + d->optarg = nameend + 1; + else + { + if (print_errors) + { + fprintf(stderr, "%s: option '-W %s' doesn't allow an argument\n",argv[0], pfound->name); + } + d->__nextchar += strlen(d->__nextchar); + return '?'; + } + } + else if (pfound->has_arg == 1) + { + if (d->optind < argc) + d->optarg = argv[d->optind++]; + else + { + if (print_errors) + { + fprintf(stderr, "%s: option '-W %s' requires an argument\n",argv[0], pfound->name); + } + d->__nextchar += strlen(d->__nextchar); + return optstring[0] == ':' ? ':' : '?'; + } + } + else + d->optarg = NULL; + d->__nextchar += strlen(d->__nextchar); + if (longind != NULL) + *longind = option_index; + if (pfound->flag) + { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } +no_longs: + d->__nextchar = NULL; + return 'W'; + } + if (temp[1] == ':') + { + if (temp[2] == ':') + { + if (*d->__nextchar != '\0') + { + d->optarg = d->__nextchar; + d->optind++; + } + else + d->optarg = NULL; + d->__nextchar = NULL; + } + else + { + if (*d->__nextchar != '\0') + { + d->optarg = d->__nextchar; + d->optind++; + } + else if (d->optind == argc) + { + if (print_errors) + { + fprintf(stderr,"%s: option requires an argument -- '%c'\n",argv[0], c); + } + d->optopt = c; + if (optstring[0] == ':') + c = ':'; + else + c = '?'; + } + else + d->optarg = argv[d->optind++]; + d->__nextchar = NULL; + } + } + return c; + } +} +int _getopt_internal_a (int argc, char *const *argv, const char *optstring, const struct option_a *longopts, int *longind, int long_only, int posixly_correct) +{ + int result; + getopt_data_a.optind = optind; + getopt_data_a.opterr = opterr; + result = _getopt_internal_r_a (argc, argv, optstring, longopts,longind, long_only, &getopt_data_a,posixly_correct); + optind = getopt_data_a.optind; + optarg_a = getopt_data_a.optarg; + optopt = getopt_data_a.optopt; + return result; +} +int getopt_a (int argc, char *const *argv, const char *optstring) _GETOPT_THROW +{ + return _getopt_internal_a (argc, argv, optstring, (const struct option_a *) 0, (int *) 0, 0, 0); +} +int getopt_long_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index) _GETOPT_THROW +{ + return _getopt_internal_a (argc, argv, options, long_options, opt_index, 0, 0); +} +int getopt_long_only_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index) _GETOPT_THROW +{ + return _getopt_internal_a (argc, argv, options, long_options, opt_index, 1, 0); +} +int _getopt_long_r_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index, struct _getopt_data_a *d) +{ + return _getopt_internal_r_a (argc, argv, options, long_options, opt_index,0, d, 0); +} +int _getopt_long_only_r_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index, struct _getopt_data_a *d) +{ + return _getopt_internal_r_a (argc, argv, options, long_options, opt_index, 1, d, 0); +} + +// +// +// Unicode Structures and Functions +// +// + +static struct _getopt_data_w +{ + int optind; + int opterr; + int optopt; + wchar_t *optarg; + int __initialized; + wchar_t *__nextchar; + enum ENUM_ORDERING __ordering; + int __posixly_correct; + int __first_nonopt; + int __last_nonopt; +} getopt_data_w; +wchar_t *optarg_w; + +static void exchange_w(wchar_t **argv, struct _getopt_data_w *d) +{ + int bottom = d->__first_nonopt; + int middle = d->__last_nonopt; + int top = d->optind; + wchar_t *tem; + while (top > middle && middle > bottom) + { + if (top - middle > middle - bottom) + { + int len = middle - bottom; + register int i; + for (i = 0; i < len; i++) + { + tem = argv[bottom + i]; + argv[bottom + i] = argv[top - (middle - bottom) + i]; + argv[top - (middle - bottom) + i] = tem; + } + top -= len; + } + else + { + int len = top - middle; + register int i; + for (i = 0; i < len; i++) + { + tem = argv[bottom + i]; + argv[bottom + i] = argv[middle + i]; + argv[middle + i] = tem; + } + bottom += len; + } + } + d->__first_nonopt += (d->optind - d->__last_nonopt); + d->__last_nonopt = d->optind; +} +static const wchar_t *_getopt_initialize_w (const wchar_t *optstring, struct _getopt_data_w *d, int posixly_correct) +{ + d->__first_nonopt = d->__last_nonopt = d->optind; + d->__nextchar = NULL; + d->__posixly_correct = posixly_correct | !!_wgetenv(L"POSIXLY_CORRECT"); + if (optstring[0] == L'-') + { + d->__ordering = RETURN_IN_ORDER; + ++optstring; + } + else if (optstring[0] == L'+') + { + d->__ordering = REQUIRE_ORDER; + ++optstring; + } + else if (d->__posixly_correct) + d->__ordering = REQUIRE_ORDER; + else + d->__ordering = PERMUTE; + return optstring; +} +int _getopt_internal_r_w (int argc, wchar_t *const *argv, const wchar_t *optstring, const struct option_w *longopts, int *longind, int long_only, struct _getopt_data_w *d, int posixly_correct) +{ + int print_errors = d->opterr; + if (argc < 1) + return -1; + d->optarg = NULL; + if (d->optind == 0 || !d->__initialized) + { + if (d->optind == 0) + d->optind = 1; + optstring = _getopt_initialize_w (optstring, d, posixly_correct); + d->__initialized = 1; + } + else if (optstring[0] == L'-' || optstring[0] == L'+') + optstring++; + if (optstring[0] == L':') + print_errors = 0; + if (d->__nextchar == NULL || *d->__nextchar == L'\0') + { + if (d->__last_nonopt > d->optind) + d->__last_nonopt = d->optind; + if (d->__first_nonopt > d->optind) + d->__first_nonopt = d->optind; + if (d->__ordering == PERMUTE) + { + if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind) + exchange_w((wchar_t **) argv, d); + else if (d->__last_nonopt != d->optind) + d->__first_nonopt = d->optind; + while (d->optind < argc && (argv[d->optind][0] != L'-' || argv[d->optind][1] == L'\0')) + d->optind++; + d->__last_nonopt = d->optind; + } + if (d->optind != argc && !wcscmp(argv[d->optind], L"--")) + { + d->optind++; + if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind) + exchange_w((wchar_t **) argv, d); + else if (d->__first_nonopt == d->__last_nonopt) + d->__first_nonopt = d->optind; + d->__last_nonopt = argc; + d->optind = argc; + } + if (d->optind == argc) + { + if (d->__first_nonopt != d->__last_nonopt) + d->optind = d->__first_nonopt; + return -1; + } + if ((argv[d->optind][0] != L'-' || argv[d->optind][1] == L'\0')) + { + if (d->__ordering == REQUIRE_ORDER) + return -1; + d->optarg = argv[d->optind++]; + return 1; + } + d->__nextchar = (argv[d->optind] + 1 + (longopts != NULL && argv[d->optind][1] == L'-')); + } + if (longopts != NULL && (argv[d->optind][1] == L'-' || (long_only && (argv[d->optind][2] || !wcschr(optstring, argv[d->optind][1]))))) + { + wchar_t *nameend; + unsigned int namelen; + const struct option_w *p; + const struct option_w *pfound = NULL; + struct option_list + { + const struct option_w *p; + struct option_list *next; + } *ambig_list = NULL; + int exact = 0; + int indfound = -1; + int option_index; + for (nameend = d->__nextchar; *nameend && *nameend != L'='; nameend++); + namelen = (unsigned int)(nameend - d->__nextchar); + for (p = longopts, option_index = 0; p->name; p++, option_index++) + if (!wcsncmp(p->name, d->__nextchar, namelen)) + { + if (namelen == (unsigned int)wcslen(p->name)) + { + pfound = p; + indfound = option_index; + exact = 1; + break; + } + else if (pfound == NULL) + { + pfound = p; + indfound = option_index; + } + else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val) + { + struct option_list *newp = (struct option_list*)alloca(sizeof(*newp)); + newp->p = p; + newp->next = ambig_list; + ambig_list = newp; + } + } + if (ambig_list != NULL && !exact) + { + if (print_errors) + { + struct option_list first; + first.p = pfound; + first.next = ambig_list; + ambig_list = &first; + fwprintf(stderr, L"%s: option '%s' is ambiguous; possibilities:", argv[0], argv[d->optind]); + do + { + fwprintf (stderr, L" '--%s'", ambig_list->p->name); + ambig_list = ambig_list->next; + } + while (ambig_list != NULL); + fputwc (L'\n', stderr); + } + d->__nextchar += wcslen(d->__nextchar); + d->optind++; + d->optopt = 0; + return L'?'; + } + if (pfound != NULL) + { + option_index = indfound; + d->optind++; + if (*nameend) + { + if (pfound->has_arg) + d->optarg = nameend + 1; + else + { + if (print_errors) + { + if (argv[d->optind - 1][1] == L'-') + { + fwprintf(stderr, L"%s: option '--%s' doesn't allow an argument\n",argv[0], pfound->name); + } + else + { + fwprintf(stderr, L"%s: option '%c%s' doesn't allow an argument\n",argv[0], argv[d->optind - 1][0],pfound->name); + } + } + d->__nextchar += wcslen(d->__nextchar); + d->optopt = pfound->val; + return L'?'; + } + } + else if (pfound->has_arg == 1) + { + if (d->optind < argc) + d->optarg = argv[d->optind++]; + else + { + if (print_errors) + { + fwprintf(stderr,L"%s: option '--%s' requires an argument\n",argv[0], pfound->name); + } + d->__nextchar += wcslen(d->__nextchar); + d->optopt = pfound->val; + return optstring[0] == L':' ? L':' : L'?'; + } + } + d->__nextchar += wcslen(d->__nextchar); + if (longind != NULL) + *longind = option_index; + if (pfound->flag) + { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } + if (!long_only || argv[d->optind][1] == L'-' || wcschr(optstring, *d->__nextchar) == NULL) + { + if (print_errors) + { + if (argv[d->optind][1] == L'-') + { + fwprintf(stderr, L"%s: unrecognized option '--%s'\n",argv[0], d->__nextchar); + } + else + { + fwprintf(stderr, L"%s: unrecognized option '%c%s'\n",argv[0], argv[d->optind][0], d->__nextchar); + } + } + d->__nextchar = (wchar_t *)L""; + d->optind++; + d->optopt = 0; + return L'?'; + } + } + { + wchar_t c = *d->__nextchar++; + wchar_t *temp = (wchar_t*)wcschr(optstring, c); + if (*d->__nextchar == L'\0') + ++d->optind; + if (temp == NULL || c == L':' || c == L';') + { + if (print_errors) + { + fwprintf(stderr, L"%s: invalid option -- '%c'\n", argv[0], c); + } + d->optopt = c; + return L'?'; + } + if (temp[0] == L'W' && temp[1] == L';') + { + wchar_t *nameend; + const struct option_w *p; + const struct option_w *pfound = NULL; + int exact = 0; + int ambig = 0; + int indfound = 0; + int option_index; + if (longopts == NULL) + goto no_longs; + if (*d->__nextchar != L'\0') + { + d->optarg = d->__nextchar; + d->optind++; + } + else if (d->optind == argc) + { + if (print_errors) + { + fwprintf(stderr,L"%s: option requires an argument -- '%c'\n",argv[0], c); + } + d->optopt = c; + if (optstring[0] == L':') + c = L':'; + else + c = L'?'; + return c; + } + else + d->optarg = argv[d->optind++]; + for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != L'='; nameend++); + for (p = longopts, option_index = 0; p->name; p++, option_index++) + if (!wcsncmp(p->name, d->__nextchar, nameend - d->__nextchar)) + { + if ((unsigned int) (nameend - d->__nextchar) == wcslen(p->name)) + { + pfound = p; + indfound = option_index; + exact = 1; + break; + } + else if (pfound == NULL) + { + pfound = p; + indfound = option_index; + } + else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val) + ambig = 1; + } + if (ambig && !exact) + { + if (print_errors) + { + fwprintf(stderr, L"%s: option '-W %s' is ambiguous\n",argv[0], d->optarg); + } + d->__nextchar += wcslen(d->__nextchar); + d->optind++; + return L'?'; + } + if (pfound != NULL) + { + option_index = indfound; + if (*nameend) + { + if (pfound->has_arg) + d->optarg = nameend + 1; + else + { + if (print_errors) + { + fwprintf(stderr, L"%s: option '-W %s' doesn't allow an argument\n",argv[0], pfound->name); + } + d->__nextchar += wcslen(d->__nextchar); + return L'?'; + } + } + else if (pfound->has_arg == 1) + { + if (d->optind < argc) + d->optarg = argv[d->optind++]; + else + { + if (print_errors) + { + fwprintf(stderr, L"%s: option '-W %s' requires an argument\n",argv[0], pfound->name); + } + d->__nextchar += wcslen(d->__nextchar); + return optstring[0] == L':' ? L':' : L'?'; + } + } + else + d->optarg = NULL; + d->__nextchar += wcslen(d->__nextchar); + if (longind != NULL) + *longind = option_index; + if (pfound->flag) + { + *(pfound->flag) = pfound->val; + return 0; + } + return pfound->val; + } +no_longs: + d->__nextchar = NULL; + return L'W'; + } + if (temp[1] == L':') + { + if (temp[2] == L':') + { + if (*d->__nextchar != L'\0') + { + d->optarg = d->__nextchar; + d->optind++; + } + else + d->optarg = NULL; + d->__nextchar = NULL; + } + else + { + if (*d->__nextchar != L'\0') + { + d->optarg = d->__nextchar; + d->optind++; + } + else if (d->optind == argc) + { + if (print_errors) + { + fwprintf(stderr,L"%s: option requires an argument -- '%c'\n",argv[0], c); + } + d->optopt = c; + if (optstring[0] == L':') + c = L':'; + else + c = L'?'; + } + else + d->optarg = argv[d->optind++]; + d->__nextchar = NULL; + } + } + return c; + } +} +int _getopt_internal_w (int argc, wchar_t *const *argv, const wchar_t *optstring, const struct option_w *longopts, int *longind, int long_only, int posixly_correct) +{ + int result; + getopt_data_w.optind = optind; + getopt_data_w.opterr = opterr; + result = _getopt_internal_r_w (argc, argv, optstring, longopts,longind, long_only, &getopt_data_w,posixly_correct); + optind = getopt_data_w.optind; + optarg_w = getopt_data_w.optarg; + optopt = getopt_data_w.optopt; + return result; +} +int getopt_w (int argc, wchar_t *const *argv, const wchar_t *optstring) _GETOPT_THROW +{ + return _getopt_internal_w (argc, argv, optstring, (const struct option_w *) 0, (int *) 0, 0, 0); +} +int getopt_long_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index) _GETOPT_THROW +{ + return _getopt_internal_w (argc, argv, options, long_options, opt_index, 0, 0); +} +int getopt_long_only_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index) _GETOPT_THROW +{ + return _getopt_internal_w (argc, argv, options, long_options, opt_index, 1, 0); +} +int _getopt_long_r_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index, struct _getopt_data_w *d) +{ + return _getopt_internal_r_w (argc, argv, options, long_options, opt_index,0, d, 0); +} +int _getopt_long_only_r_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index, struct _getopt_data_w *d) +{ + return _getopt_internal_r_w (argc, argv, options, long_options, opt_index, 1, d, 0); +} \ No newline at end of file Copied: trunk/tools/libs/getopt_mb_uni_src/getopt.h (from rev 9197, trunk/tools/ttbroadcast/getopt_mb_uni_src/getopt.h) =================================================================== --- trunk/tools/libs/getopt_mb_uni_src/getopt.h (rev 0) +++ trunk/tools/libs/getopt_mb_uni_src/getopt.h 2021-03-13 14:43:03 UTC (rev 9198) @@ -0,0 +1,136 @@ +/* Getopt for Microsoft C +This code is a modification of the Free Software Foundation, Inc. +Getopt library for parsing command line argument the purpose was +to provide a Microsoft Visual C friendly derivative. This code +provides functionality for both Unicode and Multibyte builds. + +Date: 02/03/2011 - Ludvik Jerabek - Initial Release +Version: 1.0 +Comment: Supports getopt, getopt_long, and getopt_long_only +and POSIXLY_CORRECT environment flag +License: LGPL + +Revisions: + +02/03/2011 - Ludvik Jerabek - Initial Release +02/20/2011 - Ludvik Jerabek - Fixed compiler warnings at Level 4 +07/05/2011 - Ludvik Jerabek - Added no_argument, required_argument, optional_argument defs +08/03/2011 - Ludvik Jerabek - Fixed non-argument runtime bug which caused runtime exception +08/09/2011 - Ludvik Jerabek - Added code to export functions for DLL and LIB +02/15/2012 - Ludvik Jerabek - Fixed _GETOPT_THROW definition missing in implementation file +08/01/2012 - Ludvik Jerabek - Created separate functions for char and wchar_t characters so single dll can do both unicode and ansi +10/15/2012 - Ludvik Jerabek - Modified to match latest GNU features +06/19/2015 - Ludvik Jerabek - Fixed maximum option limitation caused by option_a (255) and option_w (65535) structure val variable + +**DISCLAIMER** +THIS MATERIAL IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, +EITHER EXPRESS OR IMPLIED, INCLUDING, BUT Not LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR +PURPOSE, OR NON-INFRINGEMENT. SOME JURISDICTIONS DO NOT ALLOW THE +EXCLUSION OF IMPLIED WARRANTIES, SO THE ABOVE EXCLUSION MAY NOT +APPLY TO YOU. IN NO EVENT WILL I BE LIABLE TO ANY PARTY FOR ANY +DIRECT, INDIRECT, SPECIAL OR OTHER CONSEQUENTIAL DAMAGES FOR ANY +USE OF THIS MATERIAL INCLUDING, WITHOUT LIMITATION, ANY LOST +PROFITS, BUSINESS INTERRUPTION, LOSS OF PROGRAMS OR OTHER DATA ON +YOUR INFORMATION HANDLING SYSTEM OR OTHERWISE, EVEN If WE ARE +EXPRESSLY ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. +*/ +#ifndef __GETOPT_H_ + #define __GETOPT_H_ + + #ifdef _GETOPT_API + #undef _GETOPT_API + #endif + + #if defined(EXPORTS_GETOPT) && defined(STATIC_GETOPT) + #error "The preprocessor definitions of EXPORTS_GETOPT and STATIC_GETOPT can only be used individually" + #elif defined(STATIC_GETOPT) + #pragma message("Warning static builds of getopt violate the Lesser GNU Public License") + #define _GETOPT_API + #elif defined(EXPORTS_GETOPT) + #pragma message("Exporting getopt library") + #define _GETOPT_API __declspec(dllexport) + #else + #pragma message("Importing getopt library") + #define _GETOPT_API __declspec(dllimport) + #endif + + // Change behavior for C\C++ + #ifdef __cplusplus + #define _BEGIN_EXTERN_C extern "C" { + #define _END_EXTERN_C } + #define _GETOPT_THROW throw() + #else + #define _BEGIN_EXTERN_C + #define _END_EXTERN_C + #define _GETOPT_THROW + #endif + + // Standard GNU options + #define null_argument 0 /*Argument Null*/ + #define no_argument 0 /*Argument Switch Only*/ + #define required_argument 1 /*Argument Required*/ + #define optional_argument 2 /*Argument Optional*/ + + // Shorter Options + #define ARG_NULL 0 /*Argument Null*/ + #define ARG_NONE 0 /*Argument Switch Only*/ + #define ARG_REQ 1 /*Argument Required*/ + #define ARG_OPT 2 /*Argument Optional*/ + + #include <string.h> + #include <wchar.h> + +_BEGIN_EXTERN_C + + extern _GETOPT_API int optind; + extern _GETOPT_API int opterr; + extern _GETOPT_API int optopt; + + // Ansi + struct option_a + { + const char* name; + int has_arg; + int *flag; + int val; + }; + extern _GETOPT_API char *optarg_a; + extern _GETOPT_API int getopt_a(int argc, char *const *argv, const char *optstring) _GETOPT_THROW; + extern _GETOPT_API int getopt_long_a(int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index) _GETOPT_THROW; + extern _GETOPT_API int getopt_long_only_a(int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index) _GETOPT_THROW; + + // Unicode + struct option_w + { + const wchar_t* name; + int has_arg; + int *flag; + int val; + }; + extern _GETOPT_API wchar_t *optarg_w; + extern _GETOPT_API int getopt_w(int argc, wchar_t *const *argv, const wchar_t *optstring) _GETOPT_THROW; + extern _GETOPT_API int getopt_long_w(int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index) _GETOPT_THROW; + extern _GETOPT_API int getopt_long_only_w(int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index) _GETOPT_THROW; + +_END_EXTERN_C + + #undef _BEGIN_EXTERN_C + #undef _END_EXTERN_C + #undef _GETOPT_THROW + #undef _GETOPT_API + + #ifdef _UNICODE + #define getopt getopt_w + #define getopt_long getopt_long_w + #define getopt_long_only getopt_long_only_w + #define option option_w + #define optarg optarg_w + #else + #define getopt getopt_a + #define getopt_long getopt_long_a + #define getopt_long_only getopt_long_only_a + #define option option_a + #define optarg optarg_a + #endif +#endif // __GETOPT_H_ Added: trunk/tools/lscom/CMakeLists.txt =================================================================== --- trunk/tools/lscom/CMakeLists.txt (rev 0) +++ trunk/tools/lscom/CMakeLists.txt 2021-03-13 14:43:03 UTC (rev 9198) @@ -0,0 +1,66 @@ +set(PACKAGE_NAME "lscom") + +project(${PACKAGE_NAME}) + +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/") + +add_executable( + ${PACKAGE_NAME} + main.cpp + iswindowsntkernel.c + # + ../../teraterm/ttpcmn/ttcmn_cominfo.c + # + ../libs/getopt_mb_uni_src/getopt.c + ../libs/getopt_mb_uni_src/getopt.h + ) + +target_include_directories( + ${PACKAGE_NAME} + PRIVATE + ${CMAKE_CURRENT_SOURCE_DIR}/../../teraterm/common + ${CMAKE_CURRENT_SOURCE_DIR}/../../teraterm/ttpcmn + ${CMAKE_CURRENT_SOURCE_DIR}/../libs/getopt_mb_uni_src + ) + +target_compile_definitions( + ${PACKAGE_NAME} + PRIVATE + STATIC_GETOPT + ) + +target_link_libraries( + ${PACKAGE_NAME} + PRIVATE + common_static + #ttpcmn + # + #setupapi + ) + +if(SUPPORT_OLD_WINDOWS) + if(MSVC) + target_sources( + ${PACKAGE_NAME} + PRIVATE + ../../teraterm/common/compat_w95_vs2005.c + ) + endif() + if(MINGW) + target_link_libraries( + ${PACKAGE_NAME} + PRIVATE + -Wl,--whole-archive + mingw_msvcrt + -Wl,--no-whole-archive + ) + endif() +endif(SUPPORT_OLD_WINDOWS) + +if(MINGW) + target_link_options( + ${PACKAGE_NAME} + PRIVATE + -municode + ) +endif() Added: trunk/tools/lscom/iswindowsntkernel.c =================================================================== --- trunk/tools/lscom/iswindowsntkernel.c (rev 0) +++ trunk/tools/lscom/iswindowsntkernel.c 2021-03-13 14:43:03 UTC (rev 9198) @@ -0,0 +1,47 @@ +/* + * (C) 2021- TeraTerm Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <windows.h> + +// OS\x82\xAA WindowsNT \x83J\x81[\x83l\x83\x8B\x82\xA9\x82ǂ\xA4\x82\xA9\x82ʂ\xB7\x82\xE9\x81B +// +// return TRUE: NT kernel +// FALSE: Not NT kernel +BOOL IsWindowsNTKernel() +{ + OSVERSIONINFO osvi; + + osvi.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); + GetVersionEx(&osvi); + + if (osvi.dwPlatformId == VER_PLATFORM_WIN32_NT) { + return TRUE; + } + + return FALSE; +} Added: trunk/tools/lscom/main.cpp =================================================================== --- trunk/tools/lscom/main.cpp (rev 0) +++ trunk/tools/lscom/main.cpp 2021-03-13 14:43:03 UTC (rev 9198) @@ -0,0 +1,221 @@ +/* + * (C) 2021- TeraTerm Project + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. The name of the author may not be used to endorse or promote products + * derived from this software without specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR + * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES + * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + * IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY DIRECT, INDIRECT, + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, + * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY + * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include <stdio.h> +#include <locale.h> +#include <windows.h> +#define _CRTDBG_MAP_ALLOC +#include <crtdbg.h> + +extern "C" { +int WINAPI DetectComPorts(LPWORD ComPortTable, int ComPortMax, char **ComPortDesc); +} + +#include "comportinfo.h" + +#include "getopt.h" + +static bool show_all_devices = false; + +#define MAXCOMPORT 4096 + +void DetectComPortByQueryDosDevice() +{ + size_t buf_size = 65535; + char *devicesBuff = (char *)malloc(buf_size); + + int r = QueryDosDeviceA(NULL, devicesBuff, (DWORD)buf_size); + if (r == 0) { + int error = GetLastError(); + printf("QueryDosDeviceA() error %d\n", error); + return; + } + + int n = 0; + char *p = devicesBuff; + while (*p != '\0') { + bool show = false; + if (show_all_devices || + (strncmp(p, "COM", 3) == 0 && p[3] != '\0')) { + show = true; + } + if (show) { + printf("%d: %s\n", n, p); + } + n++; + p += strlen(p)+1; + } + free(devicesBuff); +} + +void lscom_DetectComPorts() +{ + static WORD ComPortTable[MAXCOMPORT]; // \x8Eg\x97p\x89\\x82\xC8COM\x83|\x81[\x83g\x94ԍ\x86 + static char *ComPortDesc[MAXCOMPORT]; // COM\x83|\x81[\x83g\x82̏ڍ\xEE\x95\xF1 + int com_count = DetectComPorts(ComPortTable, MAXCOMPORT, ComPortDesc); + + for(int i = 0; i < com_count; i++) { + printf("com%d: %s\n", ComPortTable[i], ComPortDesc[i]); + } +} + +void lscom_fopen() +{ +// int maxcomport = MAXCOMPORT; + int maxcomport = 20; + for (int i = 1; i <= maxcomport; i++) { + char buf[12]; // \\.\COMxxxx + NULL + _snprintf_s(buf, sizeof(buf), _TRUNCATE, "\\\\.\\COM%d", i); + FILE *fp = fopen(buf, "r"); + printf("%s %d\n", buf, fp == NULL); + if (fp != NULL) { + fclose(fp); + } + } +} + +void lscom() +{ + int comPortCount; + ComPortInfo_t *infos = ComPortInfoGet(&comPortCount, NULL); + printf("comport count %d\n", comPortCount); + for (int i = 0; i < comPortCount; i++) { + ComPortInfo_t *p = &infos[i]; + wchar_t *port = p->port_name; + wprintf( + L"========\n" + L"%s:\n", + port); + wchar_t *friendly = p->friendly_name; + wchar_t *desc = p->property; + if (friendly != NULL) { + wprintf( + L"-----\n" + L"FRIENDLY:\n" + L"%s\n", + friendly); + } + if (desc != NULL) { + wprintf( + L"-----\n" + L"DESC:\n" + L"%s\n", + desc); + } + } + ComPortInfoFree(infos, comPortCount); + + printf("end\n"); +} + +static void usage() +{ + printf( + "lscom [option]\n" + " list com devices\n" + "option\n" + " -q, querydosdevice list com devices by QueryDosDevice() API\n" + " -a, all show all devices with -q option\n" + " -d, detectcomports list by DetectComPorts()\n" + " -f, fopen list by fopen()\n" + ); +} + +int wmain(int argc, wchar_t *argv[]) +{ +#ifdef _DEBUG + _CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF); + _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE); + _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR); + _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE); + _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR); + _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE); + _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR); +#endif + setlocale(LC_ALL, ""); + + int no_newline = 0; + int multicast = 0; + bool querydosdevice = false; + bool flag_DetectComPorts = false; + bool flag_fopen = false; + static const struct option_w long_options[] = { + {L"help", no_argument, NULL, L'h'}, + {L"querydosdevice", no_argument, NULL, L'q'}, + {L"all", no_argument, NULL, L'a'}, + {L"detectcomports", no_argument, NULL, L'd'}, + {L"fopen", no_argument, NULL, L'f'}, + {} + }; + + opterr = 0; + while(1) { + int c = getopt_long_w(argc, argv, L"hqadf", long_options, NULL); + if(c == -1) break; + + switch (c) + { + case L'h': + case L'?': + usage(); + return 0; + break; + case L'q': + querydosdevice = true; + break; + case L'a': + show_all_devices = true; + break; + case L'd': + flag_DetectComPorts = true; + break; + case L'f': + flag_fopen = true; + break; + default: + printf("usage\n"); + break; + } + } + + if (querydosdevice) { + printf("query\n"); + DetectComPortByQueryDosDevice(); + } else if (flag_DetectComPorts) { + printf("DetectComPorts()\n"); + lscom_DetectComPorts(); + } else if (flag_fopen) { + printf("fopen()\n"); + lscom_fopen(); + } else { + printf("new\n"); + lscom(); + } + + return 0; +} Modified: trunk/tools/ttbroadcast/CMakeLists.txt =================================================================== --- trunk/tools/ttbroadcast/CMakeLists.txt 2021-03-13 14:42:48 UTC (rev 9197) +++ trunk/tools/ttbroadcast/CMakeLists.txt 2021-03-13 14:43:03 UTC (rev 9198) @@ -1,11 +1,13 @@ -project(ttbroadcast) +set(PACKAGE_NAME "ttbroadcast") +project(${PACKAGE_NAME}) + set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/") add_executable( - ttbroadcast - getopt_mb_uni_src/getopt.c - getopt_mb_uni_src/getopt.h + ${PACKAGE_NAME} + ../libs/getopt_mb_uni_src/getopt.c + ../libs/getopt_mb_uni_src/getopt.h main.cpp # ${CMAKE_CURRENT_SOURCE_DIR}/../../teraterm/common/asprintf.h @@ -13,20 +15,20 @@ ) target_include_directories( - ttbroadcast + ${PACKAGE_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../../teraterm/common - ${CMAKE_CURRENT_SOURCE_DIR}/getopt_mb_uni_src + ${CMAKE_CURRENT_SOURCE_DIR}/../libs/getopt_mb_uni_src ) target_compile_definitions( - ttbroadcast + ${PACKAGE_NAME} PRIVATE STATIC_GETOPT ) target_link_libraries( - ttbroadcast + ${PACKAGE_NAME} PRIVATE ttpcmn common_static @@ -34,7 +36,7 @@ if(MINGW) target_link_options( - ttbroadcast + ${PACKAGE_NAME} PRIVATE -municode ) Deleted: trunk/tools/ttbroadcast/getopt.md =================================================================== --- trunk/tools/ttbroadcast/getopt.md 2021-03-13 14:42:48 UTC (rev 9197) +++ trunk/tools/ttbroadcast/getopt.md 2021-03-13 14:43:03 UTC (rev 9198) @@ -1,6 +0,0 @@ -# getopt - -https://www.codeproject.com/Articles/157001/Full-getopt-Port-for-Unicode-and-Multibyte-Microso - - -https://github.com/bluebaroncanada/getoptW Deleted: trunk/tools/ttbroadcast/getopt_mb_uni_src/getopt.c =================================================================== --- trunk/tools/ttbroadcast/getopt_mb_uni_src/getopt.c 2021-03-13 14:42:48 UTC (rev 9197) +++ trunk/tools/ttbroadcast/getopt_mb_uni_src/getopt.c 2021-03-13 14:43:03 UTC (rev 9198) @@ -1,973 +0,0 @@ -/* Getopt for Microsoft C -This code is a modification of the Free Software Foundation, Inc. -Getopt library for parsing command line argument the purpose was -to provide a Microsoft Visual C friendly derivative. This code -provides functionality for both Unicode and Multibyte builds. - -Date: 02/03/2011 - Ludvik Jerabek - Initial Release -Version: 1.0 -Comment: Supports getopt, getopt_long, and getopt_long_only -and POSIXLY_CORRECT environment flag -License: LGPL - -Revisions: - -02/03/2011 - Ludvik Jerabek - Initial Release -02/20/2011 - Ludvik Jerabek - Fixed compiler warnings at Level 4 -07/05/2011 - Ludvik Jerabek - Added no_argument, required_argument, optional_argument defs -08/03/2011 - Ludvik Jerabek - Fixed non-argument runtime bug which caused runtime exception -08/09/2011 - Ludvik Jerabek - Added code to export functions for DLL and LIB -02/15/2012 - Ludvik Jerabek - Fixed _GETOPT_THROW definition missing in implementation file -08/01/2012 - Ludvik Jerabek - Created separate functions for char and wchar_t characters so single dll can do both unicode and ansi -10/15/2012 - Ludvik Jerabek - Modified to match latest GNU features -06/19/2015 - Ludvik Jerabek - Fixed maximum option limitation caused by option_a (255) and option_w (65535) structure val variable - -**DISCLAIMER** -THIS MATERIAL IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, -EITHER EXPRESS OR IMPLIED, INCLUDING, BUT Not LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR -PURPOSE, OR NON-INFRINGEMENT. SOME JURISDICTIONS DO NOT ALLOW THE -EXCLUSION OF IMPLIED WARRANTIES, SO THE ABOVE EXCLUSION MAY NOT -APPLY TO YOU. IN NO EVENT WILL I BE LIABLE TO ANY PARTY FOR ANY -DIRECT, INDIRECT, SPECIAL OR OTHER CONSEQUENTIAL DAMAGES FOR ANY -USE OF THIS MATERIAL INCLUDING, WITHOUT LIMITATION, ANY LOST -PROFITS, BUSINESS INTERRUPTION, LOSS OF PROGRAMS OR OTHER DATA ON -YOUR INFORMATION HANDLING SYSTEM OR OTHERWISE, EVEN If WE ARE -EXPRESSLY ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. -*/ -#define _CRT_SECURE_NO_WARNINGS -#include <stdlib.h> -#include <stdio.h> -#include <malloc.h> -#include "getopt.h" - -#ifdef __cplusplus - #define _GETOPT_THROW throw() -#else - #define _GETOPT_THROW -#endif - -int optind = 1; -int opterr = 1; -int optopt = '?'; -enum ENUM_ORDERING { REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER }; - -// -// -// Ansi structures and functions follow -// -// - -static struct _getopt_data_a -{ - int optind; - int opterr; - int optopt; - char *optarg; - int __initialized; - char *__nextchar; - enum ENUM_ORDERING __ordering; - int __posixly_correct; - int __first_nonopt; - int __last_nonopt; -} getopt_data_a; -char *optarg_a; - -static void exchange_a(char **argv, struct _getopt_data_a *d) -{ - int bottom = d->__first_nonopt; - int middle = d->__last_nonopt; - int top = d->optind; - char *tem; - while (top > middle && middle > bottom) - { - if (top - middle > middle - bottom) - { - int len = middle - bottom; - register int i; - for (i = 0; i < len; i++) - { - tem = argv[bottom + i]; - argv[bottom + i] = argv[top - (middle - bottom) + i]; - argv[top - (middle - bottom) + i] = tem; - } - top -= len; - } - else - { - int len = top - middle; - register int i; - for (i = 0; i < len; i++) - { - tem = argv[bottom + i]; - argv[bottom + i] = argv[middle + i]; - argv[middle + i] = tem; - } - bottom += len; - } - } - d->__first_nonopt += (d->optind - d->__last_nonopt); - d->__last_nonopt = d->optind; -} -static const char *_getopt_initialize_a (const char *optstring, struct _getopt_data_a *d, int posixly_correct) -{ - d->__first_nonopt = d->__last_nonopt = d->optind; - d->__nextchar = NULL; - d->__posixly_correct = posixly_correct | !!getenv("POSIXLY_CORRECT"); - if (optstring[0] == '-') - { - d->__ordering = RETURN_IN_ORDER; - ++optstring; - } - else if (optstring[0] == '+') - { - d->__ordering = REQUIRE_ORDER; - ++optstring; - } - else if (d->__posixly_correct) - d->__ordering = REQUIRE_ORDER; - else - d->__ordering = PERMUTE; - return optstring; -} -int _getopt_internal_r_a (int argc, char *const *argv, const char *optstring, const struct option_a *longopts, int *longind, int long_only, struct _getopt_data_a *d, int posixly_correct) -{ - int print_errors = d->opterr; - if (argc < 1) - return -1; - d->optarg = NULL; - if (d->optind == 0 || !d->__initialized) - { - if (d->optind == 0) - d->optind = 1; - optstring = _getopt_initialize_a (optstring, d, posixly_correct); - d->__initialized = 1; - } - else if (optstring[0] == '-' || optstring[0] == '+') - optstring++; - if (optstring[0] == ':') - print_errors = 0; - if (d->__nextchar == NULL || *d->__nextchar == '\0') - { - if (d->__last_nonopt > d->optind) - d->__last_nonopt = d->optind; - if (d->__first_nonopt > d->optind) - d->__first_nonopt = d->optind; - if (d->__ordering == PERMUTE) - { - if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind) - exchange_a ((char **) argv, d); - else if (d->__last_nonopt != d->optind) - d->__first_nonopt = d->optind; - while (d->optind < argc && (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')) - d->optind++; - d->__last_nonopt = d->optind; - } - if (d->optind != argc && !strcmp(argv[d->optind], "--")) - { - d->optind++; - if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind) - exchange_a((char **) argv, d); - else if (d->__first_nonopt == d->__last_nonopt) - d->__first_nonopt = d->optind; - d->__last_nonopt = argc; - d->optind = argc; - } - if (d->optind == argc) - { - if (d->__first_nonopt != d->__last_nonopt) - d->optind = d->__first_nonopt; - return -1; - } - if ((argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')) - { - if (d->__ordering == REQUIRE_ORDER) - return -1; - d->optarg = argv[d->optind++]; - return 1; - } - d->__nextchar = (argv[d->optind] + 1 + (longopts != NULL && argv[d->optind][1] == '-')); - } - if (longopts != NULL && (argv[d->optind][1] == '-' || (long_only && (argv[d->optind][2] || !strchr(optstring, argv[d->optind][1]))))) - { - char *nameend; - unsigned int namelen; - const struct option_a *p; - const struct option_a *pfound = NULL; - struct option_list - { - const struct option_a *p; - struct option_list *next; - } *ambig_list = NULL; - int exact = 0; - int indfound = -1; - int option_index; - for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++); - namelen = (unsigned int)(nameend - d->__nextchar); - for (p = longopts, option_index = 0; p->name; p++, option_index++) - if (!strncmp(p->name, d->__nextchar, namelen)) - { - if (namelen == (unsigned int)strlen(p->name)) - { - pfound = p; - indfound = option_index; - exact = 1; - break; - } - else if (pfound == NULL) - { - pfound = p; - indfound = option_index; - } - else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val) - { - struct option_list *newp = (struct option_list*)alloca(sizeof(*newp)); - newp->p = p; - newp->next = ambig_list; - ambig_list = newp; - } - } - if (ambig_list != NULL && !exact) - { - if (print_errors) - { - struct option_list first; - first.p = pfound; - first.next = ambig_list; - ambig_list = &first; - fprintf (stderr, "%s: option '%s' is ambiguous; possibilities:", argv[0], argv[d->optind]); - do - { - fprintf (stderr, " '--%s'", ambig_list->p->name); - ambig_list = ambig_list->next; - } - while (ambig_list != NULL); - fputc ('\n', stderr); - } - d->__nextchar += strlen(d->__nextchar); - d->optind++; - d->optopt = 0; - return '?'; - } - if (pfound != NULL) - { - option_index = indfound; - d->optind++; - if (*nameend) - { - if (pfound->has_arg) - d->optarg = nameend + 1; - else - { - if (print_errors) - { - if (argv[d->optind - 1][1] == '-') - { - fprintf(stderr, "%s: option '--%s' doesn't allow an argument\n",argv[0], pfound->name); - } - else - { - fprintf(stderr, "%s: option '%c%s' doesn't allow an argument\n",argv[0], argv[d->optind - 1][0],pfound->name); - } - } - d->__nextchar += strlen(d->__nextchar); - d->optopt = pfound->val; - return '?'; - } - } - else if (pfound->has_arg == 1) - { - if (d->optind < argc) - d->optarg = argv[d->optind++]; - else - { - if (print_errors) - { - fprintf(stderr,"%s: option '--%s' requires an argument\n",argv[0], pfound->name); - } - d->__nextchar += strlen(d->__nextchar); - d->optopt = pfound->val; - return optstring[0] == ':' ? ':' : '?'; - } - } - d->__nextchar += strlen(d->__nextchar); - if (longind != NULL) - *longind = option_index; - if (pfound->flag) - { - *(pfound->flag) = pfound->val; - return 0; - } - return pfound->val; - } - if (!long_only || argv[d->optind][1] == '-' || strchr(optstring, *d->__nextchar) == NULL) - { - if (print_errors) - { - if (argv[d->optind][1] == '-') - { - fprintf(stderr, "%s: unrecognized option '--%s'\n",argv[0], d->__nextchar); - } - else - { - fprintf(stderr, "%s: unrecognized option '%c%s'\n",argv[0], argv[d->optind][0], d->__nextchar); - } - } - d->__nextchar = (char *)""; - d->optind++; - d->optopt = 0; - return '?'; - } - } - { - char c = *d->__nextchar++; - char *temp = (char*)strchr(optstring, c); - if (*d->__nextchar == '\0') - ++d->optind; - if (temp == NULL || c == ':' || c == ';') - { - if (print_errors) - { - fprintf(stderr, "%s: invalid option -- '%c'\n", argv[0], c); - } - d->optopt = c; - return '?'; - } - if (temp[0] == 'W' && temp[1] == ';') - { - char *nameend; - const struct option_a *p; - const struct option_a *pfound = NULL; - int exact = 0; - int ambig = 0; - int indfound = 0; - int option_index; - if (longopts == NULL) - goto no_longs; - if (*d->__nextchar != '\0') - { - d->optarg = d->__nextchar; - d->optind++; - } - else if (d->optind == argc) - { - if (print_errors) - { - fprintf(stderr,"%s: option requires an argument -- '%c'\n",argv[0], c); - } - d->optopt = c; - if (optstring[0] == ':') - c = ':'; - else - c = '?'; - return c; - } - else - d->optarg = argv[d->optind++]; - for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '='; nameend++); - for (p = longopts, option_index = 0; p->name; p++, option_index++) - if (!strncmp(p->name, d->__nextchar, nameend - d->__nextchar)) - { - if ((unsigned int) (nameend - d->__nextchar) == strlen(p->name)) - { - pfound = p; - indfound = option_index; - exact = 1; - break; - } - else if (pfound == NULL) - { - pfound = p; - indfound = option_index; - } - else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val) - ambig = 1; - } - if (ambig && !exact) - { - if (print_errors) - { - fprintf(stderr, "%s: option '-W %s' is ambiguous\n",argv[0], d->optarg); - } - d->__nextchar += strlen(d->__nextchar); - d->optind++; - return '?'; - } - if (pfound != NULL) - { - option_index = indfound; - if (*nameend) - { - if (pfound->has_arg) - d->optarg = nameend + 1; - else - { - if (print_errors) - { - fprintf(stderr, "%s: option '-W %s' doesn't allow an argument\n",argv[0], pfound->name); - } - d->__nextchar += strlen(d->__nextchar); - return '?'; - } - } - else if (pfound->has_arg == 1) - { - if (d->optind < argc) - d->optarg = argv[d->optind++]; - else - { - if (print_errors) - { - fprintf(stderr, "%s: option '-W %s' requires an argument\n",argv[0], pfound->name); - } - d->__nextchar += strlen(d->__nextchar); - return optstring[0] == ':' ? ':' : '?'; - } - } - else - d->optarg = NULL; - d->__nextchar += strlen(d->__nextchar); - if (longind != NULL) - *longind = option_index; - if (pfound->flag) - { - *(pfound->flag) = pfound->val; - return 0; - } - return pfound->val; - } -no_longs: - d->__nextchar = NULL; - return 'W'; - } - if (temp[1] == ':') - { - if (temp[2] == ':') - { - if (*d->__nextchar != '\0') - { - d->optarg = d->__nextchar; - d->optind++; - } - else - d->optarg = NULL; - d->__nextchar = NULL; - } - else - { - if (*d->__nextchar != '\0') - { - d->optarg = d->__nextchar; - d->optind++; - } - else if (d->optind == argc) - { - if (print_errors) - { - fprintf(stderr,"%s: option requires an argument -- '%c'\n",argv[0], c); - } - d->optopt = c; - if (optstring[0] == ':') - c = ':'; - else - c = '?'; - } - else - d->optarg = argv[d->optind++]; - d->__nextchar = NULL; - } - } - return c; - } -} -int _getopt_internal_a (int argc, char *const *argv, const char *optstring, const struct option_a *longopts, int *longind, int long_only, int posixly_correct) -{ - int result; - getopt_data_a.optind = optind; - getopt_data_a.opterr = opterr; - result = _getopt_internal_r_a (argc, argv, optstring, longopts,longind, long_only, &getopt_data_a,posixly_correct); - optind = getopt_data_a.optind; - optarg_a = getopt_data_a.optarg; - optopt = getopt_data_a.optopt; - return result; -} -int getopt_a (int argc, char *const *argv, const char *optstring) _GETOPT_THROW -{ - return _getopt_internal_a (argc, argv, optstring, (const struct option_a *) 0, (int *) 0, 0, 0); -} -int getopt_long_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index) _GETOPT_THROW -{ - return _getopt_internal_a (argc, argv, options, long_options, opt_index, 0, 0); -} -int getopt_long_only_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index) _GETOPT_THROW -{ - return _getopt_internal_a (argc, argv, options, long_options, opt_index, 1, 0); -} -int _getopt_long_r_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index, struct _getopt_data_a *d) -{ - return _getopt_internal_r_a (argc, argv, options, long_options, opt_index,0, d, 0); -} -int _getopt_long_only_r_a (int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index, struct _getopt_data_a *d) -{ - return _getopt_internal_r_a (argc, argv, options, long_options, opt_index, 1, d, 0); -} - -// -// -// Unicode Structures and Functions -// -// - -static struct _getopt_data_w -{ - int optind; - int opterr; - int optopt; - wchar_t *optarg; - int __initialized; - wchar_t *__nextchar; - enum ENUM_ORDERING __ordering; - int __posixly_correct; - int __first_nonopt; - int __last_nonopt; -} getopt_data_w; -wchar_t *optarg_w; - -static void exchange_w(wchar_t **argv, struct _getopt_data_w *d) -{ - int bottom = d->__first_nonopt; - int middle = d->__last_nonopt; - int top = d->optind; - wchar_t *tem; - while (top > middle && middle > bottom) - { - if (top - middle > middle - bottom) - { - int len = middle - bottom; - register int i; - for (i = 0; i < len; i++) - { - tem = argv[bottom + i]; - argv[bottom + i] = argv[top - (middle - bottom) + i]; - argv[top - (middle - bottom) + i] = tem; - } - top -= len; - } - else - { - int len = top - middle; - register int i; - for (i = 0; i < len; i++) - { - tem = argv[bottom + i]; - argv[bottom + i] = argv[middle + i]; - argv[middle + i] = tem; - } - bottom += len; - } - } - d->__first_nonopt += (d->optind - d->__last_nonopt); - d->__last_nonopt = d->optind; -} -static const wchar_t *_getopt_initialize_w (const wchar_t *optstring, struct _getopt_data_w *d, int posixly_correct) -{ - d->__first_nonopt = d->__last_nonopt = d->optind; - d->__nextchar = NULL; - d->__posixly_correct = posixly_correct | !!_wgetenv(L"POSIXLY_CORRECT"); - if (optstring[0] == L'-') - { - d->__ordering = RETURN_IN_ORDER; - ++optstring; - } - else if (optstring[0] == L'+') - { - d->__ordering = REQUIRE_ORDER; - ++optstring; - } - else if (d->__posixly_correct) - d->__ordering = REQUIRE_ORDER; - else - d->__ordering = PERMUTE; - return optstring; -} -int _getopt_internal_r_w (int argc, wchar_t *const *argv, const wchar_t *optstring, const struct option_w *longopts, int *longind, int long_only, struct _getopt_data_w *d, int posixly_correct) -{ - int print_errors = d->opterr; - if (argc < 1) - return -1; - d->optarg = NULL; - if (d->optind == 0 || !d->__initialized) - { - if (d->optind == 0) - d->optind = 1; - optstring = _getopt_initialize_w (optstring, d, posixly_correct); - d->__initialized = 1; - } - else if (optstring[0] == L'-' || optstring[0] == L'+') - optstring++; - if (optstring[0] == L':') - print_errors = 0; - if (d->__nextchar == NULL || *d->__nextchar == L'\0') - { - if (d->__last_nonopt > d->optind) - d->__last_nonopt = d->optind; - if (d->__first_nonopt > d->optind) - d->__first_nonopt = d->optind; - if (d->__ordering == PERMUTE) - { - if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind) - exchange_w((wchar_t **) argv, d); - else if (d->__last_nonopt != d->optind) - d->__first_nonopt = d->optind; - while (d->optind < argc && (argv[d->optind][0] != L'-' || argv[d->optind][1] == L'\0')) - d->optind++; - d->__last_nonopt = d->optind; - } - if (d->optind != argc && !wcscmp(argv[d->optind], L"--")) - { - d->optind++; - if (d->__first_nonopt != d->__last_nonopt && d->__last_nonopt != d->optind) - exchange_w((wchar_t **) argv, d); - else if (d->__first_nonopt == d->__last_nonopt) - d->__first_nonopt = d->optind; - d->__last_nonopt = argc; - d->optind = argc; - } - if (d->optind == argc) - { - if (d->__first_nonopt != d->__last_nonopt) - d->optind = d->__first_nonopt; - return -1; - } - if ((argv[d->optind][0] != L'-' || argv[d->optind][1] == L'\0')) - { - if (d->__ordering == REQUIRE_ORDER) - return -1; - d->optarg = argv[d->optind++]; - return 1; - } - d->__nextchar = (argv[d->optind] + 1 + (longopts != NULL && argv[d->optind][1] == L'-')); - } - if (longopts != NULL && (argv[d->optind][1] == L'-' || (long_only && (argv[d->optind][2] || !wcschr(optstring, argv[d->optind][1]))))) - { - wchar_t *nameend; - unsigned int namelen; - const struct option_w *p; - const struct option_w *pfound = NULL; - struct option_list - { - const struct option_w *p; - struct option_list *next; - } *ambig_list = NULL; - int exact = 0; - int indfound = -1; - int option_index; - for (nameend = d->__nextchar; *nameend && *nameend != L'='; nameend++); - namelen = (unsigned int)(nameend - d->__nextchar); - for (p = longopts, option_index = 0; p->name; p++, option_index++) - if (!wcsncmp(p->name, d->__nextchar, namelen)) - { - if (namelen == (unsigned int)wcslen(p->name)) - { - pfound = p; - indfound = option_index; - exact = 1; - break; - } - else if (pfound == NULL) - { - pfound = p; - indfound = option_index; - } - else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val) - { - struct option_list *newp = (struct option_list*)alloca(sizeof(*newp)); - newp->p = p; - newp->next = ambig_list; - ambig_list = newp; - } - } - if (ambig_list != NULL && !exact) - { - if (print_errors) - { - struct option_list first; - first.p = pfound; - first.next = ambig_list; - ambig_list = &first; - fwprintf(stderr, L"%s: option '%s' is ambiguous; possibilities:", argv[0], argv[d->optind]); - do - { - fwprintf (stderr, L" '--%s'", ambig_list->p->name); - ambig_list = ambig_list->next; - } - while (ambig_list != NULL); - fputwc (L'\n', stderr); - } - d->__nextchar += wcslen(d->__nextchar); - d->optind++; - d->optopt = 0; - return L'?'; - } - if (pfound != NULL) - { - option_index = indfound; - d->optind++; - if (*nameend) - { - if (pfound->has_arg) - d->optarg = nameend + 1; - else - { - if (print_errors) - { - if (argv[d->optind - 1][1] == L'-') - { - fwprintf(stderr, L"%s: option '--%s' doesn't allow an argument\n",argv[0], pfound->name); - } - else - { - fwprintf(stderr, L"%s: option '%c%s' doesn't allow an argument\n",argv[0], argv[d->optind - 1][0],pfound->name); - } - } - d->__nextchar += wcslen(d->__nextchar); - d->optopt = pfound->val; - return L'?'; - } - } - else if (pfound->has_arg == 1) - { - if (d->optind < argc) - d->optarg = argv[d->optind++]; - else - { - if (print_errors) - { - fwprintf(stderr,L"%s: option '--%s' requires an argument\n",argv[0], pfound->name); - } - d->__nextchar += wcslen(d->__nextchar); - d->optopt = pfound->val; - return optstring[0] == L':' ? L':' : L'?'; - } - } - d->__nextchar += wcslen(d->__nextchar); - if (longind != NULL) - *longind = option_index; - if (pfound->flag) - { - *(pfound->flag) = pfound->val; - return 0; - } - return pfound->val; - } - if (!long_only || argv[d->optind][1] == L'-' || wcschr(optstring, *d->__nextchar) == NULL) - { - if (print_errors) - { - if (argv[d->optind][1] == L'-') - { - fwprintf(stderr, L"%s: unrecognized option '--%s'\n",argv[0], d->__nextchar); - } - else - { - fwprintf(stderr, L"%s: unrecognized option '%c%s'\n",argv[0], argv[d->optind][0], d->__nextchar); - } - } - d->__nextchar = (wchar_t *)L""; - d->optind++; - d->optopt = 0; - return L'?'; - } - } - { - wchar_t c = *d->__nextchar++; - wchar_t *temp = (wchar_t*)wcschr(optstring, c); - if (*d->__nextchar == L'\0') - ++d->optind; - if (temp == NULL || c == L':' || c == L';') - { - if (print_errors) - { - fwprintf(stderr, L"%s: invalid option -- '%c'\n", argv[0], c); - } - d->optopt = c; - return L'?'; - } - if (temp[0] == L'W' && temp[1] == L';') - { - wchar_t *nameend; - const struct option_w *p; - const struct option_w *pfound = NULL; - int exact = 0; - int ambig = 0; - int indfound = 0; - int option_index; - if (longopts == NULL) - goto no_longs; - if (*d->__nextchar != L'\0') - { - d->optarg = d->__nextchar; - d->optind++; - } - else if (d->optind == argc) - { - if (print_errors) - { - fwprintf(stderr,L"%s: option requires an argument -- '%c'\n",argv[0], c); - } - d->optopt = c; - if (optstring[0] == L':') - c = L':'; - else - c = L'?'; - return c; - } - else - d->optarg = argv[d->optind++]; - for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != L'='; nameend++); - for (p = longopts, option_index = 0; p->name; p++, option_index++) - if (!wcsncmp(p->name, d->__nextchar, nameend - d->__nextchar)) - { - if ((unsigned int) (nameend - d->__nextchar) == wcslen(p->name)) - { - pfound = p; - indfound = option_index; - exact = 1; - break; - } - else if (pfound == NULL) - { - pfound = p; - indfound = option_index; - } - else if (long_only || pfound->has_arg != p->has_arg || pfound->flag != p->flag || pfound->val != p->val) - ambig = 1; - } - if (ambig && !exact) - { - if (print_errors) - { - fwprintf(stderr, L"%s: option '-W %s' is ambiguous\n",argv[0], d->optarg); - } - d->__nextchar += wcslen(d->__nextchar); - d->optind++; - return L'?'; - } - if (pfound != NULL) - { - option_index = indfound; - if (*nameend) - { - if (pfound->has_arg) - d->optarg = nameend + 1; - else - { - if (print_errors) - { - fwprintf(stderr, L"%s: option '-W %s' doesn't allow an argument\n",argv[0], pfound->name); - } - d->__nextchar += wcslen(d->__nextchar); - return L'?'; - } - } - else if (pfound->has_arg == 1) - { - if (d->optind < argc) - d->optarg = argv[d->optind++]; - else - { - if (print_errors) - { - fwprintf(stderr, L"%s: option '-W %s' requires an argument\n",argv[0], pfound->name); - } - d->__nextchar += wcslen(d->__nextchar); - return optstring[0] == L':' ? L':' : L'?'; - } - } - else - d->optarg = NULL; - d->__nextchar += wcslen(d->__nextchar); - if (longind != NULL) - *longind = option_index; - if (pfound->flag) - { - *(pfound->flag) = pfound->val; - return 0; - } - return pfound->val; - } -no_longs: - d->__nextchar = NULL; - return L'W'; - } - if (temp[1] == L':') - { - if (temp[2] == L':') - { - if (*d->__nextchar != L'\0') - { - d->optarg = d->__nextchar; - d->optind++; - } - else - d->optarg = NULL; - d->__nextchar = NULL; - } - else - { - if (*d->__nextchar != L'\0') - { - d->optarg = d->__nextchar; - d->optind++; - } - else if (d->optind == argc) - { - if (print_errors) - { - fwprintf(stderr,L"%s: option requires an argument -- '%c'\n",argv[0], c); - } - d->optopt = c; - if (optstring[0] == L':') - c = L':'; - else - c = L'?'; - } - else - d->optarg = argv[d->optind++]; - d->__nextchar = NULL; - } - } - return c; - } -} -int _getopt_internal_w (int argc, wchar_t *const *argv, const wchar_t *optstring, const struct option_w *longopts, int *longind, int long_only, int posixly_correct) -{ - int result; - getopt_data_w.optind = optind; - getopt_data_w.opterr = opterr; - result = _getopt_internal_r_w (argc, argv, optstring, longopts,longind, long_only, &getopt_data_w,posixly_correct); - optind = getopt_data_w.optind; - optarg_w = getopt_data_w.optarg; - optopt = getopt_data_w.optopt; - return result; -} -int getopt_w (int argc, wchar_t *const *argv, const wchar_t *optstring) _GETOPT_THROW -{ - return _getopt_internal_w (argc, argv, optstring, (const struct option_w *) 0, (int *) 0, 0, 0); -} -int getopt_long_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index) _GETOPT_THROW -{ - return _getopt_internal_w (argc, argv, options, long_options, opt_index, 0, 0); -} -int getopt_long_only_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index) _GETOPT_THROW -{ - return _getopt_internal_w (argc, argv, options, long_options, opt_index, 1, 0); -} -int _getopt_long_r_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index, struct _getopt_data_w *d) -{ - return _getopt_internal_r_w (argc, argv, options, long_options, opt_index,0, d, 0); -} -int _getopt_long_only_r_w (int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index, struct _getopt_data_w *d) -{ - return _getopt_internal_r_w (argc, argv, options, long_options, opt_index, 1, d, 0); -} \ No newline at end of file Deleted: trunk/tools/ttbroadcast/getopt_mb_uni_src/getopt.h =================================================================== --- trunk/tools/ttbroadcast/getopt_mb_uni_src/getopt.h 2021-03-13 14:42:48 UTC (rev 9197) +++ trunk/tools/ttbroadcast/getopt_mb_uni_src/getopt.h 2021-03-13 14:43:03 UTC (rev 9198) @@ -1,136 +0,0 @@ -/* Getopt for Microsoft C -This code is a modification of the Free Software Foundation, Inc. -Getopt library for parsing command line argument the purpose was -to provide a Microsoft Visual C friendly derivative. This code -provides functionality for both Unicode and Multibyte builds. - -Date: 02/03/2011 - Ludvik Jerabek - Initial Release -Version: 1.0 -Comment: Supports getopt, getopt_long, and getopt_long_only -and POSIXLY_CORRECT environment flag -License: LGPL - -Revisions: - -02/03/2011 - Ludvik Jerabek - Initial Release -02/20/2011 - Ludvik Jerabek - Fixed compiler warnings at Level 4 -07/05/2011 - Ludvik Jerabek - Added no_argument, required_argument, optional_argument defs -08/03/2011 - Ludvik Jerabek - Fixed non-argument runtime bug which caused runtime exception -08/09/2011 - Ludvik Jerabek - Added code to export functions for DLL and LIB -02/15/2012 - Ludvik Jerabek - Fixed _GETOPT_THROW definition missing in implementation file -08/01/2012 - Ludvik Jerabek - Created separate functions for char and wchar_t characters so single dll can do both unicode and ansi -10/15/2012 - Ludvik Jerabek - Modified to match latest GNU features -06/19/2015 - Ludvik Jerabek - Fixed maximum option limitation caused by option_a (255) and option_w (65535) structure val variable - -**DISCLAIMER** -THIS MATERIAL IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, -EITHER EXPRESS OR IMPLIED, INCLUDING, BUT Not LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR -PURPOSE, OR NON-INFRINGEMENT. SOME JURISDICTIONS DO NOT ALLOW THE -EXCLUSION OF IMPLIED WARRANTIES, SO THE ABOVE EXCLUSION MAY NOT -APPLY TO YOU. IN NO EVENT WILL I BE LIABLE TO ANY PARTY FOR ANY -DIRECT, INDIRECT, SPECIAL OR OTHER CONSEQUENTIAL DAMAGES FOR ANY -USE OF THIS MATERIAL INCLUDING, WITHOUT LIMITATION, ANY LOST -PROFITS, BUSINESS INTERRUPTION, LOSS OF PROGRAMS OR OTHER DATA ON -YOUR INFORMATION HANDLING SYSTEM OR OTHERWISE, EVEN If WE ARE -EXPRESSLY ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. -*/ -#ifndef __GETOPT_H_ - #define __GETOPT_H_ - - #ifdef _GETOPT_API - #undef _GETOPT_API - #endif - - #if defined(EXPORTS_GETOPT) && defined(STATIC_GETOPT) - #error "The preprocessor definitions of EXPORTS_GETOPT and STATIC_GETOPT can only be used individually" - #elif defined(STATIC_GETOPT) - #pragma message("Warning static builds of getopt violate the Lesser GNU Public License") - #define _GETOPT_API - #elif defined(EXPORTS_GETOPT) - #pragma message("Exporting getopt library") - #define _GETOPT_API __declspec(dllexport) - #else - #pragma message("Importing getopt library") - #define _GETOPT_API __declspec(dllimport) - #endif - - // Change behavior for C\C++ - #ifdef __cplusplus - #define _BEGIN_EXTERN_C extern "C" { - #define _END_EXTERN_C } - #define _GETOPT_THROW throw() - #else - #define _BEGIN_EXTERN_C - #define _END_EXTERN_C - #define _GETOPT_THROW - #endif - - // Standard GNU options - #define null_argument 0 /*Argument Null*/ - #define no_argument 0 /*Argument Switch Only*/ - #define required_argument 1 /*Argument Required*/ - #define optional_argument 2 /*Argument Optional*/ - - // Shorter Options - #define ARG_NULL 0 /*Argument Null*/ - #define ARG_NONE 0 /*Argument Switch Only*/ - #define ARG_REQ 1 /*Argument Required*/ - #define ARG_OPT 2 /*Argument Optional*/ - - #include <string.h> - #include <wchar.h> - -_BEGIN_EXTERN_C - - extern _GETOPT_API int optind; - extern _GETOPT_API int opterr; - extern _GETOPT_API int optopt; - - // Ansi - struct option_a - { - const char* name; - int has_arg; - int *flag; - int val; - }; - extern _GETOPT_API char *optarg_a; - extern _GETOPT_API int getopt_a(int argc, char *const *argv, const char *optstring) _GETOPT_THROW; - extern _GETOPT_API int getopt_long_a(int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index) _GETOPT_THROW; - extern _GETOPT_API int getopt_long_only_a(int argc, char *const *argv, const char *options, const struct option_a *long_options, int *opt_index) _GETOPT_THROW; - - // Unicode - struct option_w - { - const wchar_t* name; - int has_arg; - int *flag; - int val; - }; - extern _GETOPT_API wchar_t *optarg_w; - extern _GETOPT_API int getopt_w(int argc, wchar_t *const *argv, const wchar_t *optstring) _GETOPT_THROW; - extern _GETOPT_API int getopt_long_w(int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index) _GETOPT_THROW; - extern _GETOPT_API int getopt_long_only_w(int argc, wchar_t *const *argv, const wchar_t *options, const struct option_w *long_options, int *opt_index) _GETOPT_THROW; - -_END_EXTERN_C - - #undef _BEGIN_EXTERN_C - #undef _END_EXTERN_C - #undef _GETOPT_THROW - #undef _GETOPT_API - - #ifdef _UNICODE - #define getopt getopt_w - #define getopt_long getopt_long_w - #define getopt_long_only getopt_long_only_w - #define option option_w - #define optarg optarg_w - #else - #define getopt getopt_a - #define getopt_long getopt_long_a - #define getopt_long_only getopt_long_only_a - #define option option_a - #define optarg optarg_a - #endif -#endif // __GETOPT_H_