Revert temporary syntax.

Author: ColinH

doc/Member-Extensions.md

@@ -5,7 +5,9 @@ Note that whitespace is significant within member extensions, i.e. whitespace mu
 
  * [include](#include)
  * [parse](#parse)
+ * [permanent](#permanent)
  * [schema](#schema)
+ * [temporary](#temporary)
 
 
 
@@ -87,6 +89,12 @@ foo
 
 
 
+## permanent
+
+The `permanent` member extension is used to undo the effects of [`temporary`](#temporary).
+
+
+
 ## schema
 
 The `schema` member extension tells the config library which [schema file](Writing-Schema-Files.cfg) the config must adhere to.
@@ -174,6 +182,56 @@ In order to "cancel" a schema checking the schema member can be used with `null`
 
 
 
+## temporary
+
+The `temporary` member extension marks a sub-tree of the JSON as temporary, meaning that it will be removed from the final resulting JSON value.
+This is frequently used for templates that are referenced somewhere else in the config.
+
+#### Example taoCONFIG Input File
+
+```
+(temporary template)  // Can occur before...
+
+template
+{
+    host = "127.0.0.1"
+    port = 6000
+    version = 42
+}
+
+foo = (template) +
+{
+    host = "127.0.0.2"
+}
+
+bar = (template) +
+{
+    port = 6001
+}
+
+(temporary template)  // ...and/or after.
+
+```
+
+#### Resulting JAXN Config Data
+
+```javascript
+{
+   bar: {
+      host: "127.0.0.1",
+      port: 6001,
+      version: 42
+   },
+   foo: {
+      host: "127.0.0.2",
+      port: 6000,
+      version: 42
+   }
+}
+```
+
+
+
 Copyright (c) 2018-2021 Dr. Colin Hirsch and Daniel Frey
 
 [JAXN]: https://github.com/stand-art/jaxn

doc/Writing-Config-Files.md

@@ -26,7 +26,6 @@ We assume that the reader is somewhat familiar with [JSON].
    - [Asterisks](#asterisk)
    - [References](#references)
    - [Extensions](#extensions)
-   - [Temporary](#temporary)
    - [Dotted Names](#dotted-names)
 
 Please note that, for now, this document shows basic use cases for all features, but not much beyond that.
@@ -488,7 +487,6 @@ servers.*.port = 7000  // Testing
 ```
 
 Assignments using asterisks can be combined with the literal pseudo-value `delete`.
-Assignments and additions using asterisks can be combined with the literal pseudo-values `temporary` and `permanent`.
 
 
 ## References
@@ -602,19 +600,22 @@ baz = (foo.(bar))
 }
 ```
 
-When referencing values marked as [temporary](#temporary) the copied value will not be marked as temporary, however any sub-values will retain their temporary status.
+When referencing values marked as [temporary](Member-Extensions.md#temporary) the copied value will not be marked as temporary, however any sub-values will retain their temporary status.
 Similarly schema definitions will be retained only for sub-values of the referenced value (TODO: Is this really what we want?)
 
 #### Example taoCONFIG Input File
 
 ```
-foo = temporary +
+(temporary foo)
+(temporary foo.baz)
+
+foo
 {
     bar
     {
         a = 1
     }
-    baz = temporary +
+    baz
     {
         b = 2
     }
@@ -680,71 +681,6 @@ Member extensions can similarly contain nested value extensions.
 ```
 
 
-## Temporary
-
-The literal pseudo-value `temporary` (and its counterpart, `permanent`) can occur anywhere one of the literal values `null`, `true` and `false` can occur, however it does not itself carry a value.
-Instead it marks the sub-tree of the JSON result to which it is "added" as temporary, meaning that while it is available to references it will be removed from the final resulting JSON value.
-
-#### Example taoCONFIG Input File
-
-```
-template = temporary +
-{
-    host = "127.0.0.1"
-    port = 6000
-    version = 42
-}
-
-foo = (template) +
-{
-    host = "127.0.0.2"
-}
-
-bar = (template) +
-{
-    port = 6001
-}
-
-template += temporary  // Can also be "added" later.
-
-```
-
-#### Resulting JAXN Config Data
-
-```javascript
-{
-   bar: {
-      host: "127.0.0.1",
-      port: 6001,
-      version: 42
-   },
-   foo: {
-      host: "127.0.0.2",
-      port: 6000,
-      version: 42
-   }
-}
-```
-
-Similarly, `permanent` allows removing the marking as temporary.
-Arbitrary many `temporary` and `permanent` pseudo-values can be "added" to a value with the last one "winning".
-
-#### Example taoCONFIG Input File
-
-```
-foo = temporary + permanent + 42 + permanent + temporary
-bar = temporary + temporary + 42 + permanent + permanent
-```
-
-#### Resulting JAXN Config Data
-
-```javascript
-{
-   bar: 42
-}
-```
-
-
 ## Dotted Names
 
 Wherever the name of an object member is expected it is also possible to use a name with multiple dot-separated components.

include/tao/config/access.hpp

@@ -56,8 +56,7 @@ namespace tao::config
          case key_kind::index:
             return access_index( v, k[ 0 ].get_index(), pop_front( k ) );
       }
-      assert( false );
-      std::abort();
+      throw std::logic_error( "code should be unreachable" );  // LCOV_EXCL_LINE
    }
 
 }  // namespace tao::config

include/tao/config/assign.hpp

@@ -52,8 +52,7 @@ namespace tao::config
          case key_kind::index:
             return assign( v, k[ 0 ].get_index(), pop_front( k ) );
       }
-      assert( false );
-      std::abort();
+      throw std::logic_error( "code should be unreachable" );  // LCOV_EXCL_LINE
    }
 
 }  // namespace tao::config

include/tao/config/internal/config_action.hpp

@@ -24,28 +24,6 @@ namespace tao::config::internal
       : pegtl::nothing< Rule >
    {};
 
-   template<>
-   struct config_action< rules::permanent >
-   {
-      template< typename State >
-      static void apply0( State& st, const extension_maps& )
-      {
-         const auto f = []( concat& c ) { c.temporary = false; };
-         phase1_append( st.root, st.prefix + st.suffix, f, phase1_mode::implicit );
-      }
-   };
-
-   template<>
-   struct config_action< rules::temporary >
-   {
-      template< typename State >
-      static void apply0( State& st, const extension_maps& )
-      {
-         const auto f = []( concat& c ) { c.temporary = true; };
-         phase1_append( st.root, st.prefix + st.suffix, f, phase1_mode::implicit );
-      }
-   };
-
    template<>
    struct config_action< rules::assign_head >
    {

include/tao/config/internal/config_grammar.hpp

@@ -70,10 +70,7 @@ namespace tao::config::internal::rules
 
    struct remove : pegtl::keyword< 'd', 'e', 'l', 'e', 't', 'e' > {};
 
-   struct permanent : pegtl::keyword< 'p', 'e', 'r', 'm', 'a', 'n', 'e', 'n', 't' > {};
-   struct temporary : pegtl::keyword< 't', 'e', 'm', 'p', 'o', 'r', 'a', 'r', 'y' > {};
-
-   struct value_part : pegtl::sor< array, object, permanent, temporary, bracketed_value, jaxn_value > {};
+   struct value_part : pegtl::sor< array, object, bracketed_value, jaxn_value > {};
    struct value_list : pegtl::list< value_part, pegtl::one< '+' >, jaxn::ws > {};
 
    struct assign_head : pegtl::one< ':', '=' > {};

include/tao/config/internal/config_parser.hpp

@@ -49,8 +49,10 @@ namespace tao::config::internal
                { { "include", wrap( include_function ) },
                  { "include?", wrap( include_if_function ) },
                  { "parse", wrap( member_function ) },
+                 { "permanent", wrap( permanent_function ) },
                  { "schema", wrap( schema_function ) },
-                 { "setenv", wrap( setenv_function ) } },
+                 { "setenv", wrap( setenv_function ) },
+                 { "temporary", wrap( temporary_function ) } },
                { { "parse", wrap( value_function ) } } )
       {}
 

include/tao/config/internal/member_functions.hpp

@@ -53,6 +53,14 @@ namespace tao::config::internal
       pegtl::parse_nested< rules::config_file, config_action >( p, static_cast< pegtl_input_t& >( in ), st, em );
    }
 
+   inline void permanent_function( state& st, const key1& path )
+   {
+      assert( st.suffix.empty() );
+
+      const auto f = []( concat& c ) { c.temporary = false; };
+      phase1_append( st.root, st.prefix + path, f, phase1_mode::implicit );
+   }
+
    inline void schema_function( state& st, const std::optional< std::string >& s )
    {
       assert( st.suffix.empty() );
@@ -75,6 +83,14 @@ namespace tao::config::internal
 #endif
    }
 
+   inline void temporary_function( state& st, const key1& path )
+   {
+      assert( st.suffix.empty() );
+
+      const auto f = []( concat& c ) { c.temporary = true; };
+      phase1_append( st.root, st.prefix + path, f, phase1_mode::implicit );
+   }
+
 }  // namespace tao::config::internal
 
 #endif

include/tao/config/internal/phase2_insert.hpp

@@ -23,6 +23,9 @@ namespace tao::config::internal
             if( m.second.remove ) {
                pair.first->second.remove = true;
             }
+            if( m.second.temporary ) {
+               pair.first->second.temporary = true;
+            }
             pair.first->second.concat.splice( pair.first->second.concat.begin(), m.second.concat );
          }
       }

include/tao/config/internal/phase2_replace.hpp

@@ -126,8 +126,10 @@ namespace tao::config::internal
             return;
          }
          i->set_object( star.position );
+
          for( const auto& name : names ) {
-            i->get_object().object.try_emplace( name, star );
+            [[maybe_unused]] const auto [ j, b ] = i->get_object().object.try_emplace( name, star );
+            assert( b && ( j->second.temporary == star.temporary ) );
          }
          ++i;
       }
@@ -139,6 +141,7 @@ namespace tao::config::internal
                continue;
             }
             c.remove = s.remove;
+            c.temporary |= s.temporary;
             c.concat.insert( c.concat.begin(), s.concat.begin(), s.concat.end() );
          }
       }
@@ -150,6 +153,7 @@ namespace tao::config::internal
                c.remove = true;
                c.concat.clear();
             }
+            c.temporary |= s.temporary;
             c.concat.insert( c.concat.end(), s.concat.begin(), s.concat.end() );
          }
       }