Cleanup: move "macro_" prefix to after program name.

With the macro_ being defined after f_, fl_, and fll_, it makes more sense to follow the same logic with programs.
For example, macro_iki_read_X() is now iki_read_macro_X().
This more accurately associates the macro with the program via styling practices.

diff --git a/level_3/controller/c/controller.c b/level_3/controller/c/controller.c
index ac4b91a22b0bdad445464daaf57f33644d013032..75d67fe444fdbbdab2850b803ec97da931c64aa8 100644 (file)
--- a/level_3/controller/c/controller.c
+++ b/level_3/controller/c/controller.c
@@ -257,9 +257,9 @@ extern "C" {
 
     controller_file_pid_delete(*data, setting.path_pid);
 
-    macro_controller_setting_t_delete_simple(setting);
-    macro_controller_entry_cache_t_delete_simple(cache_entry);
-    macro_controller_rule_cache_t_delete_simple(cache_rule);
+    controller_macro_setting_t_delete_simple(setting);
+    controller_macro_entry_cache_t_delete_simple(cache_entry);
+    controller_macro_rule_cache_t_delete_simple(cache_rule);
 
     controller_delete_data(data);
 

diff --git a/level_3/controller/c/private-controller.h b/level_3/controller/c/private-controller.h
index 18fffbd75bb0ca412a09a29eaabc6a351195fa01..b2c7696f80847d637a13d081e2a43445780ad23e 100644 (file)
--- a/level_3/controller/c/private-controller.h
+++ b/level_3/controller/c/private-controller.h
@@ -123,7 +123,7 @@ extern "C" {
       f_string_dynamics_t_initialize, \
     }
 
-  #define macro_controller_rule_action_t_delete_simple(action) \
+  #define controller_macro_rule_action_t_delete_simple(action) \
     f_macro_string_dynamics_t_delete_simple(action.parameters)
 #endif // _di_controller_rule_action_t_
 
@@ -147,11 +147,11 @@ extern "C" {
       0, \
     }
 
-  #define macro_controller_rule_actions_t_delete_simple(actions) \
+  #define controller_macro_rule_actions_t_delete_simple(actions) \
     actions.used = actions.size; \
     while (actions.used) { \
       actions.used--; \
-      macro_controller_rule_action_t_delete_simple(actions.array[actions.used]); \
+      controller_macro_rule_action_t_delete_simple(actions.array[actions.used]); \
     } \
     f_memory_delete((void **) & actions.array, sizeof(controller_rule_action_t), actions.size); \
     actions.size = 0;
@@ -179,8 +179,8 @@ extern "C" {
       controller_rule_actions_t_initialize, \
     }
 
-  #define macro_controller_rule_item_t_delete_simple(item) \
-    macro_controller_rule_actions_t_delete_simple(item.actions)
+  #define controller_macro_rule_item_t_delete_simple(item) \
+    controller_macro_rule_actions_t_delete_simple(item.actions)
 #endif // _di_controller_rule_item_t_
 
 #ifndef _di_controller_rule_items_t_
@@ -198,11 +198,11 @@ extern "C" {
       0, \
     }
 
-  #define macro_controller_rule_items_t_delete_simple(items) \
+  #define controller_macro_rule_items_t_delete_simple(items) \
     items.used = items.size; \
     while (items.used) { \
       items.used--; \
-      macro_controller_rule_item_t_delete_simple(items.array[items.used]); \
+      controller_macro_rule_item_t_delete_simple(items.array[items.used]); \
     } \
     f_memory_delete((void **) & items.array, sizeof(controller_rule_item_t), items.size); \
     items.size = 0;
@@ -256,7 +256,7 @@ extern "C" {
       controller_rule_items_initialize, \
     }
 
-  #define macro_controller_rule_t_delete_simple(rule) \
+  #define controller_macro_rule_t_delete_simple(rule) \
     f_macro_string_dynamic_t_delete_simple(rule.id) \
     f_macro_string_dynamic_t_delete_simple(rule.name) \
     f_macro_string_dynamic_t_delete_simple(rule.control_group) \
@@ -267,7 +267,7 @@ extern "C" {
     f_macro_string_dynamics_t_delete_simple(rule.need) \
     f_macro_string_dynamics_t_delete_simple(rule.want) \
     f_macro_string_dynamics_t_delete_simple(rule.wish) \
-    macro_controller_rule_items_t_delete_simple(rule.items)
+    controller_macro_rule_items_t_delete_simple(rule.items)
 #endif // _di_controller_rule_t_
 
 #ifndef _di_controller_rules_t_
@@ -285,11 +285,11 @@ extern "C" {
       0, \
     }
 
-  #define macro_controller_rules_t_delete_simple(rules) \
+  #define controller_macro_rules_t_delete_simple(rules) \
     rules.used = rules.size; \
     while (rules.used) { \
       rules.used--; \
-      macro_controller_rule_t_delete_simple(rules.array[rules.used]); \
+      controller_macro_rule_t_delete_simple(rules.array[rules.used]); \
     } \
     f_memory_delete((void **) & rules.array, sizeof(controller_rule_t), rules.size); \
     rules.size = 0;
@@ -335,7 +335,7 @@ extern "C" {
       f_string_dynamics_t_initialize, \
     }
 
-  #define macro_controller_entry_action_t_delete_simple(action) \
+  #define controller_macro_entry_action_t_delete_simple(action) \
     f_macro_string_dynamics_t_delete_simple(action.parameters)
 #endif // _di_controller_entry_action_t_
 
@@ -354,11 +354,11 @@ extern "C" {
       0, \
     }
 
-  #define macro_controller_entry_actions_t_delete_simple(actions) \
+  #define controller_macro_entry_actions_t_delete_simple(actions) \
     actions.used = actions.size; \
     while (actions.used) { \
       actions.used--; \
-      macro_controller_entry_action_t_delete_simple(actions.array[actions.used]); \
+      controller_macro_entry_action_t_delete_simple(actions.array[actions.used]); \
     } \
     f_memory_delete((void **) & actions.array, sizeof(controller_entry_action_t), actions.size); \
     actions.size = 0;
@@ -379,9 +379,9 @@ extern "C" {
       controller_entry_actions_t_initialize, \
     }
 
-  #define macro_controller_entry_item_t_delete_simple(item) \
+  #define controller_macro_entry_item_t_delete_simple(item) \
     f_macro_string_dynamic_t_delete_simple(item.name) \
-    macro_controller_entry_actions_t_delete_simple(item.actions)
+    controller_macro_entry_actions_t_delete_simple(item.actions)
 #endif // _di_controller_entry_item_t_
 
 #ifndef _di_controller_entry_items_t_
@@ -399,11 +399,11 @@ extern "C" {
       0, \
     }
 
-  #define macro_controller_entry_items_t_delete_simple(items) \
+  #define controller_macro_entry_items_t_delete_simple(items) \
     items.used = items.size; \
     while (items.used) { \
       items.used--; \
-      macro_controller_entry_item_t_delete_simple(items.array[items.used]); \
+      controller_macro_entry_item_t_delete_simple(items.array[items.used]); \
     } \
     f_memory_delete((void **) & items.array, sizeof(controller_entry_item_t), items.size); \
     items.size = 0;
@@ -421,8 +421,8 @@ extern "C" {
       controller_entry_items_t_initialize, \
     }
 
-  #define macro_controller_entry_t_delete_simple(entry) \
-    macro_controller_entry_items_t_delete_simple(entry.items)
+  #define controller_macro_entry_t_delete_simple(entry) \
+    controller_macro_entry_items_t_delete_simple(entry.items)
 #endif // _di_controller_entry_t_
 
 #ifndef _di_controller_setting_t
@@ -447,11 +447,11 @@ extern "C" {
       controller_rules_t_initialize, \
     }
 
-  #define macro_controller_setting_t_delete_simple(setting) \
+  #define controller_macro_setting_t_delete_simple(setting) \
     f_macro_string_dynamic_t_delete_simple(setting.path_pid) \
     f_macro_string_dynamic_t_delete_simple(setting.path_setting) \
-    macro_controller_entry_t_delete_simple(setting.entry) \
-    macro_controller_rules_t_delete_simple(setting.rules)
+    controller_macro_entry_t_delete_simple(setting.entry) \
+    controller_macro_rules_t_delete_simple(setting.rules)
 #endif // _di_controller_setting_t
 
 /**

diff --git a/level_3/controller/c/private-entry.h b/level_3/controller/c/private-entry.h
index b0c656b2cbcd5291520288bca0745729ba5b76e9..b69abf251d6da0ae1b0fa8ff4ae3453399e58c2f 100644 (file)
--- a/level_3/controller/c/private-entry.h
+++ b/level_3/controller/c/private-entry.h
@@ -50,7 +50,7 @@
       f_string_dynamic_t_initialize, \
     }
 
-  #define macro_controller_entry_cache_t_delete_simple(cache) \
+  #define controller_macro_entry_cache_t_delete_simple(cache) \
     f_macro_fss_comments_t_delete_simple(cache.comments) \
     f_macro_fss_delimits_t_delete_simple(cache.delimits) \
     f_macro_fss_content_t_delete_simple(cache.content_action) \

diff --git a/level_3/controller/c/private-rule.h b/level_3/controller/c/private-rule.h
index c8cb66503604db67b6203ecf0f61281699251af5..3c8c2011a780ca7247ea3642728b0815823767f1 100644 (file)
--- a/level_3/controller/c/private-rule.h
+++ b/level_3/controller/c/private-rule.h
@@ -59,7 +59,7 @@ extern "C" {
       f_string_dynamic_t_initialize, \
     }
 
-  #define macro_controller_rule_cache_t_delete_simple(cache) \
+  #define controller_macro_rule_cache_t_delete_simple(cache) \
     f_macro_fss_comments_t_delete_simple(cache.comments) \
     f_macro_fss_delimits_t_delete_simple(cache.delimits) \
     f_macro_fss_content_t_delete_simple(cache.content_action) \

diff --git a/level_3/fss_basic_list_read/c/fss_basic_list_read.c b/level_3/fss_basic_list_read/c/fss_basic_list_read.c
index 48635404fecf8d7a2d1ce7da915ab7097add39cc..a33092074196c6a6dc363b7730a3369097eb0c8e 100644 (file)
--- a/level_3/fss_basic_list_read/c/fss_basic_list_read.c
+++ b/level_3/fss_basic_list_read/c/fss_basic_list_read.c
@@ -399,7 +399,7 @@ extern "C" {
 
       // This standard does not support nesting, so any depth greater than 0 can be predicted without processing the file.
       if (F_status_is_error_not(status) && depths.array[0].depth > 0) {
-        macro_fss_basic_list_read_depths_t_delete_simple(depths);
+        fss_basic_list_read_macro_depths_t_delete_simple(depths);
         f_macro_fss_delimits_t_delete_simple(delimits);
         f_macro_fss_comments_t_delete_simple(comments);
 
@@ -506,7 +506,7 @@ extern "C" {
         }
       }
 
-      macro_fss_basic_list_read_depths_t_delete_simple(depths);
+      fss_basic_list_read_macro_depths_t_delete_simple(depths);
       f_macro_fss_delimits_t_delete_simple(delimits);
       f_macro_fss_comments_t_delete_simple(comments);
     }

diff --git a/level_3/fss_basic_list_read/c/private-fss_basic_list_read.c b/level_3/fss_basic_list_read/c/private-fss_basic_list_read.c
index d3555e3e3881b87e39fce87d6892a5e61a59dd6c..a05252d1c848d2cbb0c809b5c5d7718f4cc0366a 100644 (file)
--- a/level_3/fss_basic_list_read/c/private-fss_basic_list_read.c
+++ b/level_3/fss_basic_list_read/c/private-fss_basic_list_read.c
@@ -16,7 +16,7 @@ extern "C" {
         depth_size = data.parameters[fss_basic_list_read_parameter_depth].values.used;
       }
 
-      macro_fss_basic_list_read_depths_t_new(status, (*depths), depth_size);
+      fss_basic_list_read_macro_depths_t_new(status, (*depths), depth_size);
 
       if (F_status_is_error(status)) {
         fl_color_print(data.error.to.stream, data.context.set.error, "%sUnable to allocate memory.%c", fll_error_print_error, f_string_eol[0]);

diff --git a/level_3/fss_basic_list_read/c/private-fss_basic_list_read.h b/level_3/fss_basic_list_read/c/private-fss_basic_list_read.h
index c748a0263e2bcdae838c7e92ba453b7fc5900dd0..ac9f10f2ea0fa06c3b2d87441a74ec1933f468fa 100644 (file)
--- a/level_3/fss_basic_list_read/c/private-fss_basic_list_read.h
+++ b/level_3/fss_basic_list_read/c/private-fss_basic_list_read.h
@@ -43,18 +43,18 @@ extern "C" {
       f_string_dynamic_t_initialize, \
     }
 
-  #define macro_fss_basic_list_read_depth_t_clear(structure) \
+  #define fss_basic_list_read_macro_depth_t_clear(structure) \
     structure.depth = 0; \
     structure.index_at = 0; \
     structure.index_name = 0; \
     structure.value_at = 0; \
     f_macro_string_dynamic_t_clear(structure.value_name)
 
-  #define macro_fss_basic_list_read_depth_t_delete(status, structure)  f_macro_string_dynamic_t_delete(status, structure.value_name)
-  #define macro_fss_basic_list_read_depth_t_destroy(status, structure) f_macro_string_dynamic_t_destroy(status, structure.value_name)
+  #define fss_basic_list_read_macro_depth_t_delete(status, structure)  f_macro_string_dynamic_t_delete(status, structure.value_name)
+  #define fss_basic_list_read_macro_depth_t_destroy(status, structure) f_macro_string_dynamic_t_destroy(status, structure.value_name)
 
-  #define macro_fss_basic_list_read_depth_t_delete_simple(structure)  f_macro_string_dynamic_t_delete_simple(structure.value_name)
-  #define macro_fss_basic_list_read_depth_t_destroy_simple(structure) f_macro_string_dynamic_t_destroy_simple(structure.value_name)
+  #define fss_basic_list_read_macro_depth_t_delete_simple(structure)  f_macro_string_dynamic_t_delete_simple(structure.value_name)
+  #define fss_basic_list_read_macro_depth_t_destroy_simple(structure) f_macro_string_dynamic_t_destroy_simple(structure.value_name)
 #endif // _di_fss_basic_list_read_depth_t_
 
 /**
@@ -74,52 +74,52 @@ extern "C" {
 
   #define fss_basic_list_read_depths_t_initialize { 0, 0, 0 }
 
-  #define macro_fss_basic_list_read_depths_t_clear(depths) f_macro_memory_structure_t_clear(depths)
+  #define fss_basic_list_read_macro_depths_t_clear(depths) f_macro_memory_structure_t_clear(depths)
 
-  #define macro_fss_basic_list_read_depths_t_new(status, depths, length) f_macro_memory_structure_t_new(status, depths, fss_basic_list_read_depth_t, length)
+  #define fss_basic_list_read_macro_depths_t_new(status, depths, length) f_macro_memory_structure_t_new(status, depths, fss_basic_list_read_depth_t, length)
 
-  #define macro_fss_basic_list_read_depths_t_delete(status, depths) \
+  #define fss_basic_list_read_macro_depths_t_delete(status, depths) \
     status = F_none; \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_basic_list_read_depth_t_delete(status, depths.array[depths.used]); \
+      fss_basic_list_read_macro_depth_t_delete(status, depths.array[depths.used]); \
       if (status != F_none) break; \
     } \
     if (status == F_none) f_macro_memory_structure_t_delete(depths, fss_basic_list_read_depth_t)
 
-  #define macro_fss_basic_list_read_depths_t_destroy(status, depths) \
+  #define fss_basic_list_read_macro_depths_t_destroy(status, depths) \
     status = F_none; \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_basic_list_read_depth_t_destroy(status, depths.array[depths.used]); \
+      fss_basic_list_read_macro_depth_t_destroy(status, depths.array[depths.used]); \
       if (status != F_none) break; \
     } \
     if (status == F_none) f_macro_memory_structure_t_destroy(depths, fss_basic_list_read_depth_t)
 
-  #define macro_fss_basic_list_read_depths_t_delete_simple(depths) \
+  #define fss_basic_list_read_macro_depths_t_delete_simple(depths) \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_basic_list_read_depth_t_delete_simple(depths.array[depths.used]); \
+      fss_basic_list_read_macro_depth_t_delete_simple(depths.array[depths.used]); \
     } \
     if (!depths.used) f_macro_memory_structure_t_delete_simple(depths, fss_basic_list_read_depth_t)
 
-  #define macro_fss_basic_list_read_depths_t_destroy_simple(depths) \
+  #define fss_basic_list_read_macro_depths_t_destroy_simple(depths) \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_basic_list_read_depth_t_destroy_simple(depths.array[depths.used]); \
+      fss_basic_list_read_macro_depth_t_destroy_simple(depths.array[depths.used]); \
     } \
     if (!depths.used) f_macro_memory_structure_t_destroy_simple(depths, fss_basic_list_read_depth_t)
 
-  #define macro_fss_basic_list_read_depths_t_resize(status, depths, new_length) \
+  #define fss_basic_list_read_macro_depths_t_resize(status, depths, new_length) \
     status = F_none; \
     if (new_length < depths.size) { \
       f_array_length_t i = depths.size - new_length; \
       for (; i < depths.size; i++) { \
-        macro_fss_basic_list_read_depth_t_delete(status, depths.array[i]); \
+        fss_basic_list_read_macro_depth_t_delete(status, depths.array[i]); \
         if (status != F_none) break; \
       } \
     } \
@@ -135,12 +135,12 @@ extern "C" {
       if (depths.used > depths.size) depths.used = new_length; \
     }
 
-  #define macro_fss_basic_list_read_depths_t_adjust(status, depths, new_length) \
+  #define fss_basic_list_read_macro_depths_t_adjust(status, depths, new_length) \
     status = F_none; \
     if (new_length < depths.size) { \
       f_array_length_t i = depths.size - new_length; \
       for (; i < depths.size; i++) { \
-        macro_fss_basic_list_read_depth_t_delete(status, depths.array[i]); \
+        fss_basic_list_read_macro_depth_t_delete(status, depths.array[i]); \
         if (status != F_none) break; \
       } \
     } \

diff --git a/level_3/fss_basic_read/c/fss_basic_read.c b/level_3/fss_basic_read/c/fss_basic_read.c
index 0d1155860d3697386e4f5db03e4a731773c459f5..412c4b99a1da008bfbacb09e1fbe2cd0738a624a 100644 (file)
--- a/level_3/fss_basic_read/c/fss_basic_read.c
+++ b/level_3/fss_basic_read/c/fss_basic_read.c
@@ -398,7 +398,7 @@ extern "C" {
 
       // This standard does not support nesting, so any depth greater than 0 can be predicted without processing the file.
       if (F_status_is_error_not(status) && depths.array[0].depth > 0) {
-        macro_fss_basic_read_depths_t_delete_simple(depths);
+        fss_basic_read_macro_depths_t_delete_simple(depths);
         f_macro_fss_delimits_t_delete_simple(delimits);
 
         if (data->parameters[fss_basic_read_parameter_total].result == f_console_result_found) {
@@ -414,7 +414,7 @@ extern "C" {
         fl_color_print(data->error.to.stream, data->context.set.notable, "%s%s", f_console_symbol_long_enable, fss_basic_read_long_select);
         fl_color_print(data->error.to.stream, data->context.set.error, "' parameter requires a positive number.%c", f_string_eol[0]);
 
-        macro_fss_basic_read_depths_t_delete_simple(depths);
+        fss_basic_read_macro_depths_t_delete_simple(depths);
         status = F_status_set_error(F_parameter);
       }
 
@@ -505,7 +505,7 @@ extern "C" {
         }
       }
 
-      macro_fss_basic_read_depths_t_delete_simple(depths);
+      fss_basic_read_macro_depths_t_delete_simple(depths);
       f_macro_fss_delimits_t_delete_simple(delimits);
     }
     else {

diff --git a/level_3/fss_basic_read/c/private-fss_basic_read.c b/level_3/fss_basic_read/c/private-fss_basic_read.c
index e337192acdb2a8df6f94c34279c342f574226422..b1b42ac55392999e7bddda9f132836f48bd2c8ad 100644 (file)
--- a/level_3/fss_basic_read/c/private-fss_basic_read.c
+++ b/level_3/fss_basic_read/c/private-fss_basic_read.c
@@ -16,7 +16,7 @@ extern "C" {
         depth_size = data.parameters[fss_basic_read_parameter_depth].values.used;
       }
 
-      macro_fss_basic_read_depths_t_new(status, (*depths), depth_size);
+      fss_basic_read_macro_depths_t_new(status, (*depths), depth_size);
 
       if (F_status_is_error(status)) {
         fl_color_print(data.error.to.stream, data.context.set.error, "%sUnable to allocate memory.%c", fll_error_print_error, f_string_eol[0]);

diff --git a/level_3/fss_basic_read/c/private-fss_basic_read.h b/level_3/fss_basic_read/c/private-fss_basic_read.h
index c03d8d0fa8071c94d6cd0c949378e327c7dea111..e44603eb1ff8e921a2d21a5e1e6c23b56acdde2d 100644 (file)
--- a/level_3/fss_basic_read/c/private-fss_basic_read.h
+++ b/level_3/fss_basic_read/c/private-fss_basic_read.h
@@ -43,18 +43,18 @@ extern "C" {
       f_string_dynamic_t_initialize, \
     }
 
-  #define macro_fss_basic_read_depth_t_clear(structure) \
+  #define fss_basic_read_macro_depth_t_clear(structure) \
     structure.depth = 0; \
     structure.index_at = 0; \
     structure.index_name = 0; \
     structure.value_at = 0; \
     f_macro_string_dynamic_t_clear(structure.value_name)
 
-  #define macro_fss_basic_read_depth_t_delete(status, structure)  f_macro_string_dynamic_t_delete(status, structure.value_name)
-  #define macro_fss_basic_read_depth_t_destroy(status, structure) f_macro_string_dynamic_t_destroy(status, structure.value_name)
+  #define fss_basic_read_macro_depth_t_delete(status, structure)  f_macro_string_dynamic_t_delete(status, structure.value_name)
+  #define fss_basic_read_macro_depth_t_destroy(status, structure) f_macro_string_dynamic_t_destroy(status, structure.value_name)
 
-  #define macro_fss_basic_read_depth_t_delete_simple(structure)  f_macro_string_dynamic_t_delete_simple(structure.value_name)
-  #define macro_fss_basic_read_depth_t_destroy_simple(structure) f_macro_string_dynamic_t_destroy_simple(structure.value_name)
+  #define fss_basic_read_macro_depth_t_delete_simple(structure)  f_macro_string_dynamic_t_delete_simple(structure.value_name)
+  #define fss_basic_read_macro_depth_t_destroy_simple(structure) f_macro_string_dynamic_t_destroy_simple(structure.value_name)
 #endif // _di_fss_basic_read_depth_t_
 
 /**
@@ -74,52 +74,52 @@ extern "C" {
 
   #define fss_basic_read_depths_t_initialize { 0, 0, 0 }
 
-  #define macro_fss_basic_read_depths_t_clear(depths) f_macro_memory_structure_t_clear(depths)
+  #define fss_basic_read_macro_depths_t_clear(depths) f_macro_memory_structure_t_clear(depths)
 
-  #define macro_fss_basic_read_depths_t_new(status, depths, length) f_macro_memory_structure_t_new(status, depths, fss_basic_read_depth_t, length)
+  #define fss_basic_read_macro_depths_t_new(status, depths, length) f_macro_memory_structure_t_new(status, depths, fss_basic_read_depth_t, length)
 
-  #define macro_fss_basic_read_depths_t_delete(status, depths) \
+  #define fss_basic_read_macro_depths_t_delete(status, depths) \
     status = F_none; \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_basic_read_depth_t_delete(status, depths.array[depths.used]); \
+      fss_basic_read_macro_depth_t_delete(status, depths.array[depths.used]); \
       if (status != F_none) break; \
     } \
     if (status == F_none) f_macro_memory_structure_t_delete(depths, fss_basic_read_depth_t)
 
-  #define macro_fss_basic_read_depths_t_destroy(status, depths) \
+  #define fss_basic_read_macro_depths_t_destroy(status, depths) \
     status = F_none; \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_basic_read_depth_t_destroy(status, depths.array[depths.used]); \
+      fss_basic_read_macro_depth_t_destroy(status, depths.array[depths.used]); \
       if (status != F_none) break; \
     } \
     if (status == F_none) f_macro_memory_structure_t_destroy(depths, fss_basic_read_depth_t)
 
-  #define macro_fss_basic_read_depths_t_delete_simple(depths) \
+  #define fss_basic_read_macro_depths_t_delete_simple(depths) \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_basic_read_depth_t_delete_simple(depths.array[depths.used]); \
+      fss_basic_read_macro_depth_t_delete_simple(depths.array[depths.used]); \
     } \
     if (!depths.used) f_macro_memory_structure_t_delete_simple(depths, fss_basic_read_depth_t)
 
-  #define macro_fss_basic_read_depths_t_destroy_simple(depths) \
+  #define fss_basic_read_macro_depths_t_destroy_simple(depths) \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_basic_read_depth_t_destroy_simple(depths.array[depths.used]); \
+      fss_basic_read_macro_depth_t_destroy_simple(depths.array[depths.used]); \
     } \
     if (!depths.used) f_macro_memory_structure_t_destroy_simple(depths, fss_basic_read_depth_t)
 
-  #define macro_fss_basic_read_depths_t_resize(status, depths, new_length) \
+  #define fss_basic_read_macro_depths_t_resize(status, depths, new_length) \
     status = F_none; \
     if (new_length < depths.size) { \
       f_array_length_t i = depths.size - new_length; \
       for (; i < depths.size; i++) { \
-        macro_fss_basic_read_depth_t_delete(status, depths.array[i]); \
+        fss_basic_read_macro_depth_t_delete(status, depths.array[i]); \
         if (status != F_none) break; \
       } \
     } \
@@ -135,12 +135,12 @@ extern "C" {
       if (depths.used > depths.size) depths.used = new_length; \
     }
 
-  #define macro_fss_basic_read_depths_t_adjust(status, depths, new_length) \
+  #define fss_basic_read_macro_depths_t_adjust(status, depths, new_length) \
     status = F_none; \
     if (new_length < depths.size) { \
       f_array_length_t i = depths.size - new_length; \
       for (; i < depths.size; i++) { \
-        macro_fss_basic_read_depth_t_delete(status, depths.array[i]); \
+        fss_basic_read_macro_depth_t_delete(status, depths.array[i]); \
         if (status != F_none) break; \
       } \
     } \

diff --git a/level_3/fss_embedded_list_read/c/fss_embedded_list_read.c b/level_3/fss_embedded_list_read/c/fss_embedded_list_read.c
index c625e52591ff591de975fae5cc830fdf8feaec7a..abcc40cbacbf3f2c6c2bfc017e2b5f11e6d22e50 100644 (file)
--- a/level_3/fss_embedded_list_read/c/fss_embedded_list_read.c
+++ b/level_3/fss_embedded_list_read/c/fss_embedded_list_read.c
@@ -489,7 +489,7 @@ extern "C" {
         }
       }
 
-      macro_fss_embedded_list_read_depths_t_delete_simple(depths);
+      fss_embedded_list_read_macro_depths_t_delete_simple(depths);
       f_macro_fss_delimits_t_delete_simple(objects_delimits);
       f_macro_fss_delimits_t_delete_simple(contents_delimits);
       f_macro_fss_comments_t_delete_simple(comments);

diff --git a/level_3/fss_embedded_list_read/c/private-fss_embedded_list_read.c b/level_3/fss_embedded_list_read/c/private-fss_embedded_list_read.c
index 727f5e60719136805ebc11edf7b4d86fba4ccb8e..3523db1df29e3829a9e4cca15e13ee0d4338e2de 100644 (file)
--- a/level_3/fss_embedded_list_read/c/private-fss_embedded_list_read.c
+++ b/level_3/fss_embedded_list_read/c/private-fss_embedded_list_read.c
@@ -102,7 +102,7 @@ extern "C" {
         i = data.parameters[fss_embedded_list_read_parameter_depth].values.used + 1;
       }
 
-      macro_fss_embedded_list_read_depths_t_new(status, (*depths), i);
+      fss_embedded_list_read_macro_depths_t_new(status, (*depths), i);
 
       if (F_status_is_error(status)) {
         fll_error_print(data.error, F_status_set_fine(status), "fss_embedded_list_read_main_preprocess_depth", F_true);

diff --git a/level_3/fss_embedded_list_read/c/private-fss_embedded_list_read.h b/level_3/fss_embedded_list_read/c/private-fss_embedded_list_read.h
index b8100592262e517010bc1150eee2a0f69621f630..5b9537910c5a8afe1a64f9a88830bf7e8fcaabdd 100644 (file)
--- a/level_3/fss_embedded_list_read/c/private-fss_embedded_list_read.h
+++ b/level_3/fss_embedded_list_read/c/private-fss_embedded_list_read.h
@@ -43,18 +43,18 @@ extern "C" {
       f_string_dynamic_t_initialize, \
     }
 
-  #define macro_fss_embedded_list_read_depth_t_clear(structure) \
+  #define fss_embedded_list_read_macro_depth_t_clear(structure) \
     structure.depth = 0; \
     structure.index_at = 0; \
     structure.index_name = 0; \
     structure.value_at = 0; \
     f_macro_string_dynamic_t_clear(structure.value_name)
 
-  #define macro_fss_embedded_list_read_depth_t_delete(status, structure)  f_macro_string_dynamic_t_delete(status, structure.value_name)
-  #define macro_fss_embedded_list_read_depth_t_destroy(status, structure) f_macro_string_dynamic_t_destroy(status, structure.value_name)
+  #define fss_embedded_list_read_macro_depth_t_delete(status, structure)  f_macro_string_dynamic_t_delete(status, structure.value_name)
+  #define fss_embedded_list_read_macro_depth_t_destroy(status, structure) f_macro_string_dynamic_t_destroy(status, structure.value_name)
 
-  #define macro_fss_embedded_list_read_depth_t_delete_simple(structure)  f_macro_string_dynamic_t_delete_simple(structure.value_name)
-  #define macro_fss_embedded_list_read_depth_t_destroy_simple(structure) f_macro_string_dynamic_t_destroy_simple(structure.value_name)
+  #define fss_embedded_list_read_macro_depth_t_delete_simple(structure)  f_macro_string_dynamic_t_delete_simple(structure.value_name)
+  #define fss_embedded_list_read_macro_depth_t_destroy_simple(structure) f_macro_string_dynamic_t_destroy_simple(structure.value_name)
 #endif // _di_fss_embedded_list_read_depth_t_
 
 /**
@@ -75,7 +75,7 @@ extern "C" {
       0, \
     }
 
-  #define macro_fss_embedded_list_read_skip_t_initialize(skip, used) \
+  #define fss_embedded_list_read_macro_skip_t_initialize(skip, used) \
     { \
       skip, \
       used, \
@@ -99,52 +99,52 @@ extern "C" {
 
   #define fss_embedded_list_read_depths_t_initialize { 0, 0, 0 }
 
-  #define macro_fss_embedded_list_read_depths_t_clear(depths) f_macro_memory_structure_t_clear(depths)
+  #define fss_embedded_list_read_macro_depths_t_clear(depths) f_macro_memory_structure_t_clear(depths)
 
-  #define macro_fss_embedded_list_read_depths_t_new(status, depths, length) f_macro_memory_structure_t_new(status, depths, fss_embedded_list_read_depth_t, length)
+  #define fss_embedded_list_read_macro_depths_t_new(status, depths, length) f_macro_memory_structure_t_new(status, depths, fss_embedded_list_read_depth_t, length)
 
-  #define macro_fss_embedded_list_read_depths_t_delete(status, depths) \
+  #define fss_embedded_list_read_macro_depths_t_delete(status, depths) \
     status = F_none; \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_embedded_list_read_depth_t_delete(status, depths.array[depths.used]); \
+      fss_embedded_list_read_macro_depth_t_delete(status, depths.array[depths.used]); \
       if (status != F_none) break; \
     } \
     if (status == F_none) f_macro_memory_structure_t_delete(depths, fss_embedded_list_read_depth_t)
 
-  #define macro_fss_embedded_list_read_depths_t_destroy(status, depths) \
+  #define fss_embedded_list_read_macro_depths_t_destroy(status, depths) \
     status = F_none; \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_embedded_list_read_depth_t_destroy(status, depths.array[depths.used]); \
+      fss_embedded_list_read_macro_depth_t_destroy(status, depths.array[depths.used]); \
       if (status != F_none) break; \
     } \
     if (status == F_none) f_macro_memory_structure_t_destroy(depths, fss_embedded_list_read_depth_t)
 
-  #define macro_fss_embedded_list_read_depths_t_delete_simple(depths) \
+  #define fss_embedded_list_read_macro_depths_t_delete_simple(depths) \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_embedded_list_read_depth_t_delete_simple(depths.array[depths.used]); \
+      fss_embedded_list_read_macro_depth_t_delete_simple(depths.array[depths.used]); \
     } \
     if (!depths.used) f_macro_memory_structure_t_delete_simple(depths, fss_embedded_list_read_depth_t)
 
-  #define macro_fss_embedded_list_read_depths_t_destroy_simple(depths) \
+  #define fss_embedded_list_read_macro_depths_t_destroy_simple(depths) \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_embedded_list_read_depth_t_destroy_simple(depths.array[depths.used]); \
+      fss_embedded_list_read_macro_depth_t_destroy_simple(depths.array[depths.used]); \
     } \
     if (!depths.used) f_macro_memory_structure_t_destroy_simple(depths, fss_embedded_list_read_depth_t)
 
-  #define macro_fss_embedded_list_read_t_depths_resize(status, depths, new_length) \
+  #define fss_embedded_list_read_macro_depths_t_resize(status, depths, new_length) \
     status = F_none; \
     if (new_length < depths.size) { \
       f_array_length_t i = depths.size - new_length; \
       for (; i < depths.size; i++) { \
-        macro_fss_embedded_list_read_depth_t_delete(status, depths.array[i]); \
+        fss_embedded_list_read_macro_depth_t_delete(status, depths.array[i]); \
         if (status != F_none) break; \
       } \
     } \
@@ -160,12 +160,12 @@ extern "C" {
       if (depths.used > depths.size) depths.used = new_length; \
     }
 
-  #define macro_fss_embedded_list_read_depths_t_adjust(status, depths, new_length) \
+  #define fss_embedded_list_read_macro_depths_t_adjust(status, depths, new_length) \
     status = F_none; \
     if (new_length < depths.size) { \
       f_array_length_t i = depths.size - new_length; \
       for (; i < depths.size; i++) { \
-        macro_fss_embedded_list_read_depth_t_delete(status, depths.array[i]); \
+        fss_embedded_list_read_macro_depth_t_delete(status, depths.array[i]); \
         if (status != F_none) break; \
       } \
     } \

diff --git a/level_3/fss_extended_list_read/c/fss_extended_list_read.c b/level_3/fss_extended_list_read/c/fss_extended_list_read.c
index 2be6b4fc6967407aff862acb82432537fbae940a..845fab7c2b9bd66d66ab37e90a1a86517df5d65b 100644 (file)
--- a/level_3/fss_extended_list_read/c/fss_extended_list_read.c
+++ b/level_3/fss_extended_list_read/c/fss_extended_list_read.c
@@ -399,7 +399,7 @@ extern "C" {
 
       // This standard does not support nesting, so any depth greater than 0 can be predicted without processing the file.
       if (F_status_is_error_not(status) && depths.array[0].depth > 0) {
-        macro_fss_extended_list_read_depths_t_delete_simple(depths);
+        fss_extended_list_read_macro_depths_t_delete_simple(depths);
         f_macro_fss_delimits_t_delete_simple(delimits);
         f_macro_fss_comments_t_delete_simple(comments);
 
@@ -506,7 +506,7 @@ extern "C" {
         }
       }
 
-      macro_fss_extended_list_read_depths_t_delete_simple(depths);
+      fss_extended_list_read_macro_depths_t_delete_simple(depths);
       f_macro_fss_delimits_t_delete_simple(delimits);
       f_macro_fss_comments_t_delete_simple(comments);
     }

diff --git a/level_3/fss_extended_list_read/c/private-fss_extended_list_read.c b/level_3/fss_extended_list_read/c/private-fss_extended_list_read.c
index 571543cc4eebe942fa406a78af3245026240b883..9e71171061c30295a0ec0d32ce6678bccf51e4e8 100644 (file)
--- a/level_3/fss_extended_list_read/c/private-fss_extended_list_read.c
+++ b/level_3/fss_extended_list_read/c/private-fss_extended_list_read.c
@@ -16,7 +16,7 @@ extern "C" {
         depth_size = data.parameters[fss_extended_list_read_parameter_depth].values.used;
       }
 
-      macro_fss_extended_list_read_depths_t_new(status, (*depths), depth_size);
+      fss_extended_list_read_macro_depths_t_new(status, (*depths), depth_size);
 
       if (F_status_is_error(status)) {
         fl_color_print(data.error.to.stream, data.context.set.error, "%sUnable to allocate memory.%c", fll_error_print_error, f_string_eol[0]);

diff --git a/level_3/fss_extended_list_read/c/private-fss_extended_list_read.h b/level_3/fss_extended_list_read/c/private-fss_extended_list_read.h
index baf2c5765634d722e66a69413ebc623fab6fd772..eb1322d068b37207c21e2b2e855d74d37a3596f5 100644 (file)
--- a/level_3/fss_extended_list_read/c/private-fss_extended_list_read.h
+++ b/level_3/fss_extended_list_read/c/private-fss_extended_list_read.h
@@ -43,18 +43,18 @@ extern "C" {
       f_string_dynamic_t_initialize, \
     }
 
-  #define macro_fss_extended_list_read_depth_t_clear(structure) \
+  #define fss_extended_list_read_macro_depth_t_clear(structure) \
     structure.depth = 0; \
     structure.index_at = 0; \
     structure.index_name = 0; \
     structure.value_at = 0; \
     f_macro_string_dynamic_t_clear(structure.value_name)
 
-  #define macro_fss_extended_list_read_depth_t_delete(status, structure)  f_macro_string_dynamic_t_delete(status, structure.value_name)
-  #define macro_fss_extended_list_read_depth_t_destroy(status, structure) f_macro_string_dynamic_t_destroy(status, structure.value_name)
+  #define fss_extended_list_read_macro_depth_t_delete(status, structure)  f_macro_string_dynamic_t_delete(status, structure.value_name)
+  #define fss_extended_list_read_macro_depth_t_destroy(status, structure) f_macro_string_dynamic_t_destroy(status, structure.value_name)
 
-  #define macro_fss_extended_list_read_depth_t_delete_simple(structure)  f_macro_string_dynamic_t_delete_simple(structure.value_name)
-  #define macro_fss_extended_list_read_depth_t_destroy_simple(structure) f_macro_string_dynamic_t_destroy_simple(structure.value_name)
+  #define fss_extended_list_read_macro_depth_t_delete_simple(structure)  f_macro_string_dynamic_t_delete_simple(structure.value_name)
+  #define fss_extended_list_read_macro_depth_t_destroy_simple(structure) f_macro_string_dynamic_t_destroy_simple(structure.value_name)
 #endif // _di_fss_extended_list_read_depth_t_
 
 /**
@@ -74,52 +74,52 @@ extern "C" {
 
   #define fss_extended_list_read_depths_t_initialize { 0, 0, 0 }
 
-  #define macro_fss_extended_list_read_depths_t_clear(depths) f_macro_memory_structure_t_clear(depths)
+  #define fss_extended_list_read_macro_depths_t_clear(depths) f_macro_memory_structure_t_clear(depths)
 
-  #define macro_fss_extended_list_read_depths_t_new(status, depths, length) f_macro_memory_structure_t_new(status, depths, fss_extended_list_read_depth_t, length)
+  #define fss_extended_list_read_macro_depths_t_new(status, depths, length) f_macro_memory_structure_t_new(status, depths, fss_extended_list_read_depth_t, length)
 
-  #define macro_fss_extended_list_read_depths_t_delete(status, depths) \
+  #define fss_extended_list_read_macro_depths_t_delete(status, depths) \
     status = F_none; \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_extended_list_read_depth_t_delete(status, depths.array[depths.used]); \
+      fss_extended_list_read_macro_depth_t_delete(status, depths.array[depths.used]); \
       if (status != F_none) break; \
     } \
     if (status == F_none) f_macro_memory_structure_t_delete(depths, fss_extended_list_read_depth_t)
 
-  #define macro_fss_extended_list_read_depths_t_destroy(status, depths) \
+  #define fss_extended_list_read_macro_depths_t_destroy(status, depths) \
     status = F_none; \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_extended_list_read_depth_t_destroy(status, depths.array[depths.used]); \
+      fss_extended_list_read_macro_depth_t_destroy(status, depths.array[depths.used]); \
       if (status != F_none) break; \
     } \
     if (status == F_none) f_macro_memory_structure_t_destroy(depths, fss_extended_list_read_depth_t)
 
-  #define macro_fss_extended_list_read_depths_t_delete_simple(depths) \
+  #define fss_extended_list_read_macro_depths_t_delete_simple(depths) \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_extended_list_read_depth_t_delete_simple(depths.array[depths.used]); \
+      fss_extended_list_read_macro_depth_t_delete_simple(depths.array[depths.used]); \
     } \
     if (!depths.used) f_macro_memory_structure_t_delete_simple(depths, fss_extended_list_read_depth_t)
 
-  #define macro_fss_extended_list_read_depths_t_destroy_simple(depths) \
+  #define fss_extended_list_read_macro_depths_t_destroy_simple(depths) \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_extended_list_read_depth_t_destroy_simple(depths.array[depths.used]); \
+      fss_extended_list_read_macro_depth_t_destroy_simple(depths.array[depths.used]); \
     } \
     if (!depths.used) f_macro_memory_structure_t_destroy_simple(depths, fss_extended_list_read_depth_t)
 
-  #define macro_fss_extended_list_read_depths_t_resize(status, depths, new_length) \
+  #define fss_extended_list_read_macro_depths_t_resize(status, depths, new_length) \
     status = F_none; \
     if (new_length < depths.size) { \
       f_array_length_t i = depths.size - new_length; \
       for (; i < depths.size; i++) { \
-        macro_fss_extended_list_read_depth_t_delete(status, depths.array[i]); \
+        fss_extended_list_read_macro_depth_t_delete(status, depths.array[i]); \
         if (status != F_none) break; \
       } \
     } \
@@ -135,12 +135,12 @@ extern "C" {
       if (depths.used > depths.size) depths.used = new_length; \
     }
 
-  #define macro_fss_extended_list_read_depths_t_adjust(status, depths, new_length) \
+  #define fss_extended_list_read_macro_depths_t_adjust(status, depths, new_length) \
     status = F_none; \
     if (new_length < depths.size) { \
       f_array_length_t i = depths.size - new_length; \
       for (; i < depths.size; i++) { \
-        macro_fss_extended_list_read_depth_t_delete(status, depths.array[i]); \
+        fss_extended_list_read_macro_depth_t_delete(status, depths.array[i]); \
         if (status != F_none) break; \
       } \
     } \

diff --git a/level_3/fss_extended_read/c/fss_extended_read.c b/level_3/fss_extended_read/c/fss_extended_read.c
index bf05f21901f524717ed5001b5273031aaa3a9578..2742f231f63c86632c47bf23174e727dc150d58f 100644 (file)
--- a/level_3/fss_extended_read/c/fss_extended_read.c
+++ b/level_3/fss_extended_read/c/fss_extended_read.c
@@ -399,7 +399,7 @@ extern "C" {
 
       // This standard does not support nesting, so any depth greater than 0 can be predicted without processing the file.
       if (F_status_is_error_not(status) && depths.array[0].depth > 0) {
-        macro_fss_extended_read_depths_t_delete_simple(depths);
+        fss_extended_read_macro_depths_t_delete_simple(depths);
         f_macro_fss_delimits_t_delete_simple(objects_delimits);
         f_macro_fss_delimits_t_delete_simple(contents_delimits);
 
@@ -506,7 +506,7 @@ extern "C" {
         }
       }
 
-      macro_fss_extended_read_depths_t_delete_simple(depths);
+      fss_extended_read_macro_depths_t_delete_simple(depths);
       f_macro_fss_delimits_t_delete_simple(objects_delimits);
       f_macro_fss_delimits_t_delete_simple(contents_delimits);
     }

diff --git a/level_3/fss_extended_read/c/private-fss_extended_read.c b/level_3/fss_extended_read/c/private-fss_extended_read.c
index a6cf57afe8ac110a5937b18a08cc6fa63165a67f..81f698604acf2c87942b9593299501c5f0e35c4d 100644 (file)
--- a/level_3/fss_extended_read/c/private-fss_extended_read.c
+++ b/level_3/fss_extended_read/c/private-fss_extended_read.c
@@ -43,7 +43,7 @@ extern "C" {
         depth_size = data.parameters[fss_extended_read_parameter_depth].values.used;
       }
 
-      macro_fss_extended_read_depths_t_new(status, (*depths), depth_size);
+      fss_extended_read_macro_depths_t_new(status, (*depths), depth_size);
 
       if (F_status_is_error(status)) {
         fl_color_print(data.error.to.stream, data.context.set.error, "%sUnable to allocate memory.%c", fll_error_print_error, f_string_eol[0]);

diff --git a/level_3/fss_extended_read/c/private-fss_extended_read.h b/level_3/fss_extended_read/c/private-fss_extended_read.h
index 1c50929f811a71b6fbab7885efc003a8a9ac0d05..76888836148befbe3e6e71adc47dea2ea0f11515 100644 (file)
--- a/level_3/fss_extended_read/c/private-fss_extended_read.h
+++ b/level_3/fss_extended_read/c/private-fss_extended_read.h
@@ -43,18 +43,18 @@ extern "C" {
       f_string_dynamic_t_initialize, \
     }
 
-  #define macro_fss_extended_read_depth_t_clear(structure) \
+  #define fss_extended_read_macro_depth_t_clear(structure) \
     structure.depth = 0; \
     structure.index_at = 0; \
     structure.index_name = 0; \
     structure.value_at = 0; \
     f_macro_string_dynamic_t_clear(structure.value_name)
 
-  #define macro_fss_extended_read_depth_t_delete(status, structure)  f_macro_string_dynamic_t_delete(status, structure.value_name)
-  #define macro_fss_extended_read_depth_t_destroy(status, structure) f_macro_string_dynamic_t_destroy(status, structure.value_name)
+  #define fss_extended_read_macro_depth_t_delete(status, structure)  f_macro_string_dynamic_t_delete(status, structure.value_name)
+  #define fss_extended_read_macro_depth_t_destroy(status, structure) f_macro_string_dynamic_t_destroy(status, structure.value_name)
 
-  #define macro_fss_extended_read_depth_t_delete_simple(structure)  f_macro_string_dynamic_t_delete_simple(structure.value_name)
-  #define macro_fss_extended_read_depth_t_destroy_simple(structure) f_macro_string_dynamic_t_destroy_simple(structure.value_name)
+  #define fss_extended_read_macro_depth_t_delete_simple(structure)  f_macro_string_dynamic_t_delete_simple(structure.value_name)
+  #define fss_extended_read_macro_depth_t_destroy_simple(structure) f_macro_string_dynamic_t_destroy_simple(structure.value_name)
 #endif // _di_fss_extended_read_depth_t_
 
 /**
@@ -74,52 +74,52 @@ extern "C" {
 
   #define fss_extended_read_depths_t_initialize { 0, 0, 0 }
 
-  #define macro_fss_extended_read_depths_t_clear(depths) f_macro_memory_structure_t_clear(depths)
+  #define fss_extended_read_macro_depths_t_clear(depths) f_macro_memory_structure_t_clear(depths)
 
-  #define macro_fss_extended_read_depths_t_new(status, depths, length) f_macro_memory_structure_t_new(status, depths, fss_extended_read_depth_t, length)
+  #define fss_extended_read_macro_depths_t_new(status, depths, length) f_macro_memory_structure_t_new(status, depths, fss_extended_read_depth_t, length)
 
-  #define macro_fss_extended_read_depths_t_delete(status, depths) \
+  #define fss_extended_read_macro_depths_t_delete(status, depths) \
     status = F_none; \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_extended_read_depth_t_delete(status, depths.array[depths.used]); \
+      fss_extended_read_macro_depth_t_delete(status, depths.array[depths.used]); \
       if (status != F_none) break; \
     } \
     if (status == F_none) f_macro_memory_structure_t_delete(depths, fss_extended_read_depth_t)
 
-  #define macro_fss_extended_read_depths_t_destroy(status, depths) \
+  #define fss_extended_read_macro_depths_t_destroy(status, depths) \
     status = F_none; \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_extended_read_depth_t_destroy(status, depths.array[depths.used]); \
+      fss_extended_read_macro_depth_t_destroy(status, depths.array[depths.used]); \
       if (status != F_none) break; \
     } \
     if (status == F_none) f_macro_memory_structure_t_destroy(depths, fss_extended_read_depth_t)
 
-  #define macro_fss_extended_read_depths_t_delete_simple(depths) \
+  #define fss_extended_read_macro_depths_t_delete_simple(depths) \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_extended_read_depth_t_delete_simple(depths.array[depths.used]); \
+      fss_extended_read_macro_depth_t_delete_simple(depths.array[depths.used]); \
     } \
     if (!depths.used) f_macro_memory_structure_t_delete_simple(depths, fss_extended_read_depth_t)
 
-  #define macro_fss_extended_read_depths_t_destroy_simple(depths) \
+  #define fss_extended_read_macro_depths_t_destroy_simple(depths) \
     depths.used = depths.size; \
     while (depths.used > 0) { \
       depths.used--; \
-      macro_fss_extended_read_depth_t_destroy_simple(depths.array[depths.used]); \
+      fss_extended_read_macro_depth_t_destroy_simple(depths.array[depths.used]); \
     } \
     if (!depths.used) f_macro_memory_structure_t_destroy_simple(depths, fss_extended_read_depth_t)
 
-  #define macro_fss_extended_read_depths_t_resize(status, depths, new_length) \
+  #define fss_extended_read_macro_depths_t_resize(status, depths, new_length) \
     status = F_none; \
     if (new_length < depths.size) { \
       f_array_length_t i = depths.size - new_length; \
       for (; i < depths.size; i++) { \
-        macro_fss_extended_read_depth_t_delete(status, depths.array[i]); \
+        fss_extended_read_macro_depth_t_delete(status, depths.array[i]); \
         if (status != F_none) break; \
       } \
     } \
@@ -135,12 +135,12 @@ extern "C" {
       if (depths.used > depths.size) depths.used = new_length; \
     }
 
-  #define macro_fss_extended_read_depths_t_adjust(status, depths, new_length) \
+  #define fss_extended_read_macro_depths_t_adjust(status, depths, new_length) \
     status = F_none; \
     if (new_length < depths.size) { \
       f_array_length_t i = depths.size - new_length; \
       for (; i < depths.size; i++) { \
-        macro_fss_extended_read_depth_t_delete(status, depths.array[i]); \
+        fss_extended_read_macro_depth_t_delete(status, depths.array[i]); \
         if (status != F_none) break; \
       } \
     } \

diff --git a/level_3/iki_read/c/iki_read.h b/level_3/iki_read/c/iki_read.h
index b7bda483d6cd458a469369b768885eff91663b97..bdde2b85868a293eb7039764b1bfc1db3712304e 100644 (file)
--- a/level_3/iki_read/c/iki_read.h
+++ b/level_3/iki_read/c/iki_read.h
@@ -153,7 +153,7 @@ extern "C" {
       f_string_static_t_initialize, \
     }
 
-  #define macro_iki_read_substitution_t_initialize(replace, with) \
+  #define iki_read_macro_substitution_t_initialize(replace, with) \
     { \
       f_macro_string_static_t_initialize(replace), \
       f_macro_string_static_t_initialize(with), \
@@ -170,25 +170,25 @@ extern "C" {
 
   #define iki_read_substitutions_t_initialize {0, 0, 0}
 
-  #define macro_iki_read_substitutions_t_clear(replacements) f_macro_memory_structure_t_clear(replacements)
+  #define iki_read_macro_substitutions_t_clear(replacements) f_macro_memory_structure_t_clear(replacements)
 
-  #define macro_iki_read_substitutions_t_new(status, replacements, length) f_macro_memory_structure_t_new(status, replacements, iki_read_substitution_t, length)
+  #define iki_read_macro_substitutions_t_new(status, replacements, length) f_macro_memory_structure_t_new(status, replacements, iki_read_substitution_t, length)
 
-  #define macro_iki_read_substitutions_t_delete_simple(replacements) \
+  #define iki_read_macro_substitutions_t_delete_simple(replacements) \
     replacements.used = replacements.size; \
     while (replacements.used > 0) { \
       replacements.used--; \
     } \
     if (!replacements.used) f_macro_memory_structure_t_delete_simple(replacements, iki_read_substitution_t)
 
-  #define macro_iki_read_substitutions_t_destroy_simple(replacements) \
+  #define iki_read_macro_substitutions_t_destroy_simple(replacements) \
     replacements.used = replacements.size; \
     while (replacements.used > 0) { \
       replacements.used--; \
     } \
     if (!replacements.used) f_macro_memory_structure_t_destroy_simple(replacements, iki_read_substitution_t)
 
-  #define macro_iki_read_substitutions_t_resize(status, replacements, new_length) \
+  #define iki_read_macro_substitutions_t_resize(status, replacements, new_length) \
     status = F_none; \
     if (new_length < replacements.size) { \
       f_array_length_t i = replacements.size - new_length; \
@@ -208,7 +208,7 @@ extern "C" {
       if (replacements.used > replacements.size) replacements.used = new_length; \
     }
 
-  #define macro_iki_read_substitutions_t_adjust(status, replacements, new_length) \
+  #define iki_read_macro_substitutions_t_adjust(status, replacements, new_length) \
     status = F_none; \
     if (new_length < replacements.size) { \
       f_array_length_t i = replacements.size - new_length; \

diff --git a/level_3/iki_read/c/private-iki_read.c b/level_3/iki_read/c/private-iki_read.c
index c78bf6ef05786eb9aae3fe4ec5767fe451896119..c8a467709ec351cb649cb5094af2ef2b12b6a329 100644 (file)
--- a/level_3/iki_read/c/private-iki_read.c
+++ b/level_3/iki_read/c/private-iki_read.c
@@ -124,7 +124,7 @@ extern "C" {
         fll_error_print(data->error, F_status_set_fine(status), "iki_read_substitutions_identify", F_true);
 
         for (f_array_length_t i = 0; i < variable->used; i++) {
-          macro_iki_read_substitutions_t_delete_simple(substitutionss[i]);
+          iki_read_macro_substitutions_t_delete_simple(substitutionss[i]);
         } // for
 
         return status;
@@ -150,7 +150,7 @@ extern "C" {
           fll_error_print(data->error, F_status_set_fine(status), "fl_string_append_nulless", F_true);
 
           for (f_array_length_t i = 0; i < variable->used; i++) {
-            macro_iki_read_substitutions_t_delete_simple(substitutionss[i]);
+            iki_read_macro_substitutions_t_delete_simple(substitutionss[i]);
           } // for
 
           f_macro_string_dynamic_t_delete_simple(name);
@@ -206,7 +206,7 @@ extern "C" {
     }
 
     for (f_array_length_t i = 0; i < variable->used; i++) {
-      macro_iki_read_substitutions_t_delete_simple(substitutionss[i]);
+      iki_read_macro_substitutions_t_delete_simple(substitutionss[i]);
     } // for
 
     return status;
@@ -243,7 +243,7 @@ extern "C" {
         fll_error_print(data->error, F_status_set_fine(status), "iki_read_substitutions_identify", F_true);
 
         for (f_array_length_t i = 0; i < variable->used; i++) {
-          macro_iki_read_substitutions_t_delete_simple(substitutionss[i]);
+          iki_read_macro_substitutions_t_delete_simple(substitutionss[i]);
         } // for
 
         return status;
@@ -299,7 +299,7 @@ extern "C" {
 
       if (F_status_is_error(status)) {
         for (i = 0; i < variable->used; i++) {
-          macro_iki_read_substitutions_t_delete_simple(substitutionss[i]);
+          iki_read_macro_substitutions_t_delete_simple(substitutionss[i]);
         } // for
 
         f_macro_string_dynamics_t_delete_simple(names);
@@ -380,7 +380,7 @@ extern "C" {
     }
 
     for (f_array_length_t i = 0; i < variable->used; i++) {
-      macro_iki_read_substitutions_t_delete_simple(substitutionss[i]);
+      iki_read_macro_substitutions_t_delete_simple(substitutionss[i]);
     } // for
 
     f_macro_string_dynamics_t_delete_simple(names);
@@ -488,7 +488,7 @@ extern "C" {
         status = fl_string_compare(arguments.argv[index], data->buffer.string + vocabulary->array[j].start, length, (vocabulary->array[j].stop - vocabulary->array[j].start) + 1);
 
         if (status == F_equal_to) {
-          f_macro_memory_structure_macro_increment(status, substitutionss[j], 1, f_iki_default_allocation_step, macro_iki_read_substitutions_t_resize, F_array_too_large);
+          f_macro_memory_structure_macro_increment(status, substitutionss[j], 1, f_iki_default_allocation_step, iki_read_macro_substitutions_t_resize, F_array_too_large);
           if (F_status_is_error(status)) return status;
 
           index = parameter->values.array[i + 1];