before changing it!
Copyright (C) 1987, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
- Free Software Foundation, Inc.
+ Free Software Foundation, Inc.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
/* This needs to come after some library #include
to get __GNU_LIBRARY__ defined. */
-#ifdef __GNU_LIBRARY__
+#ifdef __GNU_LIBRARY__
/* Don't include stdlib.h for non-GNU C libraries because some of them
contain conflicting prototypes for getopt. */
# include <stdlib.h>
#ifndef WIN32
# include <unistd.h>
#endif
-#endif /* GNU C library. */
+#endif /* GNU C library. */
#ifdef VMS
# include <unixlib.h>
When compiling libc, the _ macro is predefined. */
# ifdef HAVE_LIBINTL_H
# include <libintl.h>
-# define _(msgid) gettext (msgid)
+# define _(msgid) gettext (msgid)
# else
-# define _(msgid) (msgid)
+# define _(msgid) (msgid)
# endif
#endif
Also, when `ordering' is RETURN_IN_ORDER,
each non-option ARGV-element is returned here. */
-#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
+#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
char *optarg;
#endif
how much of ARGV has been scanned so far. */
/* 1003.2 says this must be 1 before any call. */
-#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
+#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
int optind = 1;
#endif
causes problems with re-calling getopt as programs generally don't
know that. */
-#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
+#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
int __getopt_initialized;
#else
extern int __getopt_initialized;
/* Callers store zero here to inhibit the error message
for unrecognized options. */
-#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
+#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
int opterr = 1;
#endif
This must be initialized on some systems to avoid linking in the
system's own getopt implementation. */
-#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
+#if ! defined(HAVE_GETOPT) && ! defined(HAVE_GETOPT_LONG)
int optopt = '?';
#endif
/* Value of POSIXLY_CORRECT environment variable. */
static char *posixly_correct;
\f
-#ifdef __GNU_LIBRARY__
+#ifdef __GNU_LIBRARY__
/* We want to avoid inclusion of string.h with non-GNU libraries
because there are many ways it can cause trouble.
On some systems, it contains special magic macros that don't work
in GCC. */
# include <string.h>
-# define my_index strchr
+# define my_index strchr
#else
# if HAVE_STRING_H
while (*str)
{
if (*str == chr)
- return (char *) str;
+ return (char *) str;
str++;
}
return 0;
# endif /* text_set_element */
# define SWAP_FLAGS(ch1, ch2) \
- if (nonoption_flags_len > 0) \
- { \
- char __tmp = __getopt_nonoption_flags[ch1]; \
- __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \
- __getopt_nonoption_flags[ch2] = __tmp; \
+ if (nonoption_flags_len > 0) \
+ { \
+ char __tmp = __getopt_nonoption_flags[ch1]; \
+ __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2]; \
+ __getopt_nonoption_flags[ch2] = __tmp; \
}
-#else /* !_LIBC */
+#else /* !_LIBC */
# define SWAP_FLAGS(ch1, ch2)
-#endif /* _LIBC */
+#endif /* _LIBC */
/* Exchange two adjacent subsequences of ARGV.
One subsequence is elements [first_nonopt,last_nonopt)
if (nonoption_flags_len > 0 && top >= nonoption_flags_max_len)
{
/* We must extend the array. The user plays games with us and
- presents new arguments. */
+ presents new arguments. */
char *new_str = malloc (top + 1);
if (new_str == NULL)
- nonoption_flags_len = nonoption_flags_max_len = 0;
+ nonoption_flags_len = nonoption_flags_max_len = 0;
else
- {
- memset (__mempcpy (new_str, __getopt_nonoption_flags,
- nonoption_flags_max_len),
- '\0', top + 1 - nonoption_flags_max_len);
- nonoption_flags_max_len = top + 1;
- __getopt_nonoption_flags = new_str;
- }
+ {
+ memset (__mempcpy (new_str, __getopt_nonoption_flags,
+ nonoption_flags_max_len),
+ '\0', top + 1 - nonoption_flags_max_len);
+ nonoption_flags_max_len = top + 1;
+ __getopt_nonoption_flags = new_str;
+ }
}
#endif
while (top > middle && middle > bottom)
{
if (top - middle > middle - bottom)
- {
- /* Bottom segment is the short one. */
- int len = middle - bottom;
- register int i;
-
- /* Swap it with the top part of the top segment. */
- for (i = 0; i < len; i++)
- {
- tem = argv[bottom + i];
- argv[bottom + i] = argv[top - (middle - bottom) + i];
- argv[top - (middle - bottom) + i] = tem;
- SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
- }
- /* Exclude the moved bottom segment from further swapping. */
- top -= len;
- }
+ {
+ /* Bottom segment is the short one. */
+ int len = middle - bottom;
+ register int i;
+
+ /* Swap it with the top part of the top segment. */
+ for (i = 0; i < len; i++)
+ {
+ tem = argv[bottom + i];
+ argv[bottom + i] = argv[top - (middle - bottom) + i];
+ argv[top - (middle - bottom) + i] = tem;
+ SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
+ }
+ /* Exclude the moved bottom segment from further swapping. */
+ top -= len;
+ }
else
- {
- /* Top segment is the short one. */
- int len = top - middle;
- register int i;
-
- /* Swap it with the bottom part of the bottom segment. */
- for (i = 0; i < len; i++)
- {
- tem = argv[bottom + i];
- argv[bottom + i] = argv[middle + i];
- argv[middle + i] = tem;
- SWAP_FLAGS (bottom + i, middle + i);
- }
- /* Exclude the moved top segment from further swapping. */
- bottom += len;
- }
+ {
+ /* Top segment is the short one. */
+ int len = top - middle;
+ register int i;
+
+ /* Swap it with the bottom part of the bottom segment. */
+ for (i = 0; i < len; i++)
+ {
+ tem = argv[bottom + i];
+ argv[bottom + i] = argv[middle + i];
+ argv[middle + i] = tem;
+ SWAP_FLAGS (bottom + i, middle + i);
+ }
+ /* Exclude the moved top segment from further swapping. */
+ bottom += len;
+ }
}
/* Update records for the slots the non-options now occupy. */
&& argc == original_argc && argv == original_argv)
{
if (nonoption_flags_max_len == 0)
- {
- if (__getopt_nonoption_flags == NULL
- || __getopt_nonoption_flags[0] == '\0')
- nonoption_flags_max_len = -1;
- else
- {
- const char *orig_str = __getopt_nonoption_flags;
- int len = nonoption_flags_max_len = strlen (orig_str);
- if (nonoption_flags_max_len < argc)
- nonoption_flags_max_len = argc;
- __getopt_nonoption_flags =
- (char *) malloc (nonoption_flags_max_len);
- if (__getopt_nonoption_flags == NULL)
- nonoption_flags_max_len = -1;
- else
- memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
- '\0', nonoption_flags_max_len - len);
- }
- }
+ {
+ if (__getopt_nonoption_flags == NULL
+ || __getopt_nonoption_flags[0] == '\0')
+ nonoption_flags_max_len = -1;
+ else
+ {
+ const char *orig_str = __getopt_nonoption_flags;
+ int len = nonoption_flags_max_len = strlen (orig_str);
+ if (nonoption_flags_max_len < argc)
+ nonoption_flags_max_len = argc;
+ __getopt_nonoption_flags =
+ (char *) malloc (nonoption_flags_max_len);
+ if (__getopt_nonoption_flags == NULL)
+ nonoption_flags_max_len = -1;
+ else
+ memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
+ '\0', nonoption_flags_max_len - len);
+ }
+ }
nonoption_flags_len = nonoption_flags_max_len;
}
else
if (optind == 0 || !__getopt_initialized)
{
if (optind == 0)
- optind = 1; /* Don't scan ARGV[0], the program name. */
+ optind = 1; /* Don't scan ARGV[0], the program name. */
optstring = _getopt_initialize (argc, argv, optstring);
__getopt_initialized = 1;
}
from the shell indicating it is not an option. The later information
is only used when the used in the GNU libc. */
#ifdef _LIBC
-# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \
- || (optind < nonoption_flags_len \
- && __getopt_nonoption_flags[optind] == '1'))
+# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0' \
+ || (optind < nonoption_flags_len \
+ && __getopt_nonoption_flags[optind] == '1'))
#else
# define NONOPTION_P (argv[optind][0] != '-' || argv[optind][1] == '\0')
#endif
/* Advance to the next ARGV-element. */
/* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
- moved back by the user (who may also have changed the arguments). */
+ moved back by the user (who may also have changed the arguments). */
if (last_nonopt > optind)
- last_nonopt = optind;
+ last_nonopt = optind;
if (first_nonopt > optind)
- first_nonopt = optind;
+ first_nonopt = optind;
if (ordering == PERMUTE)
- {
- /* If we have just processed some options following some non-options,
- exchange them so that the options come first. */
+ {
+ /* If we have just processed some options following some non-options,
+ exchange them so that the options come first. */
- if (first_nonopt != last_nonopt && last_nonopt != optind)
- exchange ((char **) argv);
- else if (last_nonopt != optind)
- first_nonopt = optind;
+ if (first_nonopt != last_nonopt && last_nonopt != optind)
+ exchange ((char **) argv);
+ else if (last_nonopt != optind)
+ first_nonopt = optind;
- /* Skip any additional non-options
- and extend the range of non-options previously skipped. */
+ /* Skip any additional non-options
+ and extend the range of non-options previously skipped. */
- while (optind < argc && NONOPTION_P)
- optind++;
- last_nonopt = optind;
- }
+ while (optind < argc && NONOPTION_P)
+ optind++;
+ last_nonopt = optind;
+ }
/* The special ARGV-element `--' means premature end of options.
- Skip it like a null option,
- then exchange with previous non-options as if it were an option,
- then skip everything else like a non-option. */
+ Skip it like a null option,
+ then exchange with previous non-options as if it were an option,
+ then skip everything else like a non-option. */
if (optind != argc && !strcmp (argv[optind], "--"))
- {
- optind++;
+ {
+ optind++;
- if (first_nonopt != last_nonopt && last_nonopt != optind)
- exchange ((char **) argv);
- else if (first_nonopt == last_nonopt)
- first_nonopt = optind;
- last_nonopt = argc;
+ if (first_nonopt != last_nonopt && last_nonopt != optind)
+ exchange ((char **) argv);
+ else if (first_nonopt == last_nonopt)
+ first_nonopt = optind;
+ last_nonopt = argc;
- optind = argc;
- }
+ optind = argc;
+ }
/* If we have done all the ARGV-elements, stop the scan
- and back over any non-options that we skipped and permuted. */
+ and back over any non-options that we skipped and permuted. */
if (optind == argc)
- {
- /* Set the next-arg-index to point at the non-options
- that we previously skipped, so the caller will digest them. */
- if (first_nonopt != last_nonopt)
- optind = first_nonopt;
- return -1;
- }
+ {
+ /* Set the next-arg-index to point at the non-options
+ that we previously skipped, so the caller will digest them. */
+ if (first_nonopt != last_nonopt)
+ optind = first_nonopt;
+ return -1;
+ }
/* If we have come to a non-option and did not permute it,
- either stop the scan or describe it to the caller and pass it by. */
+ either stop the scan or describe it to the caller and pass it by. */
if (NONOPTION_P)
- {
- if (ordering == REQUIRE_ORDER)
- return -1;
- optarg = argv[optind++];
- return 1;
- }
+ {
+ if (ordering == REQUIRE_ORDER)
+ return -1;
+ optarg = argv[optind++];
+ return 1;
+ }
/* We have found another option-ARGV-element.
- Skip the initial punctuation. */
+ Skip the initial punctuation. */
nextchar = (argv[optind] + 1
- + (longopts != NULL && argv[optind][1] == '-'));
+ + (longopts != NULL && argv[optind][1] == '-'));
}
/* Decode the current option-ARGV-element. */
if (longopts != NULL
&& (argv[optind][1] == '-'
- || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
+ || (long_only && (argv[optind][2] || !my_index (optstring, argv[optind][1])))))
{
char *nameend;
const struct option *p;
int option_index;
for (nameend = nextchar; *nameend && *nameend != '='; nameend++)
- /* Do nothing. */ ;
+ /* Do nothing. */ ;
/* Test all long options for either exact match
- or abbreviated matches. */
+ or abbreviated matches. */
for (p = longopts, option_index = 0; p->name; p++, option_index++)
- if (!strncmp (p->name, nextchar, nameend - nextchar))
- {
- if ((unsigned int) (nameend - nextchar)
- == (unsigned int) strlen (p->name))
- {
- /* Exact match found. */
- pfound = p;
- indfound = option_index;
- exact = 1;
- break;
- }
- else if (pfound == NULL)
- {
- /* First nonexact match found. */
- pfound = p;
- indfound = option_index;
- }
- else
- /* Second or later nonexact match found. */
- ambig = 1;
- }
+ if (!strncmp (p->name, nextchar, nameend - nextchar))
+ {
+ if ((unsigned int) (nameend - nextchar)
+ == (unsigned int) strlen (p->name))
+ {
+ /* Exact match found. */
+ pfound = p;
+ indfound = option_index;
+ exact = 1;
+ break;
+ }
+ else if (pfound == NULL)
+ {
+ /* First nonexact match found. */
+ pfound = p;
+ indfound = option_index;
+ }
+ else
+ /* Second or later nonexact match found. */
+ ambig = 1;
+ }
if (ambig && !exact)
- {
- if (print_errors)
- fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
- argv[0], argv[optind]);
- nextchar += strlen (nextchar);
- optind++;
- optopt = 0;
- return '?';
- }
+ {
+ if (print_errors)
+ fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
+ argv[0], argv[optind]);
+ nextchar += strlen (nextchar);
+ optind++;
+ optopt = 0;
+ return '?';
+ }
if (pfound != NULL)
- {
- option_index = indfound;
- optind++;
- if (*nameend)
- {
- /* Don't test has_arg with >, because some C compilers don't
- allow it to be used on enums. */
- if (pfound->has_arg)
- optarg = nameend + 1;
- else
- {
- if (print_errors)
- {
- if (argv[optind - 1][1] == '-')
- /* --option */
- fprintf (stderr,
- _("%s: option `--%s' doesn't allow an argument\n"),
- argv[0], pfound->name);
- else
- /* +option or -option */
- fprintf (stderr,
- _("%s: option `%c%s' doesn't allow an argument\n"),
- argv[0], argv[optind - 1][0], pfound->name);
- }
-
- nextchar += strlen (nextchar);
-
- optopt = pfound->val;
- return '?';
- }
- }
- else if (pfound->has_arg == 1)
- {
- if (optind < argc)
- optarg = argv[optind++];
- else
- {
- if (print_errors)
- fprintf (stderr,
- _("%s: option `%s' requires an argument\n"),
- argv[0], argv[optind - 1]);
- nextchar += strlen (nextchar);
- optopt = pfound->val;
- return optstring[0] == ':' ? ':' : '?';
- }
- }
- nextchar += strlen (nextchar);
- if (longind != NULL)
- *longind = option_index;
- if (pfound->flag)
- {
- *(pfound->flag) = pfound->val;
- return 0;
- }
- return pfound->val;
- }
+ {
+ option_index = indfound;
+ optind++;
+ if (*nameend)
+ {
+ /* Don't test has_arg with >, because some C compilers don't
+ allow it to be used on enums. */
+ if (pfound->has_arg)
+ optarg = nameend + 1;
+ else
+ {
+ if (print_errors)
+ {
+ if (argv[optind - 1][1] == '-')
+ /* --option */
+ fprintf (stderr,
+ _("%s: option `--%s' doesn't allow an argument\n"),
+ argv[0], pfound->name);
+ else
+ /* +option or -option */
+ fprintf (stderr,
+ _("%s: option `%c%s' doesn't allow an argument\n"),
+ argv[0], argv[optind - 1][0], pfound->name);
+ }
+
+ nextchar += strlen (nextchar);
+
+ optopt = pfound->val;
+ return '?';
+ }
+ }
+ else if (pfound->has_arg == 1)
+ {
+ if (optind < argc)
+ optarg = argv[optind++];
+ else
+ {
+ if (print_errors)
+ fprintf (stderr,
+ _("%s: option `%s' requires an argument\n"),
+ argv[0], argv[optind - 1]);
+ nextchar += strlen (nextchar);
+ optopt = pfound->val;
+ return optstring[0] == ':' ? ':' : '?';
+ }
+ }
+ nextchar += strlen (nextchar);
+ if (longind != NULL)
+ *longind = option_index;
+ if (pfound->flag)
+ {
+ *(pfound->flag) = pfound->val;
+ return 0;
+ }
+ return pfound->val;
+ }
/* Can't find it as a long option. If this is not getopt_long_only,
- or the option starts with '--' or is not a valid short
- option, then it's an error.
- Otherwise interpret it as a short option. */
+ or the option starts with '--' or is not a valid short
+ option, then it's an error.
+ Otherwise interpret it as a short option. */
if (!long_only || argv[optind][1] == '-'
- || my_index (optstring, *nextchar) == NULL)
- {
- if (print_errors)
- {
- if (argv[optind][1] == '-')
- /* --option */
- fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
- argv[0], nextchar);
- else
- /* +option or -option */
- fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
- argv[0], argv[optind][0], nextchar);
- }
- nextchar = (char *) "";
- optind++;
- optopt = 0;
- return '?';
- }
+ || my_index (optstring, *nextchar) == NULL)
+ {
+ if (print_errors)
+ {
+ if (argv[optind][1] == '-')
+ /* --option */
+ fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
+ argv[0], nextchar);
+ else
+ /* +option or -option */
+ fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
+ argv[0], argv[optind][0], nextchar);
+ }
+ nextchar = (char *) "";
+ optind++;
+ optopt = 0;
+ return '?';
+ }
}
/* Look at and handle the next short option-character. */
if (temp == NULL || c == ':')
{
- if (print_errors)
- {
- if (posixly_correct)
- /* 1003.2 specifies the format of this message. */
- fprintf (stderr, _("%s: illegal option -- %c\n"),
- argv[0], c);
- else
- fprintf (stderr, _("%s: invalid option -- %c\n"),
- argv[0], c);
- }
- optopt = c;
- return '?';
+ if (print_errors)
+ {
+ if (posixly_correct)
+ /* 1003.2 specifies the format of this message. */
+ fprintf (stderr, _("%s: illegal option -- %c\n"),
+ argv[0], c);
+ else
+ fprintf (stderr, _("%s: invalid option -- %c\n"),
+ argv[0], c);
+ }
+ optopt = c;
+ return '?';
}
/* Convenience. Treat POSIX -W foo same as long option --foo */
if (temp[0] == 'W' && temp[1] == ';')
{
- char *nameend;
- const struct option *p;
- const struct option *pfound = NULL;
- int exact = 0;
- int ambig = 0;
- int indfound = 0;
- int option_index;
-
- /* This is an option that requires an argument. */
- if (*nextchar != '\0')
- {
- optarg = nextchar;
- /* If we end this ARGV-element by taking the rest as an arg,
- we must advance to the next element now. */
- optind++;
- }
- else if (optind == argc)
- {
- if (print_errors)
- {
- /* 1003.2 specifies the format of this message. */
- fprintf (stderr, _("%s: option requires an argument -- %c\n"),
- argv[0], c);
- }
- optopt = c;
- if (optstring[0] == ':')
- c = ':';
- else
- c = '?';
- return c;
- }
- else
- /* We already incremented `optind' once;
- increment it again when taking next ARGV-elt as argument. */
- optarg = argv[optind++];
-
- /* optarg is now the argument, see if it's in the
- table of longopts. */
-
- for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
- /* Do nothing. */ ;
-
- /* Test all long options for either exact match
- or abbreviated matches. */
- for (p = longopts, option_index = 0; p->name; p++, option_index++)
- if (!strncmp (p->name, nextchar, nameend - nextchar))
- {
- if ((unsigned int) (nameend - nextchar) == strlen (p->name))
- {
- /* Exact match found. */
- pfound = p;
- indfound = option_index;
- exact = 1;
- break;
- }
- else if (pfound == NULL)
- {
- /* First nonexact match found. */
- pfound = p;
- indfound = option_index;
- }
- else
- /* Second or later nonexact match found. */
- ambig = 1;
- }
- if (ambig && !exact)
- {
- if (print_errors)
- fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
- argv[0], argv[optind]);
- nextchar += strlen (nextchar);
- optind++;
- return '?';
- }
- if (pfound != NULL)
- {
- option_index = indfound;
- if (*nameend)
- {
- /* Don't test has_arg with >, because some C compilers don't
- allow it to be used on enums. */
- if (pfound->has_arg)
- optarg = nameend + 1;
- else
- {
- if (print_errors)
- fprintf (stderr, _("\
+ char *nameend;
+ const struct option *p;
+ const struct option *pfound = NULL;
+ int exact = 0;
+ int ambig = 0;
+ int indfound = 0;
+ int option_index;
+
+ /* This is an option that requires an argument. */
+ if (*nextchar != '\0')
+ {
+ optarg = nextchar;
+ /* If we end this ARGV-element by taking the rest as an arg,
+ we must advance to the next element now. */
+ optind++;
+ }
+ else if (optind == argc)
+ {
+ if (print_errors)
+ {
+ /* 1003.2 specifies the format of this message. */
+ fprintf (stderr, _("%s: option requires an argument -- %c\n"),
+ argv[0], c);
+ }
+ optopt = c;
+ if (optstring[0] == ':')
+ c = ':';
+ else
+ c = '?';
+ return c;
+ }
+ else
+ /* We already incremented `optind' once;
+ increment it again when taking next ARGV-elt as argument. */
+ optarg = argv[optind++];
+
+ /* optarg is now the argument, see if it's in the
+ table of longopts. */
+
+ for (nextchar = nameend = optarg; *nameend && *nameend != '='; nameend++)
+ /* Do nothing. */ ;
+
+ /* Test all long options for either exact match
+ or abbreviated matches. */
+ for (p = longopts, option_index = 0; p->name; p++, option_index++)
+ if (!strncmp (p->name, nextchar, nameend - nextchar))
+ {
+ if ((unsigned int) (nameend - nextchar) == strlen (p->name))
+ {
+ /* Exact match found. */
+ pfound = p;
+ indfound = option_index;
+ exact = 1;
+ break;
+ }
+ else if (pfound == NULL)
+ {
+ /* First nonexact match found. */
+ pfound = p;
+ indfound = option_index;
+ }
+ else
+ /* Second or later nonexact match found. */
+ ambig = 1;
+ }
+ if (ambig && !exact)
+ {
+ if (print_errors)
+ fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
+ argv[0], argv[optind]);
+ nextchar += strlen (nextchar);
+ optind++;
+ return '?';
+ }
+ if (pfound != NULL)
+ {
+ option_index = indfound;
+ if (*nameend)
+ {
+ /* Don't test has_arg with >, because some C compilers don't
+ allow it to be used on enums. */
+ if (pfound->has_arg)
+ optarg = nameend + 1;
+ else
+ {
+ if (print_errors)
+ fprintf (stderr, _("\
%s: option `-W %s' doesn't allow an argument\n"),
- argv[0], pfound->name);
-
- nextchar += strlen (nextchar);
- return '?';
- }
- }
- else if (pfound->has_arg == 1)
- {
- if (optind < argc)
- optarg = argv[optind++];
- else
- {
- if (print_errors)
- fprintf (stderr,
- _("%s: option `%s' requires an argument\n"),
- argv[0], argv[optind - 1]);
- nextchar += strlen (nextchar);
- return optstring[0] == ':' ? ':' : '?';
- }
- }
- nextchar += strlen (nextchar);
- if (longind != NULL)
- *longind = option_index;
- if (pfound->flag)
- {
- *(pfound->flag) = pfound->val;
- return 0;
- }
- return pfound->val;
- }
- nextchar = NULL;
- return 'W'; /* Let the application handle it. */
+ argv[0], pfound->name);
+
+ nextchar += strlen (nextchar);
+ return '?';
+ }
+ }
+ else if (pfound->has_arg == 1)
+ {
+ if (optind < argc)
+ optarg = argv[optind++];
+ else
+ {
+ if (print_errors)
+ fprintf (stderr,
+ _("%s: option `%s' requires an argument\n"),
+ argv[0], argv[optind - 1]);
+ nextchar += strlen (nextchar);
+ return optstring[0] == ':' ? ':' : '?';
+ }
+ }
+ nextchar += strlen (nextchar);
+ if (longind != NULL)
+ *longind = option_index;
+ if (pfound->flag)
+ {
+ *(pfound->flag) = pfound->val;
+ return 0;
+ }
+ return pfound->val;
+ }
+ nextchar = NULL;
+ return 'W'; /* Let the application handle it. */
}
if (temp[1] == ':')
{
- if (temp[2] == ':')
- {
- /* This is an option that accepts an argument optionally. */
- if (*nextchar != '\0')
- {
- optarg = nextchar;
- optind++;
- }
- else
- optarg = NULL;
- nextchar = NULL;
- }
- else
- {
- /* This is an option that requires an argument. */
- if (*nextchar != '\0')
- {
- optarg = nextchar;
- /* If we end this ARGV-element by taking the rest as an arg,
- we must advance to the next element now. */
- optind++;
- }
- else if (optind == argc)
- {
- if (print_errors)
- {
- /* 1003.2 specifies the format of this message. */
- fprintf (stderr,
- _("%s: option requires an argument -- %c\n"),
- argv[0], c);
- }
- optopt = c;
- if (optstring[0] == ':')
- c = ':';
- else
- c = '?';
- }
- else
- /* We already incremented `optind' once;
- increment it again when taking next ARGV-elt as argument. */
- optarg = argv[optind++];
- nextchar = NULL;
- }
+ if (temp[2] == ':')
+ {
+ /* This is an option that accepts an argument optionally. */
+ if (*nextchar != '\0')
+ {
+ optarg = nextchar;
+ optind++;
+ }
+ else
+ optarg = NULL;
+ nextchar = NULL;
+ }
+ else
+ {
+ /* This is an option that requires an argument. */
+ if (*nextchar != '\0')
+ {
+ optarg = nextchar;
+ /* If we end this ARGV-element by taking the rest as an arg,
+ we must advance to the next element now. */
+ optind++;
+ }
+ else if (optind == argc)
+ {
+ if (print_errors)
+ {
+ /* 1003.2 specifies the format of this message. */
+ fprintf (stderr,
+ _("%s: option requires an argument -- %c\n"),
+ argv[0], c);
+ }
+ optopt = c;
+ if (optstring[0] == ':')
+ c = ':';
+ else
+ c = '?';
+ }
+ else
+ /* We already incremented `optind' once;
+ increment it again when taking next ARGV-elt as argument. */
+ optarg = argv[optind++];
+ nextchar = NULL;
+ }
}
return c;
}
const char *optstring;
{
return _getopt_internal (argc, argv, optstring,
- (const struct option *) 0,
- (int *) 0,
- 0);
+ (const struct option *) 0,
+ (int *) 0,
+ 0);
}
#endif
-#endif /* Not ELIDE_CODE. */
+#endif /* Not ELIDE_CODE. */
\f
#ifdef TEST
c = getopt (argc, argv, "abc:d:0123456789");
if (c == -1)
- break;
+ break;
switch (c)
- {
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
- if (digit_optind != 0 && digit_optind != this_option_optind)
- printf ("digits occur in two different argv-elements.\n");
- digit_optind = this_option_optind;
- printf ("option %c\n", c);
- break;
-
- case 'a':
- printf ("option a\n");
- break;
-
- case 'b':
- printf ("option b\n");
- break;
-
- case 'c':
- printf ("option c with value `%s'\n", optarg);
- break;
-
- case '?':
- break;
-
- default:
- printf ("?? getopt returned character code 0%o ??\n", c);
- }
+ {
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
+ if (digit_optind != 0 && digit_optind != this_option_optind)
+ printf ("digits occur in two different argv-elements.\n");
+ digit_optind = this_option_optind;
+ printf ("option %c\n", c);
+ break;
+
+ case 'a':
+ printf ("option a\n");
+ break;
+
+ case 'b':
+ printf ("option b\n");
+ break;
+
+ case 'c':
+ printf ("option c with value `%s'\n", optarg);
+ break;
+
+ case '?':
+ break;
+
+ default:
+ printf ("?? getopt returned character code 0%o ??\n", c);
+ }
}
if (optind < argc)
{
printf ("non-option ARGV-elements: ");
while (optind < argc)
- printf ("%s ", argv[optind++]);
+ printf ("%s ", argv[optind++]);
printf ("\n");
}
#define O_BINARY 0
#endif
#endif
-
+
void
error_msg (const char *msg)
const char* pbackslash = strrchr (filename, '\\');
const char* p = filename;
if (pbackslash && (! pslash || pbackslash >= pslash))
- p = pbackslash+1;
+ p = pbackslash+1;
else if (pslash && (! pbackslash || pslash >= pbackslash))
p = pslash+1;
bool play = false;
const char* progname = argv[0];
-
+
while ((c = getopt (argc, argv, "rqvzmdph")) != -1) {
switch (c) {
case 'r':
std::cout << "Version " << g_szIdStr << std::endl;
- exit(0);
+ exit(0);
break;
case 'q':
g_quiet = true;
}
if (g_verbose || g_debug)
- std::cout << "Version " << g_szIdStr << std::endl;
+ std::cout << "Version " << g_szIdStr << std::endl;
argc -= optind;
argv += optind;
std::cout << "Enter channel number: ";
std::cin.getline (channel_buf, MAX_INPUT_STR);
}
-
+
char *channel_endptr;
int channel = static_cast<int>(strtol (channel_buf, &channel_endptr, 10));
if (*channel_endptr != 0) {
std::cout << "Enter output wav filename: ";
std::cin.getline (wav_fname, MAX_INPUT_STR);
}
-
+
if (! wdq2wav (wdq_fname, channel, wav_fname, play))
return 1;
-
+
return 0;
}
}
if (wdq.any_packed_channels()) {
- std::ostringstream os;
- os << "File contains 'packed' channels." << std::endl;
- os << "Convert to 'Advanced CODAS headers' before processing with wdq2wav.";
- error_msg (os.str().c_str());
- return false;
+ std::ostringstream os;
+ os << "File contains 'packed' channels." << std::endl;
+ os << "Convert to 'Advanced CODAS headers' before processing with wdq2wav.";
+ error_msg (os.str().c_str());
+ return false;
}
if (! g_quiet || g_verbose || g_debug) {
std::ostringstream os1;
- os1 << "File: " << wdq_fname;
+ os1 << "File: " << wdq_fname;
info_msg (os1.str().c_str());
- std::ostringstream os;
- os << "Legacy Format: ";
- if (wdq.m_bLegacy_format)
- os << "Yes";
- else
- os << "No";
- info_msg(os.str().c_str());
+ std::ostringstream os;
+ os << "Legacy Format: ";
+ if (wdq.m_bLegacy_format)
+ os << "Yes";
+ else
+ os << "No";
+ info_msg(os.str().c_str());
std::ostringstream os2;
time_t time = wdq.m_time_acq_start;
struct tm* tm = gmtime (&time);
", Sample Rate: " << wdq.m_sample_rate;
info_msg (os4.str().c_str());
}
-
+
WindaqChannel wdq_channel (wdq, channel);
if (! wdq_channel.m_valid) {
error_msg ("Error reading data from channel");
", maximum: " << wdq_channel.m_max_raw_data;
info_msg (os3.str().c_str());
}
-
+
if (g_debug) {
std::ostringstream os4;
os4 << " Scaled minimum: " << wdq_channel.m_min_scaled_data <<
if (play)
wav.Play();
-
+
return true;
}
tmp2 = tmp1;
if (read (fd, &tmp1, 1) != 1)
return false;
-
+
n = tmp2 + (tmp1 * 256);
return true;
}
tmp4 = tmp2;
if (! read_int2 (fd, tmp2))
return false;
-
+
n = tmp4 + (tmp2 * 65536);
return true;
}
short unsigned int byte1 = (element1 & 0xFF00) >> 8;
short unsigned int byte2 = element1 & 0xFF;
if (byte1 == 0 || byte1 == 1) {
- m_bLegacy_format = false;
- m_sr_denom = m_sr_numer = 0;
+ m_bLegacy_format = false;
+ m_sr_denom = m_sr_numer = 0;
} else {
- m_sr_denom = (element1 & 0x7fff) >> 5;
- m_sr_numer = (element1 & 0x8000) << 1;
+ m_sr_denom = (element1 & 0x7fff) >> 5;
+ m_sr_numer = (element1 & 0x8000) << 1;
m_bLegacy_format = true;
}
unsigned short int element2;
return false;
if (m_bLegacy_format)
- m_sr_numer |= element2;
+ m_sr_numer |= element2;
unsigned char element3;
if (! read_int1 (m_fd, element3))
return false;
m_channel_offset = element3;
if (g_debug)
- std::cout << "Channel offset: " << m_channel_offset << std::endl;
+ std::cout << "Channel offset: " << m_channel_offset << std::endl;
unsigned char element4;
if (! read_int1 (m_fd, element4))
return false;
m_nBytes_channel_header = element4;
if (g_debug)
- std::cout << "Channel header bytes: " << m_nBytes_channel_header << std::endl;
-
+ std::cout << "Channel header bytes: " << m_nBytes_channel_header << std::endl;
+
unsigned short int element5;
if (! read_int2 (m_fd, element5))
return false;
m_nHeader_bytes = element5;
if (g_debug)
- std::cout << "Header bytes: " << m_nHeader_bytes << std::endl;
+ std::cout << "Header bytes: " << m_nHeader_bytes << std::endl;
m_nMaxChannels = (m_nHeader_bytes - 112) / 36;
if (m_nMaxChannels >= 144)
- m_nChannels = byte2 & 0xFF;
+ m_nChannels = byte2 & 0xFF;
else
m_nChannels = byte2 & 0x1F;
return false;
m_nData_bytes = element6;
if (g_debug)
- std::cout << "Data bytes: " << m_nData_bytes << std::endl;
+ std::cout << "Data bytes: " << m_nData_bytes << std::endl;
m_nSamples = (m_nData_bytes / m_nChannels) / 2;
lseek (m_fd, 28, SEEK_SET);
double element13;
if (! read_float8 (m_fd, element13))
- return false;
+ return false;
m_time_between_channel_samples = element13;
if (m_bLegacy_format)
m_sample_rate = (double) m_sr_numer / (double) (m_sr_denom * m_nChannels);
- else
- m_sample_rate = (double) m_nChannels / m_time_between_channel_samples;
+ else
+ m_sample_rate = (double) m_nChannels / m_time_between_channel_samples;
lseek (m_fd, 36, SEEK_SET);
if (! read_int4 (m_fd, m_time_acq_start))
lseek (m_fd, 100, SEEK_SET);
unsigned short int element27;
if (! read_int2 (m_fd, element27))
- return false;
+ return false;
m_bHires = (element27 & 0x0001) ? true : false;
if (g_debug) {
- std::cout << "High resolution: ";
- if (m_bHires)
- std::cout << "Yes";
- else
- std::cout << "No";
+ std::cout << "High resolution: ";
+ if (m_bHires)
+ std::cout << "Yes";
+ else
+ std::cout << "No";
- std::cout << std::endl;
+ std::cout << std::endl;
}
// Verify Windaq signature
if (element35 != 0x8001) {
std::ostringstream os;
- m_error = "Incorrect signagure: file is not a valid WinDAQ file";
+ m_error = "Incorrect signagure: file is not a valid WinDAQ file";
return false;
}
bool
WindaqFile::any_packed_channels ()
{
- for (int iChannel = 0; iChannel < m_nChannels; iChannel++)
- if (is_channel_packed (iChannel))
- return true;
+ for (int iChannel = 0; iChannel < m_nChannels; iChannel++)
+ if (is_channel_packed (iChannel))
+ return true;
- return false;
+ return false;
}
bool
lseek (m_fd, iStart + 31, SEEK_SET);
unsigned char iReadings_per_data_point;
if (! read_int1 (m_fd, iReadings_per_data_point))
- return false;
+ return false;
if (iReadings_per_data_point > 1)
- return true;
-
+ return true;
+
return false;
}
if (wdq.m_valid) {
if (channel >= 1 && channel <= wdq.m_nChannels) {
if (read_channel_data())
- m_valid = true;
+ m_valid = true;
} else {
std::ostringstream os;
os << "Channel " << channel << " is invalid, valid range 1-" <<
- wdq.m_nChannels;
+ wdq.m_nChannels;
error_msg (os.str().c_str());
}
}
m_data = new signed short int [r_wdq.m_nSamples * 2];
- lseek (fd, r_wdq.m_channel_offset + 8 +
- (m_channel - 1) * r_wdq.m_nBytes_channel_header,
- SEEK_SET);
+ lseek (fd, r_wdq.m_channel_offset + 8 +
+ (m_channel - 1) * r_wdq.m_nBytes_channel_header,
+ SEEK_SET);
if (! read_float8 (fd, m_slope))
return false;
return false;
}
m_units = units;
-
+
long int row_bytes = 2 * r_wdq.m_nChannels;
signed short int *sample_row = new signed short int [row_bytes];
-
+
signed short int* psample = &sample_row[m_channel - 1];
lseek (fd, r_wdq.m_nHeader_bytes, SEEK_SET);
#if WORDS_BIG_ENDIAN
unsigned char* p = reinterpret_cast<unsigned char*>(&v);
- unsigned char c = p[0]; p[0] = p[1]; p[1] = c;
+ unsigned char c = p[0]; p[0] = p[1]; p[1] = c;
#endif
signed short int value = v;
- if (! r_wdq.m_bHires)
- value >>= 2;
+ if (! r_wdq.m_bHires)
+ value >>= 2;
m_data[i] = value;
total_data += value;
-
+
if (i == 0) {
data_max = value;
data_min = value;
} else {
if (value > data_max)
- data_max = value;
+ data_max = value;
else if (value < data_min)
- data_min = value;
+ data_min = value;
}
}
int mean = nearest<int>(dmean);
std::cout << "Removing mean: " << (dmean * m_slope) + m_intercept <<
" " << m_units << std::endl;
-
+
for (i = 0; i < r_wdq.m_nSamples; i++)
m_data[i] -= mean;
}
-
+
delete sample_row;
return true;
}
if (g_ignore_zero) {
data_offset = -wdq_channel.m_min_scaled_data;
if (wdq_channel.m_max_scaled_data != wdq_channel.m_min_scaled_data)
- data_scale = 65535. / (wdq_channel.m_max_scaled_data -
- wdq_channel.m_min_scaled_data);
+ data_scale = 65535. / (wdq_channel.m_max_scaled_data -
+ wdq_channel.m_min_scaled_data);
} else {
double max_value = fabs(wdq_channel.m_max_scaled_data);
if (fabs (wdq_channel.m_min_scaled_data) > max_value)
- max_value = fabs (wdq_channel.m_min_scaled_data);
+ max_value = fabs (wdq_channel.m_min_scaled_data);
if (max_value != 0.)
- data_scale = 32767. / max_value;
+ data_scale = 32767. / max_value;
}
-
+
if (g_debug) {
std::ostringstream os;
os << " Wav data_scale: " << data_scale << ", data_offset: " << data_offset;
info_msg (os.str().c_str());
}
-
+
m_nHeaderBytes = 44;
m_nDataBytes = m_nSamples * m_nBytesPerSample * m_nChannels;
m_nFileBytes = m_nHeaderBytes + m_nDataBytes;
signed short int* output = &m_data[nHeaderShortInts];
double slope = wdq_channel.m_slope;
double intercept = wdq_channel.m_intercept;
-
+
if (! fill_header ())
return;
double value = input[i];
value = (slope * value) + intercept;
if (g_ignore_zero) {
- value = (value + data_offset) * data_scale;
- value += 0.5 - 32768;
+ value = (value + data_offset) * data_scale;
+ value += 0.5 - 32768;
} else {
- value = value * data_scale;
+ value = value * data_scale;
}
-
+
signed short int v = static_cast<signed short int>(value);
#if WORDS_BIG_ENDIAN
unsigned char* p = reinterpret_cast<unsigned char*>(&v);
- unsigned char c = p[0]; p[0] = p[1]; p[1] = c;
+ unsigned char c = p[0]; p[0] = p[1]; p[1] = c;
#endif
output[i] = v;
}
{
if (m_fd != 0)
close (m_fd);
-
+
if (m_data != NULL)
delete m_data;
}
// Sample Rate
put_int4 (pData + 24, static_cast<int> (m_rate + 0.5));
- // Bytes per second
+ // Bytes per second
put_int4 (pData + 28, static_cast<int> (m_rate * m_nBytesPerSample + 0.5));
// Bytes per sample
put_int2 (pData + 32, m_nBytesPerSample * m_nChannels);
- // Bits per sample
+ // Bits per sample
put_int2 (pData + 34, m_nBitsPerSample);
strncpy (pData + 36, "data", 4);
if (close (m_fd) < 0)
error_msg ("Error closing output file");
-
+
m_fd = 0;
return true;
}
error_msg ("Error opening /dev/dsp");
return false;
}
-
+
int format = AFMT_S16_LE;
if (ioctl (fd, SNDCTL_DSP_SETFMT, &format) == -1) {
error_msg ("Error setting DSP format");
error_msg ("DSP Format not set");
close(fd); return false;
}
-
+
unsigned int channels = m_nChannels;
if (ioctl (fd, SNDCTL_DSP_CHANNELS, &format) == -1) {
error_msg ("Error setting number of channels");
os << "Warning: Sample rate set to " << speed << ", not " << m_rate;
error_msg (os.str().c_str());
}
-
+
if (write (fd, reinterpret_cast<char*>(m_data) + m_nHeaderBytes, m_nDataBytes) !=
m_nDataBytes) {
error_msg ("Error writing audio samples");
return true;
#else
#endif
-
+
return false;
}
-
+