Bugfix: Incorrect index usages in f_console_parameter_process().

Switch to use a pointer called `current` to simplify the code a little.

The unicode charater processing is accessing index `i` out of scope.

The process short list is accessing index `i` out of scope.

Utilize the `current` pointer to help better manage avoiding accessing index `i` out of scope.

diff --git a/level_0/f_console/c/console.c b/level_0/f_console/c/console.c
index 246179566d247cbaab49b0ebf1d94e627d94ed59..28bab12c6de724257452bda0bd8a2b05d50132ef 100644 (file)
--- a/level_0/f_console/c/console.c
+++ b/level_0/f_console/c/console.c
@@ -192,6 +192,8 @@ extern "C" {
     f_utf_char_t utf_argument = 0;
     f_utf_char_t utf_console = 0;
 
+    f_console_parameter_t *current = 0;
+
     while (process.location < arguments.argc && arguments.argv[process.location]) {
 
       if (state->interrupt) {
@@ -219,13 +221,14 @@ extern "C" {
 
         if (state->status == F_process) {
           i = process.needs.array[0];
+          current = &parameters->array[i];
 
-          if (parameters->array[i].flag & f_console_flag_stop_d) {
+          if (current->flag & f_console_flag_stop_d) {
             stop = F_true;
           }
 
-          parameters->array[i].result |= f_console_result_value_d;
-          parameters->array[i].values.array[parameters->array[i].values.used++] = process.location++;
+          current->result |= f_console_result_value_d;
+          current->values.array[current->values.used++] = process.location++;
         }
 
         --process.needs.used;
@@ -261,13 +264,12 @@ extern "C" {
 
       process.found = F_false;
       state->status = F_okay;
+      current = 0;
 
       if (process.result & f_console_result_alone_d) {
         process.location_sub = 0;
         process.needs.used = 0;
 
-        process.found = F_false;
-
         for (i = 0; i < parameters->used; ++i) {
 
           if (state->interrupt) {
@@ -275,10 +277,12 @@ extern "C" {
             if (F_status_set_fine(state->status) == F_interrupt) break;
           }
 
-          if (parameters->array[i].match_short.used || parameters->array[i].match_long.used || parameters->array[i].match_simple.used) continue;
+          current = &parameters->array[i];
 
-          if ((process.result & f_console_result_inverse_d) && (parameters->array[i].flag & f_console_flag_inverse_d) || (process.result & f_console_result_normal_d) && (parameters->array[i].flag & f_console_flag_normal_d)) {
-            if ((process.result & f_console_result_long_d) && (parameters->array[i].flag & f_console_flag_empty_long_d) || (process.result & f_console_result_short_d) && !(parameters->array[i].flag & f_console_flag_empty_long_d)) {
+          if (current->match_short.used || current->match_long.used || current->match_simple.used) continue;
+
+          if ((process.result & f_console_result_inverse_d) && (current->flag & f_console_flag_inverse_d) || (process.result & f_console_result_normal_d) && (current->flag & f_console_flag_normal_d)) {
+            if ((process.result & f_console_result_long_d) && (current->flag & f_console_flag_empty_long_d) || (process.result & f_console_result_short_d) && !(current->flag & f_console_flag_empty_long_d)) {
               if (parameters->on_match) {
                 process.type = f_console_parameter_state_type_alone_e;
                 process.at = i;
@@ -311,7 +315,7 @@ extern "C" {
           }
         } // for
 
-        if (process.found && (parameters->array[i].flag & f_console_flag_stop_d)) {
+        if (process.found && current && (current->flag & f_console_flag_stop_d)) {
           stop = F_true;
 
           ++process.location;
@@ -333,12 +337,14 @@ extern "C" {
               if (F_status_set_fine(state->status) == F_interrupt) break;
             }
 
-            if (parameters->array[i].flag & f_console_flag_disable_d) continue;
-            if ((process.result & f_console_result_normal_d) && !(parameters->array[i].flag & f_console_flag_normal_d)) continue;
-            if ((process.result & f_console_result_inverse_d) && !(parameters->array[i].flag & f_console_flag_inverse_d)) continue;
-            if (!parameters->array[i].match_short.used) continue;
-            if (!parameters->array[i].match_short.string) continue;
-            if (arguments.argv[process.location][process.location_sub] != *parameters->array[i].match_short.string) continue;
+            current = &parameters->array[i];
+
+            if (current->flag & f_console_flag_disable_d) continue;
+            if ((process.result & f_console_result_normal_d) && !(current->flag & f_console_flag_normal_d)) continue;
+            if ((process.result & f_console_result_inverse_d) && !(current->flag & f_console_flag_inverse_d)) continue;
+            if (!current->match_short.used) continue;
+            if (!current->match_short.string) continue;
+            if (arguments.argv[process.location][process.location_sub] != *current->match_short.string) continue;
 
             process.width = macro_f_utf_byte_width_is(arguments.argv[process.location][process.location_sub]);
 
@@ -375,7 +381,7 @@ extern "C" {
                 state->status = f_utf_char_to_character(arguments.argv[process.location] + process.location_sub, parameters->arguments.array[process.location].used - process.location_sub, &utf_argument);
 
                 if (F_status_is_error_not(state->status)) {
-                  state->status = f_utf_char_to_character(parameters->array[i].match_short.string, parameters->array[i].match_short.used, &utf_console);
+                  state->status = f_utf_char_to_character(current->match_short.string, current->match_short.used, &utf_console);
                 }
 
                 if (F_status_is_error(state->status)) break;
@@ -424,6 +430,8 @@ extern "C" {
           process.location_sub = 1;
           process.needs.used = 0;
 
+          current = 0;
+
           state->status = f_memory_array_increase_by(parameters->arguments.array[process.location].used, sizeof(f_number_unsigned_t), (void **) &process.needs.array, &process.needs.used, &process.needs.size);
           if (F_status_is_error(state->status)) break;
 
@@ -439,7 +447,7 @@ extern "C" {
               state->status = f_utf_char_to_character(arguments.argv[process.location] + process.location_sub, parameters->arguments.array[process.location].used - process.location_sub, &utf_argument);
               if (F_status_is_error(state->status)) break;
 
-              state->status = f_utf_char_to_character(parameters->array[i].match_short.string, parameters->array[i].match_short.used, &utf_console);
+              state->status = f_utf_char_to_character(parameters->array[process.at].match_short.string, parameters->array[process.at].match_short.used, &utf_console);
               if (F_status_is_error(state->status)) break;
 
               if (utf_argument != utf_console) continue;
@@ -455,12 +463,14 @@ extern "C" {
                 if (F_status_set_fine(state->status) == F_interrupt) break;
               }
 
-              if (parameters->array[i].flag & f_console_flag_disable_d) continue;
-              if ((process.result & f_console_result_normal_d) && !(parameters->array[i].flag & f_console_flag_normal_d)) continue;
-              if ((process.result & f_console_result_inverse_d) && !(parameters->array[i].flag & f_console_flag_inverse_d)) continue;
-              if (!parameters->array[i].match_short.used) continue;
-              if (!parameters->array[i].match_short.string) continue;
-              if (arguments.argv[process.location][process.location_sub] != *parameters->array[i].match_short.string) continue;
+              current = &parameters->array[i];
+
+              if (current->flag & f_console_flag_disable_d) continue;
+              if ((process.result & f_console_result_normal_d) && !(current->flag & f_console_flag_normal_d)) continue;
+              if ((process.result & f_console_result_inverse_d) && !(current->flag & f_console_flag_inverse_d)) continue;
+              if (!current->match_short.used) continue;
+              if (!current->match_short.string) continue;
+              if (arguments.argv[process.location][process.location_sub] != *current->match_short.string) continue;
 
               if (parameters->on_match) {
                 process.type = f_console_parameter_state_type_short_e;
@@ -488,29 +498,29 @@ extern "C" {
               }
 
               if (state->status == F_process) {
-                state->status = f_memory_array_increase(state->step_small, sizeof(f_number_unsigned_t), (void **) &parameters->array[i].locations.array, &parameters->array[i].locations.used, &parameters->array[i].locations.size);
+                state->status = f_memory_array_increase(state->step_small, sizeof(f_number_unsigned_t), (void **) &current->locations.array, &current->locations.used, &current->locations.size);
                 if (F_status_is_error(state->status)) break;
 
-                state->status = f_memory_array_increase(state->step_small, sizeof(f_number_unsigned_t), (void **) &parameters->array[i].locations_sub.array, &parameters->array[i].locations_sub.used, &parameters->array[i].locations_sub.size);
+                state->status = f_memory_array_increase(state->step_small, sizeof(f_number_unsigned_t), (void **) &current->locations_sub.array, &current->locations_sub.used, &current->locations_sub.size);
                 if (F_status_is_error(state->status)) break;
 
-                if (parameters->array[i].location != process.location) {
-                  parameters->array[i].locations.array[parameters->array[i].locations.used++] = process.location;
+                if (current->location != process.location) {
+                  current->locations.array[current->locations.used++] = process.location;
                 }
 
-                parameters->array[i].result |= process.result | f_console_result_found_d;
-                parameters->array[i].location = process.location;
-                parameters->array[i].location_sub = process.location_sub;
-                parameters->array[i].locations_sub.array[parameters->array[i].locations_sub.used++] = process.location_sub;
+                current->result |= process.result | f_console_result_found_d;
+                current->location = process.location;
+                current->location_sub = process.location_sub;
+                current->locations_sub.array[current->locations_sub.used++] = process.location_sub;
 
-                state->status = f_memory_array_increase_by(parameters->array[i].values_total, sizeof(f_number_unsigned_t), (void **) &process.needs.array, &process.needs.used, &process.needs.size);
+                state->status = f_memory_array_increase_by(current->values_total, sizeof(f_number_unsigned_t), (void **) &process.needs.array, &process.needs.used, &process.needs.size);
                 if (F_status_is_error(state->status)) break;
 
-                for (j = 0; j < parameters->array[i].values_total; ++j) {
+                for (j = 0; j < current->values_total; ++j) {
                   process.needs.array[process.needs.used++] = i;
                 } // for
 
-                state->status = f_memory_array_increase_by(process.needs.used, sizeof(f_number_unsigned_t), (void **) &parameters->array[i].values.array, &parameters->array[i].values.used, &parameters->array[i].values.size);
+                state->status = f_memory_array_increase_by(process.needs.used, sizeof(f_number_unsigned_t), (void **) &current->values.array, &current->values.used, &current->values.size);
                 if (F_status_is_error(state->status)) break;
               }
 
@@ -519,7 +529,11 @@ extern "C" {
               break;
             } // for
 
-            if (F_status_is_error(state->status)) break;
+            if (F_status_is_error(state->status)) {
+              current = 0;
+
+              break;
+            }
 
             if (state->status == F_break || state->status == F_continue) {
               if (process.depth) {
@@ -547,7 +561,7 @@ extern "C" {
             continue;
           }
 
-          if ((parameters->array[i].flag & f_console_flag_stop_d) && !process.needs.used) {
+          if (current && (current->flag & f_console_flag_stop_d) && !process.needs.used) {
             stop = F_true;
 
             ++process.location;
@@ -568,12 +582,14 @@ extern "C" {
               if (F_status_set_fine(state->status) == F_interrupt) break;
             }
 
-            if (parameters->array[i].flag & f_console_flag_disable_d) continue;
-            if ((process.result & f_console_result_normal_d) && !(parameters->array[i].flag & f_console_flag_normal_d)) continue;
-            if ((process.result & f_console_result_inverse_d) && !(parameters->array[i].flag & f_console_flag_inverse_d)) continue;
-            if (!parameters->array[i].match_long.used) continue;
-            if (!parameters->array[i].match_long.string) continue;
-            if (strncmp(&arguments.argv[process.location][process.location_sub], parameters->array[i].match_long.string, parameters->array[i].match_long.used + 1)) continue;
+            current = &parameters->array[i];
+
+            if (current->flag & f_console_flag_disable_d) continue;
+            if ((process.result & f_console_result_normal_d) && !(current->flag & f_console_flag_normal_d)) continue;
+            if ((process.result & f_console_result_inverse_d) && !(current->flag & f_console_flag_inverse_d)) continue;
+            if (!current->match_long.used) continue;
+            if (!current->match_long.string) continue;
+            if (strncmp(&arguments.argv[process.location][process.location_sub], current->match_long.string, current->match_long.used + 1)) continue;
 
             if (parameters->on_match) {
               process.type = f_console_parameter_state_type_long_e;
@@ -613,10 +629,12 @@ extern "C" {
               if (F_status_set_fine(state->status) == F_interrupt) break;
             }
 
-            if (parameters->array[i].flag & f_console_flag_disable_d) continue;
-            if (!(parameters->array[i].flag & f_console_flag_simple_d)) continue;
-            if (!parameters->array[i].match_simple.used && !parameters->array[i].match_simple.string) continue;
-            if (strncmp(arguments.argv[process.location], parameters->array[i].match_simple.string, parameters->array[i].match_simple.used + 1)) continue;
+            current = &parameters->array[i];
+
+            if (current->flag & f_console_flag_disable_d) continue;
+            if (!(current->flag & f_console_flag_simple_d)) continue;
+            if (!current->match_simple.used && !current->match_simple.string) continue;
+            if (strncmp(arguments.argv[process.location], current->match_simple.string, current->match_simple.used + 1)) continue;
 
             if (parameters->on_match) {
               process.type = f_console_parameter_state_type_simple_e;
@@ -660,30 +678,30 @@ extern "C" {
           continue;
         }
 
-        if (state->status == F_process && process.found && i < parameters->used) {
-          state->status = f_memory_array_increase(state->step_small, sizeof(f_number_unsigned_t), (void **) &parameters->array[i].locations.array, &parameters->array[i].locations.used, &parameters->array[i].locations.size);
+        if (state->status == F_process && process.found) {
+          state->status = f_memory_array_increase(state->step_small, sizeof(f_number_unsigned_t), (void **) &current->locations.array, &current->locations.used, &current->locations.size);
           if (F_status_is_error(state->status)) break;
 
-          state->status = f_memory_array_increase(state->step_small, sizeof(f_number_unsigned_t), (void **) &parameters->array[i].locations_sub.array, &parameters->array[i].locations_sub.used, &parameters->array[i].locations_sub.size);
+          state->status = f_memory_array_increase(state->step_small, sizeof(f_number_unsigned_t), (void **) &current->locations_sub.array, &current->locations_sub.used, &current->locations_sub.size);
           if (F_status_is_error(state->status)) break;
 
-          parameters->array[i].result |= process.result | f_console_result_found_d;
-          parameters->array[i].location = process.location;
-          parameters->array[i].location_sub = 0;
-          parameters->array[i].locations.array[parameters->array[i].locations.used++] = process.location;
-          parameters->array[i].locations_sub.array[parameters->array[i].locations_sub.used++] = 0;
+          current->result |= process.result | f_console_result_found_d;
+          current->location = process.location;
+          current->location_sub = 0;
+          current->locations.array[current->locations.used++] = process.location;
+          current->locations_sub.array[current->locations_sub.used++] = 0;
 
-          for (j = 0; j < parameters->array[i].values_total; ++j) {
+          for (j = 0; j < current->values_total; ++j) {
             process.needs.array[process.needs.used++] = i;
           } // for
 
-          state->status = f_memory_array_increase_by(process.needs.used, sizeof(f_number_unsigned_t), (void **) &parameters->array[i].values.array, &parameters->array[i].values.used, &parameters->array[i].values.size);
+          state->status = f_memory_array_increase_by(process.needs.used, sizeof(f_number_unsigned_t), (void **) &current->values.array, &current->values.used, &current->values.size);
           if (F_status_is_error(state->status)) break;
         }
 
         state->status = F_okay;
 
-        if (process.found && (parameters->array[i].flag & f_console_flag_stop_d) && !process.needs.used) {
+        if (process.found && current && (current->flag & f_console_flag_stop_d) && !process.needs.used) {
           stop = F_true;
 
           ++process.location;
@@ -772,6 +790,7 @@ extern "C" {
     #endif // _di_level_0_parameter_checking_
 
     f_number_unsigned_t i = 0;
+    f_console_parameter_t *current = 0;
 
     for (; i < parameters->arguments.used; ++i) {
       parameters->arguments.array[i].used = 0;
@@ -779,17 +798,19 @@ extern "C" {
 
     for (i = 0; i < parameters->used; ++i) {
 
-      memset(parameters->array[i].locations.array, 0, parameters->array[i].locations.used);
-      memset(parameters->array[i].locations_sub.array, 0, parameters->array[i].locations_sub.used);
-      memset(parameters->array[i].values.array, 0, parameters->array[i].values.used);
-
-      parameters->array[i].flag &= ~f_console_flag_disable_d;
-      parameters->array[i].result = f_console_result_none_d;
-      parameters->array[i].location = 0;
-      parameters->array[i].location_sub = 0;
-      parameters->array[i].locations.used = 0;
-      parameters->array[i].locations_sub.used = 0;
-      parameters->array[i].values.used = 0;
+      current = &parameters->array[i];
+
+      memset(current->locations.array, 0, current->locations.used);
+      memset(current->locations_sub.array, 0, current->locations_sub.used);
+      memset(current->values.array, 0, current->values.used);
+
+      current->flag &= ~f_console_flag_disable_d;
+      current->result = f_console_result_none_d;
+      current->location = 0;
+      current->location_sub = 0;
+      current->locations.used = 0;
+      current->locations_sub.used = 0;
+      current->values.used = 0;
     } // for
 
     memset(parameters->remaining.array, 0,  parameters->remaining.used);