db/pgbackrest
1
0
Fork 0
mirror of https://github.com/pgbackrest/pgbackrest.git synced 2025-04-19 11:52:32 +02:00
Code Issues Releases Activity
pgbackrest/test/src/module/build/configTest.c

1508 lines
63 KiB
C
Raw Normal View History

Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
/***********************************************************************************************************************************
Test Build Config
***********************************************************************************************************************************/
#include "common/harnessStorage.h"
/***********************************************************************************************************************************
Test Run
***********************************************************************************************************************************/
void
testRun(void)
{
FUNCTION_HARNESS_VOID();
// Create default storage object for testing
Storage *storageTest = storagePosixNewP(TEST_PATH_STR, .write = true);
// *****************************************************************************************************************************
if (testBegin("bldCfgParse() and bldCfgRender()"))
{
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("command parse errors");
HRN_STORAGE_PUT_Z(
storageTest, "src/build/config/config.yaml",
"command:\n"
" archive-get:\n"
" bogus: test\n");
TEST_ERROR(bldCfgParse(storageTest), FormatError, "unknown command definition 'bogus'");
#define TEST_COMMAND_VALID \
"command:\n" \
" archive-get:\n" \
" internal: true\n" \
"\n"
#define TEST_OPTION_GROUP_VALID \
"optionGroup:\n" \
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" repo: {}\n" \
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"\n"
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("option parse errors");
HRN_STORAGE_PUT_Z(
storageTest, "src/build/config/config.yaml",
TEST_COMMAND_VALID
TEST_OPTION_GROUP_VALID
"option:\n"
" config:\n"
" bogus: test\n");
TEST_ERROR(bldCfgParse(storageTest), FormatError, "unknown option definition 'bogus'");
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
HRN_STORAGE_PUT_Z(
storageTest, "src/build/config/config.yaml",
TEST_COMMAND_VALID
TEST_OPTION_GROUP_VALID
"option:\n"
" config:\n"
" section: global\n");
TEST_ERROR(bldCfgParse(storageTest), FormatError, "option 'config' requires 'type'");
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
HRN_STORAGE_PUT_Z(
storageTest, "src/build/config/config.yaml",
TEST_COMMAND_VALID
TEST_OPTION_GROUP_VALID
"option:\n"
" config:\n"
" depend:\n"
" bogus: test\n");
TEST_ERROR(bldCfgParse(storageTest), FormatError, "unknown depend definition 'bogus'");
HRN_STORAGE_PUT_Z(
storageTest, "src/build/config/config.yaml",
TEST_COMMAND_VALID
TEST_OPTION_GROUP_VALID
"option:\n"
" config:\n"
" command:\n"
" backup:\n"
" bogus: test\n");
TEST_ERROR(bldCfgParse(storageTest), FormatError, "unknown option command definition 'bogus'");
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
HRN_STORAGE_PUT_Z(
storageTest, "src/build/config/config.yaml",
TEST_COMMAND_VALID
TEST_OPTION_GROUP_VALID
"option:\n"
" config:\n"
" depend: bogus\n");
TEST_ERROR(bldCfgParse(storageTest), FormatError, "dependency inherited from option 'bogus' before it is defined");
HRN_STORAGE_PUT_Z(
storageTest, "src/build/config/config.yaml",
TEST_COMMAND_VALID
TEST_OPTION_GROUP_VALID
"option:\n"
" config:\n"
" type: string\n"
" command:\n"
" bogus: {}\n");
TEST_ERROR(bldCfgParse(storageTest), FormatError, "invalid command 'bogus' in option 'config' command list");
HRN_STORAGE_PUT_Z(
storageTest, "src/build/config/config.yaml",
TEST_COMMAND_VALID
TEST_OPTION_GROUP_VALID
"option:\n"
" config:\n"
" type: string\n"
" depend:\n"
" option: bogus\n");
TEST_ERROR(bldCfgParse(storageTest), FormatError, "dependency on undefined option 'bogus'");
HRN_STORAGE_PUT_Z(
storageTest, "src/build/config/config.yaml",
TEST_COMMAND_VALID
TEST_OPTION_GROUP_VALID
"option:\n"
" config:\n"
" type: string\n"
" group: bogus\n");
TEST_ERROR(bldCfgParse(storageTest), FormatError, "option 'config' has invalid group 'bogus'");
HRN_STORAGE_PUT_Z(
storageTest, "src/build/config/config.yaml",
TEST_COMMAND_VALID
TEST_OPTION_GROUP_VALID
"option:\n"
" stanza:\n"
" type: string\n"
" config:\n"
" type: string\n"
" depend:\n"
" option: online\n"
" online:\n"
" type: boolean\n"
" depend:\n"
" option: config\n");
TEST_ERROR(
bldCfgParse(storageTest), FormatError,
"unable to resolve dependencies for option(s) 'config, online'\n"
"HINT: are there circular dependencies?");
HRN_STORAGE_PUT_Z(
storageTest, "src/build/config/config.yaml",
TEST_COMMAND_VALID
TEST_OPTION_GROUP_VALID
"option:\n"
" config:\n"
" type: string\n");
TEST_ERROR(bldCfgParse(storageTest), FormatError, "option 'stanza' must exist");
HRN_STORAGE_PUT_Z(
storageTest, "src/build/config/config.yaml",
TEST_COMMAND_VALID
TEST_OPTION_GROUP_VALID
"option:\n"
" config:\n"
" type: string\n"
" stanza:\n"
" type: string\n"
" depend:\n"
" option: config\n");
TEST_ERROR(bldCfgParse(storageTest), FormatError, "option 'stanza' may not depend on other option");
HRN_STORAGE_PUT_Z(
storageTest, "src/build/config/config.yaml",
TEST_COMMAND_VALID
TEST_OPTION_GROUP_VALID
"option:\n"
" config:\n"
" type: string\n"
" stanza:\n"
" type: string\n"
" command:\n"
" archive-get:\n"
" depend:\n"
" option: config\n");
TEST_ERROR(bldCfgParse(storageTest), FormatError, "option 'stanza' command 'archive-get' may not depend on other option");
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("parse and render config");
HRN_STORAGE_PUT_Z(
storageTest, "src/build/config/config.yaml",
"command:\n"
" archive-get:\n"
" command-role:\n"
" async: {}\n"
" local: {}\n"
" remote: {}\n"
" lock-type: archive\n"
" log-file: false\n"
" log-level-default: debug\n"
" parameter-allowed: true\n"
"\n"
" backup:\n"
" internal: true\n"
" command-role:\n"
" local: {}\n"
" remote: {}\n"
" lock-type: backup\n"
" lock-required: true\n"
" lock-remote-required: true\n"
"\n"
" help: {}\n"
"\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" version: {}\n"
"\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"optionGroup:\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" pg: {}\n"
" repo: {}\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"\n"
"option:\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" timeout:\n"
" type: time\n"
" default: 10\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" command:\n"
" backup:\n"
" default: 20\n"
" archive-get:\n"
" default: 30\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" allow-range: [5, 50]\n"
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" buffer-size:\n"
" section: global\n"
" type: size\n"
" command:\n"
" backup: {}\n"
" archive-get:\n"
" default: 32768\n"
" allow-list:\n"
" - 32768\n"
" allow-list:\n"
" - 8192\n"
" - 16384\n"
" command-role:\n"
" main: {}\n"
"\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
" compress-type:\n"
" section: global\n"
" type: string\n"
" default: gz\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" command:\n"
" backup: {}\n"
" archive-get:\n"
" depend:\n"
" option: config\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
" command-role: {}\n"
" deprecate:\n"
" compress: {}\n"
"\n"
" compress-level:\n"
" section: global\n"
" type: integer\n"
" required: false\n"
" allow-range: [0, 9]\n"
" command: compress-type\n"
" depend: compress-type\n"
"\n"
" compress-level-network:\n"
" inherit: compress-level\n"
" internal: true\n"
" secure: true\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" default: ~\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
" depend:\n"
" option: compress-type\n"
" list:\n"
" - none\n"
" - gz\n"
"\n"
" config:\n"
" type: string\n"
" default: CFGOPTDEF_CONFIG_PATH \"/\" PROJECT_CONFIG_FILE\n"
" default-literal: true\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" negate: true\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" command:\n"
" backup: {}\n"
" archive-get:\n"
" default: CFGOPTDEF_CONFIG_PATH \"/.\" PROJECT_CONFIG_FILE\n"
"\n"
" config-include:\n"
" section: global\n"
" type: path\n"
" default: /include\n"
" command-role:\n"
" main: {}\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"\n"
" log-level-console:\n"
" section: global\n"
" type: string\n"
" default: warn\n"
" allow-list:\n"
" - off\n"
" - error\n"
" - warn\n"
Automatically generate option value StringIds in make build-config. Remove strIdGenerate() since bldStrId() performs the same function without cluttering the core code. Since bldStrId() is intended to work in non-debug builds, move the validity checks for input strings out of the DEBUG block. StringIds are generated as 5/6 bit, whichever is most efficient, for each option value. cfgOptionStrIdInternal() has been updated for this logic.
2021-07-26 12:02:31 -04:00
" - debug1\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"\n"
" log-level-file:\n"
" section: global\n"
" type: string\n"
" default: info\n"
" allow-list: log-level-console\n"
" command:\n"
" backup:\n"
" internal: true\n"
" required: false\n"
" default: warn\n"
" allow-list:\n"
" - off\n"
" - warn\n"
" depend:\n"
" option: log-level-console\n"
" list:\n"
" - warn\n"
" command-role:\n"
" main: {}\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" help: {}\n"
" archive-get:\n"
" default: ~\n"
"\n"
" stanza:\n"
" type: list\n"
" command:\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
" archive-get: {}\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" backup: {}\n"
"\n"
" online:\n"
" type: boolean\n"
" default: true\n"
" command:\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" backup:\n"
" default: false\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" command-role:\n"
" main: {}\n"
" deprecate:\n"
" online-old: {}\n"
"\n"
" backup-standby:\n"
" section: global\n"
" type: boolean\n"
" default: false\n"
" depend:\n"
" option: online\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" list:\n"
" - true\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" command:\n"
" backup: {}\n"
" command-role:\n"
" async: {}\n"
" main: {}\n"
" deprecate:\n"
" backup-standby-old: {}\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"\n"
" pg-path:\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" section: stanza\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
" group: pg\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" type: hash\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
" deprecate:\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" pg-path: {}\n"
" pg?-path-indexed: {}\n"
" db-path: {}\n"
" db?-path: {}\n"
"\n"
" pg-host:\n"
" section: stanza\n"
" group: pg\n"
" type: string\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" command:\n"
" archive-get:\n"
" default: host1\n"
" backup: {}\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" deprecate:\n"
" pg?-host: {}\n");
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
TEST_RESULT_VOID(bldCfgRender(storageTest, bldCfgParse(storageTest)), "parse and render");
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("bldCfgRenderVar128Size()");
TEST_RESULT_UINT(bldCfgRenderVar128Size(10000), 2, "check size");
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("check config.auto.h");
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
TEST_STORAGE_GET(
storageTest,
"src/config/config.auto.h",
COMMENT_BLOCK_BEGIN "\n"
"Command and Option Configuration\n"
"\n"
"Automatically generated by 'make build-config' -- do not modify directly.\n"
COMMENT_BLOCK_END "\n"
"#ifndef CONFIG_CONFIG_AUTO_H\n"
"#define CONFIG_CONFIG_AUTO_H\n"
"\n"
COMMENT_BLOCK_BEGIN "\n"
"Command constants\n"
COMMENT_BLOCK_END "\n"
"#define CFGCMD_ARCHIVE_GET \"archive-get\"\n"
"#define CFGCMD_BACKUP \"backup\"\n"
"#define CFGCMD_HELP \"help\"\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"#define CFGCMD_VERSION \"version\"\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"#define CFG_COMMAND_TOTAL 4\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"\n"
COMMENT_BLOCK_BEGIN "\n"
"Option group constants\n"
COMMENT_BLOCK_END "\n"
"#define CFG_OPTION_GROUP_TOTAL 2\n"
"\n"
COMMENT_BLOCK_BEGIN "\n"
"Option constants\n"
COMMENT_BLOCK_END "\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"#define CFGOPT_BACKUP_STANDBY \"backup-standby\"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
"#define CFGOPT_BUFFER_SIZE \"buffer-size\"\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"#define CFGOPT_COMPRESS_LEVEL \"compress-level\"\n"
"#define CFGOPT_COMPRESS_LEVEL_NETWORK \"compress-level-network\"\n"
"#define CFGOPT_COMPRESS_TYPE \"compress-type\"\n"
"#define CFGOPT_CONFIG \"config\"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
"#define CFGOPT_CONFIG_INCLUDE \"config-include\"\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"#define CFGOPT_LOG_LEVEL_CONSOLE \"log-level-console\"\n"
"#define CFGOPT_LOG_LEVEL_FILE \"log-level-file\"\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"#define CFGOPT_ONLINE \"online\"\n"
"#define CFGOPT_STANZA \"stanza\"\n"
"#define CFGOPT_TIMEOUT \"timeout\"\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
"#define CFG_OPTION_TOTAL 14\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"\n"
COMMENT_BLOCK_BEGIN "\n"
"Option value constants\n"
COMMENT_BLOCK_END "\n"
Automatically generate option value StringIds in make build-config. Remove strIdGenerate() since bldStrId() performs the same function without cluttering the core code. Since bldStrId() is intended to work in non-debug builds, move the validity checks for input strings out of the DEBUG block. StringIds are generated as 5/6 bit, whichever is most efficient, for each option value. cfgOptionStrIdInternal() has been updated for this logic.
2021-07-26 12:02:31 -04:00
"#define CFGOPTVAL_LOG_LEVEL_CONSOLE_DEBUG1 STRID6(\"debug1\", 0x7475421441)\n"
"#define CFGOPTVAL_LOG_LEVEL_CONSOLE_DEBUG1_Z \"debug1\"\n"
"#define CFGOPTVAL_LOG_LEVEL_CONSOLE_ERROR STRID5(\"error\", 0x127ca450)\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"#define CFGOPTVAL_LOG_LEVEL_CONSOLE_ERROR_Z \"error\"\n"
Automatically generate option value StringIds in make build-config. Remove strIdGenerate() since bldStrId() performs the same function without cluttering the core code. Since bldStrId() is intended to work in non-debug builds, move the validity checks for input strings out of the DEBUG block. StringIds are generated as 5/6 bit, whichever is most efficient, for each option value. cfgOptionStrIdInternal() has been updated for this logic.
2021-07-26 12:02:31 -04:00
"#define CFGOPTVAL_LOG_LEVEL_CONSOLE_OFF STRID5(\"off\", 0x18cf0)\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"#define CFGOPTVAL_LOG_LEVEL_CONSOLE_OFF_Z \"off\"\n"
Automatically generate option value StringIds in make build-config. Remove strIdGenerate() since bldStrId() performs the same function without cluttering the core code. Since bldStrId() is intended to work in non-debug builds, move the validity checks for input strings out of the DEBUG block. StringIds are generated as 5/6 bit, whichever is most efficient, for each option value. cfgOptionStrIdInternal() has been updated for this logic.
2021-07-26 12:02:31 -04:00
"#define CFGOPTVAL_LOG_LEVEL_CONSOLE_WARN STRID5(\"warn\", 0x748370)\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"#define CFGOPTVAL_LOG_LEVEL_CONSOLE_WARN_Z \"warn\"\n"
"\n"
Automatically generate option value StringIds in make build-config. Remove strIdGenerate() since bldStrId() performs the same function without cluttering the core code. Since bldStrId() is intended to work in non-debug builds, move the validity checks for input strings out of the DEBUG block. StringIds are generated as 5/6 bit, whichever is most efficient, for each option value. cfgOptionStrIdInternal() has been updated for this logic.
2021-07-26 12:02:31 -04:00
"#define CFGOPTVAL_LOG_LEVEL_FILE_DEBUG1 STRID6(\"debug1\", 0x7475421441)\n"
"#define CFGOPTVAL_LOG_LEVEL_FILE_DEBUG1_Z \"debug1\"\n"
"#define CFGOPTVAL_LOG_LEVEL_FILE_ERROR STRID5(\"error\", 0x127ca450)\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"#define CFGOPTVAL_LOG_LEVEL_FILE_ERROR_Z \"error\"\n"
Automatically generate option value StringIds in make build-config. Remove strIdGenerate() since bldStrId() performs the same function without cluttering the core code. Since bldStrId() is intended to work in non-debug builds, move the validity checks for input strings out of the DEBUG block. StringIds are generated as 5/6 bit, whichever is most efficient, for each option value. cfgOptionStrIdInternal() has been updated for this logic.
2021-07-26 12:02:31 -04:00
"#define CFGOPTVAL_LOG_LEVEL_FILE_OFF STRID5(\"off\", 0x18cf0)\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"#define CFGOPTVAL_LOG_LEVEL_FILE_OFF_Z \"off\"\n"
Automatically generate option value StringIds in make build-config. Remove strIdGenerate() since bldStrId() performs the same function without cluttering the core code. Since bldStrId() is intended to work in non-debug builds, move the validity checks for input strings out of the DEBUG block. StringIds are generated as 5/6 bit, whichever is most efficient, for each option value. cfgOptionStrIdInternal() has been updated for this logic.
2021-07-26 12:02:31 -04:00
"#define CFGOPTVAL_LOG_LEVEL_FILE_WARN STRID5(\"warn\", 0x748370)\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"#define CFGOPTVAL_LOG_LEVEL_FILE_WARN_Z \"warn\"\n"
"\n"
COMMENT_BLOCK_BEGIN "\n"
"Command enum\n"
COMMENT_BLOCK_END "\n"
"typedef enum\n"
"{\n"
" cfgCmdArchiveGet,\n"
" cfgCmdBackup,\n"
" cfgCmdHelp,\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" cfgCmdVersion,\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
" cfgCmdNone,\n"
"} ConfigCommand;\n"
"\n"
COMMENT_BLOCK_BEGIN "\n"
"Option group enum\n"
COMMENT_BLOCK_END "\n"
"typedef enum\n"
"{\n"
" cfgOptGrpPg,\n"
" cfgOptGrpRepo,\n"
"} ConfigOptionGroup;\n"
"\n"
COMMENT_BLOCK_BEGIN "\n"
"Option enum\n"
COMMENT_BLOCK_END "\n"
"typedef enum\n"
"{\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" cfgOptBackupStandby,\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" cfgOptBufferSize,\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
" cfgOptCompressLevel,\n"
" cfgOptCompressLevelNetwork,\n"
" cfgOptCompressType,\n"
" cfgOptConfig,\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" cfgOptConfigInclude,\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
" cfgOptLogLevelConsole,\n"
" cfgOptLogLevelFile,\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" cfgOptOnline,\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" cfgOptPgHost,\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
" cfgOptPgPath,\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" cfgOptStanza,\n"
" cfgOptTimeout,\n"
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
"} ConfigOption;\n"
"\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"#endif\n");
// -------------------------------------------------------------------------------------------------------------------------
TEST_TITLE("check parse.auto.c");
TEST_STORAGE_GET(
storageTest,
"src/config/parse.auto.c",
COMMENT_BLOCK_BEGIN "\n"
"Config Parse Rules\n"
"\n"
"Automatically generated by 'make build-config' -- do not modify directly.\n"
COMMENT_BLOCK_END "\n"
"\n"
COMMENT_BLOCK_BEGIN "\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
"Rule Strings\n"
COMMENT_BLOCK_END "\n"
"#define PARSE_RULE_VAL_STR(value) PARSE_RULE_U32_1(value)\n"
"\n"
"static const StringPub parseRuleValueStr[] =\n"
"{\n"
" PARSE_RULE_STRPUB(\"/include\"),\n"
" PARSE_RULE_STRPUB(\"10\"),\n"
" PARSE_RULE_STRPUB(\"20\"),\n"
" PARSE_RULE_STRPUB(\"30\"),\n"
" PARSE_RULE_STRPUB(\"32768\"),\n"
" PARSE_RULE_STRPUB(\"gz\"),\n"
" PARSE_RULE_STRPUB(\"host1\"),\n"
" PARSE_RULE_STRPUB(\"info\"),\n"
" PARSE_RULE_STRPUB(\"warn\"),\n"
" PARSE_RULE_STRPUB(CFGOPTDEF_CONFIG_PATH \"/\" PROJECT_CONFIG_FILE),\n"
" PARSE_RULE_STRPUB(CFGOPTDEF_CONFIG_PATH \"/.\" PROJECT_CONFIG_FILE),\n"
"};\n"
"\n"
"typedef enum\n"
"{\n"
" parseRuleValStrQT_FS_include_QT,\n"
" parseRuleValStrQT_10_QT,\n"
" parseRuleValStrQT_20_QT,\n"
" parseRuleValStrQT_30_QT,\n"
" parseRuleValStrQT_32768_QT,\n"
" parseRuleValStrQT_gz_QT,\n"
" parseRuleValStrQT_host1_QT,\n"
" parseRuleValStrQT_info_QT,\n"
" parseRuleValStrQT_warn_QT,\n"
" parseRuleValStrCFGOPTDEF_CONFIG_PATH_SP_QT_FS_QT_SP_PROJECT_CONFIG_FILE,\n"
" parseRuleValStrCFGOPTDEF_CONFIG_PATH_SP_QT_FS_DT_QT_SP_PROJECT_CONFIG_FILE,\n"
"} ParseRuleValueStr;\n"
"\n"
COMMENT_BLOCK_BEGIN "\n"
"Rule StringIds\n"
COMMENT_BLOCK_END "\n"
"#define PARSE_RULE_VAL_STRID(value) PARSE_RULE_U32_1(value)\n"
"\n"
"static const StringId parseRuleValueStrId[] =\n"
"{\n"
" STRID6(\"debug1\", 0x7475421441),\n"
" STRID5(\"error\", 0x127ca450),\n"
" STRID5(\"info\", 0x799c90),\n"
" STRID5(\"off\", 0x18cf0),\n"
" STRID5(\"warn\", 0x748370),\n"
"};\n"
"\n"
"typedef enum\n"
"{\n"
" parseRuleValStrIdDebug1,\n"
" parseRuleValStrIdError,\n"
" parseRuleValStrIdInfo,\n"
" parseRuleValStrIdOff,\n"
" parseRuleValStrIdWarn,\n"
"} ParseRuleValueStrId;\n"
"\n"
COMMENT_BLOCK_BEGIN "\n"
"Rule Ints\n"
COMMENT_BLOCK_END "\n"
"#define PARSE_RULE_VAL_INT(value) PARSE_RULE_U32_1(value)\n"
"\n"
"static const int64_t parseRuleValueInt[] =\n"
"{\n"
" 0,\n"
" 9,\n"
" 5000,\n"
" 8192,\n"
" 10000,\n"
" 16384,\n"
" 20000,\n"
" 30000,\n"
" 32768,\n"
" 50000,\n"
"};\n"
"\n"
"typedef enum\n"
"{\n"
" parseRuleValInt0,\n"
" parseRuleValInt9,\n"
" parseRuleValInt5000,\n"
" parseRuleValInt8192,\n"
" parseRuleValInt10000,\n"
" parseRuleValInt16384,\n"
" parseRuleValInt20000,\n"
" parseRuleValInt30000,\n"
" parseRuleValInt32768,\n"
" parseRuleValInt50000,\n"
"} ParseRuleValueInt;\n"
"\n"
COMMENT_BLOCK_BEGIN "\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"Command parse data\n"
COMMENT_BLOCK_END "\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
"#define PARSE_RULE_VAL_CMD(value) PARSE_RULE_U32_1(value)\n"
"\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"static const ParseRuleCommand parseRuleCommand[CFG_COMMAND_TOTAL] =\n"
"{\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_COMMAND\n"
" (\n"
" PARSE_RULE_COMMAND_NAME(\"archive-get\"),\n"
Remove generated config.auto.c file. This file duplicated the command list that already exists in parse.auto.c. Combine the data from config.auto.c into parse.auto.c and adjust the interface functions as needed. Quite a few were able to be moved to parse.c as static.
2021-07-29 14:40:30 -04:00
" PARSE_RULE_COMMAND_LOCK_TYPE(lockTypeArchive),\n"
" PARSE_RULE_COMMAND_LOG_LEVEL_DEFAULT(logLevelDebug),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" PARSE_RULE_COMMAND_PARAMETER_ALLOWED(true),\n"
"\n"
" PARSE_RULE_COMMAND_ROLE_VALID_LIST\n"
" (\n"
" PARSE_RULE_COMMAND_ROLE(cfgCmdRoleAsync)\n"
" PARSE_RULE_COMMAND_ROLE(cfgCmdRoleLocal)\n"
" PARSE_RULE_COMMAND_ROLE(cfgCmdRoleMain)\n"
" PARSE_RULE_COMMAND_ROLE(cfgCmdRoleRemote)\n"
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_COMMAND\n"
" (\n"
" PARSE_RULE_COMMAND_NAME(\"backup\"),\n"
Remove generated config.auto.c file. This file duplicated the command list that already exists in parse.auto.c. Combine the data from config.auto.c into parse.auto.c and adjust the interface functions as needed. Quite a few were able to be moved to parse.c as static.
2021-07-29 14:40:30 -04:00
" PARSE_RULE_COMMAND_LOCK_REQUIRED(true),\n"
" PARSE_RULE_COMMAND_LOCK_REMOTE_REQUIRED(true),\n"
" PARSE_RULE_COMMAND_LOCK_TYPE(lockTypeBackup),\n"
" PARSE_RULE_COMMAND_LOG_FILE(true),\n"
" PARSE_RULE_COMMAND_LOG_LEVEL_DEFAULT(logLevelInfo),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"\n"
" PARSE_RULE_COMMAND_ROLE_VALID_LIST\n"
" (\n"
" PARSE_RULE_COMMAND_ROLE(cfgCmdRoleLocal)\n"
" PARSE_RULE_COMMAND_ROLE(cfgCmdRoleMain)\n"
" PARSE_RULE_COMMAND_ROLE(cfgCmdRoleRemote)\n"
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_COMMAND\n"
" (\n"
" PARSE_RULE_COMMAND_NAME(\"help\"),\n"
Remove generated config.auto.c file. This file duplicated the command list that already exists in parse.auto.c. Combine the data from config.auto.c into parse.auto.c and adjust the interface functions as needed. Quite a few were able to be moved to parse.c as static.
2021-07-29 14:40:30 -04:00
" PARSE_RULE_COMMAND_LOCK_TYPE(lockTypeNone),\n"
" PARSE_RULE_COMMAND_LOG_FILE(true),\n"
" PARSE_RULE_COMMAND_LOG_LEVEL_DEFAULT(logLevelInfo),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"\n"
" PARSE_RULE_COMMAND_ROLE_VALID_LIST\n"
" (\n"
" PARSE_RULE_COMMAND_ROLE(cfgCmdRoleMain)\n"
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_COMMAND\n"
" (\n"
" PARSE_RULE_COMMAND_NAME(\"version\"),\n"
Remove generated config.auto.c file. This file duplicated the command list that already exists in parse.auto.c. Combine the data from config.auto.c into parse.auto.c and adjust the interface functions as needed. Quite a few were able to be moved to parse.c as static.
2021-07-29 14:40:30 -04:00
" PARSE_RULE_COMMAND_LOCK_TYPE(lockTypeNone),\n"
" PARSE_RULE_COMMAND_LOG_FILE(true),\n"
" PARSE_RULE_COMMAND_LOG_LEVEL_DEFAULT(logLevelInfo),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"\n"
" PARSE_RULE_COMMAND_ROLE_VALID_LIST\n"
" (\n"
" PARSE_RULE_COMMAND_ROLE(cfgCmdRoleMain)\n"
" ),\n"
" ),\n"
"};\n"
"\n"
COMMENT_BLOCK_BEGIN "\n"
"Option group parse data\n"
COMMENT_BLOCK_END "\n"
"static const ParseRuleOptionGroup parseRuleOptionGroup[CFG_OPTION_GROUP_TOTAL] =\n"
"{\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION_GROUP\n"
" (\n"
" PARSE_RULE_OPTION_GROUP_NAME(\"pg\"),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION_GROUP\n"
" (\n"
" PARSE_RULE_OPTION_GROUP_NAME(\"repo\"),\n"
" ),\n"
"};\n"
"\n"
COMMENT_BLOCK_BEGIN "\n"
"Option parse data\n"
COMMENT_BLOCK_END "\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
"#define PARSE_RULE_VAL_OPT(value) PARSE_RULE_U32_1(value)\n"
"\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"static const ParseRuleOption parseRuleOption[CFG_OPTION_TOTAL] =\n"
"{\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION\n"
" (\n"
" PARSE_RULE_OPTION_NAME(\"backup-standby\"),\n"
" PARSE_RULE_OPTION_TYPE(cfgOptTypeBoolean),\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" PARSE_RULE_OPTION_NEGATE(true),\n"
" PARSE_RULE_OPTION_RESET(true),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" PARSE_RULE_OPTION_REQUIRED(true),\n"
" PARSE_RULE_OPTION_SECTION(cfgSectionGlobal),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_MAIN_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_OPTIONAL_DEPEND\n"
" (\n"
" PARSE_RULE_VAL_OPT(cfgOptOnline),\n"
" PARSE_RULE_VAL_BOOL_TRUE,\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_BOOL_FALSE,\n"
" ),\n"
" ),\n"
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION\n"
" (\n"
" PARSE_RULE_OPTION_NAME(\"buffer-size\"),\n"
" PARSE_RULE_OPTION_TYPE(cfgOptTypeSize),\n"
" PARSE_RULE_OPTION_RESET(true),\n"
" PARSE_RULE_OPTION_REQUIRED(true),\n"
" PARSE_RULE_OPTION_SECTION(cfgSectionGlobal),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_MAIN_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL\n"
" (\n"
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_FILTER_CMD\n"
" (\n"
" PARSE_RULE_VAL_CMD(cfgCmdArchiveGet),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_ALLOW_LIST\n"
" (\n"
" PARSE_RULE_VAL_INT(parseRuleValInt32768),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_INT(parseRuleValInt32768),\n"
" PARSE_RULE_VAL_STR(parseRuleValStrQT_32768_QT),\n"
" ),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_OPTIONAL_ALLOW_LIST\n"
" (\n"
" PARSE_RULE_VAL_INT(parseRuleValInt8192),\n"
" PARSE_RULE_VAL_INT(parseRuleValInt16384),\n"
" ),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION\n"
" (\n"
" PARSE_RULE_OPTION_NAME(\"compress-level\"),\n"
" PARSE_RULE_OPTION_TYPE(cfgOptTypeInteger),\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" PARSE_RULE_OPTION_RESET(true),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" PARSE_RULE_OPTION_REQUIRED(false),\n"
" PARSE_RULE_OPTION_SECTION(cfgSectionGlobal),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_MAIN_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_ASYNC_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_LOCAL_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_REMOTE_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_GROUP\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_FILTER_CMD\n"
" (\n"
" PARSE_RULE_VAL_CMD(cfgCmdArchiveGet),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_DEPEND\n"
" (\n"
" PARSE_RULE_VAL_OPT(cfgOptConfig),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_ALLOW_RANGE\n"
" (\n"
" PARSE_RULE_VAL_INT(parseRuleValInt0),\n"
" PARSE_RULE_VAL_INT(parseRuleValInt9),\n"
" ),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_OPTIONAL_ALLOW_RANGE\n"
" (\n"
" PARSE_RULE_VAL_INT(parseRuleValInt0),\n"
" PARSE_RULE_VAL_INT(parseRuleValInt9),\n"
" ),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION\n"
" (\n"
" PARSE_RULE_OPTION_NAME(\"compress-level-network\"),\n"
" PARSE_RULE_OPTION_TYPE(cfgOptTypeInteger),\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" PARSE_RULE_OPTION_RESET(true),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" PARSE_RULE_OPTION_REQUIRED(false),\n"
" PARSE_RULE_OPTION_SECTION(cfgSectionGlobal),\n"
" PARSE_RULE_OPTION_SECURE(true),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_MAIN_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_ASYNC_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_LOCAL_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_REMOTE_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_GROUP\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_FILTER_CMD\n"
" (\n"
" PARSE_RULE_VAL_CMD(cfgCmdArchiveGet),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_DEPEND\n"
" (\n"
" PARSE_RULE_VAL_OPT(cfgOptConfig),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_ALLOW_RANGE\n"
" (\n"
" PARSE_RULE_VAL_INT(parseRuleValInt0),\n"
" PARSE_RULE_VAL_INT(parseRuleValInt9),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" ),\n"
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_GROUP\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_DEPEND\n"
" (\n"
" PARSE_RULE_VAL_OPT(cfgOptCompressType),\n"
" PARSE_RULE_VAL_STRID(parseRuleValStrIdNone),\n"
" PARSE_RULE_VAL_STRID(parseRuleValStrIdGz),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_ALLOW_RANGE\n"
" (\n"
" PARSE_RULE_VAL_INT(parseRuleValInt0),\n"
" PARSE_RULE_VAL_INT(parseRuleValInt9),\n"
" ),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION\n"
" (\n"
" PARSE_RULE_OPTION_NAME(\"compress-type\"),\n"
" PARSE_RULE_OPTION_TYPE(cfgOptTypeString),\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" PARSE_RULE_OPTION_RESET(true),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" PARSE_RULE_OPTION_REQUIRED(true),\n"
" PARSE_RULE_OPTION_SECTION(cfgSectionGlobal),\n"
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_GROUP\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_FILTER_CMD\n"
" (\n"
" PARSE_RULE_VAL_CMD(cfgCmdArchiveGet),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_DEPEND\n"
" (\n"
" PARSE_RULE_VAL_OPT(cfgOptConfig),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_STR(parseRuleValStrQT_gz_QT),\n"
" ),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_STR(parseRuleValStrQT_gz_QT),\n"
" ),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION\n"
" (\n"
" PARSE_RULE_OPTION_NAME(\"config\"),\n"
" PARSE_RULE_OPTION_TYPE(cfgOptTypeString),\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" PARSE_RULE_OPTION_NEGATE(true),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" PARSE_RULE_OPTION_REQUIRED(true),\n"
" PARSE_RULE_OPTION_SECTION(cfgSectionCommandLine),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_MAIN_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_ASYNC_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_LOCAL_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_REMOTE_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL\n"
" (\n"
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_FILTER_CMD\n"
" (\n"
" PARSE_RULE_VAL_CMD(cfgCmdArchiveGet),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_STR(parseRuleValStrCFGOPTDEF_CONFIG_PATH_SP_QT_FS_DT_QT_SP_PROJECT_CONFIG_FILE),\n"
" ),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_STR(parseRuleValStrCFGOPTDEF_CONFIG_PATH_SP_QT_FS_QT_SP_PROJECT_CONFIG_FILE),\n"
" ),\n"
" ),\n"
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION\n"
" (\n"
" PARSE_RULE_OPTION_NAME(\"config-include\"),\n"
" PARSE_RULE_OPTION_TYPE(cfgOptTypePath),\n"
" PARSE_RULE_OPTION_RESET(true),\n"
" PARSE_RULE_OPTION_REQUIRED(true),\n"
" PARSE_RULE_OPTION_SECTION(cfgSectionGlobal),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_MAIN_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_STR(parseRuleValStrQT_FS_include_QT),\n"
" ),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION\n"
" (\n"
" PARSE_RULE_OPTION_NAME(\"log-level-console\"),\n"
" PARSE_RULE_OPTION_TYPE(cfgOptTypeString),\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" PARSE_RULE_OPTION_RESET(true),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" PARSE_RULE_OPTION_REQUIRED(true),\n"
" PARSE_RULE_OPTION_SECTION(cfgSectionGlobal),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_MAIN_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_ASYNC_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_LOCAL_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_REMOTE_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_GROUP\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_ALLOW_LIST\n"
" (\n"
" PARSE_RULE_VAL_STRID(parseRuleValStrIdOff),\n"
" PARSE_RULE_VAL_STRID(parseRuleValStrIdError),\n"
" PARSE_RULE_VAL_STRID(parseRuleValStrIdWarn),\n"
" PARSE_RULE_VAL_STRID(parseRuleValStrIdDebug1),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_STR(parseRuleValStrQT_warn_QT),\n"
" ),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION\n"
" (\n"
" PARSE_RULE_OPTION_NAME(\"log-level-file\"),\n"
" PARSE_RULE_OPTION_TYPE(cfgOptTypeString),\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" PARSE_RULE_OPTION_RESET(true),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" PARSE_RULE_OPTION_REQUIRED(true),\n"
" PARSE_RULE_OPTION_SECTION(cfgSectionGlobal),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_MAIN_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdHelp)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_ASYNC_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_LOCAL_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_REMOTE_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" ),\n"
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_GROUP\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_FILTER_CMD\n"
" (\n"
" PARSE_RULE_VAL_CMD(cfgCmdBackup),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_DEPEND\n"
" (\n"
" PARSE_RULE_VAL_OPT(cfgOptLogLevelConsole),\n"
" PARSE_RULE_VAL_STRID(parseRuleValStrIdWarn),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_ALLOW_LIST\n"
" (\n"
" PARSE_RULE_VAL_STRID(parseRuleValStrIdOff),\n"
" PARSE_RULE_VAL_STRID(parseRuleValStrIdWarn),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_DEFAULT\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_VAL_STR(parseRuleValStrQT_warn_QT),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" ),\n"
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_NOT_REQUIRED(),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_OPTIONAL_ALLOW_LIST\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_VAL_STRID(parseRuleValStrIdOff),\n"
" PARSE_RULE_VAL_STRID(parseRuleValStrIdError),\n"
" PARSE_RULE_VAL_STRID(parseRuleValStrIdWarn),\n"
" PARSE_RULE_VAL_STRID(parseRuleValStrIdDebug1),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" ),\n"
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_STR(parseRuleValStrQT_info_QT),\n"
" ),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION\n"
" (\n"
" PARSE_RULE_OPTION_NAME(\"online\"),\n"
" PARSE_RULE_OPTION_TYPE(cfgOptTypeBoolean),\n"
" PARSE_RULE_OPTION_REQUIRED(true),\n"
" PARSE_RULE_OPTION_SECTION(cfgSectionCommandLine),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_MAIN_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_FILTER_CMD\n"
" (\n"
" PARSE_RULE_VAL_CMD(cfgCmdBackup),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_BOOL_FALSE,\n"
" ),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_BOOL_TRUE,\n"
" ),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION\n"
" (\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" PARSE_RULE_OPTION_NAME(\"pg-host\"),\n"
" PARSE_RULE_OPTION_TYPE(cfgOptTypeString),\n"
" PARSE_RULE_OPTION_RESET(true),\n"
" PARSE_RULE_OPTION_REQUIRED(true),\n"
" PARSE_RULE_OPTION_SECTION(cfgSectionStanza),\n"
" PARSE_RULE_OPTION_GROUP_MEMBER(true),\n"
" PARSE_RULE_OPTION_GROUP_ID(cfgOptGrpPg),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_MAIN_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_ASYNC_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_LOCAL_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_REMOTE_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
"\n"
" PARSE_RULE_OPTIONAL\n"
" (\n"
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_FILTER_CMD\n"
" (\n"
" PARSE_RULE_VAL_CMD(cfgCmdArchiveGet),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_STR(parseRuleValStrQT_host1_QT),\n"
" ),\n"
" ),\n"
" ),\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION\n"
" (\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" PARSE_RULE_OPTION_NAME(\"pg-path\"),\n"
" PARSE_RULE_OPTION_TYPE(cfgOptTypeHash),\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" PARSE_RULE_OPTION_RESET(true),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" PARSE_RULE_OPTION_REQUIRED(true),\n"
" PARSE_RULE_OPTION_SECTION(cfgSectionStanza),\n"
" PARSE_RULE_OPTION_MULTI(true),\n"
" PARSE_RULE_OPTION_GROUP_MEMBER(true),\n"
" PARSE_RULE_OPTION_GROUP_ID(cfgOptGrpPg),\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" PARSE_RULE_OPTION_DEPRECATE_MATCH(true),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_MAIN_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_ASYNC_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_LOCAL_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_REMOTE_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION\n"
" (\n"
" PARSE_RULE_OPTION_NAME(\"stanza\"),\n"
" PARSE_RULE_OPTION_TYPE(cfgOptTypeList),\n"
" PARSE_RULE_OPTION_REQUIRED(true),\n"
" PARSE_RULE_OPTION_SECTION(cfgSectionCommandLine),\n"
" PARSE_RULE_OPTION_MULTI(true),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_MAIN_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_ASYNC_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_LOCAL_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_REMOTE_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
" ),\n"
"\n"
COMMENT_SEPARATOR "\n"
" PARSE_RULE_OPTION\n"
" (\n"
" PARSE_RULE_OPTION_NAME(\"timeout\"),\n"
" PARSE_RULE_OPTION_TYPE(cfgOptTypeTime),\n"
" PARSE_RULE_OPTION_REQUIRED(true),\n"
" PARSE_RULE_OPTION_SECTION(cfgSectionCommandLine),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_MAIN_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_ASYNC_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_LOCAL_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
" PARSE_RULE_OPTION_COMMAND_ROLE_REMOTE_VALID_LIST\n"
" (\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdArchiveGet)\n"
" PARSE_RULE_OPTION_COMMAND(cfgCmdBackup)\n"
" ),\n"
"\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" (\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_FILTER_CMD\n"
" (\n"
" PARSE_RULE_VAL_CMD(cfgCmdArchiveGet),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_ALLOW_RANGE\n"
" (\n"
" PARSE_RULE_VAL_INT(parseRuleValInt5000),\n"
" PARSE_RULE_VAL_INT(parseRuleValInt50000),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_INT(parseRuleValInt30000),\n"
" PARSE_RULE_VAL_STR(parseRuleValStrQT_30_QT),\n"
" ),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_FILTER_CMD\n"
" (\n"
" PARSE_RULE_VAL_CMD(cfgCmdBackup),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_ALLOW_RANGE\n"
" (\n"
" PARSE_RULE_VAL_INT(parseRuleValInt5000),\n"
" PARSE_RULE_VAL_INT(parseRuleValInt50000),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_INT(parseRuleValInt20000),\n"
" PARSE_RULE_VAL_STR(parseRuleValStrQT_20_QT),\n"
" ),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_GROUP\n"
" (\n"
" PARSE_RULE_OPTIONAL_ALLOW_RANGE\n"
" (\n"
" PARSE_RULE_VAL_INT(parseRuleValInt5000),\n"
" PARSE_RULE_VAL_INT(parseRuleValInt50000),\n"
" ),\n"
"\n"
" PARSE_RULE_OPTIONAL_DEFAULT\n"
" (\n"
" PARSE_RULE_VAL_INT(parseRuleValInt10000),\n"
" PARSE_RULE_VAL_STR(parseRuleValStrQT_10_QT),\n"
" ),\n"
" ),\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" ),\n"
" ),\n"
"};\n"
"\n"
COMMENT_BLOCK_BEGIN "\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
"Option deprecations\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
COMMENT_BLOCK_END "\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
"#define CFG_OPTION_DEPRECATE_TOTAL 7\n"
"\n"
"static const ParseRuleOptionDeprecate parseRuleOptionDeprecate[CFG_OPTION_DEPRECATE_TOTAL] =\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
"{\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" // backup-standby deprecation\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" {\n"
" .name = \"backup-standby-old\",\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" .id = cfgOptBackupStandby,\n"
" .unindexed = true,\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" },\n"
"\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" // compress-type deprecation\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" {\n"
" .name = \"compress\",\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" .id = cfgOptCompressType,\n"
" .unindexed = true,\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" },\n"
"\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" // pg-path deprecation\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" {\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" .name = \"db-path\",\n"
" .id = cfgOptPgPath,\n"
" .indexed = true,\n"
" .unindexed = true,\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" },\n"
"\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" // online deprecation\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" {\n"
" .name = \"online-old\",\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" .id = cfgOptOnline,\n"
" .unindexed = true,\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" },\n"
"\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" // pg-host deprecation\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" {\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" .name = \"pg-host\",\n"
" .id = cfgOptPgHost,\n"
" .indexed = true,\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" },\n"
"\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" // pg-path deprecation\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" {\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" .name = \"pg-path\",\n"
" .id = cfgOptPgPath,\n"
" .unindexed = true,\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" },\n"
"\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" // pg-path deprecation\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" {\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" .name = \"pg-path-indexed\",\n"
" .id = cfgOptPgPath,\n"
" .indexed = true,\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" },\n"
"};\n"
"\n"
COMMENT_BLOCK_BEGIN "\n"
"Order for option parse resolution\n"
COMMENT_BLOCK_END "\n"
"static const ConfigOption optionResolveOrder[] =\n"
"{\n"
" cfgOptStanza,\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" cfgOptBufferSize,\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" cfgOptConfig,\n"
Convert configuration optional rules to pack format. The previous format was custom for configuration parsing and was not as expressive as the pack format. An immediate benefit is that commands with the same optional rules are merged. Defaults are now represented correctly (not multiplied), which simplifies the option default functions used by help.
2021-10-16 12:35:47 -04:00
" cfgOptConfigInclude,\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" cfgOptLogLevelConsole,\n"
" cfgOptLogLevelFile,\n"
" cfgOptOnline,\n"
Increase max index allowed for pg/repo options to 256. The prior limitations were based on using getopt_long() to parse command-line options, which required a static list of allowed options. Setting index max too high bloated the binary unacceptably. 45a4e80 replaced the functionality of getopt_long() but the static list remained. Improve cfgParseOption() to use available option data and remove the need for a static list. This also allows the option deprecations to be represented more compactly. Index max is still capped at 256 because a large enough index could cause parseOptionIdxValue() to run out of memory since it allocates a static list based on the highest index found. If that function were improved with a map of found index values then index max could be set to UINT64_MAX. Note that deprecations no longer set an index max or define whether reset is valid. These were space-saving measures which are no longer required. This means that indexed deprecated options will also be valid up to 256 and always allow reset, but it doesn't seem worth additional code to limit this behavior. cfgParseOptionId() is no longer needed because calling cfgParseOption() with .ignoreMissingIndex = true duplicates the functionality of cfgParseOptionId(). This leads to some simplification in the help code.
2021-08-31 12:09:50 -04:00
" cfgOptPgHost,\n"
Complete migration of config code generation to C. This was started in c5ae047e but did not include generation of parse.auto.c. The parser has also been improved with better errors and multiple passes to reduce dependency on ordering and produce and cleaner output. Option order resolution now includes cycle detection.
2021-07-28 19:59:23 -04:00
" cfgOptPgPath,\n"
" cfgOptTimeout,\n"
" cfgOptBackupStandby,\n"
" cfgOptCompressLevel,\n"
" cfgOptCompressType,\n"
" cfgOptCompressLevelNetwork,\n"
"};\n");
Partial migration of config code generation to C. Parse enough of config.yaml to auto-generate config.auto.h and config.auto.c. This commit implements most of the infrastructure needed to migrate the rest of the build code to C, but each set of auto-generated files will present its own challenges. The build is now dependent on libyaml. At this point there is no need for a hard requirement, but that will come soon so it seems better to add the dependency now.
2021-07-18 19:02:01 -04:00
}
FUNCTION_HARNESS_RETURN_VOID();
}
Reference in New Issue Copy Permalink