nhyatt/putty-source
1
0
Fork 0
mirror of https://git.tartarus.org/simon/putty.git synced 2025-01-09 17:38:00 +00:00
Code Issues Projects Releases Wiki Activity
841bf321d4
putty-source/conf.h

1289 lines
34 KiB
C
Raw Normal View History

Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
/*
* Master list of configuration options living in the Conf data
* structure.
*
* Each CONF_OPTION directive defines a single CONF_foo primary key in
* Conf, and can be equipped with the following properties:
*
* - VALUE_TYPE: the type of data associated with that key
* - SUBKEY_TYPE: if the primary key goes with a subkey (that is, the
* primary key identifies some mapping from subkeys to values), the
* data type of the subkey
Centralise defaults for non-saved options. These are now specified in conf.h and filled in by automated code, which means test_conf can make sure we didn't forget to provide them. The default for a mapping type (not that we currently have any unsaved ones) is expected to be empty. Also, while adding test_conf checks, I realised I hadn't filled in the rest of the comment in conf.h. Belatedly updated that.
2023-09-22 15:30:24 +00:00
* - DEFAULT_INT, DEFAULT_STR, DEFAULT_BOOL: the default value for
* the key, if no save data is available. Must match VALUE_TYPE, if
* the key has no subkey. Otherwise, no default is permitted, and
* the default value of the mapping is assumed to be empty (and if
* not, then LOAD_CUSTOM code must override that).
* - SAVE_KEYWORD: the keyword used for the option in the Windows
* registry or ~/.putty/sessions save files.
* - STORAGE_ENUM: for int-typed settings with no subkeys, this
* identifies an enumeration in conf-enums.h which maps internal
* values of the setting in the Conf to values in the saved data.
* - LOAD_CUSTOM, SAVE_CUSTOM: suppress automated loading or saving
* (respectively) of this setting, in favour of manual code in
* settings.c load_open_settings() or save_open_settings()
* respectively.
* - NOT_SAVED: indicate that this setting is not part of saved
* session data at all.
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
*/
CONF_OPTION(host,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("HostName"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(port,
VALUE_TYPE(INT),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
SAVE_KEYWORD("PortNumber"),
LOAD_CUSTOM, /* default value depends on the value of CONF_protocol */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(protocol,
VALUE_TYPE(INT), /* PROT_SSH, PROT_TELNET etc */
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM,
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
* Notionally SAVE_KEYWORD("Protocol"), but saving/loading is handled by
* custom code because the stored value is a string representation
* of the protocol name.
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(addressfamily,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(ADDRTYPE_UNSPEC),
SAVE_KEYWORD("AddressFamily"),
STORAGE_ENUM(addressfamily),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(close_on_exit,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("CloseOnExit"),
STORAGE_ENUM(off_auto_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(warn_on_close,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("WarnOnClose"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ping_interval,
VALUE_TYPE(INT), /* in seconds */
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM,
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
* Saving/loading is handled by custom code because for historical
* reasons this value corresponds to two save keywords,
* "PingInterval" (measured in minutes) and "PingIntervalSecs"
* (measured in seconds), which are added together on loading.
* Rationale: the value was once measured in minutes, and the
* seconds field was added later.
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(tcp_nodelay,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("TCPNoDelay"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(tcp_keepalives,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("TCPKeepalives"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(loghost, /* logical host being contacted, for host key check */
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("LogHost"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
/* Proxy options */
CONF_OPTION(proxy_exclude_list,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("ProxyExcludeList"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(proxy_dns,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("ProxyDNS"),
STORAGE_ENUM(off_auto_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(even_proxy_localhost,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("ProxyLocalhost"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(proxy_type,
VALUE_TYPE(INT), /* PROXY_NONE, PROXY_SOCKS4, ... */
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
STORAGE_ENUM(proxy_type),
SAVE_KEYWORD("ProxyMethod"),
LOAD_CUSTOM,
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
* Custom load code: there was an earlier keyword "ProxyType"
* using a different enumeration, in which SOCKS4 and SOCKS5
* shared a value, and a second keyword "ProxySOCKSVersion"
* disambiguated.
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(proxy_host,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR("proxy"),
SAVE_KEYWORD("ProxyHost"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(proxy_port,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(80),
SAVE_KEYWORD("ProxyPort"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(proxy_username,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("ProxyUsername"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(proxy_password,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("ProxyPassword"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(proxy_telnet_command,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR("connect %host %port\\n"),
SAVE_KEYWORD("ProxyTelnetCommand"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(proxy_log_to_term,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(FORCE_OFF),
SAVE_KEYWORD("ProxyLogToTerm"),
STORAGE_ENUM(on_off_auto),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
/* SSH options */
CONF_OPTION(remote_cmd,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("RemoteCommand"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(remote_cmd2,
/*
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
* Fallback command to try to run if remote_cmd fails. Only set
* internally by PSCP and PSFTP (so that they can try multiple
* methods of running an SFTP server at the remote end); never set
* by user configuration, or loaded or saved.
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
*/
VALUE_TYPE(STR),
Centralise defaults for non-saved options. These are now specified in conf.h and filled in by automated code, which means test_conf can make sure we didn't forget to provide them. The default for a mapping type (not that we currently have any unsaved ones) is expected to be empty. Also, while adding test_conf checks, I realised I hadn't filled in the rest of the comment in conf.h. Belatedly updated that.
2023-09-22 15:30:24 +00:00
DEFAULT_STR(""),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
NOT_SAVED,
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(nopty,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("NoPTY"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(compression,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("Compression"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_kexlist,
SUBKEY_TYPE(INT), /* indices in preference order: 0,...,KEX_MAX-1
* (lower is more preferred) */
VALUE_TYPE(INT), /* KEX_* enum values */
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* necessary for preference lists */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_hklist,
SUBKEY_TYPE(INT), /* indices in preference order: 0,...,HK_MAX-1
* (lower is more preferred) */
VALUE_TYPE(INT), /* HK_* enum values */
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* necessary for preference lists */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_prefer_known_hostkeys,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("PreferKnownHostKeys"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_rekey_time,
VALUE_TYPE(INT), /* in minutes */
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(60),
SAVE_KEYWORD("RekeyTime"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_rekey_data,
VALUE_TYPE(STR), /* string encoding e.g. "100K", "2M", "1G" */
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR("1G"),
SAVE_KEYWORD("RekeyBytes"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(tryagent,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("TryAgent"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(agentfwd,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("AgentFwd"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(change_username, /* allow username switching in SSH-2 */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("ChangeUsername"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_cipherlist,
SUBKEY_TYPE(INT), /* indices in preference order: 0,...,CIPHER_MAX-1
* (lower is more preferred) */
VALUE_TYPE(INT), /* CIPHER_* enum values */
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* necessary for preference lists */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(keyfile,
VALUE_TYPE(FILENAME),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
SAVE_KEYWORD("PublicKeyFile"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(detached_cert,
VALUE_TYPE(FILENAME),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
SAVE_KEYWORD("DetachedCertificate"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(auth_plugin,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("AuthPlugin"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshprot,
/*
* Which SSH protocol to use.
*
* For historical reasons, the current legal values for CONF_sshprot
* are:
* 0 = SSH-1 only
* 3 = SSH-2 only
*
* We used to also support
* 1 = SSH-1 with fallback to SSH-2
* 2 = SSH-2 with fallback to SSH-1
*
* and we continue to use 0/3 in storage formats rather than the more
* obvious 1/2 to avoid surprises if someone saves a session and later
* downgrades PuTTY. So it's easier to use these numbers internally too.
*/
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(3),
SAVE_KEYWORD("SshProt"),
STORAGE_ENUM(ssh_protocol),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_simple,
/*
* This means that we promise never to open any channel other
* than the main one, which means it can safely use a very large
* window in SSH-2.
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
*
* Only ever set internally by file transfer tools; never set by
* user configuration, or loaded or saved.
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
*/
VALUE_TYPE(BOOL),
Centralise defaults for non-saved options. These are now specified in conf.h and filled in by automated code, which means test_conf can make sure we didn't forget to provide them. The default for a mapping type (not that we currently have any unsaved ones) is expected to be empty. Also, while adding test_conf checks, I realised I hadn't filled in the rest of the comment in conf.h. Belatedly updated that.
2023-09-22 15:30:24 +00:00
DEFAULT_BOOL(false),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
NOT_SAVED,
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_connection_sharing,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("ConnectionSharing"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_connection_sharing_upstream,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("ConnectionSharingUpstream"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_connection_sharing_downstream,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("ConnectionSharingDownstream"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_manual_hostkeys,
/*
* Manually configured host keys to accept regardless of the state
* of the host key cache.
*
* This is conceptually a set rather than a dictionary: every
* value in this map is the empty string, and the set of subkeys
* that exist is the important data.
*/
SUBKEY_TYPE(STR),
VALUE_TYPE(STR),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* necessary for mappings */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh2_des_cbc, /* "des-cbc" unrecommended SSH-2 cipher */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("SSH2DES"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_no_userauth, /* bypass "ssh-userauth" (SSH-2 only) */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("SshNoAuth"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_no_trivial_userauth, /* disable trivial types of auth */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("SshNoTrivialAuth"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_show_banner, /* show USERAUTH_BANNERs (SSH-2 only) */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("SshBanner"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(try_tis_auth,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("AuthTIS"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(try_ki_auth,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("AuthKI"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(try_gssapi_auth, /* attempt gssapi via ssh userauth */
VALUE_TYPE(BOOL),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* under #ifndef NO_GSSAPI */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(try_gssapi_kex, /* attempt gssapi via ssh kex */
VALUE_TYPE(BOOL),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* under #ifndef NO_GSSAPI */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(gssapifwd, /* forward tgt via gss */
VALUE_TYPE(BOOL),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* under #ifndef NO_GSSAPI */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(gssapirekey, /* KEXGSS refresh interval (mins) */
VALUE_TYPE(INT),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* under #ifndef NO_GSSAPI */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_gsslist,
SUBKEY_TYPE(INT), /* indices in preference order: 0,...,ngsslibs
* (lower is more preferred; ngsslibs is a platform-
* dependent value) */
VALUE_TYPE(INT), /* indices of GSSAPI lib types (platform-dependent) */
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* necessary for preference lists, also this
* setting is under #ifndef NO_GSSAPI */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_gss_custom,
VALUE_TYPE(FILENAME),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* under #ifndef NO_GSSAPI */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_subsys, /* run a subsystem rather than a command */
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
* Only set internally by PSCP and PSFTP; never set by user
* configuration, or loaded or saved.
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
VALUE_TYPE(BOOL),
Centralise defaults for non-saved options. These are now specified in conf.h and filled in by automated code, which means test_conf can make sure we didn't forget to provide them. The default for a mapping type (not that we currently have any unsaved ones) is expected to be empty. Also, while adding test_conf checks, I realised I hadn't filled in the rest of the comment in conf.h. Belatedly updated that.
2023-09-22 15:30:24 +00:00
DEFAULT_BOOL(false),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
NOT_SAVED,
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
Centralise defaults for non-saved options. These are now specified in conf.h and filled in by automated code, which means test_conf can make sure we didn't forget to provide them. The default for a mapping type (not that we currently have any unsaved ones) is expected to be empty. Also, while adding test_conf checks, I realised I hadn't filled in the rest of the comment in conf.h. Belatedly updated that.
2023-09-22 15:30:24 +00:00
CONF_OPTION(ssh_subsys2, /* fallback to go with remote_cmd2 */
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
* Only set internally by PSCP and PSFTP; never set by user
* configuration, or loaded or saved.
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
VALUE_TYPE(BOOL),
Centralise defaults for non-saved options. These are now specified in conf.h and filled in by automated code, which means test_conf can make sure we didn't forget to provide them. The default for a mapping type (not that we currently have any unsaved ones) is expected to be empty. Also, while adding test_conf checks, I realised I hadn't filled in the rest of the comment in conf.h. Belatedly updated that.
2023-09-22 15:30:24 +00:00
DEFAULT_BOOL(false),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
NOT_SAVED,
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_no_shell, /* avoid running a shell */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("SshNoShell"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_nc_host, /* host to connect to in `nc' mode */
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
* Only set by the '-nc' command-line option and by the SSH proxy
* code. There's no GUI config option for this, and therefore it's
* also never loaded or saved.
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
VALUE_TYPE(STR),
Centralise defaults for non-saved options. These are now specified in conf.h and filled in by automated code, which means test_conf can make sure we didn't forget to provide them. The default for a mapping type (not that we currently have any unsaved ones) is expected to be empty. Also, while adding test_conf checks, I realised I hadn't filled in the rest of the comment in conf.h. Belatedly updated that.
2023-09-22 15:30:24 +00:00
DEFAULT_STR(""),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
NOT_SAVED,
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ssh_nc_port, /* port to connect to in `nc' mode */
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
* Only set by the '-nc' command-line option and by the SSH proxy
* code. There's no GUI config option for this, and therefore it's
* also never loaded or saved.
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
VALUE_TYPE(INT),
Centralise defaults for non-saved options. These are now specified in conf.h and filled in by automated code, which means test_conf can make sure we didn't forget to provide them. The default for a mapping type (not that we currently have any unsaved ones) is expected to be empty. Also, while adding test_conf checks, I realised I hadn't filled in the rest of the comment in conf.h. Belatedly updated that.
2023-09-22 15:30:24 +00:00
DEFAULT_INT(0),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
NOT_SAVED,
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
/* Telnet options */
CONF_OPTION(termtype,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR("xterm"),
SAVE_KEYWORD("TerminalType"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(termspeed,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR("38400,38400"),
SAVE_KEYWORD("TerminalSpeed"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ttymodes,
conf.h: improve comments for a couple of options.
2023-09-22 16:12:10 +00:00
/*
* The full set of permitted subkeys is listed in
* ssh/ttymode-list.h, as the first parameter of each TTYMODE_CHAR
* or TTYMODE_FLAG macro.
*
* The permitted value strings are:
*
* - "N" means do not include a record for this mode at all in
* the terminal mode data in the "pty-req" channel request.
* Corresponds to setting the mode to 'Nothing' in the GUI.
* - "A" means use PuTTY's automatic default, matching the
* settings for GUI PuTTY's terminal window or Unix Plink's
* controlling tty. Corresponds to setting 'Auto' in the GUI.
* - "V" followed by further string data means send a custom
* value to the SSH server. Values are as documented in the
* manual.
*/
SUBKEY_TYPE(STR),
VALUE_TYPE(STR),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* necessary for mappings */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(environmt,
SUBKEY_TYPE(STR), /* environment variable name */
VALUE_TYPE(STR), /* environment variable value */
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* necessary for mappings */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(username,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("UserName"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(username_from_env,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("UserNameFromEnvironment"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(localusername,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("LocalUserName"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(rfc_environ,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("RFCEnviron"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(passive_telnet,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("PassiveTelnet"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
/* Serial port options */
CONF_OPTION(serline,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("SerialLine"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(serspeed,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(9600),
SAVE_KEYWORD("SerialSpeed"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(serdatabits,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(8),
SAVE_KEYWORD("SerialDataBits"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(serstopbits,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(2),
SAVE_KEYWORD("SerialStopHalfbits"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(serparity,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(SER_PAR_NONE),
SAVE_KEYWORD("SerialParity"),
STORAGE_ENUM(serparity),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(serflow,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(SER_FLOW_XONXOFF),
SAVE_KEYWORD("SerialFlowControl"),
STORAGE_ENUM(serflow),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
/* SUPDUP options */
CONF_OPTION(supdup_location,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR("The Internet"),
SAVE_KEYWORD("SUPDUPLocation"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(supdup_ascii_set,
VALUE_TYPE(INT),
Fix type mismatches in new conf_key_info. I suspected there'd be one or two mistakes introduced by that transcription in spite of the test suite, and there were! CONF_mouseautocopy had its default labelled as int rather than bool, because it didn't _look_ boolean to my conversion scripts or to my eyeballs - but its default value is actually a macro that expands to 'true' or 'false' (depending on platform), so it is really. And CONF_supdup_ascii_set, conversely, is an int which had its default labelled as bool, which was due to my conversion scripts faithfully transcribing the same confusion in the original code.
2023-09-22 14:31:02 +00:00
DEFAULT_INT(SUPDUP_CHARSET_ASCII),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
SAVE_KEYWORD("SUPDUPCharset"),
STORAGE_ENUM(supdup_charset),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(supdup_more,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("SUPDUPMoreProcessing"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(supdup_scroll,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("SUPDUPScrolling"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
/* Keyboard options */
CONF_OPTION(bksp_is_delete,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("BackspaceIsDelete"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(rxvt_homeend,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("RXVTHomeEnd"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(funky_type,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(FUNKY_TILDE),
SAVE_KEYWORD("LinuxFunctionKeys"),
STORAGE_ENUM(funky_type),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sharrow_type,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(SHARROW_APPLICATION),
SAVE_KEYWORD("ShiftedArrowKeys"),
STORAGE_ENUM(sharrow_type),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(no_applic_c, /* totally disable app cursor keys */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("NoApplicationCursors"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(no_applic_k, /* totally disable app keypad */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("NoApplicationKeys"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(no_mouse_rep, /* totally disable mouse reporting */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("NoMouseReporting"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(no_remote_resize, /* disable remote resizing */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("NoRemoteResize"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(no_alt_screen, /* disable alternate screen */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("NoAltScreen"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(no_remote_wintitle, /* disable remote retitling */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("NoRemoteWinTitle"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(no_remote_clearscroll, /* disable ESC[3J */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("NoRemoteClearScroll"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(no_dbackspace, /* disable destructive backspace */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("NoDBackspace"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(no_remote_charset, /* disable remote charset config */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("NoRemoteCharset"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(remote_qtitle_action, /* handling of remote window title queries */
VALUE_TYPE(INT),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
STORAGE_ENUM(remote_qtitle_action),
SAVE_KEYWORD("RemoteQTitleAction"),
LOAD_CUSTOM, /* older versions had a boolean "NoRemoteQTitle"
* before we ended up with three options */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(app_cursor,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("ApplicationCursorKeys"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(app_keypad,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("ApplicationKeypad"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(nethack_keypad,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("NetHackKeypad"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(telnet_keyboard,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("TelnetKey"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(telnet_newline,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("TelnetRet"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(alt_f4, /* is it special? */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("AltF4"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(alt_space, /* is it special? */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("AltSpace"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(alt_only, /* is it special? */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("AltOnly"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(localecho,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("LocalEcho"),
STORAGE_ENUM(on_off_auto),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(localedit,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("LocalEdit"),
STORAGE_ENUM(on_off_auto),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(alwaysontop,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("AlwaysOnTop"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(fullscreenonaltenter,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("FullScreenOnAltEnter"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(scroll_on_key,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("ScrollOnKey"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(scroll_on_disp,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("ScrollOnDisp"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(erase_to_scrollback,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("EraseToScrollback"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(compose_key,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("ComposeKey"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ctrlaltkeys,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("CtrlAltKeys"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(osx_option_meta,
VALUE_TYPE(BOOL),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* under #ifdef OSX_META_KEY_CONFIG */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(osx_command_meta,
VALUE_TYPE(BOOL),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* under #ifdef OSX_META_KEY_CONFIG */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(wintitle, /* initial window title */
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("WinTitle"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
/* Terminal options */
CONF_OPTION(savelines,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(2000),
SAVE_KEYWORD("ScrollbackLines"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(dec_om,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("DECOriginMode"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(wrap_mode,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("AutoWrapMode"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(lfhascr,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("LFImpliesCR"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(cursor_type,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(0),
SAVE_KEYWORD("CurType"),
STORAGE_ENUM(cursor_type),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(blink_cur,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("BlinkCur"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(beep,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(BELL_DEFAULT),
SAVE_KEYWORD("Beep"),
STORAGE_ENUM(beep),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(beep_ind,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(B_IND_DISABLED),
SAVE_KEYWORD("BeepInd"),
STORAGE_ENUM(beep_indication),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(bellovl, /* bell overload protection active? */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("BellOverload"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(bellovl_n, /* number of bells to cause overload */
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(5),
SAVE_KEYWORD("BellOverloadN"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(bellovl_t, /* time interval for overload (ticks) */
VALUE_TYPE(INT),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM,
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
* Loading and saving is done in custom code because the format is
* platform-dependent for historical reasons: on Unix, the stored
* value is multiplied by 1000. (And since TICKSPERSEC=1000 on
* that platform, it means the stored value is interpreted in
* microseconds.)
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(bellovl_s, /* period of silence to re-enable bell (s) */
VALUE_TYPE(INT),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM,
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
* Loading and saving is done in custom code because the format is
* platform-dependent for historical reasons: on Unix, the stored
* value is multiplied by 1000. (And since TICKSPERSEC=1000 on
* that platform, it means the stored value is interpreted in
* microseconds.)
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(bell_wavefile,
VALUE_TYPE(FILENAME),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
SAVE_KEYWORD("BellWaveFile"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(scrollbar,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("ScrollBar"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(scrollbar_in_fullscreen,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("ScrollBarFullScreen"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(resize_action,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(RESIZE_TERM),
SAVE_KEYWORD("LockSize"),
STORAGE_ENUM(resize_effect),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(bce,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("BCE"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(blinktext,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("BlinkText"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(win_name_always,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("WinNameAlways"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(width,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(80),
SAVE_KEYWORD("TermWidth"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(height,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(24),
SAVE_KEYWORD("TermHeight"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(font,
VALUE_TYPE(FONT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
SAVE_KEYWORD("Font"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(font_quality,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(FQ_DEFAULT),
SAVE_KEYWORD("FontQuality"),
STORAGE_ENUM(font_quality),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(logfilename,
VALUE_TYPE(FILENAME),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
SAVE_KEYWORD("LogFileName"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(logtype,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(LGTYP_NONE),
SAVE_KEYWORD("LogType"),
STORAGE_ENUM(log_type),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(logxfovr,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(LGXF_ASK),
SAVE_KEYWORD("LogFileClash"),
STORAGE_ENUM(log_to_existing_file),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(logflush,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("LogFlush"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(logheader,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("LogHeader"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(logomitpass,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("SSHLogOmitPasswords"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(logomitdata,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("SSHLogOmitData"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(hide_mouseptr,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("HideMousePtr"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sunken_edge,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("SunkenEdge"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(window_border,
VALUE_TYPE(INT), /* in pixels */
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(1),
SAVE_KEYWORD("WindowBorder"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(answerback,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR("PuTTY"),
SAVE_KEYWORD("Answerback"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(printer,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("Printer"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(no_arabicshaping,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("DisableArabicShaping"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(no_bidi,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("DisableBidi"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
Add a Features checkbox to disable bracketed paste mode. I've had more than one conversation recently in which users have mentioned finding this mode inconvenient. I don't know whether any of them would want to turn it off completely, but it seems likely that _somebody_ will, sooner or later. So here's an option to do that.
2024-08-10 11:11:28 +00:00
CONF_OPTION(no_bracketed_paste,
VALUE_TYPE(BOOL),
DEFAULT_BOOL(false),
SAVE_KEYWORD("DisableBracketedPaste"),
)
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
/* Colour options */
CONF_OPTION(ansi_colour,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("ANSIColour"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(xterm_256_colour,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("Xterm256Colour"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(true_colour,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("TrueColour"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(system_colour,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("UseSystemColours"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(try_palette,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("TryPalette"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(bold_style,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(2),
SAVE_KEYWORD("BoldAsColour"),
STORAGE_ENUM(bold_style),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(colours,
conf.h: improve comments for a couple of options.
2023-09-22 16:12:10 +00:00
/*
* Subkeys in this setting are indexed based on the CONF_COLOUR_*
* enum values in putty.h. But each subkey identifies just one
* component of the RGB value. Subkey 3*a+b identifies colour #a,
* channel #b, where channels 0,1,2 mean R,G,B respectively.
*
* Values are 8-bit integers.
*/
SUBKEY_TYPE(INT),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
VALUE_TYPE(INT),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* necessary for mappings */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
/* Selection options */
CONF_OPTION(mouse_is_xterm,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(0),
SAVE_KEYWORD("MouseIsXterm"),
STORAGE_ENUM(mouse_buttons),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(rect_select,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("RectSelect"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(paste_controls,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("PasteControls"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(rawcnp,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("RawCNP"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(utf8linedraw,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("UTF8linedraw"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(rtf_paste,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("PasteRTF"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(mouse_override,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("MouseOverride"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(wordness,
SUBKEY_TYPE(INT), /* ASCII character codes (literally, just 00-7F) */
VALUE_TYPE(INT), /* arbitrary equivalence-class value for that char */
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* necessary for mappings */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(mouseautocopy,
/*
* What clipboard (if any) to copy text to as soon as it's
* selected with the mouse.
*/
VALUE_TYPE(BOOL),
Fix type mismatches in new conf_key_info. I suspected there'd be one or two mistakes introduced by that transcription in spite of the test suite, and there were! CONF_mouseautocopy had its default labelled as int rather than bool, because it didn't _look_ boolean to my conversion scripts or to my eyeballs - but its default value is actually a macro that expands to 'true' or 'false' (depending on platform), so it is really. And CONF_supdup_ascii_set, conversely, is an int which had its default labelled as bool, which was due to my conversion scripts faithfully transcribing the same confusion in the original code.
2023-09-22 14:31:02 +00:00
DEFAULT_BOOL(CLIPUI_DEFAULT_AUTOCOPY), /* platform-dependent bool-valued
* macro */
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
SAVE_KEYWORD("MouseAutocopy"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(mousepaste, /* clipboard used by one-mouse-click paste actions */
VALUE_TYPE(INT),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM,
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
* SAVE_KEYWORD("MousePaste"), but loading and saving is done by
* custom code, because the saved value is a string, and also sets
* CONF_mousepaste_custom
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ctrlshiftins, /* clipboard used by Ctrl+Ins and Shift+Ins */
VALUE_TYPE(INT),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM,
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
* SAVE_KEYWORD("CtrlShiftIns"), but loading and saving is done by
* custom code, because the saved value is a string, and also sets
* CONF_ctrlshiftins_custom
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ctrlshiftcv, /* clipboard used by Ctrl+Shift+C and Ctrl+Shift+V */
VALUE_TYPE(INT),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM,
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
* SAVE_KEYWORD("CtrlShiftCV"), but loading and saving is done by
* custom code, because the saved value is a string, and also sets
* CONF_ctrlshiftcv_custom
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(mousepaste_custom,
/* Custom clipboard name if CONF_mousepaste is set to CLIPUI_CUSTOM */
VALUE_TYPE(STR),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM,
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
* Loading and saving is handled by custom code in conjunction
* with CONF_mousepaste
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ctrlshiftins_custom,
/* Custom clipboard name if CONF_ctrlshiftins is set to CLIPUI_CUSTOM */
VALUE_TYPE(STR),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM,
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
* Loading and saving is handled by custom code in conjunction
* with CONF_ctrlshiftins
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(ctrlshiftcv_custom,
/* Custom clipboard name if CONF_ctrlshiftcv is set to CLIPUI_CUSTOM */
VALUE_TYPE(STR),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM,
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
/*
* Loading and saving is handled by custom code in conjunction
* with CONF_ctrlshiftcv
*/
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
/* Character-set translation */
CONF_OPTION(vtmode,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(VT_UNICODE),
SAVE_KEYWORD("FontVTMode"),
STORAGE_ENUM(line_drawing),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(line_codepage,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("LineCodePage"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(cjk_ambig_wide,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("CJKAmbigWide"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(utf8_override,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("UTF8Override"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(xlat_capslockcyr,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("CapsLockCyr"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
/* X11 forwarding */
CONF_OPTION(x11_forward,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("X11Forward"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(x11_display,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("X11Display"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(x11_auth,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(X11_MIT),
SAVE_KEYWORD("X11AuthType"),
STORAGE_ENUM(x11_auth),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(xauthfile,
VALUE_TYPE(FILENAME),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
SAVE_KEYWORD("X11AuthFile"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
/* Port forwarding */
CONF_OPTION(lport_acceptall, /* accept conns from hosts other than localhost */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("LocalPortAcceptAll"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(rport_acceptall, /* same for remote forwarded ports */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("RemotePortAcceptAll"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(portfwd,
/*
* Subkeys for 'portfwd' can have the following forms:
*
* [LR]localport
* [LR]localaddr:localport
*
* Dynamic forwardings are indicated by an 'L' key, and the
* special value "D". For all other forwardings, the value should
* be of the form 'host:port'.
*/
SUBKEY_TYPE(STR),
VALUE_TYPE(STR),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, SAVE_CUSTOM, /* necessary for mappings */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
/* SSH bug compatibility modes. All FORCE_ON/FORCE_OFF/AUTO */
CONF_OPTION(sshbug_ignore1,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("BugIgnore1"),
STORAGE_ENUM(auto_off_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_plainpw1,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("BugPlainPW1"),
STORAGE_ENUM(auto_off_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_rsa1,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("BugRSA1"),
STORAGE_ENUM(auto_off_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_ignore2,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("BugIgnore2"),
STORAGE_ENUM(auto_off_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_derivekey2,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("BugDeriveKey2"),
STORAGE_ENUM(auto_off_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_rsapad2,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("BugRSAPad2"),
STORAGE_ENUM(auto_off_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_pksessid2,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("BugPKSessID2"),
STORAGE_ENUM(auto_off_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_rekey2,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("BugRekey2"),
STORAGE_ENUM(auto_off_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_maxpkt2,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("BugMaxPkt2"),
STORAGE_ENUM(auto_off_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_oldgex2,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("BugOldGex2"),
STORAGE_ENUM(auto_off_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_winadj,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("BugWinadj"),
STORAGE_ENUM(auto_off_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_chanreq,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("BugChanReq"),
STORAGE_ENUM(auto_off_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_dropstart,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(FORCE_OFF),
SAVE_KEYWORD("BugDropStart"),
STORAGE_ENUM(off1_on2),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_filter_kexinit,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(FORCE_OFF),
SAVE_KEYWORD("BugFilterKexinit"),
STORAGE_ENUM(off1_on2),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_rsa_sha2_cert_userauth,
VALUE_TYPE(INT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("BugRSASHA2CertUserauth"),
STORAGE_ENUM(auto_off_on),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(sshbug_hmac2,
VALUE_TYPE(INT),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
DEFAULT_INT(AUTO),
SAVE_KEYWORD("BugHMAC2"),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
STORAGE_ENUM(auto_off_on),
Add ability to specify custom load and save separately. This allows a couple more settings to be treated automatically on save, which are more complicated on load because they still honour older alternative save keywords. In particular, CONF_proxy_type and CONF_remote_qtitle_action now have explicit enum mappings. These were needed for the automated save code, but also, I've rewritten the custom load code to use them too. This decouples the storage format of those settings from the order of values in the internal enum, which is generally an advantage of specifying storage enums explicitly. Those two settings weren't already tested by test_conf, because I wasn't changing them in previous commits. Now I've added extra code that does test them, and verified it works when backported to commit b567c9b2b5e159f where I introduced test_conf before beginning the main refactoring. A setting can also be specified explicitly as not loaded and saved at all. There were quite a few commented that way, but now there's a machine-readable indication of it. test_conf will now check that all these settings make sense together - things shouldn't have a save keyword unless they use it, and should have one if they don't, and shouldn't specify combinations of options that conflict. (For that reason, test_conf is now also running the consistency check before the main test, so that a missing keyword will cause an error message _before_ it causes a segfault, saving some debugging!)
2023-09-22 15:04:25 +00:00
LOAD_CUSTOM, /* there was an earlier keyword called "BuggyMAC" */
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
/* Options for Unix. Should split out into platform-dependent part. */
CONF_OPTION(stamp_utmp, /* used by Unix pterm */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("StampUtmp"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(login_shell, /* used by Unix pterm */
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(true),
SAVE_KEYWORD("LoginShell"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(scrollbar_on_left,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("ScrollbarOnLeft"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(shadowbold,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("ShadowBold"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(boldfont,
VALUE_TYPE(FONT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
SAVE_KEYWORD("BoldFont"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(widefont,
VALUE_TYPE(FONT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
SAVE_KEYWORD("WideFont"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(wideboldfont,
VALUE_TYPE(FONT),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
SAVE_KEYWORD("WideBoldFont"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(shadowboldoffset,
VALUE_TYPE(INT), /* in pixels */
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_INT(1),
SAVE_KEYWORD("ShadowBoldOffset"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(crhaslf,
VALUE_TYPE(BOOL),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_BOOL(false),
SAVE_KEYWORD("CRImpliesLF"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
CONF_OPTION(winclass,
VALUE_TYPE(STR),
Begin moving saved-setting semantics into conf_key_info. The new ConfKeyInfo structure now includes some fields indicating how to load and save each config option: what keyword it's stored under in the saved settings file, and what its default value should be set to when loading a session that doesn't mention it. (Including, of course, loading the null session at program startup.) So far, this only applies to the saved settings that are sufficiently simple: a single integer, string or boolean value whose internal format matches its storage format, or an integer value consisting of a finite enumeration with a fixed mapping between its internal and storage formats. Anything more difficult than that - mappings, variable defaults, config options tied together, options that still support a legacy save format alongside the up-to-date one, things under #ifdef - hasn't yet been tampered with. This allows a large amount of repetitive code in settings.c to be deleted, and replaced by simple loops over the conf_key_info array doing all the easy work. The remaining manual load/save code per option is all there because it's difficult in some way. The transitional test_conf program still passes after this upheaval.
2023-09-22 12:48:20 +00:00
DEFAULT_STR(""),
SAVE_KEYWORD("WindowClass"),
Replace conf.c's type arrays with a new conf_key_info[]. This array is planned to be exposed more widely, and used for more purposes than just checking the types of Conf options. In this commit it just takes over from the two previous smaller arrays, and adds no extra data.
2023-09-22 11:54:15 +00:00
)
Reference in New Issue Copy Permalink