parameters.parameter[i].result = f_console_result_additional;
parameters.parameter[i].values.array[parameters.parameter[i].values.used++] = location;
- needs_value.used--;
+ --needs_value.used;
// Pop the matched parameter off of the top of the needs_value array.
for (f_array_length_t i = 0; i < needs_value.used; ++i) {
#define macro_f_directory_statuss_t_delete_simple(structures) \
structures.used = structures.size; \
while (structures.used > 0) { \
- structures.used--; \
+ --structures.used; \
macro_f_directory_status_t_delete_simple(structures.array[structures.used]); \
} \
if (!structures.size) { \
#define macro_f_directory_statuss_t_destroy_simple(structures) \
structures.used = structures.size; \
while (structures.used > 0) { \
- structures.used--; \
+ --structures.used; \
macro_f_directory_status_t_destroy_simple(structures.array[structures.used]); \
} \
if (!structures.size) { \
write_amount = total / file.size_write;
if (total % file.size_write) {
- write_amount++;
+ ++write_amount;
}
}
#define macro_f_iki_seek_whitespace(status, buffer, range, width_max, condition) \
while (range->start <= range->stop && range->start < buffer->used) { \
if (buffer->string[range->start] == f_iki_syntax_placeholder) { \
- range->start++; \
+ ++range->start; \
continue; \
} \
macro_f_iki_determine_width_max(buffer, range, width_max); \
#define macro_f_iki_seek_word_dash_plus(status, buffer, range, width_max, condition) \
while (range->start <= range->stop && range->start < buffer->used) { \
if (buffer->string[range->start] == f_iki_syntax_placeholder) { \
- range->start++; \
+ ++range->start; \
continue; \
} \
macro_f_iki_determine_width_max(buffer, range, width_max); \
#define macro_f_memory_structures_delete(status, structures, type_structure, type_structures) \
structures.used = structures.size; \
while (structures.used) { \
- structures.used--; \
+ --structures.used; \
status = f_memory_structure_resize(0, sizeof(type_structure), (void **) &structures.array[structures.used].array, &structures.array[structures.used].used, &structures.array[structures.used].size); \
if (F_status_is_error(status)) break; \
} \
#define macro_f_memory_structures_destroy(status, structures, type_structure, type_structures) \
structures.used = structures.size; \
while (structures.used) { \
- structures.used--; \
+ --structures.used; \
status = f_memory_structure_adjust(0, sizeof(type_structure), (void **) &structures.array[structures.used].array, &structures.array[structures.used].used, &structures.array[structures.used].size); \
if (F_status_is_error(status)) break; \
} \
#define macro_f_memory_structures_delete_simple(structures, type_structure, type_structures) \
structures.used = structures.size; \
while (structures.used) { \
- structures.used--; \
+ --structures.used; \
f_memory_structure_resize(0, sizeof(type_structure), (void **) &structures.array[structures.used].array, &structures.array[structures.used].used, &structures.array[structures.used].size); \
} \
f_memory_structure_resize(0, sizeof(type_structures), (void **) & structures.array, &structures.used, &structures.size);
#define macro_f_memory_structures_destroy_simple(structures, type_structure, type_structures) \
structures.used = structures.size; \
while (structures.used) { \
- structures.used--; \
+ --structures.used; \
f_memory_structure_adjust(0, sizeof(type_structure), (void **) &structures.array[structures.used].array, &structures.array[structures.used].used, &structures.array[structures.used].size); \
} \
f_memory_structure_adjust(0, sizeof(type_structures), (void **) & structures.array, &structures.used, &structures.size);
memcpy(strings->array[strings->used].string, serialize.string + start, total);
strings->array[strings->used].used = total;
- strings->used++;
+ ++strings->used;
}
if (i + width > serialize.used) {
if (buffer.string[range->start] == f_string_eol_s[0]) return F_none_eol;
- range->start++;
+ ++range->start;
if (range->start >= buffer.used) return F_none_eos;
if (range->start > range->stop) return F_none_stop;
if (range->start > range->stop) return F_data_not_stop;
while (buffer.string[range->start] != seek_to_this) {
- range->start++;
+
+ ++range->start;
if (range->start >= buffer.used) return F_none_eos;
if (range->start > range->stop) return F_none_stop;
#endif // _di_level_0_parameter_checking_
if (destination->used) {
- for (; destination->used; destination->used--) {
+ for (; destination->used; --destination->used) {
if (!destination->string[destination->used - 1]) continue;
break;
if (f_conversion_character_to_duodecimal(string[i], &digit) == F_none) {
if (digits) {
- digits++;
+ ++digits;
if (negative) {
if (digits > f_conversion_digits_duodecimal_signed) {
if (F_status_is_error(status)) return status;
part.string[part.used - 1] = f_path_separator_s[0];
- part.used++;
+ ++part.used;
}
}
slash_first = range->start;
slash_count = 1;
- for (range->start++; range->start <= range->stop && range->start < buffer.used; range->start++) {
+ for (++range->start; range->start <= range->stop && range->start < buffer.used; ++range->start) {
if (state.interrupt) {
status = state.interrupt((void *) &state, 0);
status = f_string_dynamic_increase_by(slash_count, destination);
if (F_status_is_error(status)) break;
- while (slash_count--) {
+ while (--slash_count) {
destination->string[destination->used++] = f_fss_delimit_slash;
} // while
destination->string[destination->used++] = content.string[range->start];
has_graph = F_true;
- for (range->start++; range->start <= range->stop && range->start < content.used; range->start++) {
+ for (++range->start; range->start <= range->stop && range->start < content.used; ++range->start) {
if (state.interrupt) {
status = state.interrupt((void *) &state, 0);
if (content.string[range->start] != f_fss_delimit_slash) break;
destination->string[destination->used++] = f_fss_delimit_slash;
- slash_count++;
+ ++slash_count;
} // for
if (content.string[range->start] == f_fss_basic_list_open) {
status = f_string_dynamic_increase_by(slash_count + 3, destination);
if (F_status_is_error(status)) break;
- while (slash_count--) {
+ while (--slash_count) {
destination->string[destination->used++] = f_fss_delimit_slash;
} // while
}
if (buffer.string[range->start] == f_fss_eol) {
- depth++;
+ ++depth;
if (depth >= positions_start.size) {
macro_f_array_lengths_t_resize(status, positions_start, positions_start.size + state.step_small);
if (F_status_is_error(status)) break;
if (content.string[range->start] == f_fss_embedded_list_open) {
- while (slash_count--) {
+ while (--slash_count) {
destination->string[destination->used++] = f_fss_delimit_slash;
} // while
}
}
}
- if (buffer.string[range->start] == f_fss_delimit_slash) slash_count++;
+ if (buffer.string[range->start] == f_fss_delimit_slash) ++slash_count;
status = f_utf_buffer_increment(buffer, range, 1);
if (F_status_is_error(status)) break;
status = f_string_dynamic_increase_by(width, destination);
if (F_status_is_error(status)) break;
- for (i = 0; i < width; i++) {
+ for (i = 0; i < width; ++i) {
destination->string[destination->used++] = object.string[range->start + i];
} // for
}
status = f_string_dynamic_increase_by(slash_count, destination);
if (F_status_is_error(status)) break;
- while (slash_count--) {
+ while (--slash_count) {
destination->string[destination->used++] = f_fss_delimit_slash;
} // while
const f_array_length_t rear = destination_range.start + 1;
- for (; destination_range.start > front; destination_range.start--) {
+ for (; destination_range.start > front; --destination_range.start) {
if (state.interrupt) {
status = state.interrupt((void *) &state, 0);
f_array_length_t i1 = offset1;
f_array_length_t i2 = offset2;
- for (; i1 < stop1 && i2 < stop2; i1++, i2++) {
+ for (; i1 < stop1 && i2 < stop2; ++i1, ++i2) {
// skip past NULL in string1.
- while (i1 < stop1 && !string1[i1]) i1++;
+ while (i1 < stop1 && !string1[i1]) ++i1;
if (i1 == stop1) break;
// skip past NULL in string2.
- while (i2 < stop2 && !string2[i2]) i2++;
+ while (i2 < stop2 && !string2[i2]) ++i2;
if (i2 == stop2) break;
if (string1[i1] != string2[i2]) return F_equal_to_not;
} // for
// only return F_equal_to if all remaining characters are NULL.
- for (; i1 < stop1; i1++) {
+ for (; i1 < stop1; ++i1) {
if (string1[i1] != 0) return F_equal_to_not;
} // for
- for (; i2 < stop2; i2++) {
+ for (; i2 < stop2; ++i2) {
if (string2[i2] != 0) return F_equal_to_not;
} // for
while (i1 < stop1 && i2 < stop2) {
// skip past NULL in string1.
- while (i1 < stop1 && !string1[i1]) i1++;
+ while (i1 < stop1 && !string1[i1]) ++i1;
if (i1 == stop1) break;
// skip past NULL in string2.
- while (i2 < stop2 && !string2[i2]) i2++;
+ while (i2 < stop2 && !string2[i2]) ++i2;
if (i2 == stop2) break;
// skip past except characters in string1.
- while (e1 < except1.used && except1.array[e1] < i1) e1++;
+ while (e1 < except1.used && except1.array[e1] < i1) ++e1;
if (e1 < except1.used && except1.array[e1] == i1) {
- i1++;
+ ++i1;
continue;
}
// skip past except characters in string2.
- while (e2 < except2.used && except2.array[e2] < i2) e2++;
+ while (e2 < except2.used && except2.array[e2] < i2) ++e2;
if (e2 < except2.used && except2.array[e2] == i2) {
- i2++;
+ ++i2;
continue;
}
return F_equal_to_not;
}
- i1++;
- i2++;
+ ++i1;
+ ++i2;
} // while
// only return F_equal_to if all remaining characters are NULL or are designated to be ignored.
for (; i1 < stop1; i1++) {
// skip past except characters in string1.
- while (e1 < except1.used && except1.array[e1] < i1) e1++;
+ while (e1 < except1.used && except1.array[e1] < i1) ++e1;
if (e1 < except1.used && except1.array[e1] == i1) continue;
if (string1[i1] != 0) {
}
} // for
- for (; i2 < stop2; i2++) {
+ for (; i2 < stop2; ++i2) {
// skip past except characters in string2.
- while (e2 < except2.used && except2.array[e2] < i2) e2++;
+ while (e2 < except2.used && except2.array[e2] < i2) ++e2;
if (e2 < except2.used && except2.array[e2] == i2) continue;
if (string2[i2] != 0) {
for (; i1 < stop1; i1 += width) {
// skip past NULL in string1.
- while (i1 < stop1 && !string1[i1]) i1++;
+ while (i1 < stop1 && !string1[i1]) ++i1;
if (i1 == stop1) break;
// skip past except characters in string1.
- while (e1 < except1.used && except1.array[e1] < i1) e1++;
+ while (e1 < except1.used && except1.array[e1] < i1) ++e1;
if (e1 < except1.used && except1.array[e1] == i1) {
width = 1;
for (; i2 < stop2; i2 += width) {
// skip past NULL in string2.
- while (i2 < stop2 && !string2[i2]) i2++;
+ while (i2 < stop2 && !string2[i2]) ++i2;
if (i2 == stop2) break;
// skip past except characters in string2.
- while (e2 < except2.used && except2.array[e2] < i2) e2++;
+ while (e2 < except2.used && except2.array[e2] < i2) ++e2;
if (e2 < except2.used && except2.array[e2] == i2) {
width = 1;
for (j = i1; j < stop1; j += width) {
// skip past NULL in string1.
- while (j < stop1 && !string1[j]) j++;
+ while (j < stop1 && !string1[j]) ++j;
if (j == stop1) break;
// skip past except characters in string1.
- while (ej < except1.used && except1.array[ej] < j) ej++;
+ while (ej < except1.used && except1.array[ej] < j) ++ej;
if (ej < except1.used && except1.array[ej] == j) {
width = 1;
for (j = i2; j < stop2; j += width) {
// skip past NULL in string2.
- while (j < stop2 && !string2[j]) j++;
+ while (j < stop2 && !string2[j]) ++j;
if (j == stop2) break;
// skip past except characters in string2.
- while (ej < except2.used && except2.array[ej] < j) ej++;
+ while (ej < except2.used && except2.array[ej] < j) ++ej;
if (ej < except2.used && except2.array[ej] == j) {
width = 1;
continue;
while (i1 <= last1 && i2 <= last2) {
// skip past NULL in string1.
- while (i1 <= last1 && !string1[i1]) i1++;
+ while (i1 <= last1 && !string1[i1]) ++i1;
if (i1 > last1) break;
// skip past NULL in string2.
- while (i2 <= last2 && !string2[i2]) i2++;
+ while (i2 <= last2 && !string2[i2]) ++i2;
if (i2 > last2) break;
// skip past except characters in string1.
- while (e1 < except1.used && except1.array[e1] < i1) e1++;
+ while (e1 < except1.used && except1.array[e1] < i1) ++e1;
if (e1 < except1.used && except1.array[e1] == i1) {
- i1++;
+ ++i1;
continue;
}
// skip past except characters in string2.
- while (e2 < except2.used && except2.array[e2] < i2) e2++;
+ while (e2 < except2.used && except2.array[e2] < i2) ++e2;
if (e2 < except2.used && except2.array[e2] == i2) {
- i2++;
+ ++i2;
continue;
}
return F_equal_to_not;
}
- i1++;
- i2++;
+ ++i1;
+ ++i2;
} // while
// only return F_equal_to if all remaining characters are NULL.
- for (; i1 <= last1; i1++) {
+ for (; i1 <= last1; ++i1) {
if (string1[i1] != 0) {
// skip past except characters in string1.
- while (e1 < except1.used && except1.array[e1] < i1) e1++;
+ while (e1 < except1.used && except1.array[e1] < i1) ++e1;
if (e1 < except1.used && except1.array[e1] == i1) continue;
return F_equal_to_not;
}
} // for
- for (; i2 <= last2; i2++) {
+ for (; i2 <= last2; ++i2) {
if (string2[i2] != 0) {
// skip past except characters in string1.
- while (e2 < except2.used && except2.array[e2] < i2) e2++;
+ while (e2 < except2.used && except2.array[e2] < i2) ++e2;
if (e2 < except2.used && except2.array[e2] == i2) continue;
return F_equal_to_not;
for (; i1 < stop1; i1 += width) {
// skip past NULL in string1.
- while (i1 < stop1 && !string1[i1]) i1++;
+ while (i1 < stop1 && !string1[i1]) ++i1;
if (i1 == stop1) break;
width_max = (stop1 - i1) + 1;
for (; i2 < stop2; i2 += width) {
// skip past NULL in string2.
- while (i2 < stop2 && !string2[i2]) i2++;
+ while (i2 < stop2 && !string2[i2]) ++i2;
if (i2 == stop2) break;
width_max = (stop2 - i2) + 1;
for (f_array_length_t j = i1; j < stop1; j += width) {
// skip past NULL in string1.
- while (j < stop1 && !string1[j]) j++;
+ while (j < stop1 && !string1[j]) ++j;
if (j == stop1) break;
width_max = (stop1 - j) + 1;
if (status == F_false) {
last1 = j;
- size1++;
+ ++size1;
}
} // for
for (f_array_length_t j = i2; j < stop2; j += width) {
// skip past NULL in string2.
- while (j < stop2 && !string2[j]) j++;
+ while (j < stop2 && !string2[j]) ++j;
if (j == stop2) break;
width_max = (stop2 - j) + 1;
if (status == F_false) {
last2 = j;
- size2++;
+ ++size2;
}
} // for
}
}
- for (; i1 < last1 && i2 < last2; i1++, i2++) {
+ for (; i1 < last1 && i2 < last2; ++i1, ++i2) {
// skip past NULL in string1.
- while (i1 < last1 && !string1[i1]) i1++;
+ while (i1 < last1 && !string1[i1]) ++i1;
if (i1 == last1) break;
// skip past NULL in string2.
- while (i2 < last2 && !string2[i2]) i2++;
+ while (i2 < last2 && !string2[i2]) ++i2;
if (i2 == last2) break;
if (string1[i1] != string2[i2]) {
while (i1 < last1) {
if (string1[i1] != 0) return F_equal_to_not;
- i1++;
+ ++i1;
} // while
while (i2 < last2) {
if (string2[i2] != 0) return F_equal_to_not;
- i2++;
+ ++i2;
} // while
return F_equal_to;
for (; *start <= *stop; *start += width) {
// skip past NULL.
- while (*start < *stop && !source[*start]) (*start)++;
+ while (*start < *stop && !source[*start]) ++(*start);
if (*start > *stop) break;
status = f_utf_is_whitespace(source + *start, (*stop - *start) + 1);
width = macro_f_utf_byte_width(source[*start]);
} // for
- for (; *stop > *start; (*stop)--) {
+ for (; *stop > *start; --(*stop)) {
// skip past NULL.
- while (*stop > *start && !source[*stop]) (*stop)--;
+ while (*stop > *start && !source[*stop]) --(*stop);
if (!source[*stop]) continue;
if (*stop == *start) break;
width = macro_f_utf_byte_width_is(source[*stop]);
if (width == 1) {
- (*stop)--;
+ --(*stop);
if (*stop == *start) break;
}
f_array_length_t i1 = offset1;
f_array_length_t i2 = offset2;
- for (; i1 < stop1 && i2 < stop2; i1++, i2++) {
+ for (; i1 < stop1 && i2 < stop2; ++i1, ++i2) {
// skip past NULL in string1.
- while (i1 < stop1 && !string1[i1]) i1++;
+ while (i1 < stop1 && !string1[i1]) ++i1;
if (i1 == stop1) break;
// skip past NULL in string2.
- while (i2 < stop2 && !string2[i2]) i2++;
+ while (i2 < stop2 && !string2[i2]) ++i2;
if (i2 == stop2) break;
if (string1[i1] != string2[i2]) return F_equal_to_not;
} // for
// only return F_equal_to if all remaining characters are NULL.
- for (; i1 < stop1; i1++) {
+ for (; i1 < stop1; ++i1) {
if (string1[i1] != 0) return F_equal_to_not;
} // for
- for (; i2 < stop2; i2++) {
+ for (; i2 < stop2; ++i2) {
if (string2[i2] != 0) return F_equal_to_not;
} // for
f_status_t status = F_none;
// skip past leading whitespace in string1.
- for (; i1 < stop1; i1++) {
+ for (; i1 < stop1; ++i1) {
// skip past NULL in string1.
- while (i1 < stop1 && !string1[i1]) i1++;
+ while (i1 < stop1 && !string1[i1]) ++i1;
if (i1 == stop1) break;
status = f_utf_character_is_whitespace(string1[i1]);
for (; i2 < stop2; i2++) {
// skip past NULL in string2.
- while (i2 < stop2 && !string2[i2]) i2++;
+ while (i2 < stop2 && !string2[i2]) ++i2;
if (i2 == stop2) break;
status = f_utf_character_is_whitespace(string2[i2]);
f_array_length_t j = 0;
// determine where the last non-whitespace is in string1.
- for (j = i1; j < stop1; j++) {
+ for (j = i1; j < stop1; ++j) {
// skip past NULL in string1.
- while (j < stop1 && !string1[j]) j++;
+ while (j < stop1 && !string1[j]) ++j;
if (j == stop1) break;
status = f_utf_character_is_whitespace(string1[j]);
if (status == F_false) {
last1 = j;
- size1++;
+ ++size1;
}
} // for
// determine where the last non-whitespace is in string2.
- for (j = i2; j < stop2; j++) {
+ for (j = i2; j < stop2; ++j) {
// skip past NULL in string2.
- while (j < stop2 && !string2[j]) j++;
+ while (j < stop2 && !string2[j]) ++j;
if (j == stop2) break;
status = f_utf_character_is_whitespace(string2[j]);
if (status == F_false) {
last2 = j;
- size2++;
+ ++size2;
}
} // for
}
}
- for (; i1 < last1 && i2 < last2; i1++, i2++) {
+ for (; i1 < last1 && i2 < last2; ++i1, ++i2) {
// skip past NULL in string1.
- while (i1 < last1 && !string1[i1]) i1++;
+ while (i1 < last1 && !string1[i1]) ++i1;
if (i1 == last1) break;
// skip past NULL in string2.
- while (i2 < last2 && !string2[i2]) i2++;
+ while (i2 < last2 && !string2[i2]) ++i2;
if (i2 == last2) break;
if (string1[i1] != string2[i2]) return F_equal_to_not;
} // for
// only return F_equal_to if all remaining characters are NULL.
- for (; i1 < last1; i1++) {
+ for (; i1 < last1; ++i1) {
if (string1[i1] != 0) return F_equal_to_not;
} // for
- for (; i2 < last2; i2++) {
+ for (; i2 < last2; ++i2) {
if (string2[i2] != 0) return F_equal_to_not;
} // for
f_status_t status = F_none;
// skip past leading whitespace.
- for (; *start <= *stop; (*start)++) {
+ for (; *start <= *stop; ++(*start)) {
// skip past NULL.
- while (*start < *stop && !source[*start]) (*start)++;
+ while (*start < *stop && !source[*start]) ++(*start);
if (*start > *stop) break;
status = f_utf_character_is_whitespace(source[*start]);
if (status == F_false) break;
} // for
- for (; *stop > *start; (*stop)--) {
+ for (; *stop > *start; --(*stop)) {
// skip past NULL.
- while (*stop > *start && !source[*stop]) (*stop)--;
+ while (*stop > *start && !source[*stop]) --(*stop);
if (!source[*stop]) continue;
if (*stop == *start) break;
return F_none_eol;
}
- range->start++;
+ ++range->start;
if (macro_f_utf_character_t_width_is(buffer.string[range->start]) == 1) {
return F_status_set_error(F_utf);
return F_none_eol;
}
- range->start++;
+ ++range->start;
if (macro_f_utf_character_t_width_is(buffer.string[range->start]) == 1) {
return F_status_set_error(F_utf);
if (F_status_is_error(status)) return status;
if (buffer.string[range->start] == f_utf_character_t_eol) return F_none_eol;
- range->start++;
+ ++range->start;
if (macro_f_utf_character_t_width_is(buffer.string[range->start]) == 1) {
return F_status_set_error(F_utf);
while (buffer.string[range->start] != seek_to_character) {
- range->start++;
+ ++range->start;
if (macro_f_utf_character_t_width_is(buffer.string[range->start]) == 1) {
return F_status_set_error(F_utf);
f_utf_character_t seek_to_character = seek_to_this << 24;
- for (; range->start <= range->stop; range->start++) {
+ for (; range->start <= range->stop; ++range->start) {
if (macro_f_utf_character_t_width_is(string[range->start]) == 1) {
return F_status_set_error(F_utf);
return F_none_eol;
}
- range->start++;
+ ++range->start;
if (macro_f_utf_character_t_width_is(string[range->start]) == 1) {
return F_status_set_error(F_utf);
return F_none_eol;
}
- range->start++;
+ ++range->start;
if (macro_f_utf_character_t_width_is(string[range->start]) == 1) {
return F_status_set_error(F_utf);
return F_none;
}
- range->start++;
+ ++range->start;
if (macro_f_utf_character_t_width_is(string[range->start]) == 1) {
return F_status_set_error(F_utf);
f_status_t status = F_none;
- for (f_array_length_t i = 0; i < size; i++) {
+ for (f_array_length_t i = 0; i < size; ++i) {
status = private_fll_execute_arguments_add_parameter(prefix[i], prefix_length[i], name[i], name_length[i], value[i], value_length[i], arguments);
if (F_status_is_error(status)) return status;
f_status_t status = F_none;
- for (f_array_length_t i = 0; i < size; i++) {
+ for (f_array_length_t i = 0; i < size; ++i) {
status = private_fll_execute_arguments_add(source[i], length[i], arguments);
if (F_status_is_error(status)) return status;
f_status_t status = F_none;
- for (f_array_length_t i = 0; i < size; i++) {
+ for (f_array_length_t i = 0; i < size; ++i) {
status = private_fll_execute_arguments_add_parameter(prefix[i].string, prefix[i].used, name[i].string, name[i].used, value[i].string, value[i].used, arguments);
if (F_status_is_error(status)) return status;
f_status_t status = F_none;
- for (f_array_length_t i = 0; i < size; i++) {
+ for (f_array_length_t i = 0; i < size; ++i) {
status = private_fll_execute_arguments_add(source[i].string, source[i].used, arguments);
if (F_status_is_error(status)) return status;
arguments->array[arguments->used].string = argument.string;
arguments->array[arguments->used].used = argument.used;
- arguments->array[arguments->used].size = argument.size;
- arguments->used++;
+ arguments->array[arguments->used++].size = argument.size;
return F_none;
}
if (parameter && parameter->environment) {
clearenv();
- for (f_array_length_t i = 0; i < parameter->environment->used; i++) {
+ for (f_array_length_t i = 0; i < parameter->environment->used; ++i) {
f_environment_set_dynamic(parameter->environment->array[i].name, parameter->environment->array[i].value, F_true);
} // for
}
if (parameter && parameter->environment) {
clearenv();
- for (f_array_length_t i = 0; i < parameter->environment->used; i++) {
+ for (f_array_length_t i = 0; i < parameter->environment->used; ++i) {
f_environment_set_dynamic(parameter->environment->array[i].name, parameter->environment->array[i].value, F_true);
} // for
}
uint8_t i = 0;
f_array_length_t j = 0;
- for (; i < 7; i++) {
+ for (; i < 7; ++i) {
- for (j = 0; F_status_is_fine(status) && j < list[i]->used; j++) {
+ for (j = 0; F_status_is_fine(status) && j < list[i]->used; ++j) {
const f_array_length_t length = path_length + list[i]->array[j].used + 1;
macro_f_string_dynamics_t_delete_simple(listing.unknown);
- for (f_array_length_t i = 0; F_status_is_fine(status) && i < listing.directory.used; i++) {
+ for (f_array_length_t i = 0; F_status_is_fine(status) && i < listing.directory.used; ++i) {
const f_array_length_t length = path_length + listing.directory.array[i].used + 1;
uint8_t i = 0;
f_array_length_t j = 0;
- for (; i < 7; i++) {
+ for (; i < 7; ++i) {
- for (j = 0; F_status_is_fine(status) && j < list[i]->used; j++) {
+ for (j = 0; F_status_is_fine(status) && j < list[i]->used; ++j) {
const f_array_length_t length = path_length + list[i]->array[j].used + 1;
} // for
}
- for (f_array_length_t i = 0; F_status_is_fine(status) && i < listing.directory.used; i++) {
+ for (f_array_length_t i = 0; F_status_is_fine(status) && i < listing.directory.used; ++i) {
const f_array_length_t length = path_length + listing.directory.array[i].used + 1;
status = f_string_dynamic_partial_append_nulless(buffer, contents.array[i].array[0], &map->name);
if (F_status_is_error(status)) return status;
- values[j]->used++;
+ ++values[j]->used;
if (indexs) {
indexs[j]->array[indexs[j]->used] = i;
- indexs[j]->used++;
+ ++indexs[j]->used;
}
if (contents.array[i].used > 1) {
- for (k = 1; k < contents.array[i].used; k++) {
+ for (k = 1; k < contents.array[i].used; ++k) {
status = f_string_dynamic_partial_mash_nulless(glue, glue_length, buffer, contents.array[i].array[k], &map->value);
if (F_status_is_error(status)) return status;
if (range->start >= range->stop || range->start >= buffer.used) {
if (status == FL_fss_found_object || status == FL_fss_found_object_content_not) {
- objects->used++;
+ ++objects->used;
if (objects_quoted) {
- objects_quoted->used++;
+ ++objects_quoted->used;
}
macro_f_fss_content_t_increase(status2, f_fss_default_allocation_step_small, contents->array[contents->used])
if (F_status_is_error(status2)) return status2;
- contents->used++;
+ ++contents->used;
return FL_fss_found_object_content_not;
}
} while (status == FL_fss_found_object_not);
if (status == F_none_eos || status == F_none_stop) {
- contents->array[contents->used].used++;
- objects->used++;
- contents->used++;
+ ++contents->array[contents->used].used;
+ ++objects->used;
+ ++contents->used;
if (objects_quoted) {
- objects_quoted->used++;
+ ++objects_quoted->used;
}
return status;
// When content is found, the range->start is incremented, if content is found at range->stop, then range->start will be > range.stop.
else if (range->start >= range->stop || range->start >= buffer.used) {
if (status == FL_fss_found_object || status == FL_fss_found_content || status == FL_fss_found_content_not || status == FL_fss_found_object_content_not) {
- objects->used++;
- contents->used++;
+ ++objects->used;
+ ++contents->used;
if (objects_quoted) {
- objects_quoted->used++;
+ ++objects_quoted->used;
}
}
return F_none_stop;
}
- objects->used++;
- contents->used++;
+ ++objects->used;
+ ++contents->used;
if (objects_quoted) {
- objects_quoted->used++;
+ ++objects_quoted->used;
}
} while (range->start < f_string_t_size);
if (range->start >= range->stop || range->start >= buffer.used) {
if (status == FL_fss_found_object || status == FL_fss_found_object_content_not) {
- objects->used++;
+ ++objects->used;
macro_f_fss_content_t_increase(status2, f_fss_default_allocation_step_small, contents->array[contents->used])
if (F_status_is_error(status2)) return status2;
- contents->used++;
+ ++contents->used;
return FL_fss_found_object_content_not;
}
} while (status == FL_fss_found_object_not);
if (status == F_none_eos || status == F_none_stop) {
- contents->array[contents->used].used++;
- objects->used++;
- contents->used++;
+ ++contents->array[contents->used].used;
+ ++objects->used;
+ ++contents->used;
return status;
}
// When content is found, the range->start is incremented, if content is found at range->stop, then range->start will be > range.stop.
if (status == FL_fss_found_object || status == FL_fss_found_content || status == FL_fss_found_content_not || status == FL_fss_found_object_content_not) {
- objects->used++;
- contents->used++;
+ ++objects->used;
+ ++contents->used;
}
if (range->start >= buffer.used) {
return F_none_stop;
}
- objects->used++;
- contents->used++;
+ ++objects->used;
+ ++contents->used;
} while (range->start < f_string_t_size);
if (range->start >= range->stop || range->start >= buffer.used) {
if (status == FL_fss_found_object || status == FL_fss_found_object_content_not) {
- objects->used++;
+ ++objects->used;
if (objects_quoted) {
- objects_quoted->used++;
+ ++objects_quoted->used;
}
macro_f_fss_content_t_increase(status2, f_fss_default_allocation_step_small, contents->array[contents->used])
if (F_status_is_error(status2)) return status2;
- contents->used++;
+ ++contents->used;
if (contents_quoted) {
macro_f_fss_quotes_t_increase(status2, f_fss_default_allocation_step_small, contents_quoted->array[contents_quoted->used])
if (F_status_is_error(status2)) return status2;
- contents_quoted->used++;
+ ++contents_quoted->used;
}
return FL_fss_found_object_content_not;
if (status == F_none_eos || status == F_none_stop) {
contents->array[contents->used].used++;
- objects->used++;
- contents->used++;
+ ++objects->used;
+ ++contents->used;
if (objects_quoted) {
- objects_quoted->used++;
+ ++objects_quoted->used;
}
if (contents_quoted) {
- contents_quoted->array[contents_quoted->used].used++;
- contents_quoted->used++;
+ ++contents_quoted->array[contents_quoted->used].used;
+ ++contents_quoted->used;
}
return status;
// When content is found, the range->start is incremented, if content is found at range->stop, then range->start will be > range.stop.
if (status == FL_fss_found_object || status == FL_fss_found_content || status == FL_fss_found_content_not || status == FL_fss_found_object_content_not || status == F_terminated_not_group) {
- objects->used++;
- contents->used++;
+ ++objects->used;
+ ++contents->used;
if (objects_quoted) {
- objects_quoted->used++;
+ ++objects_quoted->used;
}
if (contents_quoted) {
- contents_quoted->used++;
+ ++contents_quoted->used;
}
}
return F_none_stop;
}
- objects->used++;
- contents->used++;
+ ++objects->used;
+ ++contents->used;
if (objects_quoted) {
- objects_quoted->used++;
+ ++objects_quoted->used;
}
if (contents_quoted) {
- contents_quoted->used++;
+ ++contents_quoted->used;
}
} while (range->start < f_string_t_size);
if (status == F_none || status == F_none_stop || status == F_none_eos || status == F_none_eol) {
uint8_t complete = f_fss_complete_next;
- for (f_array_length_t i = 0; i < contents.used; i++) {
+ for (f_array_length_t i = 0; i < contents.used; ++i) {
if (i + 1 == contents.used) {
complete = f_fss_complete_end;
if (range->start >= range->stop || range->start >= buffer.used) {
if (status == FL_fss_found_object || status == FL_fss_found_object_content_not) {
- objects->used++;
+ ++objects->used;
macro_f_fss_content_t_increase(status2, f_fss_default_allocation_step_small, contents->array[contents->used])
if (F_status_is_error(status2)) return status2;
- contents->used++;
+ ++contents->used;
return FL_fss_found_object_content_not;
}
} while (status == FL_fss_found_object_not);
if (status == F_none_eos || status == F_none_stop) {
- contents->array[contents->used].used++;
- objects->used++;
- contents->used++;
+ ++contents->array[contents->used].used;
+ ++objects->used;
+ ++contents->used;
return status;
}
// When content is found, the range->start is incremented, if content is found at range->stop, then range->start will be > range.stop.
if (status == FL_fss_found_object || status == FL_fss_found_content || status == FL_fss_found_content_not || status == FL_fss_found_object_content_not) {
- objects->used++;
- contents->used++;
+ ++objects->used;
+ ++contents->used;
}
if (range->start >= buffer.used) {
return F_none_stop;
}
- objects->used++;
- contents->used++;
+ ++objects->used;
+ ++contents->used;
} while (range->start < f_string_t_size);
f_array_length_t j = 0;
f_array_length_t delimits = 0;
- for (; i < content.used; i++) {
+ for (; i < content.used; ++i) {
if (content.string[i] == quote) {
if (escaped->used + delimits + 2 > escaped->size) {
if (F_status_is_error(status)) return status;
}
- for (j = 0; j < delimits; j++) {
+ for (j = 0; j < delimits; ++j) {
escaped->string[escaped->used++] = f_iki_syntax_slash;
} // for
}
if (content.string[i] == f_iki_syntax_slash) {
- delimits++;
+ ++delimits;
}
else {
delimits = 0;
if (F_status_is_error(status)) return status;
}
- for (j = 0; j < delimits; j++) {
+ for (j = 0; j < delimits; ++j) {
escaped->string[escaped->used++] = f_iki_syntax_slash;
} // for
}
const f_array_length_t used = unescaped->used;
- for (; i < content.used; i++) {
+ for (; i < content.used; ++i) {
if (content.string[i] == quote) {
delimits = 1;
if (i + 1 < content.used) {
- for (j = i + 1; j < content.used; j++) {
+ for (j = i + 1; j < content.used; ++j) {
if (content.string[j] == quote) {
if (delimits % 2 == 0) {
if (F_status_is_error(status)) return status;
}
- for (j = 0; j < delimits; j++) {
+ for (j = 0; j < delimits; ++j) {
unescaped->string[unescaped->used++] = f_iki_syntax_slash;
} // for
break;
}
else if (content.string[j] == f_iki_syntax_slash) {
- delimits++;
+ ++delimits;
}
else if (content.string[j]) {
if (unescaped->used + (j - i) + 1 > unescaped->size) {
if (F_status_is_error(status)) return status;
}
- for (; i <= j; i++) {
+ for (; i <= j; ++i) {
unescaped->string[unescaped->used++] = content.string[i];
} // for
delimits = 0;
- i--;
+ --i;
break;
}
} // for
if (F_status_is_error(status)) return status;
}
- for (j = 0; j < delimits; j++) {
+ for (j = 0; j < delimits; ++j) {
unescaped->string[unescaped->used++] = f_iki_syntax_slash;
} // for
status = f_string_append_assure("/", 1, canonical);
if (F_status_is_error(status)) return status;
- for (; path[at]; at++) {
+ for (; path[at]; ++at) {
if (!size_chunk && path[at] == f_path_separator_current_s[0]) {
if (!previous_1 || previous_1 == f_path_separator_s[0]) {
if (previous_1 == f_path_separator_current_s[0]) {
if (previous_2 == f_path_separator_current_s[0]) {
if (canonical->used > 1) {
- for (canonical->used--; canonical->used > 0; canonical->used--) {
+ for (--canonical->used; canonical->used > 0; --canonical->used) {
if (canonical->string[canonical->used - 1] == f_path_separator_s[0]) break;
} // for
}
}
}
else {
- size_chunk++;
+ ++size_chunk;
if (size_chunk) {
status = f_string_append(path + position, size_chunk, canonical);
size_chunk = 2;
}
else if (previous_1 && previous_1 != f_path_separator_s[0]) {
- position--;
+ --position;
size_chunk = 1;
}
}
previous_2 = 0;
}
- size_chunk++;
+ ++size_chunk;
}
} // for
if (previous_2 == f_path_separator_current_s[0]) {
if (canonical->used > 1) {
- for (canonical->used--; canonical->used > 0; canonical->used--) {
+ for (--canonical->used; canonical->used > 0; --canonical->used) {
if (canonical->string[canonical->used - 1] == f_path_separator_s[0]) break;
} // for
}
f_array_length_t length = 0;
const f_array_length_t start = destination->used;
- for (f_array_length_t i = 0; i < values.used; i++) {
+ for (f_array_length_t i = 0; i < values.used; ++i) {
length = strnlen(argv[values.array[i]], f_console_parameter_size);
macro_f_memory_structure_increment(status, (*destination), 1, f_memory_default_allocation_small, macro_f_string_dynamics_t_resize, F_array_too_large);
if (F_status_is_error(status)) break;
- destination->array[destination->used] = ripped;
- destination->used++;
+ destination->array[destination->used++] = ripped;
}
}
} // for
f_array_length_t length = 0;
const f_array_length_t start = destination->used;
- for (f_array_length_t i = 0; i < values.used; i++) {
+ for (f_array_length_t i = 0; i < values.used; ++i) {
length = strnlen(argv[values.array[i]], f_console_parameter_size);
f_array_length_t length = 0;
const f_array_length_t start = destination->used;
- for (f_array_length_t i = 0; i < values.used; i++) {
+ for (f_array_length_t i = 0; i < values.used; ++i) {
length = strnlen(argv[values.array[i]], f_console_parameter_size);
macro_f_string_dynamics_t_increase(status, f_memory_default_allocation_small, (*destination));
if (F_status_is_error(status)) return status;
- destination->array[destination->used] = ripped;
- destination->used++;
+ destination->array[destination->used++] = ripped;
}
}
} // for
const f_array_length_t start = destination->used;
f_string_dynamic_t ripped = f_string_dynamic_t_initialize;
- for (f_array_length_t i = 0; i < values.used; i++) {
+ for (f_array_length_t i = 0; i < values.used; ++i) {
length = strnlen(argv[values.array[i]], f_console_parameter_size);
{
f_status_t missing_files = F_none;
- for (f_array_length_t counter = 0; counter < main->remaining.used; counter++) {
+ for (f_array_length_t counter = 0; counter < main->remaining.used; ++counter) {
status = f_file_exists(arguments.argv[main->remaining.array[counter]]);
f_file_t file = f_file_t_initialize;
- for (f_array_length_t counter = 0; counter < main->remaining.used; counter++) {
+ for (f_array_length_t counter = 0; counter < main->remaining.used; ++counter) {
status = f_file_stream_open(arguments.argv[main->remaining.array[counter]], 0, &file);
#ifndef _di_byte_dump_main_delete_
f_status_t byte_dump_main_delete(byte_dump_main_t *main) {
- for (f_array_length_t i = 0; i < byte_dump_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < byte_dump_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
macro_f_array_lengths_t_delete_simple(main->parameters[i].values);
if (previous->bytes > 0) {
if (main.parameters[byte_dump_parameter_placeholder].result == f_console_result_found) {
- for (; j < previous->bytes && j < main.width; j++) {
+ for (; j < previous->bytes && j < main.width; ++j) {
if (previous->invalid) {
f_color_print(main.output.stream, main.context.set.error, "%s", byte_dump_character_placeholder);
} // for
}
else {
- for (; j < previous->bytes && j < main.width; j++) {
+ for (; j < previous->bytes && j < main.width; ++j) {
fprintf(main.output.stream, "%s", f_string_space_s);
} // for
}
}
}
- for (uint8_t i = 0; i < characters.used && j < main.width; i++, j++) {
+ for (uint8_t i = 0; i < characters.used && j < main.width; ++i, ++j) {
output = macro_f_utf_character_t_to_char_1(characters.string[i]);
width_utf = macro_f_utf_byte_width_is(output);
// Print placeholder for the remaining parts of the line.
if (main.parameters[byte_dump_parameter_placeholder].result == f_console_result_found) {
- for (; j < main.width; j++) {
+ for (; j < main.width; ++j) {
if (invalid[j]) {
f_color_print(main.output.stream, main.context.set.error, "%s", byte_dump_character_placeholder);
} // for
}
else {
- for (; j < main.width; j++) {
+ for (; j < main.width; ++j) {
fprintf(main.output.stream, "%s", f_string_space_s);
} // for
}
#ifndef _di_control_main_delete_
f_status_t control_main_delete(control_main_t *main) {
- for (f_array_length_t i = 0; i < control_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < control_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
macro_f_array_lengths_t_delete_simple(main->parameters[i].values);
at_j -= 2;
cache->ats.used -= 2;
- cache->ats.array[at_j]++;
+ ++cache->ats.array[at_j];
cache->action.line_item = entry->items.array[cache->ats.array[at_i]].line;
cache->action.name_item.used = 0;
at_j -= 2;
cache->ats.used -= 2;
- cache->ats.array[at_j]++;
+ ++cache->ats.array[at_j];
cache->action.line_item = entry->items.array[cache->ats.array[at_i]].line;
cache->action.name_item.used = 0;
break;
}
- cache->action.line_item++;
+ ++cache->action.line_item;
for (j = (code & 0x1) ? 1 : 0; j < entry->items.used; ++j) {
return status;
}
- parameters->used++;
+ ++parameters->used;
}
if (content && content->used) {
status = controller_rule_parameters_read(global, cache->buffer_item, &cache->object_actions.array[i], &cache->content_actions.array[i], &actions->array[actions->used].parameters);
- actions->array[actions->used].status = controller_status_simplify_error(F_status_set_fine(status));
- actions->used++;
+ actions->array[actions->used++].status = controller_status_simplify_error(F_status_set_fine(status));
} // for
range->start = cache->content_action.array[0].start;
controller_error_print(global.main->error, F_status_set_fine(status), "f_string_dynamic_terminate_after", F_true, global.thread);
}
else {
- actions->array[actions->used].parameters.used = 1;
- actions->used++;
+ actions->array[actions->used++].parameters.used = 1;
}
}
}
#ifndef _di_fake_main_delete_
f_status_t fake_main_delete(fake_main_t *main) {
- for (f_array_length_t i = 0; i < fake_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < fake_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
macro_f_array_lengths_t_delete_simple(main->parameters[i].values);
if (F_status_is_error(*status)) return;
// reset the environment.
- for (f_array_length_t i = 0; i < environment->used; i++) {
+ for (f_array_length_t i = 0; i < environment->used; ++i) {
environment->array[i].name.used = 0;
environment->array[i].value.used = 0;
} // for
}
// Ensure that the terminating NULL is after the end of the string used size.
- data_make->setting_build.environment.array[data_make->setting_build.environment.used].used--;
- data_make->setting_build.environment.used++;
+ --data_make->setting_build.environment.array[data_make->setting_build.environment.used++].used;
}
else if (main.error.verbosity == f_console_verbosity_verbose) {
fprintf(main.output.stream, "%c", f_string_eol_s[0]);
return;
}
else {
- data_make->parameter.verbosity.used++;
+ ++data_make->parameter.verbosity.used;
}
}
}
}
- arguments->used++;
+ ++arguments->used;
unmatched = F_false;
}
else {
status = f_string_dynamic_terminate_after(&arguments->array[arguments->used]);
if (F_status_is_error_not(status)) {
- arguments->used++;
+ ++arguments->used;
}
}
}
if (operation == fake_make_operation_type_pop) {
macro_f_string_dynamic_t_delete_simple(data_make->path.stack.array[data_make->path.stack.used - 1]);
- data_make->path.stack.used--;
+ --data_make->path.stack.used;
*status = f_path_change(data_make->path.stack.array[data_make->path.stack.used - 1].string);
// fifo = 0x8 (0000 1000) invalid = 0x80 (1000 0000)
uint8_t type_file = 0;
- for (i = 1; i < arguments.used; i++) {
+ for (i = 1; i < arguments.used; ++i) {
if (fl_string_dynamic_compare_string(fake_make_operation_argument_if_is_for, arguments.array[i], fake_make_operation_argument_if_is_for_length) == F_equal_to) {
- i++;
+ ++i;
break;
}
}
if (i < arguments.used) {
- for (f_status_t status_file = F_none; i < arguments.used; i++) {
+ for (f_status_t status_file = F_none; i < arguments.used; ++i) {
status_file = fake_make_assure_inside_project(main, arguments.array[i], data_make);
&main.path_work_programs_static,
};
- for (uint8_t i = 0; i < 20; i++) {
+ for (uint8_t i = 0; i < 20; ++i) {
if (fake_signal_received(main)) {
return F_status_set_error(F_signal);
f_array_length_t counter = 0;
- for (; counter < main->remaining.used; counter++) {
+ for (; counter < main->remaining.used; ++counter) {
if (strncmp("nat", arguments.argv[main->remaining.array[counter]], 4) != 0) {
if (strncmp("mangle", arguments.argv[main->remaining.array[counter]], 7) != 0) {
f_color_print_code(f_type_error, main->context.error);
fprintf(f_type_error, "%s ", firewall_tool_iptables);
- for (; i < parameters.used; i++) {
+ for (; i < parameters.used; ++i) {
fprintf(f_type_error, "%s ", parameters.array[i].string);
} // for
{
f_array_length_t i = 0;
- for (; i < main->devices.used; i++) {
+ for (; i < main->devices.used; ++i) {
if (fl_string_compare((f_string_t) firewall_device_loop, main->devices.array[i].string, firewall_device_loop_length + 1, main->devices.array[i].used) == F_equal_to) {
f_string_dynamic_t swap_string = main->devices.array[i];
- main->devices.used--;
+ --main->devices.used;
- for (; i < main->devices.used; i++) {
+ for (; i < main->devices.used; ++i) {
main->devices.array[i] = main->devices.array[i+1];
} // for
f_array_length_t i = 0;
f_array_length_t length = 0;
- for (; i < local.chain_objects.used; i++) {
+ for (; i < local.chain_objects.used; ++i) {
length = local.chain_objects.array[i].stop - local.chain_objects.array[i].start + 1;
if (!reserved.has_stop && fl_string_compare((f_string_t) firewall_group_stop, local.buffer.string + local.chain_objects.array[i].start, firewall_group_stop_length, length) == F_equal_to) {
return status;
}
- i++;
+ ++i;
} // while
firewall_delete_local_data(&local);
- for (i = 0; i < main->devices.used; i++) {
+ for (i = 0; i < main->devices.used; ++i) {
local.device = i;
{
local.is_stop = F_false;
local.is_lock = F_false;
- for (; j < local.chain_contents.used; j++) {
+ for (; j < local.chain_contents.used; ++j) {
input.start = local.chain_contents.array[j].array[0].start;
input.stop = local.chain_contents.array[j].array[0].stop;
return status;
}
- i++;
+ ++i;
} // while
}
#ifndef _di_firewall_main_delete_
f_status_t firewall_main_delete(firewall_main_t *main) {
- for (f_array_length_t i = 0; i < firewall_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < firewall_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
macro_f_array_lengths_t_delete_simple(main->parameters[i].values);
\
arguments.array[arguments.used].string = argument.string; \
arguments.array[arguments.used].size = argument.size; \
- arguments.array[arguments.used].used = argument.used; \
- arguments.used++; \
+ arguments.array[arguments.used++].used = argument.used; \
\
macro_f_string_dynamic_t_clear(argument);
chain = firewall_chain_custom_id;
}
- for (; i < local.rule_objects.used; i++) {
+ for (; i < local.rule_objects.used; ++i) {
length = macro_firewall_structure_size(local.rule_objects, i);
invalid = F_false;
continue;
}
- for (r = repeat; r > 0; r--) {
+ for (r = repeat; r > 0; --r) {
// first add the program name
f_string_dynamics_resize(0, &arguments);
f_array_length_t subcounter = 0;
if (is_ip_list) {
+
// skip past the chain
- subcounter++;
+ ++subcounter;
length = macro_firewall_structure_size(local.rule_contents.array[i], subcounter);
macro_firewall_concat_string(ip_list.string, local.buffer.string + local.rule_contents.array[i].array[subcounter].start, length);
ip_list.used = length;
- subcounter++;
+ ++subcounter;
}
}
}
- for (; subcounter < local.rule_contents.array[i].used; subcounter++) {
+ for (; subcounter < local.rule_contents.array[i].used; ++subcounter) {
length = macro_firewall_structure_size(local.rule_contents.array[i], subcounter);
}
// the ip_list file contains objects and no content, all objects are what matter an nothing else
- for (; buffer_counter < basic_objects.used; buffer_counter++) {
+ for (; buffer_counter < basic_objects.used; ++buffer_counter) {
ip_length = macro_firewall_structure_size(basic_objects, buffer_counter);
f_color_print_code(f_type_debug, main.context.warning);
fprintf(f_type_debug, "%s ", current_tool);
- for (f_array_length_t i = 0; i < arguments.used; i++) {
+ for (f_array_length_t i = 0; i < arguments.used; ++i) {
fprintf(f_type_debug, "%.*s ", arguments.array[i].used, arguments.array[i].string);
} // for
f_color_print_code(f_type_error, main.context.error);
fprintf(f_type_error, "%s ", current_tool);
- for (f_array_length_t i = 0; i < arguments.used; i++) {
+ for (f_array_length_t i = 0; i < arguments.used; ++i) {
fprintf(f_type_error, "%.*s ", arguments.array[i].used, arguments.array[i].string);
} // for
fprintf(f_type_error, "\n");
// remove ip_argument from arguments string.
- macro_f_string_dynamic_t_delete_simple(arguments.array[arguments.used]);
- arguments.used--;
+ macro_f_string_dynamic_t_delete_simple(arguments.array[arguments.used--]);
break;
}
f_color_print(main.error.to.stream, main.context.set.error, "%sInvalid parameter when calling fll_execute_program()%c", fll_error_print_error, f_string_eol_s[0]);
// remove ip_argument from arguments string.
- macro_f_string_dynamic_t_delete_simple(arguments.array[arguments.used]);
- arguments.used--;
+ macro_f_string_dynamic_t_delete_simple(arguments.array[arguments.used--]);
break;
}
// remove ip_argument from arguments string.
- macro_f_string_dynamic_t_delete_simple(arguments.array[arguments.used]);
- arguments.used--;
+ macro_f_string_dynamic_t_delete_simple(arguments.array[arguments.used--]);
} // for
macro_f_string_dynamic_t_delete_simple(ip_argument);
// remove ip_list_action from arguments string.
- macro_f_string_dynamic_t_delete_simple(arguments.array[arguments.used]);
- arguments.used--;
+ macro_f_string_dynamic_t_delete_simple(arguments.array[arguments.used--]);
}
}
f_color_print_code(f_type_debug, main.context.warning);
fprintf(f_type_debug, "%s ", current_tool);
- for (f_array_length_t i = 0; i < arguments.used; i++) {
+ for (f_array_length_t i = 0; i < arguments.used; ++i) {
fprintf(f_type_debug, "%.*s ", arguments.array[i].used, arguments.array[i].string);
} // for
f_color_print_code(f_type_error, main.context.error);
fprintf(f_type_error, "%s ", current_tool);
- for (f_array_length_t i = 0; i < arguments.used; i++) {
+ for (f_array_length_t i = 0; i < arguments.used; ++i) {
fprintf(f_type_error, "%.*s ", arguments.array[i].used, arguments.array[i].string);
} // for
break;
}
- j++;
+ ++j;
} // while
}
while (j <= local->chain_objects.array[i].stop) {
if (local->buffer.string[j] == f_fss_delimit_placeholder) {
- j++;
+ ++j;
continue;
}
- main->chains.array[main->chains.used].string[main->chains.array[main->chains.used].used] = local->buffer.string[j];
- main->chains.array[main->chains.used].used++;
- arguments.array[1].string[arguments.array[1].used] = local->buffer.string[j];
- arguments.array[1].used++;
- j++;
+ main->chains.array[main->chains.used].string[main->chains.array[main->chains.used].used++] = local->buffer.string[j];
+ arguments.array[1].string[arguments.array[1].used++] = local->buffer.string[j];
+ ++j;
} // while
if (fl_string_compare(arguments.array[1].string, firewall_chain_forward, arguments.array[1].used, firewall_chain_forward_length) == F_equal_to) {
f_color_print_code(f_type_debug, main->context.warning);
fprintf(f_type_debug, "%s ", firewall_tool_iptables);
- for (f_array_length_t i = 0; i < arguments.used; i++) {
+ for (f_array_length_t i = 0; i < arguments.used; ++i) {
fprintf(f_type_debug, "%.*s ", arguments.array[i].used, arguments.array[i].string);
} // for
f_color_print_code(f_type_debug, main->context.warning);
fprintf(f_type_debug, "%s ", firewall_tool_ip6tables);
- for (f_array_length_t i = 0; i < arguments.used; i++) {
+ for (f_array_length_t i = 0; i < arguments.used; ++i) {
fprintf(f_type_debug, "%.*s ", arguments.array[i].used, arguments.array[i].string);
} // for
fprintf(f_type_error, "%s ", firewall_tool_ip6tables);
}
- for (f_array_length_t i = 0; i < arguments.used; i++) {
+ for (f_array_length_t i = 0; i < arguments.used; ++i) {
fprintf(f_type_error, "%.*s ", arguments.array[i].used, arguments.array[i].string);
} // for
}
}
- main->chains.used++;
+ ++main->chains.used;
}
- i++;
+ ++i;
} // while
macro_f_string_dynamics_t_delete_simple(arguments);
const f_string_t tools[2] = { firewall_tool_iptables, firewall_tool_ip6tables };
f_status_t status = F_none;
- for (f_array_length_t i = 0; i < 2; i++) {
+ for (f_array_length_t i = 0; i < 2; ++i) {
f_string_dynamics_t arguments = f_string_dynamics_t_initialize;
f_string_dynamic_t argument[1] = f_string_dynamic_t_initialize;
int return_code = 0;
f_color_print_code(f_type_debug, main.context.warning);
fprintf(f_type_debug, "%s ", tools[i]);
- for (f_array_length_t i = 0; i < arguments.used; i++) {
+ for (f_array_length_t i = 0; i < arguments.used; ++i) {
fprintf(f_type_debug, "%.*s ", arguments.array[i].used, arguments.array[i].string);
} // for
f_color_print_code(f_type_error, main.context.error);
fprintf(f_type_error, "%s ", tools[i]);
- for (f_array_length_t i = 0; i < arguments.used; i++) {
+ for (f_array_length_t i = 0; i < arguments.used; ++i) {
fprintf(f_type_error, "%.*s ", arguments.array[i].used, arguments.array[i].string);
} // for
}
} // for
- for (f_array_length_t i = 0; i < 2; i++) {
+ for (f_array_length_t i = 0; i < 2; ++i) {
f_string_dynamics_t arguments = f_string_dynamics_t_initialize;
f_string_dynamic_t argument[1] = f_string_dynamic_t_initialize;
int return_code = 0;
f_color_print_code(f_type_debug, main.context.warning);
fprintf(f_type_debug, "%s ", tools[i]);
- for (f_array_length_t j = 0; j < arguments.used; j++) {
+ for (f_array_length_t j = 0; j < arguments.used; ++j) {
fprintf(f_type_debug, "%.*s ", arguments.array[j].used, arguments.array[j].string);
} // for
f_color_print_code(f_type_error, main.context.error);
fprintf(f_type_error, "%s ", tools[i]);
- for (f_array_length_t j = 0; j < arguments.used; j++) {
+ for (f_array_length_t j = 0; j < arguments.used; ++j) {
fprintf(f_type_error, "%.*s ", arguments.array[j].used, arguments.array[j].string);
} // for
f_status_t status = F_none;
- for (f_array_length_t i = 0; i < 3; i++) {
+ for (f_array_length_t i = 0; i < 3; ++i) {
f_string_dynamics_t arguments = f_string_dynamics_t_initialize;
f_string_dynamic_t argument[3];
arguments.array[1].size = arguments.array[1].used;
arguments.array[2].size = arguments.array[2].used;
- for (f_array_length_t j = 0; j < 2; j++) {
+ for (f_array_length_t j = 0; j < 2; ++j) {
int return_code = 0;
// print command when debugging.
}
if (main->parameters[fss_basic_list_read_parameter_name].result == f_console_result_additional) {
- for (; position_name < main->parameters[fss_basic_list_read_parameter_name].values.used; position_name++) {
+ for (; position_name < main->parameters[fss_basic_list_read_parameter_name].values.used; ++position_name) {
if (main->parameters[fss_basic_list_read_parameter_name].values.array[position_name] < position_depth) {
continue;
f_array_length_t location_sub_object = 0;
f_array_length_t location_sub_content = 0;
- for (f_array_length_t i = 0; i < main->parameters[fss_basic_list_write_parameter_object].locations.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_basic_list_write_parameter_object].locations.used; ++i) {
location_object = main->parameters[fss_basic_list_write_parameter_object].locations.array[i];
location_content = main->parameters[fss_basic_list_write_parameter_content].locations.array[i];
location_sub_object = main->parameters[fss_basic_list_write_parameter_object].locations_sub.array[i];
if (main->parameters[fss_basic_list_write_parameter_partial].result == f_console_result_found) {
if (main->parameters[fss_basic_list_write_parameter_object].result == f_console_result_additional) {
- for (f_array_length_t i = 0; i < main->parameters[fss_basic_list_write_parameter_object].values.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_basic_list_write_parameter_object].values.used; ++i) {
object.string = arguments.argv[main->parameters[fss_basic_list_write_parameter_object].values.array[i]];
object.used = strnlen(object.string, f_console_parameter_size);
} // for
}
else {
- for (f_array_length_t i = 0; i < main->parameters[fss_basic_list_write_parameter_content].values.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_basic_list_write_parameter_content].values.used; ++i) {
content.string = arguments.argv[main->parameters[fss_basic_list_write_parameter_content].values.array[i]];
content.used = strnlen(content.string, f_console_parameter_size);
}
}
else {
- for (f_array_length_t i = 0; i < main->parameters[fss_basic_list_write_parameter_object].values.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_basic_list_write_parameter_object].values.used; ++i) {
object.string = arguments.argv[main->parameters[fss_basic_list_write_parameter_object].values.array[i]];
object.used = strnlen(object.string, f_console_parameter_size);
#ifndef _di_fss_basic_list_write_main_delete_
f_status_t fss_basic_list_write_main_delete(fss_basic_list_write_main_t *main) {
- for (f_array_length_t i = 0; i < fss_basic_list_write_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < fss_basic_list_write_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
macro_f_array_lengths_t_delete_simple(main->parameters[i].values);
f_array_length_t location_sub_object = 0;
f_array_length_t location_sub_content = 0;
- for (f_array_length_t i = 0; i < main->parameters[fss_basic_write_parameter_object].locations.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_basic_write_parameter_object].locations.used; ++i) {
location_object = main->parameters[fss_basic_write_parameter_object].locations.array[i];
location_content = main->parameters[fss_basic_write_parameter_content].locations.array[i];
location_sub_object = main->parameters[fss_basic_write_parameter_object].locations_sub.array[i];
if (main->parameters[fss_basic_write_parameter_object].result == f_console_result_additional) {
content.used = 0;
- for (f_array_length_t i = 0; i < main->parameters[fss_basic_write_parameter_object].values.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_basic_write_parameter_object].values.used; ++i) {
object.string = arguments.argv[main->parameters[fss_basic_write_parameter_object].values.array[i]];
object.used = strnlen(object.string, f_console_parameter_size);
else {
object.used = 0;
- for (f_array_length_t i = 0; i < main->parameters[fss_basic_write_parameter_content].values.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_basic_write_parameter_content].values.used; ++i) {
content.string = arguments.argv[main->parameters[fss_basic_write_parameter_content].values.array[i]];
content.used = strnlen(content.string, f_console_parameter_size);
}
}
else {
- for (f_array_length_t i = 0; i < main->parameters[fss_basic_write_parameter_object].values.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_basic_write_parameter_object].values.used; ++i) {
object.string = arguments.argv[main->parameters[fss_basic_write_parameter_object].values.array[i]];
object.used = strnlen(object.string, f_console_parameter_size);
#ifndef _di_fss_basic_write_main_delete_
f_status_t fss_basic_write_main_delete(fss_basic_write_main_t *main) {
- for (f_array_length_t i = 0; i < fss_basic_write_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < fss_basic_write_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
macro_f_array_lengths_t_delete_simple(main->parameters[i].values);
main->delimit_mode = fss_embedded_list_read_delimit_mode_depth_greater;
// shorten the length to better convert the remainder to a number.
- length--;
+ --length;
}
else if (arguments.argv[location][length - 1] == fss_embedded_list_read_delimit_mode_name_lesser[0]) {
main->delimit_mode = fss_embedded_list_read_delimit_mode_depth_lesser;
// shorten the length to better convert the remainder to a number.
- length--;
+ --length;
}
f_string_range_t range = macro_f_string_range_t_initialize(length);
// ignore leading plus sign.
if (arguments.argv[location][0] == '+') {
- range.start++;
+ ++range.start;
}
status = fl_conversion_string_to_number_unsigned(arguments.argv[location], range, &main->delimit_depth);
}
if (F_status_is_error_not(status) && main->remaining.used > 0) {
- for (f_array_length_t i = 0; i < main->remaining.used; i++) {
+ for (f_array_length_t i = 0; i < main->remaining.used; ++i) {
f_file_t file = f_file_t_initialize;
status = f_file_open(arguments.argv[main->remaining.array[i]], 0, &file);
#ifndef _di_fss_embedded_list_read_main_delete_
f_status_t fss_embedded_list_read_main_delete(fss_embedded_list_read_main_t *main) {
- for (f_array_length_t i = 0; i < fss_embedded_list_read_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < fss_embedded_list_read_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
macro_f_array_lengths_t_delete_simple(main->parameters[i].values);
#define macro_fss_embedded_list_read_depths_t_delete_simple(depths) \
depths.used = depths.size; \
while (depths.used > 0) { \
- depths.used--; \
+ --depths.used; \
macro_fss_embedded_list_read_depth_t_delete_simple(depths.array[depths.used]); \
} \
if (!depths.used) macro_f_memory_structure_delete_simple(depths, fss_embedded_list_read_depth_t)
status = F_none; \
if (new_length < depths.size) { \
f_array_length_t i = depths.size - new_length; \
- for (; i < depths.size; i++) { \
+ for (; i < depths.size; ++i) { \
macro_fss_embedded_list_read_depth_t_delete_simple(depths.array[i]); \
} \
} \
status = F_none; \
if (new_length < depths.size) { \
f_array_length_t i = depths.size - new_length; \
- for (; i < depths.size; i++) { \
+ for (; i < depths.size; ++i) { \
macro_fss_embedded_list_read_depth_t_delete_simple(depths.array[i]); \
} \
} \
depths->used++;
}
- for (i = 0; i < depths->used; i++) {
+ for (i = 0; i < depths->used; ++i) {
- for (j = i + 1; j < depths->used; j++) {
+ for (j = i + 1; j < depths->used; ++j) {
if (depths->array[i].depth == depths->array[j].depth) {
fprintf(main.error.to.stream, "%c", f_string_eol_s[0]);
if (main->parameters[fss_embedded_list_read_parameter_total].result == f_console_result_found) {
f_array_length_t total = 0;
- for (i = 0; i < items->used; i++) {
+ for (i = 0; i < items->used; ++i) {
if (skip[i]) continue;
- total++;
+ ++total;
} // for
fprintf(main->output.stream, "%llu%c", total, f_string_eol_s[0]);
print_object = &fl_print_trim_except_dynamic_partial;
}
- for (i = 0; i < items->used; i++) {
+ for (i = 0; i < items->used; ++i) {
if (skip[i]) continue;
if (!items->array[i].content.used) {
if (include_empty) {
- total++;
+ ++total;
}
continue;
if (!main->buffer.string[j]) continue;
if (main->buffer.string[j] == f_string_eol_s[0]) {
- total++;
+ ++total;
}
} // for
} // for
break;
}
- line_current++;
+ ++line_current;
}
continue;
for (; j <= items->array[i].content.array[0].stop; ++j) {
if (main->buffer.string[j] == f_string_eol_s[0]) {
- line_current++;
+ ++line_current;
if (line_current == line) {
++j;
return F_none;
}
- for (i = 0; i < items->used; i++) {
+ for (i = 0; i < items->used; ++i) {
if (skip[i]) continue;
if (fss_embedded_list_read_process_delimits_within_greater(main, depth, original_delimits[j]) == F_false) {
delimits->array[l] = original_delimits[j];
- delimits->used++;
+ ++delimits->used;
}
break;
if (fss_embedded_list_read_process_delimits_within_greater(main, depth, original_delimits[j]) == F_false) {
delimits->array[k] = original_delimits[j];
- delimits->used++;
+ ++delimits->used;
}
break;
f_array_length_t location_sub_object = 0;
f_array_length_t location_sub_content = 0;
- for (f_array_length_t i = 0; i < main->parameters[fss_embedded_list_write_parameter_object].locations.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_embedded_list_write_parameter_object].locations.used; ++i) {
location_object = main->parameters[fss_embedded_list_write_parameter_object].locations.array[i];
location_content = main->parameters[fss_embedded_list_write_parameter_content].locations.array[i];
location_sub_object = main->parameters[fss_embedded_list_write_parameter_object].locations_sub.array[i];
main->prepend.used = length;
main->prepend.size = length;
- for (; range.start < length; range.start++) {
+ for (; range.start < length; ++range.start) {
status = f_fss_is_space(main->prepend, range);
if (F_status_is_error(status)) break;
if (main->parameters[fss_embedded_list_write_parameter_partial].result == f_console_result_found) {
if (main->parameters[fss_embedded_list_write_parameter_object].result == f_console_result_additional) {
- for (f_array_length_t i = 0; i < main->parameters[fss_embedded_list_write_parameter_object].values.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_embedded_list_write_parameter_object].values.used; ++i) {
object.string = arguments.argv[main->parameters[fss_embedded_list_write_parameter_object].values.array[i]];
object.used = strnlen(object.string, f_console_parameter_size);
} // for
}
else {
- for (f_array_length_t i = 0; i < main->parameters[fss_embedded_list_write_parameter_content].values.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_embedded_list_write_parameter_content].values.used; ++i) {
status = fss_embedded_list_write_process_parameter_ignore(arguments, *main, main->parameters[fss_embedded_list_write_parameter_content].locations, i, &ignore);
if (F_status_is_error(status)) break;
}
}
else {
- for (f_array_length_t i = 0; i < main->parameters[fss_embedded_list_write_parameter_object].values.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_embedded_list_write_parameter_object].values.used; ++i) {
status = fss_embedded_list_write_process_parameter_ignore(arguments, *main, main->parameters[fss_embedded_list_write_parameter_content].locations, i, &ignore);
if (F_status_is_error(status)) break;
#ifndef _di_fss_embedded_list_write_main_delete_
f_status_t fss_embedded_list_write_main_delete(fss_embedded_list_write_main_t *main) {
- for (f_array_length_t i = 0; i < fss_embedded_list_write_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < fss_embedded_list_write_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
macro_f_array_lengths_t_delete_simple(main->parameters[i].values);
if (block.string[range.start] == fss_embedded_list_write_pipe_content_end) {
state = 0x3;
- range.start++;
+ ++range.start;
break;
}
}
if (main->parameters[fss_extended_list_read_parameter_name].result == f_console_result_additional) {
- for (; position_name < main->parameters[fss_extended_list_read_parameter_name].values.used; position_name++) {
+ for (; position_name < main->parameters[fss_extended_list_read_parameter_name].values.used; ++position_name) {
if (main->parameters[fss_extended_list_read_parameter_name].values.array[position_name] < position_depth) {
continue;
fprintf(main->output.stream, "%c", fss_extended_list_read_pipe_content_end);
}
else {
- if ((data->option & fss_extended_list_read_data_option_object) && (data->option & fss_extended_list_read_data_option_content)) {
- fprintf(main->output.stream, "%c%c", f_fss_extended_list_close, f_fss_extended_list_close_end);
- }
- else if ((data->option & fss_extended_list_read_data_option_object) && !(data->option & fss_extended_list_read_data_option_content)) {
- fprintf(main->output.stream, "%c", f_fss_eol);
+ if (data->option & fss_extended_list_read_data_option_object) {
+ if (data->option & fss_extended_list_read_data_option_content) {
+ fprintf(main->output.stream, "%c%c", f_fss_extended_list_close, f_fss_extended_list_close_end);
+ }
+ else if (!(data->option & fss_extended_list_read_data_option_content)) {
+ fprintf(main->output.stream, "%c", f_fss_eol);
+ }
}
}
}
f_array_length_t location_sub_object = 0;
f_array_length_t location_sub_content = 0;
- for (f_array_length_t i = 0; i < main->parameters[fss_extended_list_write_parameter_object].locations.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_extended_list_write_parameter_object].locations.used; ++i) {
location_object = main->parameters[fss_extended_list_write_parameter_object].locations.array[i];
location_content = main->parameters[fss_extended_list_write_parameter_content].locations.array[i];
location_sub_object = main->parameters[fss_extended_list_write_parameter_object].locations_sub.array[i];
main->prepend.used = length;
main->prepend.size = length;
- for (; range.start < length; range.start++) {
+ for (; range.start < length; ++range.start) {
status = f_fss_is_space(main->prepend, range);
if (F_status_is_error(status)) break;
if (main->parameters[fss_extended_list_write_parameter_partial].result == f_console_result_found) {
if (main->parameters[fss_extended_list_write_parameter_object].result == f_console_result_additional) {
- for (f_array_length_t i = 0; i < main->parameters[fss_extended_list_write_parameter_object].values.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_extended_list_write_parameter_object].values.used; ++i) {
object.string = arguments.argv[main->parameters[fss_extended_list_write_parameter_object].values.array[i]];
object.used = strnlen(object.string, f_console_parameter_size);
} // for
}
else {
- for (f_array_length_t i = 0; i < main->parameters[fss_extended_list_write_parameter_content].values.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_extended_list_write_parameter_content].values.used; ++i) {
status = fss_extended_list_write_process_parameter_ignore(arguments, *main, main->parameters[fss_extended_list_write_parameter_content].locations, i, &ignore);
if (F_status_is_error(status)) break;
}
}
else {
- for (f_array_length_t i = 0; i < main->parameters[fss_extended_list_write_parameter_object].values.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_extended_list_write_parameter_object].values.used; ++i) {
status = fss_extended_list_write_process_parameter_ignore(arguments, *main, main->parameters[fss_extended_list_write_parameter_content].locations, i, &ignore);
if (F_status_is_error(status)) break;
#ifndef _di_fss_extended_list_write_main_delete_
f_status_t fss_extended_list_write_main_delete(fss_extended_list_write_main_t *main) {
- for (f_array_length_t i = 0; i < fss_extended_list_write_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < fss_extended_list_write_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
macro_f_array_lengths_t_delete_simple(main->parameters[i].values);
}
}
- for (; range.start <= range.stop; range.start++) {
+ for (; range.start <= range.stop; ++range.start) {
if (block.string[range.start] == fss_extended_list_write_pipe_content_start) {
state = 0x2;
f_string_range_t range = macro_f_string_range_t_initialize(length);
const f_string_static_t prepend = macro_f_string_static_t_initialize(arguments.argv[index], length);
- for (; range.start < length; range.start++) {
+ for (; range.start < length; ++range.start) {
status = f_fss_is_space(prepend, range);
if (F_status_is_error(status)) break;
if (main->parameters[fss_extended_write_parameter_object].result == f_console_result_additional) {
contents.used = 0;
- for (f_array_length_t i = 0; i < main->parameters[fss_extended_write_parameter_object].values.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[fss_extended_write_parameter_object].values.used; ++i) {
object.string = arguments.argv[main->parameters[fss_extended_write_parameter_object].values.array[i]];
object.used = strnlen(object.string, f_console_parameter_size);
else {
f_array_length_t i = 0;
- for (; i < main->parameters[fss_extended_write_parameter_content].values.used; i++) {
+ for (; i < main->parameters[fss_extended_write_parameter_content].values.used; ++i) {
contents.array[contents.used].string = arguments.argv[main->parameters[fss_extended_write_parameter_content].values.array[i]];
contents.array[contents.used].used = strnlen(contents.array[contents.used].string, f_console_parameter_size);
contents.array[contents.used].size = contents.array[contents.used].used;
- contents.used++;
+ ++contents.used;
} // for
status = fss_extended_write_process(*main, output, quote, 0, &contents, &buffer);
// clear the contents array of the static strings to avoid deallocation attempts on static variables.
- for (; i < main->parameters[fss_extended_write_parameter_content].values.used; i++) {
+ for (; i < main->parameters[fss_extended_write_parameter_content].values.used; ++i) {
contents.array[contents.used].string = 0;
contents.array[contents.used].used = 0;
contents.array[contents.used].size = 0;
f_array_length_t object_next = 0;
f_array_length_t content_current = 0;
- for (; i < main->parameters[fss_extended_write_parameter_object].values.used; i++) {
+ for (; i < main->parameters[fss_extended_write_parameter_object].values.used; ++i) {
object_current = main->parameters[fss_extended_write_parameter_object].locations.array[i];
contents.used = 0;
- for (; j < main->parameters[fss_extended_write_parameter_content].values.used; j++) {
+ for (; j < main->parameters[fss_extended_write_parameter_content].values.used; ++j) {
content_current = main->parameters[fss_extended_write_parameter_content].locations.array[j];
break;
}
- contents.used++;
+ ++contents.used;
} // for
if (F_status_is_error(status)) break;
#ifndef _di_fss_extended_write_main_delete_
f_status_t fss_extended_write_main_delete(fss_extended_write_main_t *main) {
- for (f_array_length_t i = 0; i < fss_extended_write_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < fss_extended_write_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
macro_f_array_lengths_t_delete_simple(main->parameters[i].values);
if (contents) {
if (contents->used) {
- for (f_array_length_t i = 0; i < contents->used; i++) {
+ for (f_array_length_t i = 0; i < contents->used; ++i) {
if (contents->array[i].used) {
range.start = 0;
}
}
- for (; range.start <= range.stop; range.start++) {
+ for (; range.start <= range.stop; ++range.start) {
if (block.string[range.start] == fss_extended_write_pipe_content_start) {
state = 0x2;
#ifndef _di_fss_identify_main_delete_
f_status_t fss_identify_main_delete(fss_identify_main_t *main) {
- for (f_array_length_t i = 0; i < fss_identify_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < fss_identify_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
}
if (main->remaining.used > 0) {
- for (f_array_length_t i = 0; i < main->remaining.used; i++) {
+ for (f_array_length_t i = 0; i < main->remaining.used; ++i) {
status2 = fss_status_code_process_check(*main, arguments.argv[main->remaining.array[i]]);
}
if (main->remaining.used > 0) {
- for (f_array_length_t i = 0; i < main->remaining.used; i++) {
+ for (f_array_length_t i = 0; i < main->remaining.used; ++i) {
status2 = fss_status_code_process_number(*main, arguments.argv[main->remaining.array[i]]);
}
if (main->remaining.used > 0) {
- for (f_array_length_t i = 0; i < main->remaining.used; i++) {
+ for (f_array_length_t i = 0; i < main->remaining.used; ++i) {
status2 = fss_status_code_process_normal(*main, arguments.argv[main->remaining.array[i]]);
if (F_status_is_error(status2) && status == F_none) {
#ifndef _di_fss_status_code_main_delete_
f_status_t fss_status_code_main_delete(fss_status_code_main_t *main) {
- for (f_array_length_t i = 0; i < fss_status_code_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < fss_status_code_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
macro_f_array_lengths_t_delete_simple(main->parameters[i].values);
f_array_length_t total = 0;
f_file_t file = f_file_t_initialize;
- for (; i < main->remaining.used; i++) {
+ for (; i < main->remaining.used; ++i) {
macro_f_file_t_reset(file);
total = 0;
#ifndef _di_iki_read_main_delete_
f_status_t iki_read_main_delete(iki_read_main_t *main) {
- for (f_array_length_t i = 0; i < iki_read_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < iki_read_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
macro_f_array_lengths_t_delete_simple(main->parameters[i].values);
range->start = 0;
if (main->line > 0) {
- for (; line < main->line && range->start < main->buffer.used; range->start++) {
- if (main->buffer.string[range->start] == f_string_eol_s[0]) line++;
+ for (; line < main->line && range->start < main->buffer.used; ++range->start) {
+ if (main->buffer.string[range->start] == f_string_eol_s[0]) ++line;
} // for
}
if (line == main->line) {
- for (range->stop = range->start; range->stop < main->buffer.used; range->stop++) {
+ for (range->stop = range->start; range->stop < main->buffer.used; ++range->stop) {
if (main->buffer.string[range->stop] == f_string_eol_s[0]) break;
} // for
if (F_status_is_error(status)) {
fll_error_print(main->error, F_status_set_fine(status), "iki_read_substitutions_identify", F_true);
- for (f_array_length_t i = 0; i < variable->used; i++) {
+ for (f_array_length_t i = 0; i < variable->used; ++i) {
macro_iki_read_substitutions_t_delete_simple(substitutionss[i]);
} // for
f_array_length_t j = 0;
buffer_range->start = 0;
- for (; i < main->parameters[iki_read_parameter_name].values.used; i++) {
+ for (; i < main->parameters[iki_read_parameter_name].values.used; ++i) {
index = main->parameters[iki_read_parameter_name].values.array[i];
name.used = 0;
if (F_status_is_error(status)) {
fll_error_print(main->error, F_status_set_fine(status), "f_string_append_nulless", F_true);
- for (f_array_length_t i = 0; i < variable->used; i++) {
+ for (f_array_length_t i = 0; i < variable->used; ++i) {
macro_iki_read_substitutions_t_delete_simple(substitutionss[i]);
} // for
buffer_range->stop = name.used - 1;
- for (j = 0; j < vocabulary->used; j++) {
+ for (j = 0; j < vocabulary->used; ++j) {
status = fl_string_dynamic_partial_compare(name, main->buffer, *buffer_range, vocabulary->array[j]);
f_array_length_t i = 0;
f_array_length_t j = 0;
- for (; i < ranges->used; i++) {
+ for (; i < ranges->used; ++i) {
if (substitutionss[i].used) {
iki_read_substitutions_print(*main, *variable, *content, *ranges, substitutionss[i], i, content_only);
status = F_data_not;
}
- for (f_array_length_t i = 0; i < variable->used; i++) {
+ for (f_array_length_t i = 0; i < variable->used; ++i) {
macro_iki_read_substitutions_t_delete_simple(substitutionss[i]);
} // for
if (F_status_is_error(status)) {
fll_error_print(main->error, F_status_set_fine(status), "iki_read_substitutions_identify", F_true);
- for (f_array_length_t i = 0; i < variable->used; i++) {
+ for (f_array_length_t i = 0; i < variable->used; ++i) {
macro_iki_read_substitutions_t_delete_simple(substitutionss[i]);
} // for
f_array_length_t j = 0;
f_array_length_t length_argument = 0;
- for (f_array_length_t index = 0; i < main->parameters[iki_read_parameter_name].values.used; i++) {
+ for (f_array_length_t index = 0; i < main->parameters[iki_read_parameter_name].values.used; ++i) {
index = main->parameters[iki_read_parameter_name].values.array[i];
length_argument = strnlen(arguments.argv[index], f_console_parameter_size);
- for (j = 0, name_missed = F_true; j < names.used; j++) {
+ for (j = 0, name_missed = F_true; j < names.used; ++j) {
status = fl_string_compare(arguments.argv[index], names.array[j].string, length_argument, names.array[j].used);
break;
}
- names.used++;
+ ++names.used;
}
} // for
if (F_status_is_error(status)) {
- for (i = 0; i < variable->used; i++) {
+ for (i = 0; i < variable->used; ++i) {
macro_iki_read_substitutions_t_delete_simple(substitutionss[i]);
} // for
if (names.used) {
name_missed = F_true;
- for (k = 0; k < names.used; k++) {
+ for (k = 0; k < names.used; ++k) {
name_range.stop = names.array[k].used - 1;
status = fl_string_dynamic_partial_compare(main->buffer, names.array[k], vocabulary->array[j], name_range);
}
i = variable->array[j].stop + 1;
- j++;
+ ++j;
} // while
if (i <= buffer_range.stop) {
}
}
- for (f_array_length_t i = 0; i < variable->used; i++) {
+ for (f_array_length_t i = 0; i < variable->used; ++i) {
macro_iki_read_substitutions_t_delete_simple(substitutionss[i]);
} // for
range.start = 0;
- for (; i < main->parameters[iki_read_parameter_name].values.used; i++) {
+ for (; i < main->parameters[iki_read_parameter_name].values.used; ++i) {
index = main->parameters[iki_read_parameter_name].values.array[i];
name.used = 0;
range.stop = name.used - 1;
- for (j = 0; j < vocabulary->used; j++) {
+ for (j = 0; j < vocabulary->used; ++j) {
status = fl_string_dynamic_partial_compare(name, main->buffer, range, vocabulary->array[j]);
- if (status == F_equal_to) total++;
+ if (status == F_equal_to) ++total;
} // for
} // for
index = parameter->values.array[i];
length = strnlen(arguments.argv[index], f_console_parameter_size);
- for (j = 0; j < vocabulary->used; j++) {
+ for (j = 0; j < vocabulary->used; ++j) {
status = fl_string_compare(arguments.argv[index], main->buffer.string + vocabulary->array[j].start, length, (vocabulary->array[j].stop - vocabulary->array[j].start) + 1);
substitutionss[j].array[index_2].with.used = strnlen(arguments.argv[index], f_console_parameter_size);
substitutionss[j].array[index_2].with.size = substitutionss[j].array[index_2].with.used;
- substitutionss[j].used++;
+ ++substitutionss[j].used;
}
} // for
} // for
range.start = 0;
- for (; i < substitutions.used; i++) {
+ for (; i < substitutions.used; ++i) {
range.stop = substitutions.array[i].replace.used - 1;
f_string_static_t object = f_string_static_t_initialize;
f_string_static_t content = f_string_static_t_initialize;
- for (f_array_length_t i = 0; i < main->parameters[iki_write_parameter_object].values.used; i++) {
+ for (f_array_length_t i = 0; i < main->parameters[iki_write_parameter_object].values.used; ++i) {
object.string = arguments.argv[main->parameters[iki_write_parameter_object].values.array[i]];
object.used = strnlen(object.string, f_console_parameter_size);
#ifndef _di_iki_write_main_delete_
f_status_t iki_write_main_delete(iki_write_main_t *main) {
- for (f_array_length_t i = 0; i < iki_write_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < iki_write_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
macro_f_array_lengths_t_delete_simple(main->parameters[i].values);
}
if (main->remaining.used > 0) {
- for (f_array_length_t i = 0; i < main->remaining.used; i++) {
+ for (f_array_length_t i = 0; i < main->remaining.used; ++i) {
status2 = status_code_process_check(*main, arguments.argv[main->remaining.array[i]]);
}
if (main->remaining.used > 0) {
- for (f_array_length_t i = 0; i < main->remaining.used; i++) {
+ for (f_array_length_t i = 0; i < main->remaining.used; ++i) {
status2 = status_code_process_number(*main, arguments.argv[main->remaining.array[i]]);
}
if (main->remaining.used > 0) {
- for (f_array_length_t i = 0; i < main->remaining.used; i++) {
+ for (f_array_length_t i = 0; i < main->remaining.used; ++i) {
status2 = status_code_process_normal(*main, arguments.argv[main->remaining.array[i]]);
#ifndef _di_status_code_main_delete_
f_status_t status_code_main_delete(status_code_main_t *main) {
- for (f_array_length_t i = 0; i < status_code_total_parameters; i++) {
+ for (f_array_length_t i = 0; i < status_code_total_parameters; ++i) {
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations);
macro_f_array_lengths_t_delete_simple(main->parameters[i].locations_sub);
macro_f_array_lengths_t_delete_simple(main->parameters[i].values);
projects / fll / commitdiff