diff options
Diffstat (limited to 'src')
49 files changed, 1412 insertions, 971 deletions
diff --git a/src/libopts/COPYING.gplv3 b/src/libopts/COPYING.gplv3 index 6c1b848d6b..f22cdbb209 100644 --- a/src/libopts/COPYING.gplv3 +++ b/src/libopts/COPYING.gplv3 @@ -1,7 +1,7 @@ GNU GENERAL PUBLIC LICENSE Version 3, 29 June 2007 - Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + Copyright (c) 1992-2012 by Bruce Korb - all rights reserved Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. diff --git a/src/libopts/COPYING.lgplv3 b/src/libopts/COPYING.lgplv3 index c7759a01b2..a1bc40ddf8 100644 --- a/src/libopts/COPYING.lgplv3 +++ b/src/libopts/COPYING.lgplv3 @@ -1,7 +1,7 @@ GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007 - Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + Copyright (c) 1992-2012 by Bruce Korb - all rights reserved Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. diff --git a/src/libopts/Makefile.am b/src/libopts/Makefile.am index 84595b0d67..80b01e346b 100644 --- a/src/libopts/Makefile.am +++ b/src/libopts/Makefile.am @@ -7,21 +7,22 @@ noinst_LTLIBRARIES = libopts.la endif libopts_la_SOURCES = libopts.c libopts_la_CPPFLAGS = -I$(top_srcdir) -libopts_la_LDFLAGS = -version-info 36:1:11 +libopts_la_LDFLAGS = -version-info 36:2:11 EXTRA_DIST = \ - COPYING.gplv3 COPYING.lgplv3 COPYING.mbsd \ - MakeDefs.inc README ag-char-map.h \ - autoopts/project.h autoopts/options.h autoopts/usage-txt.h \ - autoopts.c autoopts.h boolean.c \ - check.c compat/pathfind.c compat/strchr.c \ - compat/windows-config.h compat/snprintf.c compat/compat.h \ - compat/strdup.c configfile.c cook.c \ - enum.c env.c file.c \ - find.c genshell.c genshell.h \ - load.c m4/liboptschk.m4 m4/libopts.m4 \ - makeshell.c nested.c numeric.c \ - parse-duration.c parse-duration.h pgusage.c \ - proto.h putshell.c reset.c \ + ag-char-map.h alias.c ao-strs.c \ + ao-strs.h autoopts/options.h autoopts/project.h \ + autoopts/usage-txt.h autoopts.c autoopts.h \ + boolean.c check.c compat/strchr.c \ + compat/pathfind.c compat/strdup.c compat/windows-config.h \ + compat/snprintf.c compat/compat.h configfile.c \ + cook.c COPYING.gplv3 COPYING.lgplv3 \ + COPYING.mbsd enum.c env.c \ + file.c find.c genshell.c \ + genshell.h load.c m4/liboptschk.m4 \ + m4/libopts.m4 MakeDefs.inc makeshell.c \ + nested.c numeric.c parse-duration.c \ + parse-duration.h pgusage.c proto.h \ + putshell.c README reset.c \ restore.c save.c sort.c \ stack.c streqvcmp.c text_mmap.c \ time.c tokenize.c usage.c \ diff --git a/src/libopts/README b/src/libopts/README index afa5409874..0d9ac649f6 100644 --- a/src/libopts/README +++ b/src/libopts/README @@ -115,7 +115,7 @@ These macros work as follows: LICENSING: -This material is Copyright (c) 1992-2011 by Bruce Korb. You are +This material is Copyright (c) 1992-2012 by Bruce Korb. You are licensed to use this under the terms of either the GNU Lesser General Public License (see: COPYING.lgpl), or, at your option, the modified Berkeley Software Distribution License (see: COPYING.mbsd). Both of diff --git a/src/libopts/ag-char-map.h b/src/libopts/ag-char-map.h index 0fb9794d41..2a9105ff27 100644 --- a/src/libopts/ag-char-map.h +++ b/src/libopts/ag-char-map.h @@ -1,17 +1,22 @@ /* - * Character mapping generated 12/29/11 12:02:33 + * Character mapping generated 02/10/12 19:53:35 * * This file contains the character classifications * used by AutoGen and AutoOpts for identifying tokens. + * The table is static scope, so %guard is empty. + * * This file is part of AutoGen. - * Copyright (c) 1992-2011 Bruce Korb - all rights reserved + * Copyright (c) 1992-2012 Bruce Korb - all rights reserved + * * AutoGen is free software: you can redistribute it and/or modify it under the * terms of the GNU General Public License as published by the Free Software * Foundation, either version 3 of the License, or (at your option) any later * version. + * * AutoGen is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR * A PARTICULAR PURPOSE. See the GNU General Public License for more details. + * * You should have received a copy of the GNU General Public License along * with this program. If not, see <http://www.gnu.org/licenses/>. */ @@ -20,76 +25,49 @@ #ifdef HAVE_CONFIG_H # if defined(HAVE_INTTYPES_H) -# include <inttypes.h> +# include <inttypes.h> # elif defined(HAVE_STDINT_H) -# include <stdint.h> +# include <stdint.h> # else -# ifndef HAVE_INT8_T - typedef signed char int8_t; -# endif # ifndef HAVE_UINT8_T typedef unsigned char uint8_t; # endif -# ifndef HAVE_INT16_T - typedef signed short int16_t; -# endif # ifndef HAVE_UINT16_T typedef unsigned short uint16_t; # endif -# ifndef HAVE_UINT_T - typedef unsigned int uint_t; -# endif - -# ifndef HAVE_INT32_T -# if SIZEOF_INT == 4 - typedef signed int int32_t; -# elif SIZEOF_LONG == 4 - typedef signed long int32_t; -# endif -# endif # ifndef HAVE_UINT32_T -# if SIZEOF_INT == 4 +# if SIZEOF_INT == 4 typedef unsigned int uint32_t; -# elif SIZEOF_LONG == 4 +# elif SIZEOF_LONG == 4 typedef unsigned long uint32_t; -# endif +# endif +# endif + +# ifndef HAVE_UINT64_T +# if SIZEOF_LONG == 8 + typedef unsigned long uint64_t; +# elif SIZEOF_LONG_LONG == 8 + typedef unsigned long long uint64_t; +# endif # endif # endif /* HAVE_*INT*_H header */ #else /* not HAVE_CONFIG_H -- */ # ifdef __sun -# include <inttypes.h> +# include <inttypes.h> # else -# include <stdint.h> +# include <stdint.h> # endif #endif /* HAVE_CONFIG_H */ #if 0 /* mapping specification source (from autogen.map) */ // -// %guard autoopts_internal +// %guard // %file ag-char-map.h -// %static-table option-char-category // -// %comment -// This file contains the character classifications -// used by AutoGen and AutoOpts for identifying tokens. -// -// This file is part of AutoGen. -// Copyright (c) 1992-2011 Bruce Korb - all rights reserved -// -// AutoGen is free software: you can redistribute it and/or modify it under the -// terms of the GNU General Public License as published by the Free Software -// Foundation, either version 3 of the License, or (at your option) any later -// version. -// -// AutoGen is distributed in the hope that it will be useful, but WITHOUT ANY -// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR -// A PARTICULAR PURPOSE. See the GNU General Public License for more details. -// -// You should have received a copy of the GNU General Public License along -// with this program. If not, see <http://www.gnu.org/licenses/>. +// %comment -- see above // % // // lower-case "a-z" @@ -104,7 +82,8 @@ // option-name "^-" +variable-name // value-name ":" +option-name // horiz-white "\t " -// compound-name "[.]" +value-name +horiz-white +// name-sep "[.]" +// compound-name +value-name +name-sep +horiz-white // whitespace "\v\f\r\n\b" +horiz-white // unquotable "!-~" -"\"#(),;<=>[\\]`{}?*'" // end-xml-token "/>" +whitespace @@ -117,55 +96,106 @@ // file-name "/" +suffix // end-token "\x00" +whitespace // end-list-entry "," +end-token +// set-separator "|+" +end-list-entry // #endif /* 0 -- mapping spec. source */ -typedef uint32_t option_char_category_mask_t; -static option_char_category_mask_t const option_char_category[128]; - -static inline int is_option_char_category_char(char ch, option_char_category_mask_t mask) { - unsigned int ix = (unsigned char)ch; - return ((ix < 128) && ((option_char_category[ix] & mask) != 0)); } +typedef uint32_t ag_char_map_mask_t; -#define IS_LOWER_CASE_CHAR(_c) is_option_char_category_char((_c), 0x000001) -#define IS_UPPER_CASE_CHAR(_c) is_option_char_category_char((_c), 0x000002) -#define IS_ALPHABETIC_CHAR(_c) is_option_char_category_char((_c), 0x000003) -#define IS_OCT_DIGIT_CHAR(_c) is_option_char_category_char((_c), 0x000004) -#define IS_DEC_DIGIT_CHAR(_c) is_option_char_category_char((_c), 0x00000C) -#define IS_HEX_DIGIT_CHAR(_c) is_option_char_category_char((_c), 0x00001C) -#define IS_ALPHANUMERIC_CHAR(_c) is_option_char_category_char((_c), 0x00000F) -#define IS_VAR_FIRST_CHAR(_c) is_option_char_category_char((_c), 0x000023) -#define IS_VARIABLE_NAME_CHAR(_c) is_option_char_category_char((_c), 0x00002F) -#define IS_OPTION_NAME_CHAR(_c) is_option_char_category_char((_c), 0x00006F) -#define IS_VALUE_NAME_CHAR(_c) is_option_char_category_char((_c), 0x0000EF) -#define IS_HORIZ_WHITE_CHAR(_c) is_option_char_category_char((_c), 0x000100) -#define IS_COMPOUND_NAME_CHAR(_c) is_option_char_category_char((_c), 0x0003EF) -#define IS_WHITESPACE_CHAR(_c) is_option_char_category_char((_c), 0x000500) -#define IS_UNQUOTABLE_CHAR(_c) is_option_char_category_char((_c), 0x000800) -#define IS_END_XML_TOKEN_CHAR(_c) is_option_char_category_char((_c), 0x001500) -#define IS_GRAPHIC_CHAR(_c) is_option_char_category_char((_c), 0x002000) -#define IS_PLUS_N_SPACE_CHAR(_c) is_option_char_category_char((_c), 0x004500) -#define IS_PUNCTUATION_CHAR(_c) is_option_char_category_char((_c), 0x008000) -#define IS_SUFFIX_CHAR(_c) is_option_char_category_char((_c), 0x01000F) -#define IS_SUFFIX_FMT_CHAR(_c) is_option_char_category_char((_c), 0x03000F) -#define IS_FALSE_TYPE_CHAR(_c) is_option_char_category_char((_c), 0x040000) -#define IS_FILE_NAME_CHAR(_c) is_option_char_category_char((_c), 0x09000F) -#define IS_END_TOKEN_CHAR(_c) is_option_char_category_char((_c), 0x100500) -#define IS_END_LIST_ENTRY_CHAR(_c) is_option_char_category_char((_c), 0x300500) +#define IS_LOWER_CASE_CHAR( _c) is_ag_char_map_char((char)( _c), 0x000001) +#define SPN_LOWER_CASE_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x000001) +#define BRK_LOWER_CASE_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x000001) +#define IS_UPPER_CASE_CHAR( _c) is_ag_char_map_char((char)( _c), 0x000002) +#define SPN_UPPER_CASE_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x000002) +#define BRK_UPPER_CASE_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x000002) +#define IS_ALPHABETIC_CHAR( _c) is_ag_char_map_char((char)( _c), 0x000003) +#define SPN_ALPHABETIC_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x000003) +#define BRK_ALPHABETIC_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x000003) +#define IS_OCT_DIGIT_CHAR( _c) is_ag_char_map_char((char)( _c), 0x000004) +#define SPN_OCT_DIGIT_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x000004) +#define BRK_OCT_DIGIT_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x000004) +#define IS_DEC_DIGIT_CHAR( _c) is_ag_char_map_char((char)( _c), 0x00000C) +#define SPN_DEC_DIGIT_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x00000C) +#define BRK_DEC_DIGIT_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x00000C) +#define IS_HEX_DIGIT_CHAR( _c) is_ag_char_map_char((char)( _c), 0x00001C) +#define SPN_HEX_DIGIT_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x00001C) +#define BRK_HEX_DIGIT_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x00001C) +#define IS_ALPHANUMERIC_CHAR( _c) is_ag_char_map_char((char)( _c), 0x00000F) +#define SPN_ALPHANUMERIC_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x00000F) +#define BRK_ALPHANUMERIC_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x00000F) +#define IS_VAR_FIRST_CHAR( _c) is_ag_char_map_char((char)( _c), 0x000023) +#define SPN_VAR_FIRST_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x000023) +#define BRK_VAR_FIRST_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x000023) +#define IS_VARIABLE_NAME_CHAR( _c) is_ag_char_map_char((char)( _c), 0x00002F) +#define SPN_VARIABLE_NAME_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x00002F) +#define BRK_VARIABLE_NAME_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x00002F) +#define IS_OPTION_NAME_CHAR( _c) is_ag_char_map_char((char)( _c), 0x00006F) +#define SPN_OPTION_NAME_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x00006F) +#define BRK_OPTION_NAME_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x00006F) +#define IS_VALUE_NAME_CHAR( _c) is_ag_char_map_char((char)( _c), 0x0000EF) +#define SPN_VALUE_NAME_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x0000EF) +#define BRK_VALUE_NAME_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x0000EF) +#define IS_HORIZ_WHITE_CHAR( _c) is_ag_char_map_char((char)( _c), 0x000100) +#define SPN_HORIZ_WHITE_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x000100) +#define BRK_HORIZ_WHITE_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x000100) +#define IS_NAME_SEP_CHAR( _c) is_ag_char_map_char((char)( _c), 0x000200) +#define SPN_NAME_SEP_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x000200) +#define BRK_NAME_SEP_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x000200) +#define IS_COMPOUND_NAME_CHAR( _c) is_ag_char_map_char((char)( _c), 0x0003EF) +#define SPN_COMPOUND_NAME_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x0003EF) +#define BRK_COMPOUND_NAME_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x0003EF) +#define IS_WHITESPACE_CHAR( _c) is_ag_char_map_char((char)( _c), 0x000500) +#define SPN_WHITESPACE_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x000500) +#define BRK_WHITESPACE_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x000500) +#define IS_UNQUOTABLE_CHAR( _c) is_ag_char_map_char((char)( _c), 0x000800) +#define SPN_UNQUOTABLE_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x000800) +#define BRK_UNQUOTABLE_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x000800) +#define IS_END_XML_TOKEN_CHAR( _c) is_ag_char_map_char((char)( _c), 0x001500) +#define SPN_END_XML_TOKEN_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x001500) +#define BRK_END_XML_TOKEN_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x001500) +#define IS_GRAPHIC_CHAR( _c) is_ag_char_map_char((char)( _c), 0x002000) +#define SPN_GRAPHIC_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x002000) +#define BRK_GRAPHIC_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x002000) +#define IS_PLUS_N_SPACE_CHAR( _c) is_ag_char_map_char((char)( _c), 0x004500) +#define SPN_PLUS_N_SPACE_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x004500) +#define BRK_PLUS_N_SPACE_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x004500) +#define IS_PUNCTUATION_CHAR( _c) is_ag_char_map_char((char)( _c), 0x008000) +#define SPN_PUNCTUATION_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x008000) +#define BRK_PUNCTUATION_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x008000) +#define IS_SUFFIX_CHAR( _c) is_ag_char_map_char((char)( _c), 0x01000F) +#define SPN_SUFFIX_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x01000F) +#define BRK_SUFFIX_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x01000F) +#define IS_SUFFIX_FMT_CHAR( _c) is_ag_char_map_char((char)( _c), 0x03000F) +#define SPN_SUFFIX_FMT_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x03000F) +#define BRK_SUFFIX_FMT_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x03000F) +#define IS_FALSE_TYPE_CHAR( _c) is_ag_char_map_char((char)( _c), 0x040000) +#define SPN_FALSE_TYPE_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x040000) +#define BRK_FALSE_TYPE_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x040000) +#define IS_FILE_NAME_CHAR( _c) is_ag_char_map_char((char)( _c), 0x09000F) +#define SPN_FILE_NAME_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x09000F) +#define BRK_FILE_NAME_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x09000F) +#define IS_END_TOKEN_CHAR( _c) is_ag_char_map_char((char)( _c), 0x100500) +#define SPN_END_TOKEN_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x100500) +#define BRK_END_TOKEN_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x100500) +#define IS_END_LIST_ENTRY_CHAR( _c) is_ag_char_map_char((char)( _c), 0x300500) +#define SPN_END_LIST_ENTRY_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x300500) +#define BRK_END_LIST_ENTRY_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x300500) +#define IS_SET_SEPARATOR_CHAR( _c) is_ag_char_map_char((char)( _c), 0x700500) +#define SPN_SET_SEPARATOR_CHARS(_s) spn_ag_char_map_chars((char *)_s, 0x700500) +#define BRK_SET_SEPARATOR_CHARS(_s) brk_ag_char_map_chars((char *)_s, 0x700500) -#if 1 /* def AUTOOPTS_INTERNAL */ -static option_char_category_mask_t const option_char_category[128] = { - /*x00*/ 0x140000, /*x01*/ 0x000000, /*x02*/ 0x000000, /*x03*/ 0x000000, - /*x04*/ 0x000000, /*x05*/ 0x000000, /*x06*/ 0x000000, /*\a */ 0x000000, - /*\b */ 0x000400, /*\t */ 0x000100, /*\n */ 0x000400, /*\v */ 0x000400, - /*\f */ 0x000400, /*\r */ 0x000400, /*x0E*/ 0x000000, /*x0F*/ 0x000000, +static ag_char_map_mask_t const ag_char_map_table[128] = { + /*NUL*/ 0x140000, /*x01*/ 0x000000, /*x02*/ 0x000000, /*x03*/ 0x000000, + /*x04*/ 0x000000, /*x05*/ 0x000000, /*x06*/ 0x000000, /*BEL*/ 0x000000, + /* BS*/ 0x000400, /* HT*/ 0x000100, /* NL*/ 0x000400, /* VT*/ 0x000400, + /* FF*/ 0x000400, /* CR*/ 0x000400, /*x0E*/ 0x000000, /*x0F*/ 0x000000, /*x10*/ 0x000000, /*x11*/ 0x000000, /*x12*/ 0x000000, /*x13*/ 0x000000, /*x14*/ 0x000000, /*x15*/ 0x000000, /*x16*/ 0x000000, /*x17*/ 0x000000, - /*x18*/ 0x000000, /*x19*/ 0x000000, /*x1A*/ 0x000000, /*x1B*/ 0x000000, + /*x18*/ 0x000000, /*x19*/ 0x000000, /*x1A*/ 0x000000, /*ESC*/ 0x000000, /*x1C*/ 0x000000, /*x1D*/ 0x000000, /*x1E*/ 0x000000, /*x1F*/ 0x000000, /* */ 0x000100, /* ! */ 0x00A800, /* " */ 0x00A000, /* # */ 0x00A000, /* $ */ 0x00A800, /* % */ 0x02A800, /* & */ 0x00A800, /* ' */ 0x00A000, - /* ( */ 0x00A000, /* ) */ 0x00A000, /* * */ 0x00A000, /* + */ 0x00E800, + /* ( */ 0x00A000, /* ) */ 0x00A000, /* * */ 0x00A000, /* + */ 0x40E800, /* , */ 0x20A000, /* - */ 0x01A840, /* . */ 0x01AA00, /* / */ 0x0AB800, /* 0 */ 0x042804, /* 1 */ 0x002804, /* 2 */ 0x002804, /* 3 */ 0x002804, /* 4 */ 0x002804, /* 5 */ 0x002804, /* 6 */ 0x002804, /* 7 */ 0x002804, @@ -186,7 +216,28 @@ static option_char_category_mask_t const option_char_category[128] = { /* p */ 0x002801, /* q */ 0x002801, /* r */ 0x002801, /* s */ 0x002801, /* t */ 0x002801, /* u */ 0x002801, /* v */ 0x002801, /* w */ 0x002801, /* x */ 0x002801, /* y */ 0x002801, /* z */ 0x002801, /* { */ 0x00A000, - /* | */ 0x00A800, /* } */ 0x00A000, /* ~ */ 0x00A800, /*x7F*/ 0x000000 + /* | */ 0x40A800, /* } */ 0x00A000, /* ~ */ 0x00A800, /*x7F*/ 0x000000 }; -#endif /* AUTOOPTS_INTERNAL */ + +static inline int +is_ag_char_map_char(char ch, ag_char_map_mask_t mask) +{ + unsigned int ix = (unsigned char)ch; + return ((ix < 128) && ((ag_char_map_table[ix] & mask) != 0)); +} + +static inline char * +spn_ag_char_map_chars(char * p, ag_char_map_mask_t mask) +{ + while ((*p != '\0') && is_ag_char_map_char(*p, mask)) p++; + return p; +} + +static inline char * +brk_ag_char_map_chars(char * p, ag_char_map_mask_t mask) +{ + while ((*p != '\0') && (! is_ag_char_map_char(*p, mask))) p++; + return p; +} + #endif /* AG_CHAR_MAP_H_GUARD */ diff --git a/src/libopts/alias.c b/src/libopts/alias.c new file mode 100644 index 0000000000..ad9606b409 --- /dev/null +++ b/src/libopts/alias.c @@ -0,0 +1,108 @@ + +/** + * \file alias.c + * + * Time-stamp: "2012-02-10 19:41:42 bkorb" + * + * Automated Options Paged Usage module. + * + * This routine will forward an option alias to the correct option code. + * + * This file is part of AutoOpts, a companion to AutoGen. + * AutoOpts is free software. + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved + * + * AutoOpts is available under any one of two licenses. The license + * in use must be one of these two and the choice is under the control + * of the user of the license. + * + * The GNU Lesser General Public License, version 3 or later + * See the files "COPYING.lgplv3" and "COPYING.gplv3" + * + * The Modified Berkeley Software Distribution License + * See the file "COPYING.mbsd" + * + * These files have the following md5sums: + * + * 43b91e8ca915626ed3818ffb1b71248b pkg/libopts/COPYING.gplv3 + * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3 + * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd + */ + +/*=export_func optionAlias + * private: + * + * what: relay an option to its alias + * arg: + tOptions* + pOpts + program options descriptor + + * arg: + tOptDesc* + pOptDesc + the descriptor for this arg + + * arg: + unsigned int + alias + the aliased-to option index + + * ret-type: int + * + * doc: + * Handle one option as if it had been specified as another. Exactly. + * Returns "-1" if the aliased-to option has appeared too many times. +=*/ +int +optionAlias(tOptions * pOpts, tOptDesc * pOldOD, unsigned int alias) +{ + tOptDesc * pOD; + + if (pOpts == OPTPROC_EMIT_USAGE) + return 0; + + pOD = pOpts->pOptDesc + alias; + if ((unsigned)pOpts->optCt <= alias) { + fwrite(zAliasRange, strlen (zAliasRange), 1, stderr); + exit(EXIT_FAILURE); + } + + /* + * Copy over the option instance flags + */ + pOD->fOptState &= OPTST_PERSISTENT_MASK; + pOD->fOptState |= (pOldOD->fOptState & ~OPTST_PERSISTENT_MASK); + pOD->optArg.argString = pOldOD->optArg.argString; + + /* + * Keep track of count only for DEFINED (command line) options. + * IF we have too many, build up an error message and bail. + */ + if ( (pOD->fOptState & OPTST_DEFINED) + && (++pOD->optOccCt > pOD->optMaxCt) ) { + + if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0) { + char const * pzEqv = + (pOD->optEquivIndex != NO_EQUIVALENT) ? zEquiv : zNil; + + fputs(zErrOnly, stderr); + + if (pOD->optMaxCt > 1) + fprintf(stderr, zAtMost, pOD->optMaxCt, pOD->pz_Name, pzEqv); + else + fprintf(stderr, zOnlyOne, pOD->pz_Name, pzEqv); + } + + return -1; + } + + /* + * Clear the state bits and counters + */ + pOldOD->fOptState &= OPTST_PERSISTENT_MASK; + pOldOD->optOccCt = 0; + + /* + * If there is a procedure to call, call it + */ + if (pOD->pOptProc != NULL) + (*pOD->pOptProc)(pOpts, pOD); + return 0; +} + +/* + * Local Variables: + * mode: C + * c-file-style: "stroustrup" + * indent-tabs-mode: nil + * End: + * end of autoopts/alias.c */ diff --git a/src/libopts/ao-strs.c b/src/libopts/ao-strs.c new file mode 100644 index 0000000000..f6e835e20d --- /dev/null +++ b/src/libopts/ao-strs.c @@ -0,0 +1,323 @@ +/* -*- buffer-read-only: t -*- vi: set ro: + * + * DO NOT EDIT THIS FILE (ao-strs.c) + * + * It has been AutoGen-ed February 10, 2012 at 07:53:35 PM by AutoGen 5.15pre7 + * From the definitions ao-strs.def + * and the template file strings + * + * Copyright (C) 2011-2012 Bruce Korb, all rights reserved. + * This is free software. It is licensed for use, modification and + * redistribution under the terms of the + * Modified (3 clause) Berkeley Software Distribution License + * <http://www.xfree86.org/3.3.6/COPYRIGHT2.html> + * + * 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. Neither the name ``Bruce Korb'' nor the name of any other + * contributor may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * strings IS PROVIDED BY Bruce Korb ``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 Bruce Korb OR ANY OTHER CONTRIBUTORS + * 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 "ao-strs.h" + +char const ao_strs_strtable[6266] = +/* 0 */ " \t\n" + ":=\0" +/* 6 */ "INVALID-%d\0" +/* 17 */ "*INVALID*\0" +/* 27 */ "none\0" +/* 32 */ " + \0" +/* 36 */ " | \0" +/* 40 */ "%s\n\0" +/* 44 */ "PAGER\0" +/* 50 */ "/tmp/use.%lu\0" +/* 63 */ "more\0" +/* 68 */ " --* )\n\0" +/* 79 */ "%s\n" + " \0" +/* 85 */ " \0" +/* 88 */ " -* )\n\0" +/* 98 */ " ;;\n\n\0" +/* 111 */ "stdout\0" +/* 118 */ "%A %B %e, %Y at %r %Z\0" +/* 140 */ "#! %s\n\0" +/* 147 */ "%s_%s=\0" +/* 154 */ "\n" + "export %s_%s\n\0" +/* 169 */ "''\0" +/* 172 */ "\\'\0" +/* 175 */ "'%s'\0" +/* 180 */ "%s_%s_%d=\0" +/* 190 */ "\n" + "export %s_%s_%d\n\0" +/* 208 */ "set --\0" +/* 215 */ " '%s'\0" +/* 221 */ "'\\''\0" +/* 226 */ "\n" + "OPTION_CT=0\n\0" +/* 240 */ "=%1$lu # 0x%1$lX\n\0" +/* 258 */ "true\0" +/* 263 */ "false\0" +/* 269 */ "VERSION\0" +/* 277 */ "OPT_ARG_NEEDED=OK\0" +/* 295 */ "OPT_ARG_NEEDED=NO\0" +/* 313 */ "OPT_ARG_NEEDED=YES\0" +/* 332 */ "LONGUSAGE\0" +/* 342 */ "flag\0" +/* 347 */ "%s_%s_TEXT='\0" +/* 360 */ "'\n\n\0" +/* 364 */ "option\0" +/* 371 */ "\n" + "env | grep '^%s_'\n\0" +/* 391 */ " -- %s\0" +/* 398 */ "--\0" +/* 401 */ "\t\t\t\t- \0" +/* 408 */ "\t\t\t\t \0" +/* 415 */ "\t\0" +/* 417 */ " * )\n" + " OPT_PROCESS=false\n" + " ;;\n" + " esac\n\0" +/* 474 */ " %s\n\0" +/* 480 */ "%%-%ds\0" +/* 487 */ "%1$s /tmp/use.%2$lu ; rm -f /tmp/use.%2$lu\0" +/* 530 */ "# # # # # # # # # # -- do not modify this marker --\n" + "#\n" + "# DO NOT EDIT THIS SECTION\n\0" +/* 613 */ "%s OF %s\n" + "#\n" + "# From here to the next `-- do not modify this marker --',\n" + "# the text has been generated %s\n\0" +/* 719 */ "# From the %s option definitions\n" + "#\n\0" +/* 756 */ "\n" + "if test -z \"${%1$s_%2$s}\"\n" + "then\n" + " %1$s_%2$s_CT=0\n" + "else\n" + " %1$s_%2$s_CT=1\n" + " %1$s_%2$s_1=${%1$s_%2$s}\n" + "fi\n" + "export %1$s_%2$s_CT\0" +/* 877 */ "\n" + "%1$s_%2$s=${%1$s_%2$s-'%3$s'}\n" + "%1$s_%2$s_set=false\n" + "export %1$s_%2$s\0" +/* 945 */ "\n" + "%1$s_%2$s=${%1$s_%2$s}\n" + "%1$s_%2$s_set=false\n" + "export %1$s_%2$s\n\0" +/* 1007 */ "\n" + "OPT_PROCESS=true\n" + "OPT_ARG=$1\n" + "while ${OPT_PROCESS} && [ $# -gt 0 ]\n" + "do\n" + " OPT_ELEMENT=''\n" + " OPT_ARG_VAL=''\n\n" + " case \"${OPT_ARG}\" in\n" + " -- )\n" + " OPT_PROCESS=false\n" + " shift\n" + " ;;\n\0" +/* 1201 */ "\n" + "OPT_ARG=$1\n" + "while [ $# -gt 0 ]\n" + "do\n" + " OPT_ELEMENT=''\n" + " OPT_ARG_VAL=''\n" + " OPT_ARG=${1}\n\0" +/* 1291 */ " if [ -n \"${OPT_ARG_VAL}\" ]\n" + " then\n" + " eval %1$s_${OPT_NAME}${OPT_ELEMENT}=\"'${OPT_ARG_VAL}'\"\n" + " export %1$s_${OPT_NAME}${OPT_ELEMENT}\n" + " fi\n" + "done\n" + "unset OPT_PROCESS || :\n" + "unset OPT_ELEMENT || :\n" + "unset OPT_ARG || :\n" + "unset OPT_ARG_NEEDED || :\n" + "unset OPT_NAME || :\n" + "unset OPT_CODE || :\n" + "unset OPT_ARG_VAL || :\n" + "%2$s\0" +/* 1621 */ "\n" + "# # # # # # # # # #\n" + "#\n" + "# END OF AUTOMATED OPTION PROCESSING\n" + "#\n" + "# # # # # # # # # # -- do not modify this marker --\n\0" +/* 1737 */ " case \"${OPT_CODE}\" in\n\0" +/* 1768 */ " '%s' | \\\n\0" +/* 1786 */ " '%s' )\n\0" +/* 1802 */ " '%c' )\n\0" +/* 1818 */ " ;;\n\n\0" +/* 1835 */ " * )\n" + " echo Unknown %s: \"${OPT_CODE}\" >&2\n" + " echo \"$%s_USAGE_TEXT\"\n" + " exit 1\n" + " ;;\n" + " esac\n\n\0" +/* 1977 */ " echo \"$%s_%s_TEXT\"\n" + " exit 0\n\0" +/* 2028 */ " echo \"$%s_LONGUSAGE_TEXT\" | ${PAGER-more}\n" + " exit 0\n\0" +/* 2102 */ " %s\n\0" +/* 2118 */ " if [ $%1$s_%2$s_CT -ge %3$d ] ; then\n" + " echo Error: more than %3$d %2$s options >&2\n" + " echo \"$%1$s_USAGE_TEXT\"\n" + " exit 1 ; fi\n\0" +/* 2297 */ " %1$s_%2$s_CT=`expr ${%1$s_%2$s_CT} + 1`\n" + " OPT_ELEMENT=\"_${%1$s_%2$s_CT}\"\n" + " OPT_NAME='%2$s'\n\0" +/* 2421 */ " if [ -n \"${%1$s_%2$s}\" ] && ${%1$s_%2$s_set} ; then\n" + " echo Error: duplicate %2$s option >&2\n" + " echo \"$%1$s_USAGE_TEXT\"\n" + " exit 1 ; fi\n" + " %1$s_%2$s_set=true\n" + " OPT_NAME='%2$s'\n\0" +/* 2668 */ " %1$s_%2$s_CT=0\n" + " OPT_ELEMENT=''\n" + " %1$s_%2$s='%3$s'\n" + " export %1$s_%2$s\n" + " OPT_NAME='%2$s'\n\0" +/* 2809 */ " if [ -n \"${%1$s_%2$s}\" ] && ${%1$s_%2$s_set} ; then\n" + " echo 'Error: duplicate %2$s option' >&2\n" + " echo \"$%1$s_USAGE_TEXT\"\n" + " exit 1 ; fi\n" + " %1$s_%2$s_set=true\n" + " %1$s_%2$s='%3$s'\n" + " export %1$s_%2$s\n" + " OPT_NAME='%2$s'\n\0" +/* 3116 */ " eval %1$s_%2$s${OPT_ELEMENT}=true\n" + " export %1$s_%2$s${OPT_ELEMENT}\n" + " OPT_ARG_NEEDED=OK\n\0" +/* 3236 */ " OPT_ARG_NEEDED=YES\n\0" +/* 3268 */ " eval %1$s_%2$s${OPT_ELEMENT}=true\n" + " export %1$s_%2$s${OPT_ELEMENT}\n" + " OPT_ARG_NEEDED=NO\n\0" +/* 3388 */ " OPT_CODE=`echo \"X${OPT_ARG}\"|sed 's/^X-*//'`\n" + " shift\n" + " OPT_ARG=$1\n" + " case \"${OPT_CODE}\" in *=* )\n" + " OPT_ARG_VAL=`echo \"${OPT_CODE}\"|sed 's/^[^=]*=//'`\n" + " OPT_CODE=`echo \"${OPT_CODE}\"|sed 's/=.*$//'` ;; esac\n\0" +/* 3639 */ " case \"${OPT_ARG_NEEDED}\" in\n" + " NO )\n" + " OPT_ARG_VAL=''\n" + " ;;\n" + " YES )\n" + " if [ -z \"${OPT_ARG_VAL}\" ]\n" + " then\n" + " if [ $# -eq 0 ]\n" + " then\n" + " echo No argument provided for ${OPT_NAME} option >&2\n" + " echo \"$%s_USAGE_TEXT\"\n" + " exit 1\n" + " fi\n" + " OPT_ARG_VAL=${OPT_ARG}\n" + " shift\n" + " OPT_ARG=$1\n" + " fi\n" + " ;;\n" + " OK )\n" + " if [ -z \"${OPT_ARG_VAL}\" ] && [ $# -gt 0 ]\n" + " then\n" + " case \"${OPT_ARG}\" in -* ) ;; * )\n" + " OPT_ARG_VAL=${OPT_ARG}\n" + " shift\n" + " OPT_ARG=$1 ;; esac\n" + " fi\n" + " ;;\n" + " esac\n\0" +/* 4418 */ " OPT_CODE=`echo \"X${OPT_ARG}\" | sed 's/X-\\(.\\).*/\\1/'`\n" + " OPT_ARG=` echo \"X${OPT_ARG}\" | sed 's/X-.//'`\n\0" +/* 4535 */ " case \"${OPT_ARG_NEEDED}\" in\n" + " NO )\n" + " if [ -n \"${OPT_ARG}\" ]\n" + " then\n" + " OPT_ARG=-${OPT_ARG}\n" + " else\n" + " shift\n" + " OPT_ARG=$1\n" + " fi\n" + " ;;\n" + " YES )\n" + " if [ -n \"${OPT_ARG}\" ]\n" + " then\n" + " OPT_ARG_VAL=${OPT_ARG}\n" + " else\n" + " if [ $# -eq 0 ]\n" + " then\n" + " echo No argument provided for ${OPT_NAME} option >&2\n" + " echo \"$%s_USAGE_TEXT\"\n" + " exit 1\n" + " fi\n" + " shift\n" + " OPT_ARG_VAL=$1\n" + " fi\n" + " shift\n" + " OPT_ARG=$1\n" + " ;;\n" + " OK )\n" + " if [ -n \"${OPT_ARG}\" ]\n" + " then\n" + " OPT_ARG_VAL=${OPT_ARG}\n" + " shift\n" + " OPT_ARG=$1\n" + " else\n" + " shift\n" + " if [ $# -gt 0 ]\n" + " then\n" + " case \"$1\" in -* ) ;; * )\n" + " OPT_ARG_VAL=$1\n" + " shift ;; esac\n" + " OPT_ARG=$1\n" + " fi\n" + " fi\n" + " ;;\n" + " esac\n\0" +/* 5689 */ "%1$s_%2$s=%3$d # 0x%3$X\n" + "export %1$s_%2$s\n\0" +/* 5731 */ "%1$s_%2$s_CT=%3$d\n" + "export %1$s_%2$s_CT\n\0" +/* 5770 */ "OPTION_CT=%d\n" + "export OPTION_CT\n\0" +/* 5801 */ "%1$s_%2$s=%3$s\n" + "export %1$s_%2$s\n\0" +/* 5834 */ "%1$s_%2$s='%3$s'\n" + "export %1$s_%2$s\n\0" +/* 5869 */ "%1$s_%2$s_MODE='%3$s'\n" + "export %1$s_%2$s_MODE\n\0" +/* 5914 */ "echo 'Warning: Cannot load options files' >&2\0" +/* 5961 */ "echo 'Warning: Cannot save options files' >&2\0" +/* 6008 */ "echo 'Warning: Cannot suppress the loading of options files' >&2\0" +/* 6074 */ "%1$s_%2$s_TEXT='no %2$s text'\n\0" +/* 6105 */ "%s WARNING: cannot save options - \0" +/* 6141 */ "<%s/>\n\0" +/* 6148 */ "<%s>\0" +/* 6153 */ "</%s>\n\0" +/* 6160 */ "<%s type=%s>\0" +/* 6173 */ "<%s type=nested>\n\0" +/* 6191 */ "#x%02X;\0" +/* 6199 */ "<%1$s type=boolean>%2$s</%1$s>\n\0" +/* 6231 */ "<%1$s type=integer>0x%2$lX</%1$s>\n"; + +/* end of ao-strs.c */ diff --git a/src/libopts/ao-strs.h b/src/libopts/ao-strs.h new file mode 100644 index 0000000000..96f37504ca --- /dev/null +++ b/src/libopts/ao-strs.h @@ -0,0 +1,251 @@ +/* -*- buffer-read-only: t -*- vi: set ro: + * + * DO NOT EDIT THIS FILE (ao-strs.h) + * + * It has been AutoGen-ed February 10, 2012 at 07:53:35 PM by AutoGen 5.15pre7 + * From the definitions ao-strs.def + * and the template file strings + * + * Copyright (C) 2011-2012 Bruce Korb, all rights reserved. + * This is free software. It is licensed for use, modification and + * redistribution under the terms of the + * Modified (3 clause) Berkeley Software Distribution License + * <http://www.xfree86.org/3.3.6/COPYRIGHT2.html> + * + * 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. Neither the name ``Bruce Korb'' nor the name of any other + * contributor may be used to endorse or promote products derived + * from this software without specific prior written permission. + * + * strings IS PROVIDED BY Bruce Korb ``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 Bruce Korb OR ANY OTHER CONTRIBUTORS + * 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. + */ +#ifndef STRINGS_AO_STRS_H_GUARD +#define STRINGS_AO_STRS_H_GUARD 1 +/* + * 102 strings in ao_strs_strtable string table + */ +#define ARG_BREAK_STR (ao_strs_strtable+0) +#define ARG_BREAK_STR_LEN 5 +#define INVALID_FMT (ao_strs_strtable+6) +#define INVALID_FMT_LEN 10 +#define INVALID_STR (ao_strs_strtable+17) +#define INVALID_STR_LEN 9 +#define NONE_STR (ao_strs_strtable+27) +#define NONE_STR_LEN 4 +#define PLUS_STR (ao_strs_strtable+32) +#define PLUS_STR_LEN 3 +#define OR_STR (ao_strs_strtable+36) +#define OR_STR_LEN 3 +#define NLSTR_FMT (ao_strs_strtable+40) +#define NLSTR_FMT_LEN 3 +#define PAGER_NAME (ao_strs_strtable+44) +#define PAGER_NAME_LEN 5 +#define TMP_USAGE_FMT (ao_strs_strtable+50) +#define TMP_USAGE_FMT_LEN 12 +#define MORE_STR (ao_strs_strtable+63) +#define MORE_STR_LEN 4 +#define LONG_OPT_MARK (ao_strs_strtable+68) +#define LONG_OPT_MARK_LEN 10 +#define NLSTR_SPACE_FMT (ao_strs_strtable+79) +#define NLSTR_SPACE_FMT_LEN 5 +#define TWO_SPACES_STR (ao_strs_strtable+85) +#define TWO_SPACES_STR_LEN 2 +#define FLAG_OPT_MARK (ao_strs_strtable+88) +#define FLAG_OPT_MARK_LEN 9 +#define END_OPT_SEL_STR (ao_strs_strtable+98) +#define END_OPT_SEL_STR_LEN 12 +#define STDOUT (ao_strs_strtable+111) +#define STDOUT_LEN 6 +#define TIME_FMT (ao_strs_strtable+118) +#define TIME_FMT_LEN 21 +#define SHELL_MAGIC (ao_strs_strtable+140) +#define SHELL_MAGIC_LEN 6 +#define OPT_VAL_FMT (ao_strs_strtable+147) +#define OPT_VAL_FMT_LEN 6 +#define OPT_END_FMT (ao_strs_strtable+154) +#define OPT_END_FMT_LEN 14 +#define EMPTY_ARG (ao_strs_strtable+169) +#define EMPTY_ARG_LEN 2 +#define QUOT_APOS (ao_strs_strtable+172) +#define QUOT_APOS_LEN 2 +#define QUOT_ARG_FMT (ao_strs_strtable+175) +#define QUOT_ARG_FMT_LEN 4 +#define ARG_BY_NUM_FMT (ao_strs_strtable+180) +#define ARG_BY_NUM_FMT_LEN 9 +#define EXPORT_ARG_FMT (ao_strs_strtable+190) +#define EXPORT_ARG_FMT_LEN 17 +#define set_dash (ao_strs_strtable+208) +#define set_dash_LEN 6 +#define arg_fmt (ao_strs_strtable+215) +#define arg_fmt_LEN 5 +#define apostrophy (ao_strs_strtable+221) +#define apostrophy_LEN 4 +#define init_optct (ao_strs_strtable+226) +#define init_optct_LEN 13 +#define SHOW_VAL_FMT (ao_strs_strtable+240) +#define SHOW_VAL_FMT_LEN 17 +#define TRUE_STR (ao_strs_strtable+258) +#define TRUE_STR_LEN 4 +#define FALSE_STR (ao_strs_strtable+263) +#define FALSE_STR_LEN 5 +#define VER_STR (ao_strs_strtable+269) +#define VER_STR_LEN 7 +#define OK_NEED_OPT_ARG (ao_strs_strtable+277) +#define OK_NEED_OPT_ARG_LEN 17 +#define NO_ARG_NEEDED (ao_strs_strtable+295) +#define NO_ARG_NEEDED_LEN 17 +#define YES_NEED_OPT_ARG (ao_strs_strtable+313) +#define YES_NEED_OPT_ARG_LEN 18 +#define LONG_USE_STR (ao_strs_strtable+332) +#define LONG_USE_STR_LEN 9 +#define FLAG_STR (ao_strs_strtable+342) +#define FLAG_STR_LEN 4 +#define SET_TEXT_FMT (ao_strs_strtable+347) +#define SET_TEXT_FMT_LEN 12 +#define END_SET_TEXT (ao_strs_strtable+360) +#define END_SET_TEXT_LEN 3 +#define OPTION_STR (ao_strs_strtable+364) +#define OPTION_STR_LEN 6 +#define SHOW_PROG_ENV (ao_strs_strtable+371) +#define SHOW_PROG_ENV_LEN 19 +#define SET_OFF_FMT (ao_strs_strtable+391) +#define SET_OFF_FMT_LEN 6 +#define LONG_OPT_MARKER (ao_strs_strtable+398) +#define LONG_OPT_MARKER_LEN 2 +#define BULLET_STR (ao_strs_strtable+401) +#define BULLET_STR_LEN 6 +#define DEEP_INDENT_STR (ao_strs_strtable+408) +#define DEEP_INDENT_STR_LEN 6 +#define ONE_TAB_STR (ao_strs_strtable+415) +#define ONE_TAB_STR_LEN 1 +#define NOT_FOUND_STR (ao_strs_strtable+417) +#define NOT_FOUND_STR_LEN 56 +#define ENUM_ERR_SEP_LINE_FMT (ao_strs_strtable+474) +#define ENUM_ERR_SEP_LINE_FMT_LEN 5 +#define ENUM_ERR_STR_WIDTH_FMT (ao_strs_strtable+480) +#define ENUM_ERR_STR_WIDTH_FMT_LEN 6 +#define PAGE_USAGE_FMT (ao_strs_strtable+487) +#define PAGE_USAGE_FMT_LEN 42 +#define START_MARK (ao_strs_strtable+530) +#define START_MARK_LEN 82 +#define PREAMBLE_FMT (ao_strs_strtable+613) +#define PREAMBLE_FMT_LEN 105 +#define END_PRE_FMT (ao_strs_strtable+719) +#define END_PRE_FMT_LEN 36 +#define MULTI_DEF_FMT (ao_strs_strtable+756) +#define MULTI_DEF_FMT_LEN 120 +#define SGL_DEF_FMT (ao_strs_strtable+877) +#define SGL_DEF_FMT_LEN 67 +#define SGL_NO_DEF_FMT (ao_strs_strtable+945) +#define SGL_NO_DEF_FMT_LEN 61 +#define LOOP_STR (ao_strs_strtable+1007) +#define LOOP_STR_LEN 193 +#define ONLY_OPTS_LOOP (ao_strs_strtable+1201) +#define ONLY_OPTS_LOOP_LEN 89 +#define zLoopEnd (ao_strs_strtable+1291) +#define zLoopEnd_LEN 329 +#define END_MARK (ao_strs_strtable+1621) +#define END_MARK_LEN 115 +#define zOptionCase (ao_strs_strtable+1737) +#define zOptionCase_LEN 30 +#define zOptionPartName (ao_strs_strtable+1768) +#define zOptionPartName_LEN 17 +#define zOptionFullName (ao_strs_strtable+1786) +#define zOptionFullName_LEN 15 +#define zOptionFlag (ao_strs_strtable+1802) +#define zOptionFlag_LEN 15 +#define zOptionEndSelect (ao_strs_strtable+1818) +#define zOptionEndSelect_LEN 16 +#define UNK_OPT_FMT (ao_strs_strtable+1835) +#define UNK_OPT_FMT_LEN 141 +#define zTextExit (ao_strs_strtable+1977) +#define zTextExit_LEN 50 +#define zPagedUsageExit (ao_strs_strtable+2028) +#define zPagedUsageExit_LEN 73 +#define zCmdFmt (ao_strs_strtable+2102) +#define zCmdFmt_LEN 15 +#define zCountTest (ao_strs_strtable+2118) +#define zCountTest_LEN 178 +#define MULTI_ARG_FMT (ao_strs_strtable+2297) +#define MULTI_ARG_FMT_LEN 123 +#define SGL_ARG_FMT (ao_strs_strtable+2421) +#define SGL_ARG_FMT_LEN 246 +#define NO_MULTI_ARG_FMT (ao_strs_strtable+2668) +#define NO_MULTI_ARG_FMT_LEN 140 +#define NO_SGL_ARG_FMT (ao_strs_strtable+2809) +#define NO_SGL_ARG_FMT_LEN 306 +#define zMayArg (ao_strs_strtable+3116) +#define zMayArg_LEN 119 +#define zMustArg (ao_strs_strtable+3236) +#define zMustArg_LEN 31 +#define zCantArg (ao_strs_strtable+3268) +#define zCantArg_LEN 119 +#define INIT_LOPT_STR (ao_strs_strtable+3388) +#define INIT_LOPT_STR_LEN 250 +#define LOPT_ARG_FMT (ao_strs_strtable+3639) +#define LOPT_ARG_FMT_LEN 778 +#define INIT_OPT_STR (ao_strs_strtable+4418) +#define INIT_OPT_STR_LEN 116 +#define OPT_ARG_FMT (ao_strs_strtable+4535) +#define OPT_ARG_FMT_LEN 1153 +#define zOptNumFmt (ao_strs_strtable+5689) +#define zOptNumFmt_LEN 41 +#define zOptCookieCt (ao_strs_strtable+5731) +#define zOptCookieCt_LEN 38 +#define zOptCtFmt (ao_strs_strtable+5770) +#define zOptCtFmt_LEN 30 +#define zOptDisabl (ao_strs_strtable+5801) +#define zOptDisabl_LEN 32 +#define zFullOptFmt (ao_strs_strtable+5834) +#define zFullOptFmt_LEN 34 +#define zEquivMode (ao_strs_strtable+5869) +#define zEquivMode_LEN 44 +#define NO_LOAD_WARN (ao_strs_strtable+5914) +#define NO_LOAD_WARN_LEN 46 +#define NO_SAVE_OPTS (ao_strs_strtable+5961) +#define NO_SAVE_OPTS_LEN 46 +#define NO_SUPPRESS_LOAD (ao_strs_strtable+6008) +#define NO_SUPPRESS_LOAD_LEN 65 +#define SET_NO_TEXT_FMT (ao_strs_strtable+6074) +#define SET_NO_TEXT_FMT_LEN 30 +#define SAVE_WARN (ao_strs_strtable+6105) +#define SAVE_WARN_LEN 35 +#define OPEN_CLOSE_FMT (ao_strs_strtable+6141) +#define OPEN_CLOSE_FMT_LEN 6 +#define OPEN_XML_FMT (ao_strs_strtable+6148) +#define OPEN_XML_FMT_LEN 4 +#define END_XML_FMT (ao_strs_strtable+6153) +#define END_XML_FMT_LEN 6 +#define TYPE_ATR_FMT (ao_strs_strtable+6160) +#define TYPE_ATR_FMT_LEN 12 +#define NULL_ATR_FMT (ao_strs_strtable+6141) +#define NULL_ATR_FMT_LEN 6 +#define NESTED_OPT_FMT (ao_strs_strtable+6173) +#define NESTED_OPT_FMT_LEN 17 +#define XML_HEX_BYTE_FMT (ao_strs_strtable+6191) +#define XML_HEX_BYTE_FMT_LEN 7 +#define BOOL_ATR_FMT (ao_strs_strtable+6199) +#define BOOL_ATR_FMT_LEN 31 +#define NUMB_ATR_FMT (ao_strs_strtable+6231) +#define NUMB_ATR_FMT_LEN 34 + +extern char const ao_strs_strtable[6266]; + +#endif /* STRINGS_AO_STRS_H_GUARD */ diff --git a/src/libopts/autoopts.c b/src/libopts/autoopts.c index c1129f2a01..df9e3cb927 100644 --- a/src/libopts/autoopts.c +++ b/src/libopts/autoopts.c @@ -2,7 +2,7 @@ /** * \file autoopts.c * - * Time-stamp: "2011-08-07 14:31:49 bkorb" + * Time-stamp: "2012-01-29 09:58:30 bkorb" * * This file contains all of the routines that must be linked into * an executable to use the generated option processing. The optional @@ -11,7 +11,7 @@ * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -36,7 +36,7 @@ static char const zNil[] = ""; static arg_types_t argTypes = { NULL }; -static char zOptFmtLine[32] = { NUL }; +static char line_fmt_buf[32]; static ag_bool displayEnum = AG_FALSE; static char const pkgdatadir_default[] = PKGDATADIR; static char const * program_pkgdatadir = pkgdatadir_default; @@ -452,9 +452,9 @@ immediate_opts(tOptions * pOpts) * are marked for immediate processing. */ for (;;) { - tOptState optState = OPTSTATE_INITIALIZER(PRESET); + tOptState opt_st = OPTSTATE_INITIALIZER(PRESET); - res = next_opt(pOpts, &optState); + res = next_opt(pOpts, &opt_st); switch (res) { case FAILURE: goto failed_option; case PROBLEM: res = SUCCESS; goto leave; @@ -464,10 +464,10 @@ immediate_opts(tOptions * pOpts) /* * IF this is an immediate-attribute option, then do it. */ - if (! DO_IMMEDIATELY(optState.flags)) + if (! DO_IMMEDIATELY(opt_st.flags)) continue; - if (! SUCCESSFUL(handle_opt(pOpts, &optState))) + if (! SUCCESSFUL(handle_opt(pOpts, &opt_st))) break; } failed_option:; @@ -494,9 +494,9 @@ regular_opts(tOptions * pOpts) { /* assert: pOpts->fOptSet & OPTPROC_IMMEDIATE == 0 */ for (;;) { - tOptState optState = OPTSTATE_INITIALIZER(DEFINED); + tOptState opt_st = OPTSTATE_INITIALIZER(DEFINED); - switch (next_opt(pOpts, &optState)) { + switch (next_opt(pOpts, &opt_st)) { case FAILURE: goto failed_option; case PROBLEM: return SUCCESS; /* no more args */ case SUCCESS: break; @@ -506,13 +506,13 @@ regular_opts(tOptions * pOpts) * IF this is an immediate action option, * THEN skip it (unless we are supposed to do it a second time). */ - if (! DO_NORMALLY(optState.flags)) { - if (! DO_SECOND_TIME(optState.flags)) + if (! DO_NORMALLY(opt_st.flags)) { + if (! DO_SECOND_TIME(opt_st.flags)) continue; - optState.pOD->optOccCt--; /* don't count this repetition */ + opt_st.pOD->optOccCt--; /* don't count this repetition */ } - if (! SUCCESSFUL(handle_opt(pOpts, &optState))) + if (! SUCCESSFUL(handle_opt(pOpts, &opt_st))) break; } failed_option:; @@ -640,7 +640,7 @@ optionProcess(tOptions * pOpts, int argCt, char ** argVect) * and do all the presetting the first time thru only. */ if ((pOpts->fOptSet & OPTPROC_INITDONE) == 0) { - pOpts->origArgCt = argCt; + pOpts->origArgCt = (unsigned int)argCt; pOpts->origArgVect = argVect; pOpts->fOptSet |= OPTPROC_INITDONE; if (HAS_pzPkgDataDir(pOpts)) diff --git a/src/libopts/autoopts.h b/src/libopts/autoopts.h index 831a52b188..14cbbf1650 100644 --- a/src/libopts/autoopts.h +++ b/src/libopts/autoopts.h @@ -2,14 +2,14 @@ /* * \file autoopts.h * - * Time-stamp: "2011-03-25 17:51:34 bkorb" + * Time-stamp: "2012-02-10 19:04:40 bkorb" * * This file defines all the global structures and special values * used in the automated option processing library. * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -69,6 +69,8 @@ # define EX_CONFIG 78 #endif +#define NL '\n' + /* * Convert the number to a list usable in a printf call */ @@ -77,7 +79,7 @@ #define NAMED_OPTS(po) \ (((po)->fOptSet & (OPTPROC_SHORTOPT | OPTPROC_LONGOPT)) == 0) -#define SKIP_OPT(p) (((p)->fOptState & (OPTST_DOCUMENT|OPTST_OMITTED)) != 0) +#define SKIP_OPT(p) (((p)->fOptState & OPTST_IMMUTABLE_MASK) != 0) typedef int tDirection; #define DIRECTION_PRESET -1 diff --git a/src/libopts/autoopts/options.h b/src/libopts/autoopts/options.h index 1e59faa61b..d4256118f4 100644 --- a/src/libopts/autoopts/options.h +++ b/src/libopts/autoopts/options.h @@ -2,14 +2,14 @@ * * DO NOT EDIT THIS FILE (options.h) * - * It has been AutoGen-ed December 29, 2011 at 12:02:36 PM by AutoGen 5.14 + * It has been AutoGen-ed February 10, 2012 at 07:53:40 PM by AutoGen 5.15pre7 * From the definitions funcs.def * and the template file options_h * * This file defines all the global structures and special values * used in the automated option processing library. * - * Automated Options Copyright (C) 1992-2011 by Bruce Korb + * Automated Options Copyright (C) 1992-2012 by Bruce Korb * * * AutoOpts is free software: you can redistribute it and/or modify it * under the terms of the GNU Lesser General Public License as published @@ -65,8 +65,8 @@ * See the relevant generated header file to determine which and what * values for "opt_name" are available. */ -#define OPTIONS_STRUCT_VERSION 147457 -#define OPTIONS_VERSION_STRING "36:1:11" +#define OPTIONS_STRUCT_VERSION 147458 +#define OPTIONS_VERSION_STRING "36:2:11" #define OPTIONS_MINIMUM_VERSION 102400 #define OPTIONS_MIN_VER_STRING "25:0:0" #define OPTIONS_VER_TO_NUM(_v, _r) (((_v) * 4096) + (_r)) @@ -154,7 +154,8 @@ typedef enum { OPTST_DISABLE_TWICE_ID = 23, /* process disabled option twice */ OPTST_SCALED_NUM_ID = 24, /* scaled integer value */ OPTST_NO_COMMAND_ID = 25, /* disable from cmd line */ - OPTST_DEPRECATED_ID = 26 /* support is being removed */ + OPTST_DEPRECATED_ID = 26, /* support is being removed */ + OPTST_ALIAS_ID = 27 /* alias for other option */ } opt_state_enum_t; #define OPTST_INIT 0U @@ -184,7 +185,8 @@ typedef enum { #define OPTST_SCALED_NUM (1U << OPTST_SCALED_NUM_ID) #define OPTST_NO_COMMAND (1U << OPTST_NO_COMMAND_ID) #define OPTST_DEPRECATED (1U << OPTST_DEPRECATED_ID) -#define OPT_STATE_MASK 0x07FFFF7FU +#define OPTST_ALIAS (1U << OPTST_ALIAS_ID) +#define OPT_STATE_MASK 0x0FFFFF7FU #define OPTST_SET_MASK ( \ OPTST_DEFINED | OPTST_PRESET | OPTST_RESET | \ @@ -207,13 +209,21 @@ typedef enum { OPTST_ARG_TYPE_4 \ /* 0x0000F000U */ ) +#define OPTST_NO_USAGE_MASK ( \ + OPTST_DEPRECATED | OPTST_NO_COMMAND | OPTST_OMITTED \ + /* 0x06080000U */ ) + +#define OPTST_IMMUTABLE_MASK ( \ + OPTST_DOCUMENT | OPTST_OMITTED \ + /* 0x00280000U */ ) + #define OPTST_DO_NOT_SAVE_MASK ( \ OPTST_DOCUMENT | OPTST_NO_INIT | OPTST_OMITTED \ /* 0x00280100U */ ) -#define OPTST_NO_USAGE_MASK ( \ - OPTST_DEPRECATED | OPTST_NO_COMMAND | OPTST_OMITTED \ - /* 0x06080000U */ ) +#define OPTST_NO_OUTPUT_MASK ( \ + OPTST_ALIAS | OPTST_DOCUMENT | OPTST_OMITTED \ + /* 0x08280000U */ ) #ifdef NO_OPTIONAL_OPT_ARGS # undef OPTST_ARG_OPTIONAL @@ -339,7 +349,7 @@ typedef tOptProc* tpOptProc; */ // coverity[+kill] typedef void (tUsageProc)(tOptions* pOpts, int exitCode); -typedef tUsageProc* tpUsageProc; +typedef tUsageProc * tpUsageProc; /* * Special definitions. "NOLIMIT" is the 'max' value to use when @@ -419,7 +429,7 @@ typedef void (tOptionXlateProc)(void); */ struct options { int const structVersion; - int origArgCt; + unsigned int origArgCt; char** origArgVect; unsigned int fOptSet; unsigned int curOptIdx; @@ -588,7 +598,7 @@ extern token_list_t* ao_string_tokenize(char const*); extern const tOptionValue* configFileLoad(char const*); -/* From: configfile.c line 1057 +/* From: configfile.c line 1059 * * optionFileLoad - Load the locatable config files, in order * @@ -618,7 +628,7 @@ extern const tOptionValue* configFileLoad(char const*); extern int optionFileLoad(tOptions*, char const*); -/* From: configfile.c line 209 +/* From: configfile.c line 211 * * optionFindNextValue - find a hierarcicaly valued option instance * @@ -637,7 +647,7 @@ extern int optionFileLoad(tOptions*, char const*); extern const tOptionValue* optionFindNextValue(const tOptDesc*, const tOptionValue*, char const*, char const*); -/* From: configfile.c line 135 +/* From: configfile.c line 137 * * optionFindValue - find a hierarcicaly valued option instance * @@ -667,7 +677,7 @@ extern const tOptionValue* optionFindValue(const tOptDesc*, char const*, char co extern void optionFree(tOptions*); -/* From: configfile.c line 278 +/* From: configfile.c line 280 * * optionGetValue - get a specific value from a hierarcical list * @@ -687,7 +697,7 @@ extern void optionFree(tOptions*); extern const tOptionValue* optionGetValue(const tOptionValue*, char const*); -/* From: load.c line 477 +/* From: load.c line 476 * * optionLoadLine - process a string for an option name and value * @@ -711,7 +721,7 @@ extern const tOptionValue* optionGetValue(const tOptionValue*, char const*); extern void optionLoadLine(tOptions*, char const*); -/* From: configfile.c line 338 +/* From: configfile.c line 340 * * optionNextValue - get the next value from a hierarchical list * @@ -792,7 +802,7 @@ extern int optionProcess(tOptions*, int, char**); extern void optionRestore(tOptions*); -/* From: save.c line 664 +/* From: save.c line 648 * * optionSaveFile - saves the option state to a file * @@ -839,7 +849,7 @@ extern void optionSaveFile(tOptions*); extern void optionSaveState(tOptions*); -/* From: nested.c line 551 +/* From: nested.c line 562 * * optionUnloadNested - Deallocate the memory for a nested value * @@ -1018,6 +1028,8 @@ extern unsigned int ao_string_cook_escape_char(char const*, char*, unsigned int) extern void genshelloptUsage(tOptions*, int); +extern int optionAlias(tOptions*, tOptDesc*, unsigned int); + extern void optionBooleanVal(tOptions*, tOptDesc*); extern uintptr_t optionEnumerationVal(tOptions*, tOptDesc*, char const * const *, unsigned int); diff --git a/src/libopts/autoopts/usage-txt.h b/src/libopts/autoopts/usage-txt.h index 20492a4666..0e29fc1810 100644 --- a/src/libopts/autoopts/usage-txt.h +++ b/src/libopts/autoopts/usage-txt.h @@ -2,7 +2,7 @@ * * DO NOT EDIT THIS FILE (usage-txt.h) * - * It has been AutoGen-ed December 29, 2011 at 12:02:34 PM by AutoGen 5.14 + * It has been AutoGen-ed February 10, 2012 at 07:53:38 PM by AutoGen 5.15pre7 * From the definitions usage-txt.def * and the template file usage-txt.tpl * @@ -13,7 +13,7 @@ * they may substitute translated strings using a procedure that steps through * all the string pointers. * - * Copyright (C) 1992-2011 Bruce Korb, all rights reserved. + * Copyright (C) 1992-2012 Bruce Korb, all rights reserved. * This is free software. It is licensed for use, modification and * redistribution under the terms of the * GNU Lesser General Public License, version 3 or later @@ -232,7 +232,7 @@ static char const usage_txt[4619] = /* 260 */ "\tThis is less than the minimum library version: \0" /* 310 */ "strdup of %d byte string failed\n\0" /* 343 */ "Automated Options version %s\n" - "\tcopyright (c) 1999-2011 by Bruce Korb - all rights reserved\n\0" + "\tcopyright (c) 1999-2012 by Bruce Korb - all rights reserved\n\0" /* 434 */ "AutoOpts lib error: defaulted to option with optional arg\n\0" /* 493 */ "(AutoOpts bug): Aliasing option is out of range.\0" /* 543 */ "all\0" diff --git a/src/libopts/boolean.c b/src/libopts/boolean.c index 8079231105..37d18e12b3 100644 --- a/src/libopts/boolean.c +++ b/src/libopts/boolean.c @@ -11,7 +11,7 @@ * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control diff --git a/src/libopts/check.c b/src/libopts/check.c index b4355b4557..003fe1363e 100644 --- a/src/libopts/check.c +++ b/src/libopts/check.c @@ -10,7 +10,7 @@ * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control diff --git a/src/libopts/compat/compat.h b/src/libopts/compat/compat.h index b288a7c2a3..24abed2aee 100644 --- a/src/libopts/compat/compat.h +++ b/src/libopts/compat/compat.h @@ -3,12 +3,12 @@ /** * \file compat.h --- fake the preprocessor into handlng portability * - * Time-stamp: "2010-07-16 15:11:57 bkorb" + * Time-stamp: "2012-02-10 17:00:09 bkorb" * * compat.h is free software. * This file is part of AutoGen. * - * AutoGen Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoGen Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoGen is free software: you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the @@ -83,7 +83,7 @@ #endif #include <sys/stat.h> #ifdef HAVE_SYS_WAIT_H -# include <sys/wait.h> +# include <sys/wait.h> #endif #if defined( HAVE_SOLARIS_SYSINFO ) diff --git a/src/libopts/compat/windows-config.h b/src/libopts/compat/windows-config.h index 360af1098c..076c046602 100644 --- a/src/libopts/compat/windows-config.h +++ b/src/libopts/compat/windows-config.h @@ -4,7 +4,7 @@ * * This file is part of AutoGen. * - * AutoGen Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoGen Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoGen is free software: you can redistribute it and/or modify it * under the terms of the GNU General Public License as published by the diff --git a/src/libopts/configfile.c b/src/libopts/configfile.c index 758ce272da..40d31c6bbf 100644 --- a/src/libopts/configfile.c +++ b/src/libopts/configfile.c @@ -1,13 +1,13 @@ /** * \file configfile.c * - * Time-stamp: "2011-12-17 12:51:30 bkorb" + * Time-stamp: "2012-01-29 15:57:40 bkorb" * * configuration/rc/ini file handling. * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -97,7 +97,9 @@ skip_unkn(char* pzText); * @code{mmap(2)} or other file system calls, or it may be: * @itemize @bullet * @item - * @code{ENOENT} - the file was empty. + * @code{ENOENT} - the file was not found. + * @item + * @code{ENOMSG} - the file was empty. * @item * @code{EINVAL} - the file contents are invalid -- not properly formed. * @item @@ -463,7 +465,7 @@ file_preset(tOptions * opts, char const * fname, int dir) break; case '#': - ftext = strchr(ftext + 1, '\n'); + ftext = strchr(ftext + 1, NL); break; default: @@ -501,7 +503,7 @@ static char * handle_cfg(tOptions * pOpts, tOptState * pOS, char * pzText, int dir) { char* pzName = pzText++; - char* pzEnd = strchr(pzText, '\n'); + char* pzEnd = strchr(pzText, NL); if (pzEnd == NULL) return pzText + strlen(pzText); @@ -541,13 +543,13 @@ handle_cfg(tOptions * pOpts, tOptState * pOS, char * pzText, int dir) case NUL: pcS = NULL; - case '\n': + case NL: *pcD = NUL; pzEnd = pcS; goto copy_done; case '\\': - if (*pcS == '\n') { + if (*pcS == NL) { ch = *(pcS++); } /* FALLTHROUGH */ @@ -700,7 +702,7 @@ handle_section(tOptions * pOpts, char * pzText) size_t len = strlen(pOpts->pzPROGNAME); if ( (strncmp(pzText+1, pOpts->pzPROGNAME, len) == 0) && (pzText[len+1] == ']')) - return strchr(pzText + len + 2, '\n'); + return strchr(pzText + len + 2, NL); if (len > 16) return NULL; @@ -712,7 +714,7 @@ handle_section(tOptions * pOpts, char * pzText) } if (pzText != NULL) - pzText = strchr(pzText, '\n'); + pzText = strchr(pzText, NL); return pzText; } @@ -731,7 +733,7 @@ parse_xml_encoding(char ** ppz) _xmlNm_(cr, '\r') \ _xmlNm_(vt, '\v') \ _xmlNm_(bel, '\a') \ - _xmlNm_(nl, '\n') \ + _xmlNm_(nl, NL) \ _xmlNm_(space, ' ') \ _xmlNm_(quot, '"') \ _xmlNm_(apos, '\'') @@ -849,8 +851,8 @@ cook_xml_text(char * pzData) return; case '&': - *(pzd++) = \ - ch = parse_xml_encoding(&pzs); + ch = parse_xml_encoding(&pzs); + *(pzd++) = (char)ch; if (ch == NUL) return; break; @@ -867,7 +869,7 @@ cook_xml_text(char * pzData) /* FALLTHROUGH */ default: - *(pzd++) = ch; + *(pzd++) = (char)ch; } } } diff --git a/src/libopts/cook.c b/src/libopts/cook.c index 49c12a3294..a81ce91b09 100644 --- a/src/libopts/cook.c +++ b/src/libopts/cook.c @@ -1,14 +1,14 @@ /** * \file cook.c * - * Time-stamp: "2011-03-12 15:05:26 bkorb" + * Time-stamp: "2012-02-10 17:00:47 bkorb" * * This file contains the routines that deal with processing quoted strings * into an internal format. * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -59,7 +59,7 @@ contiguous_quote(char ** pps, char * pq, int * lnct_p); * err: @code{NULL} is returned if the string is mal-formed. =*/ unsigned int -ao_string_cook_escape_char( char const* pzIn, char* pRes, unsigned nl ) +ao_string_cook_escape_char( char const* pzIn, char* pRes, uint_t nl ) { unsigned int res = 1; @@ -67,18 +67,18 @@ ao_string_cook_escape_char( char const* pzIn, char* pRes, unsigned nl ) case NUL: /* NUL - end of input string */ return 0; case '\r': - if (*pzIn != '\n') + if (*pzIn != NL) return 1; res++; /* FALLTHROUGH */ - case '\n': /* NL - emit newline */ + case NL: /* NL - emit newline */ *pRes = (char)nl; return res; case 'a': *pRes = '\a'; break; case 'b': *pRes = '\b'; break; case 'f': *pRes = '\f'; break; - case 'n': *pRes = '\n'; break; + case 'n': *pRes = NL; break; case 'r': *pRes = '\r'; break; case 't': *pRes = '\t'; break; case 'v': *pRes = '\v'; break; @@ -137,7 +137,7 @@ contiguous_quote(char ** pps, char * pq, int * lnct_p) for (;;) { while (IS_WHITESPACE_CHAR(*ps)) - if (*(ps++) == '\n') + if (*(ps++) == NL) (*lnct_p)++; /* @@ -164,7 +164,7 @@ contiguous_quote(char ** pps, char * pq, int * lnct_p) /* * Skip to end of line */ - ps = strchr(ps, '\n'); + ps = strchr(ps, NL); if (ps == NULL) { *pps = NULL; return AG_FALSE; @@ -183,7 +183,7 @@ contiguous_quote(char ** pps, char * pq, int * lnct_p) } while (ps < p) { - if (*(ps++) == '\n') + if (*(ps++) == NL) (*lnct_p)++; } @@ -261,7 +261,7 @@ ao_string_cook(char * pzScan, int * lnct_p) case NUL: return NULL; - case '\n': + case NL: (*lnct_p)++; break; @@ -271,7 +271,7 @@ ao_string_cook(char * pzScan, int * lnct_p) * THEN drop both the escape and the newline from * the result string. */ - if (*pzS == '\n') { + if (*pzS == NL) { pzS++; pzD--; (*lnct_p)++; @@ -282,7 +282,7 @@ ao_string_cook(char * pzScan, int * lnct_p) * THEN we do the full escape character processing */ else if (q != '\'') { - int ct = ao_string_cook_escape_char( pzS, pzD-1, (unsigned)'\n' ); + int ct = ao_string_cook_escape_char(pzS, pzD-1, (uint_t)NL); if (ct == 0) return NULL; diff --git a/src/libopts/enum.c b/src/libopts/enum.c index a79a32e5d3..6ce6b4bfb9 100644 --- a/src/libopts/enum.c +++ b/src/libopts/enum.c @@ -2,7 +2,7 @@ /** * \file enumeration.c * - * Time-stamp: "2011-04-06 10:48:22 bkorb" + * Time-stamp: "2012-01-29 19:07:59 bkorb" * * Automated Options Paged Usage module. * @@ -11,7 +11,7 @@ * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -105,7 +105,7 @@ enum_err(tOptions * pOpts, tOptDesc * pOD, */ if (max_len > 35) { do { - fprintf(option_usage_fp, " %s\n", *(paz_names++)); + fprintf(option_usage_fp, ENUM_ERR_SEP_LINE_FMT, *(paz_names++)); } while (--ct_down > 0); } @@ -118,19 +118,19 @@ enum_err(tOptions * pOpts, tOptDesc * pOD, fputc(' ', option_usage_fp); fputs(*(paz_names++), option_usage_fp); } while (--ct_down > 0); - fputc('\n', option_usage_fp); + fputc(NL, option_usage_fp); } /* * Otherwise, columnize the output */ else { - int ent_no = 0; + unsigned int ent_no = 0; char zFmt[16]; /* format for all-but-last entries on a line */ - sprintf(zFmt, "%%-%ds", (int)max_len); + sprintf(zFmt, ENUM_ERR_STR_WIDTH_FMT, (int)max_len); max_len = 78 / max_len; /* max_len is now max entries on a line */ - fputs(" ", option_usage_fp); + fputs(TWO_SPACES_STR, option_usage_fp); /* * Loop through all but the last entry @@ -141,14 +141,14 @@ enum_err(tOptions * pOpts, tOptDesc * pOD, /* * Last entry on a line. Start next line, too. */ - fprintf(option_usage_fp, "%s\n ", *(paz_names++)); + fprintf(option_usage_fp, NLSTR_SPACE_FMT, *(paz_names++)); ent_no = 0; } else fprintf(option_usage_fp, zFmt, *(paz_names++) ); } - fprintf(option_usage_fp, "%s\n", *paz_names); + fprintf(option_usage_fp, NLSTR_FMT, *paz_names); } if (pOpts > OPTPROC_EMIT_LIMIT) { @@ -277,7 +277,7 @@ optionEnumerationVal(tOptions * pOpts, tOptDesc * pOD, * print the name string. */ if (ix >= name_ct) - printf("INVALID-%d", ix); + printf(INVALID_FMT, ix); else fputs(paz_names[ ix ], stdout); @@ -286,13 +286,12 @@ optionEnumerationVal(tOptions * pOpts, tOptDesc * pOD, case (uintptr_t)OPTPROC_RETURN_VALNAME: { - tSCC zInval[] = "*INVALID*"; unsigned int ix = pOD->optArg.argEnum; /* * Replace the enumeration value with the name string. */ if (ix >= name_ct) - return (uintptr_t)zInval; + return (uintptr_t)INVALID_STR; pOD->optArg.argString = paz_names[ix]; break; @@ -328,15 +327,15 @@ set_memb_shell(tOptions * pOpts, tOptDesc * pOD, char const * const * paz_names, /* * print the name string. */ - int ix = 0; - uintptr_t bits = (uintptr_t)pOD->optCookie; - size_t len = 0; + unsigned int ix = 0; + uintptr_t bits = (uintptr_t)pOD->optCookie; + size_t len = 0; bits &= ((uintptr_t)1 << (uintptr_t)name_ct) - (uintptr_t)1; while (bits != 0) { if (bits & 1) { - if (len++ > 0) fputs(" | ", stdout); + if (len++ > 0) fputs(OR_STR, stdout); fputs(paz_names[ix], stdout); } if (++ix >= name_ct) break; @@ -348,13 +347,10 @@ static void set_memb_names(tOptions * pOpts, tOptDesc * pOD, char const * const * paz_names, unsigned int name_ct) { - static char const none[] = "none"; - static char const plus[3] = " + "; - - char * pz; - uintptr_t bits = (uintptr_t)pOD->optCookie; - int ix = 0; - size_t len = sizeof(none); + char * pz; + uintptr_t bits = (uintptr_t)pOD->optCookie; + unsigned int ix = 0; + size_t len = NONE_STR_LEN + 1; bits &= ((uintptr_t)1 << (uintptr_t)name_ct) - (uintptr_t)1; @@ -364,20 +360,20 @@ set_memb_names(tOptions * pOpts, tOptDesc * pOD, char const * const * paz_names, */ while (bits != 0) { if (bits & 1) - len += strlen(paz_names[ix]) + sizeof(plus); + len += strlen(paz_names[ix]) + PLUS_STR_LEN + 1; if (++ix >= name_ct) break; bits >>= 1; } - pOD->optArg.argString = pz = AGALOC(len, "enum name"); + pOD->optArg.argString = pz = AGALOC(len, "enum"); /* * Start by clearing all the bits. We want to turn off any defaults * because we will be restoring to current state, not adding to * the default set of bits. */ - memcpy(pz, none, sizeof(none)-1); - pz += sizeof(none)-1; + memcpy(pz, NONE_STR, NONE_STR_LEN); + pz += NONE_STR_LEN; bits = (uintptr_t)pOD->optCookie; bits &= ((uintptr_t)1 << (uintptr_t)name_ct) - (uintptr_t)1; ix = 0; @@ -385,9 +381,9 @@ set_memb_names(tOptions * pOpts, tOptDesc * pOD, char const * const * paz_names, while (bits != 0) { if (bits & 1) { size_t nln = strlen(paz_names[ix]); - memcpy(pz, plus, sizeof(plus)); - memcpy(pz+sizeof(plus), paz_names[ix], nln); - pz += strlen(paz_names[ix]) + 3; + memcpy(pz, PLUS_STR, PLUS_STR_LEN); + memcpy(pz+PLUS_STR_LEN, paz_names[ix], nln); + pz += nln + PLUS_STR_LEN; } if (++ix >= name_ct) break; bits >>= 1; @@ -440,7 +436,7 @@ optionSetMembers(tOptions * pOpts, tOptDesc * pOD, return; { - char const* pzArg = pOD->optArg.argString; + char const * pzArg = pOD->optArg.argString; uintptr_t res; if ((pzArg == NULL) || (*pzArg == NUL)) { pOD->optCookie = (void*)0; @@ -449,15 +445,14 @@ optionSetMembers(tOptions * pOpts, tOptDesc * pOD, res = (uintptr_t)pOD->optCookie; for (;;) { - tSCC zSpn[] = " ,|+\t\r\f\n"; int iv, len; - pzArg += strspn(pzArg, zSpn); + pzArg = SPN_SET_SEPARATOR_CHARS(pzArg); iv = (*pzArg == '!'); if (iv) - pzArg += strspn(pzArg+1, zSpn) + 1; + pzArg = SPN_WHITESPACE_CHARS(pzArg+1); - len = strcspn(pzArg, zSpn); + len = BRK_SET_SEPARATOR_CHARS(pzArg) - pzArg; if (len == 0) break; @@ -477,7 +472,7 @@ optionSetMembers(tOptions * pOpts, tOptDesc * pOD, if (pz != pzArg + len) { char z[ AO_NAME_SIZE ]; char const* p; - int shift_ct; + unsigned int shift_ct; if (*pz != NUL) { if (len >= AO_NAME_LIMIT) diff --git a/src/libopts/env.c b/src/libopts/env.c index c8e9154af4..60e8a037f7 100644 --- a/src/libopts/env.c +++ b/src/libopts/env.c @@ -11,7 +11,7 @@ * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control diff --git a/src/libopts/file.c b/src/libopts/file.c index 23994748ca..5a5b3eb53f 100644 --- a/src/libopts/file.c +++ b/src/libopts/file.c @@ -6,7 +6,7 @@ * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control diff --git a/src/libopts/find.c b/src/libopts/find.c index 7a9ba175c1..aa730c6fd9 100644 --- a/src/libopts/find.c +++ b/src/libopts/find.c @@ -3,14 +3,14 @@ * * @brief Hunt for options in the option descriptor list * - * Time-stamp: "2011-08-07 13:15:45 bkorb" + * Time-stamp: "2012-01-29 19:07:30 bkorb" * * This file contains the routines that deal with processing quoted strings * into an internal format. * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -44,7 +44,7 @@ parse_opt(char const ** nm_pp, char ** arg_pp, char * buf, size_t bufsz) case NUL: return res; case '=': - if (res >= bufsz) + if (res >= (int)bufsz) return -1; memcpy(buf, *nm_pp, res); @@ -70,7 +70,7 @@ static void opt_ambiguities(tOptions * opts, char const * name, int nm_len) { char const * const hyph = - NAMED_OPTS(opts) ? "" : "--"; + NAMED_OPTS(opts) ? "" : LONG_OPT_MARKER; tOptDesc * pOD = opts->pOptDesc; int idx = 0; @@ -183,8 +183,8 @@ opt_set(tOptions * opts, char * arg, int idx, ag_bool disable, tOptState * st) fprintf(stderr, zDisabledErr, opts->pzProgName, pOD->pz_Name); if (pOD->pzText != NULL) - fprintf(stderr, " -- %s", pOD->pzText); - fputc('\n', stderr); + fprintf(stderr, SET_OFF_FMT, pOD->pzText); + fputc(NL, stderr); (*opts->pUsageProc)(opts, EXIT_FAILURE); /* NOTREACHED */ _exit(EXIT_FAILURE); /* to be certain */ @@ -284,47 +284,37 @@ void optionVendorOption(tOptions * pOpts, tOptDesc * pOD) { tOptState opt_st = OPTSTATE_INITIALIZER(PRESET); - unsigned long st_flags = opt_st.flags; - tSuccess res; char const * vopt_str = pOD->optArg.argString; - if ((pOpts->fOptSet & OPTPROC_VENDOR_OPT) == 0) - goto illegal; - if ((pOD->fOptState & OPTPROC_IMMEDIATE) == 0) - st_flags = OPTST_DEFINED; - res = opt_find_long(pOpts, vopt_str, &opt_st); + opt_st.flags = OPTST_DEFINED; - switch (res) { - case FAILURE: - case PROBLEM: - illegal: + if ( ((pOpts->fOptSet & OPTPROC_VENDOR_OPT) == 0) + || ! SUCCESSFUL(opt_find_long(pOpts, vopt_str, &opt_st)) + || ! SUCCESSFUL(get_opt_arg(pOpts, &opt_st)) ) + { fprintf(stderr, zIllVendOptStr, vopt_str); (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE); /* NOTREACHED */ + } - case SUCCESS: - if (! SUCCESSFUL(get_opt_arg(pOpts, &opt_st))) - goto illegal; - + /* + * See if we are in immediate handling state. + */ + if (pOpts->fOptSet & OPTPROC_IMMEDIATE) { /* - * See if we are in immediate handling state. + * See if the enclosed option is okay with that state. */ - if (pOpts->fOptSet & OPTPROC_IMMEDIATE) { - /* - * See if the enclosed option is okay with that state. - */ - if (DO_IMMEDIATELY(opt_st.flags)) - (void)handle_opt(pOpts, &opt_st); + if (DO_IMMEDIATELY(opt_st.flags)) + (void)handle_opt(pOpts, &opt_st); - } else { - /* - * non-immediate direction. - * See if the enclosed option is okay with that state. - */ - if (DO_NORMALLY(opt_st.flags) || DO_SECOND_TIME(opt_st.flags)) - (void)handle_opt(pOpts, &opt_st); - } + } else { + /* + * non-immediate direction. + * See if the enclosed option is okay with that state. + */ + if (DO_NORMALLY(opt_st.flags) || DO_SECOND_TIME(opt_st.flags)) + (void)handle_opt(pOpts, &opt_st); } } @@ -385,8 +375,8 @@ opt_find_short(tOptions* pOpts, uint_t optValue, tOptState* pOptState) && (pRes->pz_Name != NULL)) { fprintf(stderr, zDisabledErr, pOpts->pzProgPath, pRes->pz_Name); if (pRes->pzText != NULL) - fprintf(stderr, " -- %s", pRes->pzText); - fputc('\n', stderr); + fprintf(stderr, SET_OFF_FMT, pRes->pzText); + fputc(NL, stderr); (*pOpts->pUsageProc)(pOpts, EXIT_FAILURE); /* NOTREACHED */ _exit(EXIT_FAILURE); /* to be certain */ @@ -566,3 +556,11 @@ find_opt(tOptions * pOpts, tOptState * pOptState) return opt_find_long(pOpts, pOpts->pzCurOpt, pOptState); } + +/* + * Local Variables: + * mode: C + * c-file-style: "stroustrup" + * indent-tabs-mode: nil + * End: + * end of autoopts/find.c */ diff --git a/src/libopts/genshell.c b/src/libopts/genshell.c index 230b13de62..71e2c7d891 100644 --- a/src/libopts/genshell.c +++ b/src/libopts/genshell.c @@ -2,11 +2,11 @@ * * DO NOT EDIT THIS FILE (genshell.c) * - * It has been AutoGen-ed December 29, 2011 at 12:02:33 PM by AutoGen 5.14 + * It has been AutoGen-ed February 10, 2012 at 07:53:37 PM by AutoGen 5.15pre7 * From the definitions genshell.def * and the template file options * - * Generated from AutoOpts 36:1:11 templates. + * Generated from AutoOpts 36:2:11 templates. * * AutoOpts is a copyrighted work. This source file is not encumbered * by AutoOpts licensing, but is provided under the licensing terms chosen @@ -19,7 +19,7 @@ * The genshellopt program is copyrighted and licensed * under the following terms: * - * Copyright (C) 1999-2011 Bruce Korb, all rights reserved. + * Copyright (C) 1999-2012 Bruce Korb, all rights reserved. * This is free software. It is licensed for use, modification and * redistribution under the terms of the * GNU General Public License, version 3 or later @@ -68,7 +68,7 @@ extern tUsageProc genshelloptUsage; */ static char const genshellopt_opt_strs[1691] = /* 0 */ "genshellopt 1\n" - "Copyright (C) 1999-2011 Bruce Korb, all rights reserved.\n" + "Copyright (C) 1999-2012 Bruce Korb, all rights reserved.\n" "This is free software. It is licensed for use, modification and\n" "redistribution under the terms of the\n" "GNU General Public License, version 3 or later\n" @@ -269,7 +269,7 @@ doUsageOpt(tOptions * pOptions, tOptDesc * pOptDesc) (void)pOptions; GENSHELL_USAGE(GENSHELLOPT_EXIT_SUCCESS); } -/* extracted from optmain.tlib near line 1148 */ +/* extracted from optmain.tlib near line 1133 */ #ifndef PKGDATADIR # define PKGDATADIR "" diff --git a/src/libopts/genshell.h b/src/libopts/genshell.h index 2718bbf7cf..eecbe44bf4 100644 --- a/src/libopts/genshell.h +++ b/src/libopts/genshell.h @@ -2,11 +2,11 @@ * * DO NOT EDIT THIS FILE (genshell.h) * - * It has been AutoGen-ed December 29, 2011 at 12:02:33 PM by AutoGen 5.14 + * It has been AutoGen-ed February 10, 2012 at 07:53:37 PM by AutoGen 5.15pre7 * From the definitions genshell.def * and the template file options * - * Generated from AutoOpts 36:1:11 templates. + * Generated from AutoOpts 36:2:11 templates. * * AutoOpts is a copyrighted work. This header file is not encumbered * by AutoOpts licensing, but is provided under the licensing terms chosen @@ -19,7 +19,7 @@ * The genshellopt program is copyrighted and licensed * under the following terms: * - * Copyright (C) 1999-2011 Bruce Korb, all rights reserved. + * Copyright (C) 1999-2012 Bruce Korb, all rights reserved. * This is free software. It is licensed for use, modification and * redistribution under the terms of the * GNU General Public License, version 3 or later @@ -55,7 +55,7 @@ * tolerable version is at least as old as what was current when the header * template was released. */ -#define AO_TEMPLATE_VERSION 147457 +#define AO_TEMPLATE_VERSION 147458 #if (AO_TEMPLATE_VERSION < OPTIONS_MINIMUM_VERSION) \ || (AO_TEMPLATE_VERSION > OPTIONS_STRUCT_VERSION) # error option template version mismatches autoopts/options.h header diff --git a/src/libopts/libopts.c b/src/libopts/libopts.c index ca256eb7ef..bd5f87244f 100644 --- a/src/libopts/libopts.c +++ b/src/libopts/libopts.c @@ -2,23 +2,27 @@ #define AUTOOPTS_INTERNAL 1 #include "compat/compat.h" #define LOCAL static +#include "ao-strs.h" #include "autoopts/options.h" #include "autoopts/usage-txt.h" #include "genshell.h" #include "xat-attribute.h" #include "value-type.h" +#include "ao-strs.h" #include "ag-char-map.h" #include "autoopts.h" -#include "proto.h" #include "parse-duration.h" +#include "proto.h" #include "parse-duration.c" +#include "ao-strs.c" #include "value-type.c" #include "xat-attribute.c" #include "autoopts.c" +#include "alias.c" #include "boolean.c" +#include "check.c" #include "configfile.c" #include "cook.c" -#include "check.c" #include "enum.c" #include "env.c" #include "file.c" @@ -37,7 +41,7 @@ #include "stack.c" #include "streqvcmp.c" #include "text_mmap.c" -#include "tokenize.c" #include "time.c" +#include "tokenize.c" #include "usage.c" #include "version.c" diff --git a/src/libopts/load.c b/src/libopts/load.c index e4f231d4b7..a1380709bb 100644 --- a/src/libopts/load.c +++ b/src/libopts/load.c @@ -1,7 +1,7 @@ /** * \file load.c - * Time-stamp: "2011-12-17 12:53:04 bkorb" + * Time-stamp: "2012-01-29 19:37:15 bkorb" * * This file contains the routines that deal with processing text strings * for options, either from a NUL-terminated string passed in or from an @@ -9,7 +9,7 @@ * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -37,8 +37,8 @@ static ag_bool add_env_val(char * pzBuf, int bufSize, char const * pzName, char const * pzProgPath); -static char* -assemble_arg_val(char* pzTxt, tOptionLoadMode mode); +static char * +assemble_arg_val(char * pzTxt, tOptionLoadMode mode); /* = = = END-STATIC-FORWARD = = = */ /*=export_func optionMakePath @@ -98,7 +98,7 @@ optionMakePath(char * pzBuf, int bufSize, char const * pzName, { size_t name_len = strlen(pzName); - if ((bufSize <= name_len) || (name_len == 0)) + if (((size_t)bufSize <= name_len) || (name_len == 0)) return AG_FALSE; /* @@ -225,7 +225,7 @@ add_prog_path(char * pzBuf, int bufSize, char const * pzName, * Concatenate the file name to the end of the executable path. * The result may be either a file or a directory. */ - if ((pz - pzPath)+1 + strlen(pzName) >= bufSize) + if ((pz - pzPath)+1 + strlen(pzName) >= (unsigned)bufSize) return AG_FALSE; memcpy(pzBuf, pzPath, (size_t)((pz - pzPath)+1)); @@ -267,7 +267,7 @@ add_env_val(char * pzBuf, int bufSize, char const * pzName, if (pzDir == NULL) return AG_FALSE; - if (strlen(pzDir) + 1 + strlen(pzName) >= bufSize) + if (strlen(pzDir) + 1 + strlen(pzName) >= (unsigned)bufSize) return AG_FALSE; sprintf(pzBuf, "%s%s", pzDir, pzName); @@ -314,11 +314,10 @@ mungeString(char* pzTxt, tOptionLoadMode mode) } -static char* -assemble_arg_val(char* pzTxt, tOptionLoadMode mode) +static char * +assemble_arg_val(char * pzTxt, tOptionLoadMode mode) { - static char const zBrk[] = " \t\n:="; - char* pzEnd = strpbrk(pzTxt, zBrk); + char* pzEnd = strpbrk(pzTxt, ARG_BREAK_STR); int space_break; /* diff --git a/src/libopts/m4/libopts.m4 b/src/libopts/m4/libopts.m4 index bb8da673d9..1f981aaefe 100644 --- a/src/libopts/m4/libopts.m4 +++ b/src/libopts/m4/libopts.m4 @@ -2,7 +2,7 @@ dnl -*- buffer-read-only: t -*- vi: set ro: dnl dnl DO NOT EDIT THIS FILE (libopts.m4) dnl -dnl It has been AutoGen-ed December 29, 2011 at 12:02:31 PM by AutoGen 5.14 +dnl It has been AutoGen-ed February 10, 2012 at 07:53:33 PM by AutoGen 5.15pre7 dnl From the definitions libopts.def dnl and the template file conftest.tpl dnl @@ -78,16 +78,16 @@ AC_DEFUN([INVOKE_LIBOPTS_MACROS_FIRST],[ # ---------------------------------------------------------------------- AC_CHECK_TYPES(wchar_t) AC_CHECK_TYPES(wint_t, [], [], [ - AC_INCLUDES_DEFAULT - #if HAVE_RUNETYPE_H - # include <runetype.h> - #endif - #if HAVE_WCHAR_H - # include <wchar.h> - #endif + AC_INCLUDES_DEFAULT + #if HAVE_RUNETYPE_H + # include <runetype.h> + #endif + #if HAVE_WCHAR_H + # include <wchar.h> + #endif ]) AC_CHECK_TYPES([int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, - intptr_t, uintptr_t, uint_t, pid_t, size_t]) + intptr_t, uintptr_t, uint_t, pid_t, size_t]) # ===== # sizes @@ -454,7 +454,7 @@ dnl the config tests that the library needs. Invoke the dnl "INVOKE_LIBOPTS_MACROS" macro iff we are building libopts. dnl dnl This file is part of AutoGen. -dnl AutoGen Copyright (c) 1992-2011 by Bruce Korb - all rights reserved +dnl AutoGen Copyright (c) 1992-2012 by Bruce Korb - all rights reserved dnl dnl AutoGen is free software: you can redistribute it and/or modify it dnl under the terms of the GNU General Public License as published by the @@ -574,9 +574,8 @@ AC_DEFUN([LIBOPTS_CHECK], [ LIBOPTS_CHECK_COMMON(AO_Libopts_Dir) AM_COND_IF([NEED_LIBOPTS], [ INVOKE_LIBOPTS_MACROS + AC_CONFIG_FILES(AO_Libopts_Dir/Makefile) ])dnl - - AC_CONFIG_FILES(AO_Libopts_Dir/Makefile) m4_popdef([AO_Libopts_Dir])dnl # end of AC_DEFUN of LIBOPTS_CHECK ]) diff --git a/src/libopts/m4/liboptschk.m4 b/src/libopts/m4/liboptschk.m4 index 48e4ceb7a1..4a45bdefc6 100644 --- a/src/libopts/m4/liboptschk.m4 +++ b/src/libopts/m4/liboptschk.m4 @@ -1,5 +1,5 @@ # liboptschk.m4 serial 2 (autogen - 5.11.4) -dnl Copyright (c) 2005-2011 by Bruce Korb - all rights reserved +dnl Copyright (c) 2005-2012 by Bruce Korb - all rights reserved dnl dnl This file is free software; the Free Software Foundation dnl gives unlimited permission to copy and/or distribute it, diff --git a/src/libopts/makeshell.c b/src/libopts/makeshell.c index 20964ff316..1730c8176d 100644 --- a/src/libopts/makeshell.c +++ b/src/libopts/makeshell.c @@ -2,14 +2,14 @@ /** * \file makeshell.c * - * Time-stamp: "2011-04-20 11:06:57 bkorb" + * Time-stamp: "2012-01-29 19:01:07 bkorb" * * This module will interpret the options set in the tOptions * structure and create a Bourne shell script capable of parsing them. * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -30,347 +30,40 @@ tOptions * optionParseShellOptions = NULL; -/* * * * * * * * * * * * * * * * * * * * * - * - * Setup Format Strings - */ -static char const zStartMarker[] = -"# # # # # # # # # # -- do not modify this marker --\n#\n" -"# DO NOT EDIT THIS SECTION"; - -static char const zPreamble[] = -"%s OF %s\n#\n" -"# From here to the next `-- do not modify this marker --',\n" -"# the text has been generated %s\n"; - -static char const zEndPreamble[] = -"# From the %s option definitions\n#\n"; - -static char const zMultiDef[] = "\n" -"if test -z \"${%1$s_%2$s}\"\n" -"then\n" -" %1$s_%2$s_CT=0\n" -"else\n" -" %1$s_%2$s_CT=1\n" -" %1$s_%2$s_1=\"${%1$s_%2$s}\"\n" -"fi\n" -"export %1$s_%2$s_CT"; - -static char const zSingleDef[] = "\n" -"%1$s_%2$s=\"${%1$s_%2$s-'%3$s'}\"\n" -"%1$s_%2$s_set=false\n" -"export %1$s_%2$s\n"; - -static char const zSingleNoDef[] = "\n" -"%1$s_%2$s=\"${%1$s_%2$s}\"\n" -"%1$s_%2$s_set=false\n" -"export %1$s_%2$s\n"; - -/* * * * * * * * * * * * * * * * * * * * * - * - * LOOP START - * - * The loop may run in either of two modes: - * all options are named options (loop only) - * regular, marked option processing. - */ -static char const zLoopCase[] = "\n" -"OPT_PROCESS=true\n" -"OPT_ARG=\"$1\"\n\n" -"while ${OPT_PROCESS} && [ $# -gt 0 ]\ndo\n" -" OPT_ELEMENT=''\n" -" OPT_ARG_VAL=''\n\n" - /* - * 'OPT_ARG' may or may not match the current $1 - */ -" case \"${OPT_ARG}\" in\n" -" -- )\n" -" OPT_PROCESS=false\n" -" shift\n" -" ;;\n\n"; - -static char const zLoopOnly[] = "\n" -"OPT_ARG=\"$1\"\n\n" -"while [ $# -gt 0 ]\ndo\n" -" OPT_ELEMENT=''\n" -" OPT_ARG_VAL=''\n\n" -" OPT_ARG=\"${1}\"\n"; - -/* * * * * * * * * * * * * * * * - * - * CASE SELECTORS - * - * If the loop runs as a regular option loop, - * then we must have selectors for each acceptable option - * type (long option, flag character and non-option) - */ -static char const zLongSelection[] = -" --* )\n"; - -static char const zFlagSelection[] = -" -* )\n"; - -static char const zEndSelection[] = -" ;;\n\n"; - -static char const zNoSelection[] = -" * )\n" -" OPT_PROCESS=false\n" -" ;;\n" -" esac\n\n"; - -/* * * * * * * * * * * * * * * * - * - * LOOP END - */ -static char const zLoopEnd[] = -" if [ -n \"${OPT_ARG_VAL}\" ]\n" -" then\n" -" eval %1$s_${OPT_NAME}${OPT_ELEMENT}=\"'${OPT_ARG_VAL}'\"\n" -" export %1$s_${OPT_NAME}${OPT_ELEMENT}\n" -" fi\n" -"done\n\n" -"unset OPT_PROCESS || :\n" -"unset OPT_ELEMENT || :\n" -"unset OPT_ARG || :\n" -"unset OPT_ARG_NEEDED || :\n" -"unset OPT_NAME || :\n" -"unset OPT_CODE || :\n" -"unset OPT_ARG_VAL || :\n%2$s"; - -static char const zTrailerMarker[] = "\n" -"# # # # # # # # # #\n#\n" -"# END OF AUTOMATED OPTION PROCESSING\n" -"#\n# # # # # # # # # # -- do not modify this marker --\n"; - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * - * OPTION SELECTION - */ -static char const zOptionCase[] = -" case \"${OPT_CODE}\" in\n"; - -static char const zOptionPartName[] = -" '%s' | \\\n"; - -static char const zOptionFullName[] = -" '%s' )\n"; - -static char const zOptionFlag[] = -" '%c' )\n"; - -static char const zOptionEndSelect[] = -" ;;\n\n"; - -static char const zOptionUnknown[] = -" * )\n" -" echo Unknown %s: \"${OPT_CODE}\" >&2\n" -" echo \"$%s_USAGE_TEXT\"\n" -" exit 1\n" -" ;;\n" -" esac\n\n"; - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * - * OPTION PROCESSING - * - * Formats for emitting the text for handling particular options - */ -static char const zTextExit[] = -" echo \"$%s_%s_TEXT\"\n" -" exit 0\n"; - -static char const zPagedUsageExit[] = -" echo \"$%s_LONGUSAGE_TEXT\" | ${PAGER-more}\n" -" exit 0\n"; - -static char const zCmdFmt[] = -" %s\n"; - -static char const zCountTest[] = -" if [ $%1$s_%2$s_CT -ge %3$d ] ; then\n" -" echo Error: more than %3$d %2$s options >&2\n" -" echo \"$%1$s_USAGE_TEXT\"\n" -" exit 1 ; fi\n"; - -static char const zMultiArg[] = -" %1$s_%2$s_CT=`expr ${%1$s_%2$s_CT} + 1`\n" -" OPT_ELEMENT=\"_${%1$s_%2$s_CT}\"\n" -" OPT_NAME='%2$s'\n"; - -static char const zSingleArg[] = -" if [ -n \"${%1$s_%2$s}\" ] && ${%1$s_%2$s_set} ; then\n" -" echo Error: duplicate %2$s option >&2\n" -" echo \"$%1$s_USAGE_TEXT\"\n" -" exit 1 ; fi\n" -" %1$s_%2$s_set=true\n" -" OPT_NAME='%2$s'\n"; - -static char const zNoMultiArg[] = -" %1$s_%2$s_CT=0\n" -" OPT_ELEMENT=''\n" -" %1$s_%2$s='%3$s'\n" -" export %1$s_%2$s\n" -" OPT_NAME='%2$s'\n"; - -static char const zNoSingleArg[] = -" if [ -n \"${%1$s_%2$s}\" ] && ${%1$s_%2$s_set} ; then\n" -" echo Error: duplicate %2$s option >&2\n" -" echo \"$%1$s_USAGE_TEXT\"\n" -" exit 1 ; fi\n" -" %1$s_%2$s_set=true\n" -" %1$s_%2$s='%3$s'\n" -" export %1$s_%2$s\n" -" OPT_NAME='%2$s'\n"; - -static char const zMayArg[] = -" eval %1$s_%2$s${OPT_ELEMENT}=true\n" -" export %1$s_%2$s${OPT_ELEMENT}\n" -" OPT_ARG_NEEDED=OK\n"; - -static char const zMustArg[] = -" OPT_ARG_NEEDED=YES\n"; - -static char const zCantArg[] = -" eval %1$s_%2$s${OPT_ELEMENT}=true\n" -" export %1$s_%2$s${OPT_ELEMENT}\n" -" OPT_ARG_NEEDED=NO\n"; - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * - * LONG OPTION PROCESSING - * - * Formats for emitting the text for handling long option types - */ -static char const zLongOptInit[] = -" OPT_CODE=`echo \"X${OPT_ARG}\"|sed 's/^X-*//'`\n" -" shift\n" -" OPT_ARG=\"$1\"\n\n" -" case \"${OPT_CODE}\" in *=* )\n" -" OPT_ARG_VAL=`echo \"${OPT_CODE}\"|sed 's/^[^=]*=//'`\n" -" OPT_CODE=`echo \"${OPT_CODE}\"|sed 's/=.*$//'` ;; esac\n\n"; - -static char const zLongOptArg[] = -" case \"${OPT_ARG_NEEDED}\" in\n" -" NO )\n" -" OPT_ARG_VAL=''\n" -" ;;\n\n" -" YES )\n" -" if [ -z \"${OPT_ARG_VAL}\" ]\n" -" then\n" -" if [ $# -eq 0 ]\n" -" then\n" -" echo No argument provided for ${OPT_NAME} option >&2\n" -" echo \"$%s_USAGE_TEXT\"\n" -" exit 1\n" -" fi\n\n" -" OPT_ARG_VAL=\"${OPT_ARG}\"\n" -" shift\n" -" OPT_ARG=\"$1\"\n" -" fi\n" -" ;;\n\n" -" OK )\n" -" if [ -z \"${OPT_ARG_VAL}\" ] && [ $# -gt 0 ]\n" -" then\n" -" case \"${OPT_ARG}\" in -* ) ;; * )\n" -" OPT_ARG_VAL=\"${OPT_ARG}\"\n" -" shift\n" -" OPT_ARG=\"$1\" ;; esac\n" -" fi\n" -" ;;\n" -" esac\n"; - -/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * - * - * FLAG OPTION PROCESSING - * - * Formats for emitting the text for handling flag option types - */ -static char const zFlagOptInit[] = -" OPT_CODE=`echo \"X${OPT_ARG}\" | sed 's/X-\\(.\\).*/\\1/'`\n" -" OPT_ARG=` echo \"X${OPT_ARG}\" | sed 's/X-.//'`\n\n"; - -static char const zFlagOptArg[] = -" case \"${OPT_ARG_NEEDED}\" in\n" -" NO )\n" -" if [ -n \"${OPT_ARG}\" ]\n" -" then\n" -" OPT_ARG=-\"${OPT_ARG}\"\n" -" else\n" -" shift\n" -" OPT_ARG=\"$1\"\n" -" fi\n" -" ;;\n\n" -" YES )\n" -" if [ -n \"${OPT_ARG}\" ]\n" -" then\n" -" OPT_ARG_VAL=\"${OPT_ARG}\"\n\n" -" else\n" -" if [ $# -eq 0 ]\n" -" then\n" -" echo No argument provided for ${OPT_NAME} option >&2\n" -" echo \"$%s_USAGE_TEXT\"\n" -" exit 1\n" -" fi\n" -" shift\n" -" OPT_ARG_VAL=\"$1\"\n" -" fi\n\n" -" shift\n" -" OPT_ARG=\"$1\"\n" -" ;;\n\n" -" OK )\n" -" if [ -n \"${OPT_ARG}\" ]\n" -" then\n" -" OPT_ARG_VAL=\"${OPT_ARG}\"\n" -" shift\n" -" OPT_ARG=\"$1\"\n\n" -" else\n" -" shift\n" -" if [ $# -gt 0 ]\n" -" then\n" -" case \"$1\" in -* ) ;; * )\n" -" OPT_ARG_VAL=\"$1\"\n" -" shift ;; esac\n" -" OPT_ARG=\"$1\"\n" -" fi\n" -" fi\n" -" ;;\n" -" esac\n"; - -tSCC* pzShell = NULL; -static char* pzLeader = NULL; -static char* pzTrailer = NULL; +static char const * shell_prog = NULL; +static char * script_leader = NULL; +static char * script_trailer = NULL; /* = = = START-STATIC-FORWARD = = = */ static void emit_var_text(char const * prog, char const * var, int fdin); static void -textToVariable(tOptions * pOpts, teTextTo whichVar, tOptDesc * pOD); +text_to_var(tOptions * pOpts, teTextTo whichVar, tOptDesc * pOD); static void -emitUsage(tOptions* pOpts); +emit_usage(tOptions * pOpts); static void -emitSetup(tOptions* pOpts); +emit_setup(tOptions * pOpts); static void -printOptionAction(tOptions* pOpts, tOptDesc* pOptDesc); +emit_action(tOptions * pOpts, tOptDesc* pOptDesc); static void -printOptionInaction(tOptions* pOpts, tOptDesc* pOptDesc); +emit_inaction(tOptions * pOpts, tOptDesc* pOptDesc); static void -emitFlag(tOptions* pOpts); +emit_flag(tOptions * pOpts); static void -emitMatchExpr(tCC* pzMatchName, tOptDesc* pCurOpt, tOptions* pOpts); +emit_match_expr(char const * pzMatchName, tOptDesc* pCurOpt, tOptions* pOpts); static void -emitLong(tOptions* pOpts); +emitLong(tOptions * pOpts); static void -openOutput(char const* pzFile); +open_out(char const * pzFile); /* = = = END-STATIC-FORWARD = = = */ /*=export_func optionParseShell @@ -383,7 +76,7 @@ openOutput(char const* pzFile); * Emit a shell script that will parse the command line options. =*/ void -optionParseShell(tOptions* pOpts) +optionParseShell(tOptions * pOpts) { /* * Check for our SHELL option now. @@ -391,89 +84,87 @@ optionParseShell(tOptions* pOpts) * it will override anything we do here. */ if (HAVE_GENSHELL_OPT(SHELL)) - pzShell = GENSHELL_OPT_ARG(SHELL); + shell_prog = GENSHELL_OPT_ARG(SHELL); else if (! ENABLED_GENSHELL_OPT(SHELL)) - pzShell = NULL; + shell_prog = NULL; - else if ((pzShell = getenv("SHELL")), - pzShell == NULL) + else if ((shell_prog = getenv("SHELL")), + shell_prog == NULL) - pzShell = POSIX_SHELL; + shell_prog = POSIX_SHELL; /* * Check for a specified output file */ if (HAVE_GENSHELL_OPT(SCRIPT)) - openOutput(GENSHELL_OPT_ARG(SCRIPT)); + open_out(GENSHELL_OPT_ARG(SCRIPT)); - emitUsage(pOpts); - emitSetup(pOpts); + emit_usage(pOpts); + emit_setup(pOpts); /* * There are four modes of option processing. */ switch (pOpts->fOptSet & (OPTPROC_LONGOPT|OPTPROC_SHORTOPT)) { case OPTPROC_LONGOPT: - fputs(zLoopCase, stdout); + fputs(LOOP_STR, stdout); - fputs(zLongSelection, stdout); - fputs(zLongOptInit, stdout); + fputs(LONG_OPT_MARK, stdout); + fputs(INIT_LOPT_STR, stdout); emitLong(pOpts); - printf(zLongOptArg, pOpts->pzPROGNAME); - fputs(zEndSelection, stdout); + printf(LOPT_ARG_FMT, pOpts->pzPROGNAME); + fputs(END_OPT_SEL_STR, stdout); - fputs(zNoSelection, stdout); + fputs(NOT_FOUND_STR, stdout); break; case 0: - fputs(zLoopOnly, stdout); - fputs(zLongOptInit, stdout); + fputs(ONLY_OPTS_LOOP, stdout); + fputs(INIT_LOPT_STR, stdout); emitLong(pOpts); - printf(zLongOptArg, pOpts->pzPROGNAME); + printf(LOPT_ARG_FMT, pOpts->pzPROGNAME); break; case OPTPROC_SHORTOPT: - fputs(zLoopCase, stdout); + fputs(LOOP_STR, stdout); - fputs(zFlagSelection, stdout); - fputs(zFlagOptInit, stdout); - emitFlag(pOpts); - printf(zFlagOptArg, pOpts->pzPROGNAME); - fputs(zEndSelection, stdout); + fputs(FLAG_OPT_MARK, stdout); + fputs(INIT_OPT_STR, stdout); + emit_flag(pOpts); + printf(OPT_ARG_FMT, pOpts->pzPROGNAME); + fputs(END_OPT_SEL_STR, stdout); - fputs(zNoSelection, stdout); + fputs(NOT_FOUND_STR, stdout); break; case OPTPROC_LONGOPT|OPTPROC_SHORTOPT: - fputs(zLoopCase, stdout); + fputs(LOOP_STR, stdout); - fputs(zLongSelection, stdout); - fputs(zLongOptInit, stdout); + fputs(LONG_OPT_MARK, stdout); + fputs(INIT_LOPT_STR, stdout); emitLong(pOpts); - printf(zLongOptArg, pOpts->pzPROGNAME); - fputs(zEndSelection, stdout); + printf(LOPT_ARG_FMT, pOpts->pzPROGNAME); + fputs(END_OPT_SEL_STR, stdout); - fputs(zFlagSelection, stdout); - fputs(zFlagOptInit, stdout); - emitFlag(pOpts); - printf(zFlagOptArg, pOpts->pzPROGNAME); - fputs(zEndSelection, stdout); + fputs(FLAG_OPT_MARK, stdout); + fputs(INIT_OPT_STR, stdout); + emit_flag(pOpts); + printf(OPT_ARG_FMT, pOpts->pzPROGNAME); + fputs(END_OPT_SEL_STR, stdout); - fputs(zNoSelection, stdout); + fputs(NOT_FOUND_STR, stdout); break; } - printf(zLoopEnd, pOpts->pzPROGNAME, zTrailerMarker); - if ((pzTrailer != NULL) && (*pzTrailer != '\0')) - fputs(pzTrailer, stdout); + printf(zLoopEnd, pOpts->pzPROGNAME, END_MARK); + if ((script_trailer != NULL) && (*script_trailer != NUL)) + fputs(script_trailer, stdout); else if (ENABLED_GENSHELL_OPT(SHELL)) - printf("\nenv | grep '^%s_'\n", pOpts->pzPROGNAME); + printf(SHOW_PROG_ENV, pOpts->pzPROGNAME); fflush(stdout); -#ifdef HAVE_FCHMOD fchmod(STDOUT_FILENO, 0755); -#endif fclose(stdout); if (ferror(stdout)) { fputs(zOutputFail, stderr); @@ -488,7 +179,7 @@ emit_var_text(char const * prog, char const * var, int fdin) FILE * fp = fdopen(fdin, "r" FOPEN_BINARY_FLAG); int nlct = 0; /* defer newlines and skip trailing ones */ - printf("%s_%s_TEXT='", prog, var); + printf(SET_TEXT_FMT, prog, var); if (fp == NULL) goto skip_text; @@ -496,16 +187,16 @@ emit_var_text(char const * prog, char const * var, int fdin) int ch = fgetc(fp); switch (ch) { - case '\n': + case NL: nlct++; break; case '\'': while (nlct > 0) { - fputc('\n', stdout); + fputc(NL, stdout); nlct--; } - fputs("'\\''", stdout); + fputs(apostrophy, stdout); break; case EOF: @@ -513,7 +204,7 @@ emit_var_text(char const * prog, char const * var, int fdin) default: while (nlct > 0) { - fputc('\n', stdout); + fputc(NL, stdout); nlct--; } fputc(ch, stdout); @@ -525,7 +216,7 @@ emit_var_text(char const * prog, char const * var, int fdin) skip_text: - fputs("'\n\n", stdout); + fputs(END_SET_TEXT, stdout); } #endif @@ -538,7 +229,7 @@ skip_text: * capture the output in the parent process. */ static void -textToVariable(tOptions * pOpts, teTextTo whichVar, tOptDesc * pOD) +text_to_var(tOptions * pOpts, teTextTo whichVar, tOptDesc * pOD) { # define _TT_(n) static char const z ## n [] = #n; TEXTTO_TABLE @@ -548,8 +239,7 @@ textToVariable(tOptions * pOpts, teTextTo whichVar, tOptDesc * pOD) # undef _TT_ #if ! defined(HAVE_WORKING_FORK) - printf("%1$s_%2$s_TEXT='no %2$s text'\n", - pOpts->pzPROGNAME, apzTTNames[ whichVar ]); + printf(SET_NO_TEXT_FMT, pOpts->pzPROGNAME, apzTTNames[ whichVar]); #else int pipeFd[2]; @@ -608,7 +298,7 @@ textToVariable(tOptions * pOpts, teTextTo whichVar, tOptDesc * pOD) static void -emitUsage(tOptions* pOpts) +emit_usage(tOptions * pOpts) { char zTimeBuf[AO_NAME_SIZE]; @@ -618,30 +308,29 @@ emitUsage(tOptions* pOpts) * by the definitions (rather than the current * executable name). Down case the upper cased name. */ - if (pzLeader != NULL) - fputs(pzLeader, stdout); + if (script_leader != NULL) + fputs(script_leader, stdout); { - tSCC zStdout[] = "stdout"; - tCC* pzOutName; + char const * out_nm; { - time_t curTime = time(NULL); - struct tm* pTime = localtime(&curTime); - strftime(zTimeBuf, AO_NAME_SIZE, "%A %B %e, %Y at %r %Z", pTime ); + time_t c_tim = time(NULL); + struct tm * ptm = localtime(&c_tim); + strftime(zTimeBuf, AO_NAME_SIZE, TIME_FMT, ptm ); } if (HAVE_GENSHELL_OPT(SCRIPT)) - pzOutName = GENSHELL_OPT_ARG(SCRIPT); - else pzOutName = zStdout; + out_nm = GENSHELL_OPT_ARG(SCRIPT); + else out_nm = STDOUT; - if ((pzLeader == NULL) && (pzShell != NULL)) - printf("#! %s\n", pzShell); + if ((script_leader == NULL) && (shell_prog != NULL)) + printf(SHELL_MAGIC, shell_prog); - printf(zPreamble, zStartMarker, pzOutName, zTimeBuf); + printf(PREAMBLE_FMT, START_MARK, out_nm, zTimeBuf); } - printf(zEndPreamble, pOpts->pzPROGNAME); + printf(END_PRE_FMT, pOpts->pzPROGNAME); /* * Get a copy of the original program name in lower case and @@ -653,7 +342,7 @@ emitUsage(tOptions* pOpts) char ** pp; for (;;) { - if ((*pzPN++ = tolower(*pz++)) == '\0') + if ((*pzPN++ = (char)tolower(*pz++)) == NUL) break; } @@ -663,8 +352,8 @@ emitUsage(tOptions* pOpts) *pp = zTimeBuf; } - textToVariable(pOpts, TT_LONGUSAGE, NULL); - textToVariable(pOpts, TT_USAGE, NULL); + text_to_var(pOpts, TT_LONGUSAGE, NULL); + text_to_var(pOpts, TT_USAGE, NULL); { tOptDesc* pOptDesc = pOpts->pOptDesc; @@ -672,7 +361,7 @@ emitUsage(tOptions* pOpts) for (;;) { if (pOptDesc->pOptProc == optionPrintVersion) { - textToVariable(pOpts, TT_VERSION, pOptDesc); + text_to_var(pOpts, TT_VERSION, pOptDesc); break; } @@ -685,15 +374,15 @@ emitUsage(tOptions* pOpts) static void -emitSetup(tOptions* pOpts) +emit_setup(tOptions * pOpts) { - tOptDesc* pOptDesc = pOpts->pOptDesc; - int optionCt = pOpts->presetOptCt; - char const* pzFmt; - char const* pzDefault; + tOptDesc * pOptDesc = pOpts->pOptDesc; + int optionCt = pOpts->presetOptCt; + char const * pzFmt; + char const * pzDefault; for (;optionCt > 0; pOptDesc++, --optionCt) { - char zVal[16]; + char zVal[32]; /* * Options that are either usage documentation or are compiled out @@ -703,8 +392,8 @@ emitSetup(tOptions* pOpts) continue; if (pOptDesc->optMaxCt > 1) - pzFmt = zMultiDef; - else pzFmt = zSingleDef; + pzFmt = MULTI_DEF_FMT; + else pzFmt = SGL_DEF_FMT; /* * IF this is an enumeration/bitmask option, then convert the value @@ -732,13 +421,13 @@ emitSetup(tOptions* pOpts) break; case OPARG_TYPE_BOOLEAN: - pzDefault = (pOptDesc->optArg.argBool) ? "true" : "false"; + pzDefault = (pOptDesc->optArg.argBool) ? TRUE_STR : FALSE_STR; break; default: if (pOptDesc->optArg.argString == NULL) { - if (pzFmt == zSingleDef) - pzFmt = zSingleNoDef; + if (pzFmt == SGL_DEF_FMT) + pzFmt = SGL_NO_DEF_FMT; pzDefault = NULL; } else @@ -749,38 +438,36 @@ emitSetup(tOptions* pOpts) } } - static void -printOptionAction(tOptions* pOpts, tOptDesc* pOptDesc) +emit_action(tOptions * pOpts, tOptDesc* pOptDesc) { if (pOptDesc->pOptProc == optionPrintVersion) - printf(zTextExit, pOpts->pzPROGNAME, "VERSION"); + printf(zTextExit, pOpts->pzPROGNAME, VER_STR); else if (pOptDesc->pOptProc == optionPagedUsage) printf(zPagedUsageExit, pOpts->pzPROGNAME); else if (pOptDesc->pOptProc == optionLoadOpt) { - printf(zCmdFmt, "echo 'Warning: Cannot load options files' >&2"); - printf(zCmdFmt, "OPT_ARG_NEEDED=YES"); + printf(zCmdFmt, NO_LOAD_WARN); + printf(zCmdFmt, YES_NEED_OPT_ARG); } else if (pOptDesc->pz_NAME == NULL) { if (pOptDesc->pOptProc == NULL) { - printf(zCmdFmt, "echo 'Warning: Cannot save options files' " - ">&2"); - printf(zCmdFmt, "OPT_ARG_NEEDED=OK"); + printf(zCmdFmt, NO_SAVE_OPTS); + printf(zCmdFmt, OK_NEED_OPT_ARG); } else - printf(zTextExit, pOpts->pzPROGNAME, "LONGUSAGE"); + printf(zTextExit, pOpts->pzPROGNAME, LONG_USE_STR); } else { if (pOptDesc->optMaxCt == 1) - printf(zSingleArg, pOpts->pzPROGNAME, pOptDesc->pz_NAME); + printf(SGL_ARG_FMT, pOpts->pzPROGNAME, pOptDesc->pz_NAME); else { if ((unsigned)pOptDesc->optMaxCt < NOLIMIT) printf(zCountTest, pOpts->pzPROGNAME, pOptDesc->pz_NAME, pOptDesc->optMaxCt); - printf(zMultiArg, pOpts->pzPROGNAME, pOptDesc->pz_NAME); + printf(MULTI_ARG_FMT, pOpts->pzPROGNAME, pOptDesc->pz_NAME); } /* @@ -801,26 +488,25 @@ printOptionAction(tOptions* pOpts, tOptDesc* pOptDesc) static void -printOptionInaction(tOptions* pOpts, tOptDesc* pOptDesc) +emit_inaction(tOptions * pOpts, tOptDesc* pOptDesc) { if (pOptDesc->pOptProc == optionLoadOpt) { - printf(zCmdFmt, "echo 'Warning: Cannot suppress the loading of " - "options files' >&2"); + printf(zCmdFmt, NO_SUPPRESS_LOAD); } else if (pOptDesc->optMaxCt == 1) - printf(zNoSingleArg, pOpts->pzPROGNAME, + printf(NO_SGL_ARG_FMT, pOpts->pzPROGNAME, pOptDesc->pz_NAME, pOptDesc->pz_DisablePfx); else - printf(zNoMultiArg, pOpts->pzPROGNAME, + printf(NO_MULTI_ARG_FMT, pOpts->pzPROGNAME, pOptDesc->pz_NAME, pOptDesc->pz_DisablePfx); - printf(zCmdFmt, "OPT_ARG_NEEDED=NO"); + printf(zCmdFmt, NO_ARG_NEEDED); fputs(zOptionEndSelect, stdout); } static void -emitFlag(tOptions* pOpts) +emit_flag(tOptions * pOpts) { tOptDesc* pOptDesc = pOpts->pOptDesc; int optionCt = pOpts->optCt; @@ -834,10 +520,10 @@ emitFlag(tOptions* pOpts) if (IS_GRAPHIC_CHAR(pOptDesc->optValue)) { printf(zOptionFlag, pOptDesc->optValue); - printOptionAction(pOpts, pOptDesc); + emit_action(pOpts, pOptDesc); } } - printf(zOptionUnknown, "flag", pOpts->pzPROGNAME); + printf(UNK_OPT_FMT, FLAG_STR, pOpts->pzPROGNAME); } @@ -845,7 +531,7 @@ emitFlag(tOptions* pOpts) * Emit the match text for a long option */ static void -emitMatchExpr(tCC* pzMatchName, tOptDesc* pCurOpt, tOptions* pOpts) +emit_match_expr(char const * pzMatchName, tOptDesc* pCurOpt, tOptions* pOpts) { tOptDesc* pOD = pOpts->pOptDesc; int oCt = pOpts->optCt; @@ -925,7 +611,7 @@ emitMatchExpr(tCC* pzMatchName, tOptDesc* pCurOpt, tOptions* pOpts) * Emit GNU-standard long option handling code */ static void -emitLong(tOptions* pOpts) +emitLong(tOptions * pOpts) { tOptDesc* pOD = pOpts->pOptDesc; int ct = pOpts->optCt; @@ -942,24 +628,24 @@ emitLong(tOptions* pOpts) if (SKIP_OPT(pOD)) continue; - emitMatchExpr(pOD->pz_Name, pOD, pOpts); - printOptionAction(pOpts, pOD); + emit_match_expr(pOD->pz_Name, pOD, pOpts); + emit_action(pOpts, pOD); /* * Now, do the same thing for the disablement version of the option. */ if (pOD->pz_DisableName != NULL) { - emitMatchExpr(pOD->pz_DisableName, pOD, pOpts); - printOptionInaction(pOpts, pOD); + emit_match_expr(pOD->pz_DisableName, pOD, pOpts); + emit_inaction(pOpts, pOD); } } while (pOD++, --ct > 0); - printf(zOptionUnknown, "option", pOpts->pzPROGNAME); + printf(UNK_OPT_FMT, OPTION_STR, pOpts->pzPROGNAME); } static void -openOutput(char const* pzFile) +open_out(char const * pzFile) { FILE* fp; char* pzData = NULL; @@ -985,7 +671,7 @@ openOutput(char const* pzFile) exit(EXIT_FAILURE); } - pzData = AGALOC(stbf.st_size + 1, "file data"); + pzData = AGALOC(stbf.st_size + 1, "f data"); fp = fopen(pzFile, "r" FOPEN_BINARY_FLAG); sizeLeft = (unsigned)stbf.st_size; @@ -1009,18 +695,18 @@ openOutput(char const* pzFile) /* * NUL-terminate the leader and look for the trailer */ - *pzScan = '\0'; + *pzScan = NUL; fclose(fp); - pzScan = strstr(pzData, zStartMarker); + pzScan = strstr(pzData, START_MARK); if (pzScan == NULL) { - pzTrailer = pzData; + script_trailer = pzData; break; } *(pzScan++) = NUL; - pzScan = strstr(pzScan, zTrailerMarker); + pzScan = strstr(pzScan, END_MARK); if (pzScan == NULL) { - pzTrailer = pzData; + script_trailer = pzData; break; } @@ -1028,8 +714,8 @@ openOutput(char const* pzFile) * Check to see if the data contains our marker. * If it does, then we will skip over it */ - pzTrailer = pzScan + sizeof(zTrailerMarker) - 1; - pzLeader = pzData; + script_trailer = pzScan + END_MARK_LEN; + script_leader = pzData; } while (AG_FALSE); if (freopen(pzFile, "w" FOPEN_BINARY_FLAG, stdout) != stdout) { @@ -1100,7 +786,7 @@ genshelloptUsage(tOptions * pOpts, int exitCode) { char * pz; char ** pp = (char **)(void *)&(optionParseShellOptions->pzProgName); - AGDUPSTR(pz, optionParseShellOptions->pzPROGNAME, "program name"); + AGDUPSTR(pz, optionParseShellOptions->pzPROGNAME, "prog name"); *pp = pz; while (*pz != NUL) { *pz = tolower(*pz); diff --git a/src/libopts/nested.c b/src/libopts/nested.c index f9f7e7ae7b..b7f15866e1 100644 --- a/src/libopts/nested.c +++ b/src/libopts/nested.c @@ -2,13 +2,13 @@ /** * \file nested.c * - * Time-stamp: "2010-08-22 11:17:56 bkorb" + * Time-stamp: "2012-01-29 07:00:04 bkorb" * * Automated Options Nested Values module. * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -41,6 +41,10 @@ static xml_xlate_t const xml_xlate[] = { { '\'',5, "apos;" } }; +#ifndef ENOMSG +#define ENOMSG ENOENT +#endif + /* = = = START-STATIC-FORWARD = = = */ static void remove_continuation(char* pzSrc); @@ -48,12 +52,12 @@ remove_continuation(char* pzSrc); static char const* scan_q_str(char const* pzTxt); -static tOptionValue* -add_string(void** pp, char const* pzName, size_t nameLen, - char const* pzValue, size_t dataLen); +static tOptionValue * +add_string(void ** pp, char const * pzName, size_t nameLen, + char const* pzValue, size_t dataLen); -static tOptionValue* -add_bool(void** pp, char const* pzName, size_t nameLen, +static tOptionValue * +add_bool(void ** pp, char const * pzName, size_t nameLen, char const* pzValue, size_t dataLen); static tOptionValue* @@ -84,8 +88,8 @@ remove_continuation(char* pzSrc) char* pzD; do { - while (*pzSrc == '\n') pzSrc++; - pzD = strchr(pzSrc, '\n'); + while (*pzSrc == NL) pzSrc++; + pzD = strchr(pzSrc, NL); if (pzD == NULL) return; @@ -107,7 +111,7 @@ remove_continuation(char* pzSrc) switch (ch) { case NUL: return; case '\\': - if (*pzSrc == '\n') + if (*pzSrc == NL) --pzD; /* rewrite on next iteration */ } } @@ -153,9 +157,9 @@ scan_q_str(char const* pzTxt) /** * Associate a name with either a string or no value. */ -static tOptionValue* -add_string(void** pp, char const* pzName, size_t nameLen, - char const* pzValue, size_t dataLen) +static tOptionValue * +add_string(void ** pp, char const * pzName, size_t nameLen, + char const* pzValue, size_t dataLen) { tOptionValue* pNV; size_t sz = nameLen + dataLen + sizeof(*pNV); @@ -179,7 +183,7 @@ add_string(void** pp, char const* pzName, size_t nameLen, if (ch == NUL) goto data_copy_done; if (ch == '&') ch = get_special_char(&pzSrc, &ct); - *(pzDst++) = ch; + *(pzDst++) = (char)ch; } while (--ct > 0); data_copy_done: *pzDst = NUL; @@ -200,19 +204,23 @@ add_string(void** pp, char const* pzName, size_t nameLen, /** * Associate a name with either a string or no value. */ -static tOptionValue* -add_bool(void** pp, char const* pzName, size_t nameLen, +static tOptionValue * +add_bool(void ** pp, char const * pzName, size_t nameLen, char const* pzValue, size_t dataLen) { - tOptionValue* pNV; - size_t sz = nameLen + sizeof(*pNV) + 1; + tOptionValue * pNV; - pNV = AGALOC(sz, "option name/bool value pair"); - if (pNV == NULL) - return NULL; - while (IS_WHITESPACE_CHAR(*pzValue) && (dataLen > 0)) { - dataLen--; pzValue++; + { + size_t sz = nameLen + sizeof(tOptionValue) + 1; + pNV = AGALOC(sz, "name/bool value"); } + + { + char * p = SPN_WHITESPACE_CHARS(pzValue); + dataLen -= p - pzValue; + pzValue = p; + } + if (dataLen == 0) pNV->v.boolVal = 0; @@ -305,21 +313,24 @@ scan_name(char const* pzName, tOptionValue* pRes) * Scan over characters that name a value. These names may not end * with a colon, but they may contain colons. */ - while (IS_VALUE_NAME_CHAR(*pzScan)) { pzScan++; nameLen++; } - if (pzScan[-1] == ':') { pzScan--; nameLen--; } - while (IS_HORIZ_WHITE_CHAR(*pzScan)) pzScan++; + pzScan = SPN_VALUE_NAME_CHARS(pzName + 1); + if (pzScan[-1] == ':') + pzScan--; + nameLen = pzScan - pzName; + + pzScan = SPN_HORIZ_WHITE_CHARS(pzScan); re_switch: switch (*pzScan) { case '=': case ':': - while (IS_HORIZ_WHITE_CHAR((int)*++pzScan)) ; + pzScan = SPN_HORIZ_WHITE_CHARS(pzScan + 1); if ((*pzScan == '=') || (*pzScan == ':')) goto default_char; goto re_switch; - case '\n': + case NL: case ',': pzScan++; /* FALLTHROUGH */ @@ -334,7 +345,7 @@ scan_name(char const* pzName, tOptionValue* pRes) pzScan = scan_q_str(pzScan); dataLen = pzScan - pzVal; pNV = add_string(&(pRes->v.nestVal), pzName, nameLen, pzVal, - dataLen); + dataLen); if ((pNV != NULL) && (option_load_mode == OPTION_LOAD_COOKED)) ao_string_cook(pNV->v.strVal, NULL); break; @@ -355,7 +366,7 @@ scan_name(char const* pzName, tOptionValue* pRes) goto string_done; /* FALLTHROUGH */ - case '\n': + case NL: if ( (pzScan > pzVal + 2) && (pzScan[-2] == '\\') && (pzScan[ 0] != NUL)) @@ -611,7 +622,7 @@ sort_list(tArgList* pAL) } } -/* optionLoadNested +/*= * private: * * what: parse a hierarchical option argument @@ -626,7 +637,17 @@ sort_list(tArgList* pAL) * A block of text represents a series of values. It may be an * entire configuration file, or it may be an argument to an * option that takes a hierarchical value. - */ + * + * If NULL is returned, errno will be set: + * @itemize @bullet + * @item + * @code{EINVAL} the input text was NULL. + * @item + * @code{ENOMEM} the storage structures could not be allocated + * @item + * @code{ENOMSG} no configuration values were found + * @end itemize +=*/ LOCAL tOptionValue* optionLoadNested(char const* pzTxt, char const* pzName, size_t nameLen) { @@ -639,9 +660,9 @@ optionLoadNested(char const* pzTxt, char const* pzName, size_t nameLen) errno = EINVAL; return NULL; } - while (IS_WHITESPACE_CHAR(*pzTxt)) pzTxt++; + pzTxt = SPN_WHITESPACE_CHARS(pzTxt); if (*pzTxt == NUL) { - errno = ENOENT; + errno = ENOMSG; return NULL; } pRes = AGALOC(sizeof(*pRes) + nameLen + 1, "nested args"); @@ -670,23 +691,27 @@ optionLoadNested(char const* pzTxt, char const* pzName, size_t nameLen) * Scan until we hit a NUL. */ do { - while (IS_WHITESPACE_CHAR((int)*pzTxt)) pzTxt++; - if (IS_VAR_FIRST_CHAR((int)*pzTxt)) { + pzTxt = SPN_WHITESPACE_CHARS(pzTxt); + if (IS_VAR_FIRST_CHAR(*pzTxt)) pzTxt = scan_name(pzTxt, pRes); - } + else switch (*pzTxt) { case NUL: goto scan_done; case '<': pzTxt = scan_xml(pzTxt, pRes); if (pzTxt == NULL) goto woops; if (*pzTxt == ',') pzTxt++; break; - case '#': pzTxt = strchr(pzTxt, '\n'); break; + case '#': pzTxt = strchr(pzTxt, NL); break; default: goto woops; } } while (pzTxt != NULL); scan_done:; { tArgList * al = pRes->v.nestVal; - if (al->useCt != 0) + if (al->useCt == 0) { + errno = ENOMSG; + goto woops; + } + if (al->useCt > 1) sort_list(al); } @@ -811,7 +836,7 @@ emit_special_char(FILE * fp, int ch) break; xlatp++; } - fprintf(fp, "#x%02X;", (ch & 0xFF)); + fprintf(fp, XML_HEX_BYTE_FMT, (ch & 0xFF)); } /* diff --git a/src/libopts/numeric.c b/src/libopts/numeric.c index ff6b2a50f2..c6e6ba7007 100644 --- a/src/libopts/numeric.c +++ b/src/libopts/numeric.c @@ -2,11 +2,11 @@ /** * \file numeric.c * - * Time-stamp: "2011-03-25 16:26:10 bkorb" + * Time-stamp: "2012-01-29 19:10:40 bkorb" * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -38,15 +38,11 @@ * Show information about a numeric option with range constraints. =*/ void -optionShowRange(tOptions* pOpts, tOptDesc* pOD, void * rng_table, int rng_ct) +optionShowRange(tOptions * pOpts, tOptDesc * pOD, void * rng_table, int rng_ct) { - static char const bullet[] = "\t\t\t\t- "; - static char const deepin[] = "\t\t\t\t "; - static char const onetab[] = "\t"; - const struct {long const rmin, rmax;} * rng = rng_table; - char const * pz_indent = bullet; + char const * pz_indent = BULLET_STR; /* * The range is shown only for full usage requests and an error @@ -55,7 +51,7 @@ optionShowRange(tOptions* pOpts, tOptDesc* pOD, void * rng_table, int rng_ct) if (pOpts != OPTPROC_EMIT_USAGE) { if (pOpts <= OPTPROC_EMIT_LIMIT) return; - pz_indent = onetab; + pz_indent = ONE_TAB_STR; fprintf(option_usage_fp, zRangeErr, pOpts->pzProgName, pOD->pz_Name, pOD->optArg.argString); @@ -66,7 +62,7 @@ optionShowRange(tOptions* pOpts, tOptDesc* pOD, void * rng_table, int rng_ct) fprintf(option_usage_fp, zRangeScaled, pz_indent); fprintf(option_usage_fp, (rng_ct > 1) ? zRangeLie : zRangeOnly, pz_indent); - pz_indent = (pOpts != OPTPROC_EMIT_USAGE) ? onetab : deepin; + pz_indent = (pOpts != OPTPROC_EMIT_USAGE) ? ONE_TAB_STR : DEEP_INDENT_STR; for (;;) { if (rng->rmax == LONG_MIN) @@ -80,7 +76,7 @@ optionShowRange(tOptions* pOpts, tOptDesc* pOD, void * rng_table, int rng_ct) rng->rmax); if (--rng_ct <= 0) { - fputc('\n', option_usage_fp); + fputc(NL, option_usage_fp); break; } fputs(zRangeOr, option_usage_fp); @@ -125,7 +121,7 @@ optionNumericVal(tOptions* pOpts, tOptDesc* pOD ) if ((pOD->fOptState & OPTST_SCALED_NUM) != 0) switch (*(pz++)) { - case '\0': pz--; break; + case NUL: pz--; break; case 't': val *= 1000; case 'g': val *= 1000; case 'm': val *= 1000; diff --git a/src/libopts/parse-duration.c b/src/libopts/parse-duration.c index 0a8c4ada84..e49060aec3 100644 --- a/src/libopts/parse-duration.c +++ b/src/libopts/parse-duration.c @@ -1,5 +1,5 @@ /* Parse a time duration and return a seconds count - Copyright (C) 2008-2011 Free Software Foundation, Inc. + Copyright (C) 2008-2012 Free Software Foundation, Inc. Written by Bruce Korb <bkorb@gnu.org>, 2008. This program is free software: you can redistribute it and/or modify diff --git a/src/libopts/parse-duration.h b/src/libopts/parse-duration.h index 9fd2a364cd..caefb759b4 100644 --- a/src/libopts/parse-duration.h +++ b/src/libopts/parse-duration.h @@ -1,5 +1,5 @@ /* Parse a time duration and return a seconds count - Copyright (C) 2008-2011 Free Software Foundation, Inc. + Copyright (C) 2008-2012 Free Software Foundation, Inc. Written by Bruce Korb <bkorb@gnu.org>, 2008. This program is free software: you can redistribute it and/or modify @@ -31,7 +31,7 @@ the string may contain: NNN Y NNN M NNN W NNN d NNN h NNN m NNN s This represents NNN years, NNN months, NNN weeks, NNN days, NNN hours, NNN minutes and NNN seconds. - The embeded white space is optional. + The embedded white space is optional. These terms must appear in this order. Case is significant: 'M' is months and 'm' is minutes. The final "s" is optional. diff --git a/src/libopts/pgusage.c b/src/libopts/pgusage.c index 2e2194867e..4dbbd53be1 100644 --- a/src/libopts/pgusage.c +++ b/src/libopts/pgusage.c @@ -2,7 +2,7 @@ /** * \file pgusage.c * - * Time-stamp: "2011-03-25 17:54:41 bkorb" + * Time-stamp: "2012-01-29 16:09:14 bkorb" * * Automated Options Paged Usage module. * @@ -11,7 +11,7 @@ * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -67,9 +67,9 @@ optionPagedUsage(tOptions* pOptions, tOptDesc* pOD) my_pid = getpid(); #ifdef HAVE_SNPRINTF - snprintf(zPageUsage, sizeof(zPageUsage), "/tmp/use.%lu", (tAoUL)my_pid); + snprintf(zPageUsage, sizeof(zPageUsage), TMP_USAGE_FMT, (tAoUL)my_pid); #else - sprintf(zPageUsage, "/tmp/use.%lu", (tAoUL)my_pid); + sprintf(zPageUsage, TMP_USAGE_FMT, (tAoUL)my_pid); #endif unlink(zPageUsage); @@ -99,22 +99,21 @@ optionPagedUsage(tOptions* pOptions, tOptDesc* pOD) case PAGER_STATE_READY: { - tSCC zPage[] = "%1$s /tmp/use.%2$lu ; rm -f /tmp/use.%2$lu"; - tCC* pzPager = (tCC*)getenv("PAGER"); + tCC* pzPager = (tCC*)getenv(PAGER_NAME); /* * Use the "more(1)" program if "PAGER" has not been defined */ if (pzPager == NULL) - pzPager = "more"; + pzPager = MORE_STR; /* * Page the file and remove it when done. */ #ifdef HAVE_SNPRINTF - snprintf(zPageUsage, sizeof(zPageUsage), zPage, pzPager, (tAoUL)my_pid); + snprintf(zPageUsage, sizeof(zPageUsage), PAGE_USAGE_FMT, pzPager, (tAoUL)my_pid); #else - sprintf(zPageUsage, zPage, pzPager, (tAoUL)my_pid); + sprintf(zPageUsage, PAGE_USAGE_FMT, pzPager, (tAoUL)my_pid); #endif fclose(stderr); dup2(STDOUT_FILENO, STDERR_FILENO); diff --git a/src/libopts/proto.h b/src/libopts/proto.h index 48746f19f6..3f77b2cfc5 100644 --- a/src/libopts/proto.h +++ b/src/libopts/proto.h @@ -1,7 +1,7 @@ /* -*- buffer-read-only: t -*- vi: set ro: * * Prototypes for autoopts - * Generated Thu Dec 29 12:02:41 PST 2011 + * Generated Fri Feb 10 19:53:45 PST 2012 */ #ifndef AUTOOPTS_PROTO_H_GUARD #define AUTOOPTS_PROTO_H_GUARD 1 diff --git a/src/libopts/putshell.c b/src/libopts/putshell.c index f15284f6b9..10d14bd9af 100644 --- a/src/libopts/putshell.c +++ b/src/libopts/putshell.c @@ -2,7 +2,7 @@ /** * \file putshell.c * - * Time-stamp: "2010-09-05 06:10:56 bkorb" + * Time-stamp: "2012-02-10 19:14:49 bkorb" * * This module will interpret the options set in the tOptions * structure and print them to standard out in a fashion that @@ -10,7 +10,7 @@ * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -28,13 +28,10 @@ * 06a1a2e4760c90ea5e1dad8dfaac4d39 pkg/libopts/COPYING.lgplv3 * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd */ -static char const zOptValFmt[] = "%s_%s="; -static char const zOptEnd[] = "\nexport %s_%s\n"; -static char const zOptNumFmt[] = "%1$s_%2$s=%3$d # 0x%3$X\nexport %1$s_%2$s\n"; /* = = = START-STATIC-FORWARD = = = */ static void -print_quot_str(tCC* pzStr); +print_quot_str(char const * pzStr); static void print_enumeration(tOptions * pOpts, tOptDesc * pOD); @@ -54,13 +51,13 @@ print_reordering(tOptions * pOpts); * been emitted and the closing quote will be upon return. */ static void -print_quot_str(tCC* pzStr) +print_quot_str(char const * pzStr) { /* * Handle empty strings to make the rest of the logic simpler. */ if ((pzStr == NULL) || (*pzStr == NUL)) { - fputs("''", stdout); + fputs(EMPTY_ARG, stdout); return; } @@ -69,7 +66,7 @@ print_quot_str(tCC* pzStr) * bail if that is all we need to do. */ while (*pzStr == '\'') { - fputs("\\'", stdout); + fputs(QUOT_APOS, stdout); pzStr++; } if (*pzStr == NUL) @@ -80,7 +77,7 @@ print_quot_str(tCC* pzStr) */ fputc('\'', stdout); for (;;) { - tCC* pz = strchr(pzStr, '\''); + char const * pz = strchr(pzStr, '\''); if (pz == NULL) break; @@ -114,18 +111,18 @@ static void print_enumeration(tOptions * pOpts, tOptDesc * pOD) { uintptr_t e_val = pOD->optArg.argEnum; - printf(zOptValFmt, pOpts->pzPROGNAME, pOD->pz_NAME); + printf(OPT_VAL_FMT, pOpts->pzPROGNAME, pOD->pz_NAME); /* * Convert value to string, print that and restore numeric value. */ (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD); - printf("'%s'", pOD->optArg.argString); + printf(QUOT_ARG_FMT, pOD->optArg.argString); if (pOD->fOptState & OPTST_ALLOC_ARG) AGFREE(pOD->optArg.argString); pOD->optArg.argEnum = e_val; - printf(zOptEnd, pOpts->pzPROGNAME, pOD->pz_NAME); + printf(OPT_END_FMT, pOpts->pzPROGNAME, pOD->pz_NAME); } static void @@ -155,7 +152,7 @@ print_membership(tOptions * pOpts, tOptDesc * pOD) else if (ch == NUL) { pz--; goto name_done; } else fputc('_', stdout); } name_done:; - printf("=%1$lu # 0x%1$lX\n", (unsigned long)val); + printf(SHOW_VAL_FMT, (unsigned long)val); val <<= 1; } @@ -167,8 +164,6 @@ print_membership(tOptions * pOpts, tOptDesc * pOD) static void print_stacked_arg(tOptions * pOpts, tOptDesc * pOD) { - tSCC zOptCookieCt[] = "%1$s_%2$s_CT=%3$d\nexport %1$s_%2$s_CT\n"; - tArgList* pAL = (tArgList*)pOD->optCookie; tCC** ppz = pAL->apzArgs; int ct = pAL->useCt; @@ -176,13 +171,10 @@ print_stacked_arg(tOptions * pOpts, tOptDesc * pOD) printf(zOptCookieCt, pOpts->pzPROGNAME, pOD->pz_NAME, ct); while (--ct >= 0) { - tSCC numarg_z[] = "%s_%s_%d="; - tSCC end_z[] = "\nexport %s_%s_%d\n"; - - printf(numarg_z, pOpts->pzPROGNAME, pOD->pz_NAME, + printf(ARG_BY_NUM_FMT, pOpts->pzPROGNAME, pOD->pz_NAME, pAL->useCt - ct); print_quot_str(*(ppz++)); - printf(end_z, pOpts->pzPROGNAME, pOD->pz_NAME, + printf(EXPORT_ARG_FMT, pOpts->pzPROGNAME, pOD->pz_NAME, pAL->useCt - ct); } } @@ -192,21 +184,21 @@ print_reordering(tOptions * pOpts) { int optIx; - fputs("set --", stdout); + fputs(set_dash, stdout); for (optIx = pOpts->curOptIdx; optIx < pOpts->origArgCt; optIx++) { char* pzArg = pOpts->origArgVect[ optIx ]; if (strchr(pzArg, '\'') == NULL) - printf(" '%s'", pzArg); + printf(arg_fmt, pzArg); else { fputs(" '", stdout); for (;;) { char ch = *(pzArg++); switch (ch) { - case '\'': fputs("'\\''", stdout); break; + case '\'': fputs(apostrophy, stdout); break; case NUL: goto arg_done; default: fputc(ch, stdout); break; } @@ -214,7 +206,7 @@ print_reordering(tOptions * pOpts) fputc('\'', stdout); } } - fputs("\nOPTION_CT=0\n", stdout); + fputs(init_optct, stdout); } /*=export_func optionPutShell @@ -228,17 +220,13 @@ void optionPutShell(tOptions* pOpts) { int optIx = 0; - tSCC zOptCtFmt[] = "OPTION_CT=%d\nexport OPTION_CT\n"; - tSCC zOptDisabl[] = "%1$s_%2$s=%3$s\nexport %1$s_%2$s\n"; - tSCC zFullOptFmt[]= "%1$s_%2$s='%3$s'\nexport %1$s_%2$s\n"; - tSCC zEquivMode[] = "%1$s_%2$s_MODE='%3$s'\nexport %1$s_%2$s_MODE\n"; printf(zOptCtFmt, pOpts->curOptIdx-1); do { tOptDesc* pOD = pOpts->pOptDesc + optIx; - if (SKIP_OPT(pOD)) + if ((pOD->fOptState & OPTST_NO_OUTPUT_MASK) != 0) continue; /* @@ -281,9 +269,8 @@ optionPutShell(tOptions* pOpts) * The idea is that if someone defines an option to initialize * enabled, we should tell our shell script that it is enabled. */ - if (UNUSED_OPT(pOD) && DISABLED_OPT(pOD)) { + if (UNUSED_OPT(pOD) && DISABLED_OPT(pOD)) continue; - } /* * Handle stacked arguments @@ -350,9 +337,9 @@ optionPutShell(tOptions* pOpts) /* * This option has a text value */ - printf(zOptValFmt, pOpts->pzPROGNAME, pOD->pz_NAME); + printf(OPT_VAL_FMT, pOpts->pzPROGNAME, pOD->pz_NAME); print_quot_str(pOD->optArg.argString); - printf(zOptEnd, pOpts->pzPROGNAME, pOD->pz_NAME); + printf(OPT_END_FMT, pOpts->pzPROGNAME, pOD->pz_NAME); } while (++optIx < pOpts->presetOptCt ); diff --git a/src/libopts/reset.c b/src/libopts/reset.c index 59850fe76f..2345d51e3c 100644 --- a/src/libopts/reset.c +++ b/src/libopts/reset.c @@ -6,7 +6,7 @@ * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control diff --git a/src/libopts/restore.c b/src/libopts/restore.c index f55f3d2499..4fd76f88e1 100644 --- a/src/libopts/restore.c +++ b/src/libopts/restore.c @@ -10,7 +10,7 @@ * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control diff --git a/src/libopts/save.c b/src/libopts/save.c index 9c36bc83fd..a1357ffece 100644 --- a/src/libopts/save.c +++ b/src/libopts/save.c @@ -2,7 +2,7 @@ /* * \file save.c * - * Time-stamp: "2011-04-06 09:21:44 bkorb" + * Time-stamp: "2012-01-29 19:30:39 bkorb" * * This module's routines will take the currently set options and * store them into an ".rc" file for re-interpretation the next @@ -10,7 +10,7 @@ * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -29,57 +29,51 @@ * 66a5cedaf62c4b2637025f049f9b826f pkg/libopts/COPYING.mbsd */ -static char const zWarn[] = "%s WARNING: cannot save options - "; -static char const close_xml[] = "</%s>\n"; - /* = = = START-STATIC-FORWARD = = = */ -static tCC* -findDirName(tOptions* pOpts, int* p_free); +static char const * +find_dir_name(tOptions * pOpts, int * p_free); static char const * -findFileName(tOptions * pOpts, int * p_free_name); +find_file_name(tOptions * pOpts, int * p_free_name); static void -printEntry( - FILE * fp, - tOptDesc * p, - tCC* pzLA ); +prt_entry(FILE * fp, tOptDesc * p, char const * pzLA); static void -print_a_value(FILE * fp, int depth, tOptDesc * pOD, tOptionValue const * ovp); +prt_value(FILE * fp, int depth, tOptDesc * pOD, tOptionValue const * ovp); static void -print_a_string(FILE * fp, char const * name, char const * pz); +prt_string(FILE * fp, char const * name, char const * pz); static void -printValueList(FILE * fp, char const * name, tArgList * al); +prt_val_list(FILE * fp, char const * name, tArgList * al); static void -printHierarchy(FILE * fp, tOptDesc * p); +prt_nested(FILE * fp, tOptDesc * p); static FILE * -openSaveFile(tOptions* pOpts); +open_sv_file(tOptions* pOpts); static void -printNoArgOpt(FILE * fp, tOptDesc * p, tOptDesc * pOD); +prt_no_arg_opt(FILE * fp, tOptDesc * p, tOptDesc * pOD); static void -printStringArg(FILE * fp, tOptDesc * pOD); +prt_str_arg(FILE * fp, tOptDesc * pOD); static void -printEnumArg(FILE * fp, tOptDesc * pOD); +prt_enum_arg(FILE * fp, tOptDesc * pOD); static void -printSetMemberArg(FILE * fp, tOptDesc * pOD); +prt_set_arg(FILE * fp, tOptDesc * pOD); static void -printFileArg(FILE * fp, tOptDesc * pOD, tOptions* pOpts); +prt_file_arg(FILE * fp, tOptDesc * pOD, tOptions* pOpts); /* = = = END-STATIC-FORWARD = = = */ -static tCC* -findDirName(tOptions* pOpts, int* p_free) +static char const * +find_dir_name(tOptions * pOpts, int * p_free) { - tCC* pzDir; + char const * pzDir; if ( (pOpts->specOptIdx.save_opts == NO_EQUIVALENT) || (pOpts->specOptIdx.save_opts == 0)) @@ -94,7 +88,7 @@ findDirName(tOptions* pOpts, int* p_free) * we can stash the RC (INI) file. */ { - tCC* const* papz = pOpts->papzHomeList; + char const * const* papz = pOpts->papzHomeList; if (papz == NULL) return NULL; @@ -109,9 +103,9 @@ findDirName(tOptions* pOpts, int* p_free) return pzDir; { - tCC* pzEndDir = strchr(++pzDir, DIRCH); - char* pzFileName; - char* pzEnv; + char const * pzEndDir = strchr(++pzDir, DIRCH); + char * pzFileName; + char * pzEnv; if (pzEndDir != NULL) { char z[ AO_NAME_SIZE ]; @@ -130,7 +124,7 @@ findDirName(tOptions* pOpts, int* p_free) } if (pzEnv == NULL) { - fprintf(stderr, zWarn, pOpts->pzProgName); + fprintf(stderr, SAVE_WARN, pOpts->pzProgName); fprintf(stderr, zNotDef, pzDir); return NULL; } @@ -158,12 +152,12 @@ findDirName(tOptions* pOpts, int* p_free) static char const * -findFileName(tOptions * pOpts, int * p_free_name) +find_file_name(tOptions * pOpts, int * p_free_name) { struct stat stBuf; int free_dir_name = 0; - char const * pzDir = findDirName(pOpts, &free_dir_name); + char const * pzDir = find_dir_name(pOpts, &free_dir_name); if (pzDir == NULL) return NULL; @@ -181,7 +175,7 @@ findFileName(tOptions * pOpts, int * p_free_name) */ if (errno != ENOENT) { bogus_name: - fprintf(stderr, zWarn, pOpts->pzProgName); + fprintf(stderr, SAVE_WARN, pOpts->pzProgName); fprintf(stderr, zNoStat, errno, strerror(errno), pzDir); if (free_dir_name) AGFREE((void*)pzDir); @@ -217,7 +211,7 @@ findFileName(tOptions * pOpts, int * p_free_name) size_t sz = strlen(pzDir) + strlen(pOpts->pzRcName) + 2; { - char* pzPath = (char*)AGALOC(sz, "file name"); + char * pzPath = (char*)AGALOC(sz, "file name"); #ifdef HAVE_SNPRINTF snprintf(pzPath, sz, "%s/%s", pzDir, pOpts->pzRcName); #else @@ -235,7 +229,7 @@ findFileName(tOptions * pOpts, int * p_free_name) */ if (stat(pzDir, &stBuf) != 0) { if (errno != ENOENT) { - fprintf(stderr, zWarn, pOpts->pzProgName); + fprintf(stderr, SAVE_WARN, pOpts->pzProgName); fprintf(stderr, zNoStat, errno, strerror(errno), pzDir); AGFREE((void*)pzDir); @@ -254,7 +248,7 @@ findFileName(tOptions * pOpts, int * p_free_name) * or will soon be a file. */ if (! S_ISREG(stBuf.st_mode)) { - fprintf(stderr, zWarn, pOpts->pzProgName); + fprintf(stderr, SAVE_WARN, pOpts->pzProgName); fprintf(stderr, zNotFile, pzDir); if (free_dir_name) AGFREE((void*)pzDir); @@ -271,10 +265,7 @@ findFileName(tOptions * pOpts, int * p_free_name) static void -printEntry( - FILE * fp, - tOptDesc * p, - tCC* pzLA ) +prt_entry(FILE * fp, tOptDesc * p, char const * pzLA) { /* * There is an argument. Pad the name so values line up. @@ -302,12 +293,12 @@ printEntry( * OTHERWISE, FOR each line of the value text, ... */ else if (pzLA == NULL) - fputc('\n', fp); + fputc(NL, fp); else { fputc(' ', fp); fputc(' ', fp); for (;;) { - tCC* pzNl = strchr(pzLA, '\n'); + char const * pzNl = strchr(pzLA, NL); /* * IF this is the last line @@ -328,30 +319,25 @@ printEntry( * Terminate the entry */ fputs(pzLA, fp); - fputc('\n', fp); + fputc(NL, fp); } } static void -print_a_value(FILE * fp, int depth, tOptDesc * pOD, tOptionValue const * ovp) +prt_value(FILE * fp, int depth, tOptDesc * pOD, tOptionValue const * ovp) { - static char const bool_atr[] = "<%1$s type=boolean>%2$s</%1$s>\n"; - static char const numb_atr[] = "<%1$s type=integer>0x%2$lX</%1$s>\n"; - static char const type_atr[] = "<%s type=%s>"; - static char const null_atr[] = "<%s/>\n"; - while (--depth >= 0) putc(' ', fp), putc(' ', fp); switch (ovp->valType) { default: case OPARG_TYPE_NONE: - fprintf(fp, null_atr, ovp->pzName); + fprintf(fp, NULL_ATR_FMT, ovp->pzName); break; case OPARG_TYPE_STRING: - print_a_string(fp, ovp->pzName, ovp->v.strVal); + prt_string(fp, ovp->pzName, ovp->v.strVal); break; case OPARG_TYPE_ENUMERATION: @@ -362,7 +348,7 @@ print_a_value(FILE * fp, int depth, tOptDesc * pOD, tOptionValue const * ovp) char const * typ = (ovp->valType == OPARG_TYPE_ENUMERATION) ? "keyword" : "set-membership"; - fprintf(fp, type_atr, ovp->pzName, typ); + fprintf(fp, TYPE_ATR_FMT, ovp->pzName, typ); /* * This is a magic incantation that will convert the @@ -382,33 +368,31 @@ print_a_value(FILE * fp, int depth, tOptDesc * pOD, tOptionValue const * ovp) pOD->optArg.argEnum = val; pOD->fOptState = opt_state; - fprintf(fp, close_xml, ovp->pzName); + fprintf(fp, END_XML_FMT, ovp->pzName); break; } /* FALLTHROUGH */ case OPARG_TYPE_NUMERIC: - fprintf(fp, numb_atr, ovp->pzName, ovp->v.longVal); + fprintf(fp, NUMB_ATR_FMT, ovp->pzName, ovp->v.longVal); break; case OPARG_TYPE_BOOLEAN: - fprintf(fp, bool_atr, ovp->pzName, + fprintf(fp, BOOL_ATR_FMT, ovp->pzName, ovp->v.boolVal ? "true" : "false"); break; case OPARG_TYPE_HIERARCHY: - printValueList(fp, ovp->pzName, ovp->v.nestVal); + prt_val_list(fp, ovp->pzName, ovp->v.nestVal); break; } } static void -print_a_string(FILE * fp, char const * name, char const * pz) +prt_string(FILE * fp, char const * name, char const * pz) { - static char const open_atr[] = "<%s>"; - - fprintf(fp, open_atr, name); + fprintf(fp, OPEN_XML_FMT, name); for (;;) { int ch = ((int)*(pz++)) & 0xFF; @@ -436,12 +420,12 @@ print_a_string(FILE * fp, char const * name, char const * pz) putc(ch, fp); } } string_done:; - fprintf(fp, close_xml, name); + fprintf(fp, END_XML_FMT, name); } static void -printValueList(FILE * fp, char const * name, tArgList * al) +prt_val_list(FILE * fp, char const * name, tArgList * al) { static int depth = 1; @@ -455,17 +439,17 @@ printValueList(FILE * fp, char const * name, tArgList * al) opt_list = (void **)al->apzArgs; if (opt_ct <= 0) { - fprintf(fp, "<%s/>\n", name); + fprintf(fp, OPEN_CLOSE_FMT, name); return; } - fprintf(fp, "<%s type=nested>\n", name); + fprintf(fp, NESTED_OPT_FMT, name); depth++; while (--opt_ct >= 0) { tOptionValue const * ovp = *(opt_list++); - print_a_value(fp, depth, NULL, ovp); + prt_value(fp, depth, NULL, ovp); } depth--; @@ -476,7 +460,7 @@ printValueList(FILE * fp, char const * name, tArgList * al) static void -printHierarchy(FILE * fp, tOptDesc * p) +prt_nested(FILE * fp, tOptDesc * p) { int opt_ct; tArgList * al = p->optCookie; @@ -498,10 +482,10 @@ printHierarchy(FILE * fp, tOptDesc * p) if (ovp == NULL) continue; - fprintf(fp, "<%s type=nested>\n", p->pz_Name); + fprintf(fp, NESTED_OPT_FMT, p->pz_Name); do { - print_a_value(fp, 1, p, ovp); + prt_value(fp, 1, p, ovp); } while (ovp = optionNextValue(base, ovp), ovp != NULL); @@ -512,19 +496,19 @@ printHierarchy(FILE * fp, tOptDesc * p) static FILE * -openSaveFile(tOptions* pOpts) +open_sv_file(tOptions* pOpts) { - FILE* fp; + FILE * fp; { int free_name = 0; - tCC* pzFName = findFileName(pOpts, &free_name); + char const * pzFName = find_file_name(pOpts, &free_name); if (pzFName == NULL) return NULL; fp = fopen(pzFName, "w" FOPEN_BINARY_FLAG); if (fp == NULL) { - fprintf(stderr, zWarn, pOpts->pzProgName); + fprintf(stderr, SAVE_WARN, pOpts->pzProgName); fprintf(stderr, zNoCreat, errno, strerror(errno), pzFName); if (free_name) AGFREE((void*) pzFName ); @@ -536,14 +520,14 @@ openSaveFile(tOptions* pOpts) } { - char const* pz = pOpts->pzUsageTitle; + char const * pz = pOpts->pzUsageTitle; fputs("# ", fp); - do { fputc(*pz, fp); } while (*(pz++) != '\n'); + do { fputc(*pz, fp); } while (*(pz++) != NL); } { time_t timeVal = time(NULL); - char* pzTime = ctime(&timeVal); + char * pzTime = ctime(&timeVal); fprintf(fp, zPresetFile, pzTime); #ifdef HAVE_ALLOCATED_CTIME @@ -560,7 +544,7 @@ openSaveFile(tOptions* pOpts) } static void -printNoArgOpt(FILE * fp, tOptDesc * p, tOptDesc * pOD) +prt_no_arg_opt(FILE * fp, tOptDesc * p, tOptDesc * pOD) { /* * The aliased to argument indicates whether or not the option @@ -581,12 +565,12 @@ printNoArgOpt(FILE * fp, tOptDesc * p, tOptDesc * pOD) } static void -printStringArg(FILE * fp, tOptDesc * pOD) +prt_str_arg(FILE * fp, tOptDesc * pOD) { if (pOD->fOptState & OPTST_STACKED) { - tArgList* pAL = (tArgList*)pOD->optCookie; + tArgList * pAL = (tArgList*)pOD->optCookie; int uct = pAL->useCt; - tCC** ppz = pAL->apzArgs; + char const ** ppz = pAL->apzArgs; /* * un-disable multiple copies of disabled options. @@ -595,14 +579,14 @@ printStringArg(FILE * fp, tOptDesc * pOD) pOD->fOptState &= ~OPTST_DISABLED; while (uct-- > 0) - printEntry(fp, pOD, *(ppz++)); + prt_entry(fp, pOD, *(ppz++)); } else { - printEntry(fp, pOD, pOD->optArg.argString); + prt_entry(fp, pOD, pOD->optArg.argString); } } static void -printEnumArg(FILE * fp, tOptDesc * pOD) +prt_enum_arg(FILE * fp, tOptDesc * pOD) { uintptr_t val = pOD->optArg.argEnum; @@ -611,13 +595,13 @@ printEnumArg(FILE * fp, tOptDesc * pOD) * bit flag values back into a string suitable for printing. */ (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD); - printEntry(fp, pOD, (void*)(pOD->optArg.argString)); + prt_entry(fp, pOD, (void*)(pOD->optArg.argString)); pOD->optArg.argEnum = val; } static void -printSetMemberArg(FILE * fp, tOptDesc * pOD) +prt_set_arg(FILE * fp, tOptDesc * pOD) { uintptr_t val = pOD->optArg.argEnum; @@ -626,7 +610,7 @@ printSetMemberArg(FILE * fp, tOptDesc * pOD) * bit flag values back into a string suitable for printing. */ (*(pOD->pOptProc))(OPTPROC_RETURN_VALNAME, pOD); - printEntry(fp, pOD, (void*)(pOD->optArg.argString)); + prt_entry(fp, pOD, (void*)(pOD->optArg.argString)); if (pOD->optArg.argString != NULL) { /* @@ -640,14 +624,14 @@ printSetMemberArg(FILE * fp, tOptDesc * pOD) } static void -printFileArg(FILE * fp, tOptDesc * pOD, tOptions* pOpts) +prt_file_arg(FILE * fp, tOptDesc * pOD, tOptions* pOpts) { /* * If the cookie is not NULL, then it has the file name, period. * Otherwise, if we have a non-NULL string argument, then.... */ if (pOD->optCookie != NULL) - printEntry(fp, pOD, pOD->optCookie); + prt_entry(fp, pOD, pOD->optCookie); else if (HAS_originalOptArgArray(pOpts)) { char const * orig = @@ -656,7 +640,7 @@ printFileArg(FILE * fp, tOptDesc * pOD, tOptions* pOpts) if (pOD->optArg.argString == orig) return; - printEntry(fp, pOD, pOD->optArg.argString); + prt_entry(fp, pOD, pOD->optArg.argString); } } @@ -695,7 +679,7 @@ optionSaveFile(tOptions* pOpts) { tOptDesc* pOD; int ct; - FILE* fp = openSaveFile(pOpts); + FILE * fp = open_sv_file(pOpts); if (fp == NULL) return; @@ -706,7 +690,7 @@ optionSaveFile(tOptions* pOpts) ct = pOpts->presetOptCt; pOD = pOpts->pOptDesc; do { - tOptDesc* p; + tOptDesc * p; /* * IF the option has not been defined @@ -737,35 +721,35 @@ optionSaveFile(tOptions* pOpts) switch (OPTST_GET_ARGTYPE(pOD->fOptState)) { case OPARG_TYPE_NONE: - printNoArgOpt(fp, p, pOD); + prt_no_arg_opt(fp, p, pOD); break; case OPARG_TYPE_NUMERIC: - printEntry(fp, p, (void*)(p->optArg.argInt)); + prt_entry(fp, p, (void*)(p->optArg.argInt)); break; case OPARG_TYPE_STRING: - printStringArg(fp, p); + prt_str_arg(fp, p); break; case OPARG_TYPE_ENUMERATION: - printEnumArg(fp, p); + prt_enum_arg(fp, p); break; case OPARG_TYPE_MEMBERSHIP: - printSetMemberArg(fp, p); + prt_set_arg(fp, p); break; case OPARG_TYPE_BOOLEAN: - printEntry(fp, p, p->optArg.argBool ? "true" : "false"); + prt_entry(fp, p, p->optArg.argBool ? "true" : "false"); break; case OPARG_TYPE_HIERARCHY: - printHierarchy(fp, p); + prt_nested(fp, p); break; case OPARG_TYPE_FILE: - printFileArg(fp, p, pOpts); + prt_file_arg(fp, p, pOpts); break; default: diff --git a/src/libopts/sort.c b/src/libopts/sort.c index 89d716a9bb..a05588dd1b 100644 --- a/src/libopts/sort.c +++ b/src/libopts/sort.c @@ -8,7 +8,7 @@ * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control diff --git a/src/libopts/stack.c b/src/libopts/stack.c index d930772b7d..bb962f78a2 100644 --- a/src/libopts/stack.c +++ b/src/libopts/stack.c @@ -2,14 +2,14 @@ /** * \file stack.c * - * Time-stamp: "2010-07-17 10:42:27 bkorb" + * Time-stamp: "2012-01-29 09:42:12 bkorb" * * This is a special option processing routine that will save the * argument to an option in a FIFO queue. * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -47,8 +47,6 @@ optionUnstackArg( tOptions* pOpts, tOptDesc* pOptDesc ) { - int res; - tArgList* pAL; if ((pOptDesc->fOptState & OPTST_RESET) != 0) @@ -81,8 +79,10 @@ optionUnstackArg( * we are keeping a define. */ for (i = 0, dIdx = 0, ct = pAL->useCt; --ct >= 0; i++) { - tCC* pzSrc = pAL->apzArgs[ i ]; - char* pzEq = strchr(pzSrc, '='); + char const * pzSrc = pAL->apzArgs[ i ]; + char * pzEq = strchr(pzSrc, '='); + int res; + if (pzEq != NULL) *pzEq = NUL; diff --git a/src/libopts/streqvcmp.c b/src/libopts/streqvcmp.c index d2cb65de63..d08f9c9dc1 100644 --- a/src/libopts/streqvcmp.c +++ b/src/libopts/streqvcmp.c @@ -2,7 +2,7 @@ /** * \file streqvcmp.c * - * Time-stamp: "2010-07-17 10:16:24 bkorb" + * Time-stamp: "2012-01-29 19:03:24 bkorb" * * String Equivalence Comparison * @@ -13,7 +13,7 @@ * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -36,8 +36,8 @@ * based upon ascii character sequences. */ static unsigned char charmap[] = { - 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, '\a', - '\b', '\t', '\n', '\v', '\f', '\r', 0x0E, 0x0F, + NUL, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, '\a', + '\b', '\t', NL, '\v', '\f', '\r', 0x0E, 0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, @@ -187,7 +187,7 @@ streqvmap(char From, char To, int ct) if (ct == 0) { ct = sizeof(charmap) - 1; do { - charmap[ ct ] = ct; + charmap[ct] = (unsigned char)ct; } while (--ct >= 0); } @@ -196,7 +196,7 @@ streqvmap(char From, char To, int ct) int chFrom = (int)From & 0xFF; do { - charmap[ chFrom ] = (unsigned)chTo; + charmap[chFrom] = (unsigned char)chTo; chFrom++; chTo++; if ((chFrom >= sizeof(charmap)) || (chTo >= sizeof(charmap))) diff --git a/src/libopts/text_mmap.c b/src/libopts/text_mmap.c index e46d594690..4a7aa1a238 100644 --- a/src/libopts/text_mmap.c +++ b/src/libopts/text_mmap.c @@ -3,11 +3,11 @@ * * Map a text file, ensuring the text always has an ending NUL byte. * - * Time-stamp: "2011-06-25 11:42:22 bkorb" + * Time-stamp: "2012-01-29 09:40:21 bkorb" * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -76,9 +76,11 @@ * * @param mapinfo a structure holding everything we need to know * about the mapping. + * + * @param pzFile name of the file, for error reporting. */ static void -load_text_file(tmap_info_t * mapinfo) +load_text_file(tmap_info_t * mapinfo, char const * pzFile) { #if ! defined(HAVE_MMAP) mapinfo->txt_data = AGALOC(mapinfo->txt_size+1, "file text"); @@ -96,7 +98,7 @@ load_text_file(tmap_info_t * mapinfo) if (rdct <= 0) { mapinfo->txt_errno = errno; fprintf(stderr, zFSErrReadFile, - errno, strerror(errno), "mapped file"); + errno, strerror(errno), pzFile); free(mapinfo->txt_data); return; } @@ -114,6 +116,8 @@ load_text_file(tmap_info_t * mapinfo) size_t const pgsz = GETPAGESIZE(); void * map_addr = NULL; + (void)pzFile; + mapinfo->txt_full_size = (mapinfo->txt_size + pgsz) & ~(pgsz - 1); if (mapinfo->txt_full_size == (mapinfo->txt_size + pgsz)) { /* @@ -297,7 +301,7 @@ text_mmap(char const * pzFile, int prot, int flags, tmap_info_t * mi) if (mi->txt_errno != 0) return MAP_FAILED_PTR; - load_text_file(mi); + load_text_file(mi, pzFile); if (mi->txt_errno == 0) return mi->txt_data; diff --git a/src/libopts/time.c b/src/libopts/time.c index 656c78d601..7348bdb406 100644 --- a/src/libopts/time.c +++ b/src/libopts/time.c @@ -2,11 +2,11 @@ /** * \file time.c * - * Time-stamp: "2011-03-06 11:52:23 bkorb" + * Time-stamp: "2012-01-29 12:52:31 bkorb" * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -55,7 +55,7 @@ optionTimeVal(tOptions * pOpts, tOptDesc * pOD) pOD->fOptState &= ~OPTST_ALLOC_ARG; } - pOD->optArg.argInt = val; + pOD->optArg.argInt = (unsigned long)val; } /*=export_func optionTimeDate diff --git a/src/libopts/tokenize.c b/src/libopts/tokenize.c index 4ca1245cf0..ca0ad53ab3 100644 --- a/src/libopts/tokenize.c +++ b/src/libopts/tokenize.c @@ -1,10 +1,10 @@ /* * This file defines the string_tokenize interface - * Time-stamp: "2010-07-17 10:40:26 bkorb" + * Time-stamp: "2012-01-29 19:02:51 bkorb" * * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -87,11 +87,11 @@ copy_raw(ch_t** ppDest, char const ** ppSrc) switch (*pSrc) { case NUL: *ppSrc = NULL; return; case '\r': - if (*(++pSrc) == '\n') + if (*(++pSrc) == NL) ++pSrc; continue; - case '\n': + case NL: ++pSrc; continue; @@ -281,7 +281,7 @@ ao_string_tokenize(char const* str) default: str++; - *(pzDest++) = ch; + *(pzDest++) = (unsigned char)ch; } } copy_done:; diff --git a/src/libopts/usage.c b/src/libopts/usage.c index e2751cb6e7..8634cfce53 100644 --- a/src/libopts/usage.c +++ b/src/libopts/usage.c @@ -2,7 +2,7 @@ /* * \file usage.c * - * Time-stamp: "2011-11-22 11:41:18 bkorb" + * Time-stamp: "2012-01-29 09:57:43 bkorb" * * This module implements the default usage procedure for * Automated Options. It may be overridden, of course. @@ -16,7 +16,7 @@ /* * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -248,12 +248,12 @@ print_usage_details(tOptions * opts, int exit_code) */ if (do_gnu_usage(opts)) { int flen = setGnuOptFmts(opts, &pOptTitle); - sprintf(zOptFmtLine, zFmtFmt, flen); - fputc('\n', option_usage_fp); + sprintf(line_fmt_buf, zFmtFmt, flen); + fputc(NL, option_usage_fp); } else { int flen = setStdOptFmts(opts, &pOptTitle); - sprintf(zOptFmtLine, zFmtFmt, flen); + sprintf(line_fmt_buf, zFmtFmt, flen); /* * When we exit with EXIT_SUCCESS and the first option is a doc @@ -716,7 +716,7 @@ prt_ini_list(char const * const * papz, ag_bool * pInitIntro, } } - fputc('\n', option_usage_fp); + fputc(NL, option_usage_fp); } } @@ -787,7 +787,7 @@ prt_one_usage(tOptions * pOptions, tOptDesc * pOD, arg_types_t * pAT) snprintf(z, sizeof(z), pAT->pzOptFmt, pzArgType, pOD->pz_Name, (pOD->optMinCt != 0) ? pAT->pzReq : pAT->pzOpt); - fprintf(option_usage_fp, zOptFmtLine, z, pOD->pzText); + fprintf(option_usage_fp, line_fmt_buf, z, pOD->pzText); switch (OPTST_GET_ARGTYPE(pOD->fOptState)) { case OPARG_TYPE_ENUMERATION: @@ -884,7 +884,7 @@ prt_opt_usage(tOptions * pOpts, int ex_code, char const * pOptTitle) } while (pOD++, optNo++, (--ct > 0)); - fputc('\n', option_usage_fp); + fputc(NL, option_usage_fp); } @@ -923,7 +923,7 @@ prt_prog_detail(tOptions* pOptions) int optNo = 0; tOptDesc* pOD = pOptions->pOptDesc; - fputc('\n', option_usage_fp); + fputc(NL, option_usage_fp); fflush(option_usage_fp); do { switch (OPTST_GET_ARGTYPE(pOD->fOptState)) { diff --git a/src/libopts/value-type.h b/src/libopts/value-type.h index 28ee23ed51..a2ca5ad566 100644 --- a/src/libopts/value-type.h +++ b/src/libopts/value-type.h @@ -1,5 +1,5 @@ /* - * Generated header for gperf generated source Thu Dec 29 12:02:33 PST 2011 + * Generated header for gperf generated source Fri Feb 10 19:53:37 PST 2012 * This file enumerates the list of names and declares the * procedure for mapping string names to the enum value. */ diff --git a/src/libopts/version.c b/src/libopts/version.c index 1ebf93f26f..24041b2013 100644 --- a/src/libopts/version.c +++ b/src/libopts/version.c @@ -1,6 +1,6 @@ /* - * Time-stamp: "2011-05-02 12:04:47 bkorb" + * Time-stamp: "2012-01-29 19:44:24 bkorb" * * This module implements the default usage procedure for * Automated Options. It may be overridden, of course. @@ -9,7 +9,7 @@ /* * This file is part of AutoOpts, a companion to AutoGen. * AutoOpts is free software. - * AutoOpts is Copyright (c) 1992-2011 by Bruce Korb - all rights reserved + * AutoOpts is Copyright (c) 1992-2012 by Bruce Korb - all rights reserved * * AutoOpts is available under any one of two licenses. The license * in use must be one of these two and the choice is under the control @@ -46,26 +46,41 @@ optionVersion(void) return zVersion; } +/** + * Select among various ways to emit version information. + * + * @param pOpts the option descriptor + * @param fp the output stream + */ static void emit_simple_ver(tOptions * pOpts, FILE * fp) { + /* + * Use the supplied string + */ if (pOpts->pzFullVersion != NULL) fputs(pOpts->pzFullVersion, fp); + /* + * Extract the interesting part of the copyright string + */ else if (pOpts->pzCopyright != NULL) { - char const * pe = strchr(pOpts->pzCopyright, '\n'); + char const * pe = strchr(pOpts->pzCopyright, NL); if (pe == NULL) pe = pOpts->pzCopyright + strlen(pOpts->pzCopyright); fwrite(pOpts->pzCopyright, 1, pe - pOpts->pzCopyright, fp); } + /* + * Extract the interesting part of the usage title string + */ else { - char const * pe = strchr(pOpts->pzUsageTitle, '\n'); + char const * pe = strchr(pOpts->pzUsageTitle, NL); if (pe == NULL) pe = pOpts->pzUsageTitle + strlen(pOpts->pzUsageTitle); - fwrite(pOpts->pzUsageTitle, 1, pe - pOpts->pzCopyright, fp); + fwrite(pOpts->pzUsageTitle, 1, pe - pOpts->pzUsageTitle, fp); } - fputc('\n', fp); + fputc(NL, fp); } static void @@ -78,13 +93,13 @@ emit_copy_ver(tOptions * pOpts, FILE * fp) fputs(pOpts->pzFullVersion, fp); else { - char const * pe = strchr(pOpts->pzUsageTitle, '\n'); + char const * pe = strchr(pOpts->pzUsageTitle, NL); if (pe == NULL) pe = pOpts->pzUsageTitle + strlen(pOpts->pzUsageTitle); fwrite(pOpts->pzUsageTitle, 1, pe - pOpts->pzCopyright, fp); } - fputc('\n', fp); + fputc(NL, fp); if (HAS_pzPkgDataDir(pOpts) && (pOpts->pzPackager != NULL)) fputs(pOpts->pzPackager, fp); @@ -98,12 +113,12 @@ emit_copy_note(tOptions * pOpts, FILE * fp) { if (pOpts->pzCopyright != NULL) { fputs(pOpts->pzCopyright, fp); - fputc('\n', fp); + fputc(NL, fp); } if (pOpts->pzCopyNotice != NULL) { fputs(pOpts->pzCopyNotice, fp); - fputc('\n', fp); + fputc(NL, fp); } fprintf(fp, zAO_Ver, optionVersion()); diff --git a/src/libopts/xat-attribute.h b/src/libopts/xat-attribute.h index cbcf6e5ac4..b452b309be 100644 --- a/src/libopts/xat-attribute.h +++ b/src/libopts/xat-attribute.h @@ -1,5 +1,5 @@ /* - * Generated header for gperf generated source Thu Dec 29 12:02:33 PST 2011 + * Generated header for gperf generated source Fri Feb 10 19:53:37 PST 2012 * This file enumerates the list of names and declares the * procedure for mapping string names to the enum value. */ |