The fl_status_is_fine(), fl_status_is_warning(), and fl_status_is_error() functions are no longer needed or valid with the current design around using error and warning bits.
The status conversion code should be more aware of digits.
Get rid of the "context" parameter in the status programs.
Redesign logic in the status programs to work with changes and function correctly (and consistently).
The status programs will eventually need to perform more extensive tests on parameters when digits or non-digits are required.
The current design only provides a very basic test on the first character of a given parameter.
case '7':
case '8':
case '9':
- return f_true;
+ break;
default:
return f_false;
}
- return f_unknown;
+ return f_true;
}
#endif // _di_f_is_digit_
case 'd':
case 'e':
case 'f':
- return f_true;
+ break;
default:
return f_false;
}
+
+ return f_true;
}
#endif // _di_f_is_hexdigit_
#endif // _di_level_0_parameter_checking_
switch (character) {
- case '0': *digit = 0; break;
- case '1': *digit = 1; break;
- case '2': *digit = 2; break;
- case '3': *digit = 3; break;
- case '4': *digit = 4; break;
- case '5': *digit = 5; break;
- case '6': *digit = 6; break;
- case '7': *digit = 7; break;
- case '8': *digit = 8; break;
- case '9': *digit = 9; break;
+ case '0': *digit = 0; break;
+ case '1': *digit = 1; break;
+ case '2': *digit = 2; break;
+ case '3': *digit = 3; break;
+ case '4': *digit = 4; break;
+ case '5': *digit = 5; break;
+ case '6': *digit = 6; break;
+ case '7': *digit = 7; break;
+ case '8': *digit = 8; break;
+ case '9': *digit = 9; break;
default:
return f_no_data;
}
#endif // _di_level_0_parameter_checking_
switch (character) {
- case '0': *digit = 0; break;
- case '1': *digit = 1; break;
- case '2': *digit = 2; break;
- case '3': *digit = 3; break;
- case '4': *digit = 4; break;
- case '5': *digit = 5; break;
- case '6': *digit = 6; break;
- case '7': *digit = 7; break;
- case '8': *digit = 8; break;
- case '9': *digit = 9; break;
+ case '0': *digit = 0; break;
+ case '1': *digit = 1; break;
+ case '2': *digit = 2; break;
+ case '3': *digit = 3; break;
+ case '4': *digit = 4; break;
+ case '5': *digit = 5; break;
+ case '6': *digit = 6; break;
+ case '7': *digit = 7; break;
+ case '8': *digit = 8; break;
+ case '9': *digit = 9; break;
case 'A': *digit = 10; break;
case 'B': *digit = 11; break;
case 'C': *digit = 12; break;
}
#endif // _di_fl_status_to_string_
-#ifndef _di_fl_status_is_error_
- f_return_status fl_status_is_error(const f_status code) {
- if (fl_status_is_fine(code) == f_true) {
- return f_false;
- }
- else if (fl_status_is_warning(code) == f_true) {
- return f_false;
- }
-
- return f_true;
- }
-#endif // _di_fl_status_is_error_
-
-#ifndef _di_fl_status_is_warning_
- f_return_status fl_status_is_warning(const f_status code) {
- switch (code) {
- #ifndef _di_fl_status_basic_
- case f_no_data:
- return f_true;
- #endif // _di_fl_status_basic_
-
- #ifndef _di_f_status_buffers_
- case f_no_data_on_eof:
- return f_true;
- case f_no_data_on_eol:
- return f_true;
- case f_no_data_on_eos:
- return f_true;
- case f_no_data_on_stop:
- return f_true;
- case f_none_on_eof:
- return f_true;
- case f_none_on_eol:
- return f_true;
- case f_none_on_eos:
- return f_true;
- case f_none_on_stop:
- return f_true;
- #endif // _di_f_status_buffers_
- }
-
- return f_false;
- }
-#endif // _di_fl_status_is_warning_
-
-#ifndef _di_fl_status_is_fine_
- f_return_status fl_status_is_fine(const f_status code) {
- switch (code) {
- #ifndef _di_fl_status_booleans_
- case f_false:
- return f_true;
- case f_true:
- return f_true;
- #endif // _di_fl_status_booleans_
-
- #ifndef _di_fl_status_basic_
- case f_none:
- return f_true;
- case f_dummy:
- return f_true;
- #endif // _di_fl_status_basic_
-
- #ifndef _di_fl_status_non_
- case f_less_than:
- return f_true;
- case f_equal_to:
- return f_true;
- case f_not_equal_to:
- return f_true;
- case f_greater_than:
- return f_true;
- #endif // _di_fl_status_non_
- }
-
- return f_false;
- }
-#endif // _di_fl_status_is_fine_
-
#ifdef __cplusplus
} // extern "C"
#endif
extern f_return_status fl_status_to_string(const f_status code, f_string *string);
#endif // _di_fl_status_to_string_
-#ifndef _di_fl_status_is_error_
- /**
- * Returns true or false depending on whether the standard context of the error code represents an error.
- * Keep in mind that many of the status codes are context-specific and may be reported as an error here when it is in fact not an error.
- */
- extern f_return_status fl_status_is_error(const f_status code);
-#endif // _di_fl_status_is_error_
-
-#ifndef _di_fl_status_is_warning_
- /**
- * Returns true or false depending on whether the standard context of the error code represents a warning.
- * Keep in mind that many of the status codes are context-specific and may be reported as a warning here when it is in fact not a warning.
- */
- extern f_return_status fl_status_is_warning(const f_status code);
-#endif // _di_fl_status_is_warning_
-
-#ifndef _di_fl_status_is_fine_
- /**
- * Returns true or false depending on whether the standard context of the error code represents an normal return status and not an error.
- * Keep in mind that many of the status codes are context-specific and may be reported as an "fine" here when it is in fact not fine.
- */
- extern f_return_status fl_status_is_fine(const f_status code);
-#endif // _di_fl_status_is_fine_
-
#ifdef __cplusplus
} // extern "C"
#endif
f_status status = f_none;
f_string_length length = strlen(string);
+ if (length == 0) {
+ return f_no_data;
+ }
+
+ // numbers are not valid status code strings.
+ if ((status = f_is_digit(string[0])) == f_true) {
+ return f_invalid_data;
+ }
+
+ if (f_status_is_error(status)) {
+ return status;
+ }
+
#ifndef _di_fll_fss_status_error_
if (fl_compare_strings(string, fll_fss_status_string_invalid_format, length, fll_fss_status_string_invalid_format_length) == f_equal_to) {
*error = fl_fss_invalid_format;
#define _FLL_fss_status_h
// fll-0 includes
+#include <level_0/conversion.h>
#include <level_0/status.h>
#include <level_0/fss.h>
#include <level_0/memory.h>
*
* @return
* f_none on success.
+ * f_no_data if string is empty.
* f_invalid_data if not found.
* f_invalid_parameter (with error bit) if a parameter is invalid.
*
f_status
f_strings
f_memory
+f_conversion
+f_utf
f_fss
fl_fss
fl_status
build_compiler gcc
build_linker ar
build_libraries -lc
-build_libraries_fll -lfl_status -lfl_strings -lfl_fss -lf_conversion -lf_file -lf_memory -lf_utf
+build_libraries_fll -lfl_status -lfl_strings -lfl_fss -lf_conversion -lf_file -lf_memory -lf_conversion -lf_utf
build_sources_library fss_basic.c fss_basic_list.c fss_extended.c fss_status.c
build_sources_program
build_sources_headers fss_basic.h fss_basic_list.h fss_extended.h fss_status.h
f_status status = f_none;
f_string_length length = strlen(string);
+ if (length == 0) {
+ return f_no_data;
+ }
+
+ // numbers are not valid status code strings.
+ if ((status = f_is_digit(string[0])) == f_true) {
+ return f_invalid_data;
+ }
+
+ if (f_status_is_error(status)) {
+ return status;
+ }
+
#ifndef _di_fll_status_booleans_
if (fl_compare_strings(string, fl_status_string_false, length, fl_status_string_false_length) == f_equal_to) {
*code = f_false;
#define _FLL_errors_h
// fll-0 includes
+#include <level_0/conversion.h>
#include <level_0/status.h>
#include <level_0/strings.h>
#include <level_0/types.h>
*
* @return
* f_none on success.
+ * f_no_data if string is empty.
* f_invalid_data if not found.
* f_invalid_parameter (with error bit) if a parameter is invalid.
*/
f_types
f_status
f_memory
+f_conversion
f_strings
f_utf
fl_strings
build_compiler gcc
build_linker ar
build_libraries -lc
-build_libraries_fll -lfl_status -lfl_strings -lf_memory -lf_utf
+build_libraries_fll -lfl_status -lfl_strings -lf_memory -lf_conversion -lf_utf
build_sources_library status.c
build_sources_program
build_sources_headers status.h
printf(" Returns true if the error code is an error.");
printf("\n %s", f_console_symbol_short_enable);
- fl_color_print(f_standard_output, data.context.standout, data.context.reset, fss_status_code_short_context);
-
- printf(", %s", f_console_symbol_long_enable);
- fl_color_print(f_standard_output, data.context.standout, data.context.reset, fss_status_code_long_context);
- printf(" Guess error state from context of error (ignores masks).");
-
- printf("\n %s", f_console_symbol_short_enable);
fl_color_print(f_standard_output, data.context.standout, data.context.reset, fss_status_code_short_number);
printf(", %s", f_console_symbol_long_enable);
f_array_length counter = 0;
f_status code = f_none;
+ f_u_int true = 0;
for (; counter < data->remaining.used; counter++) {
- code = (f_status) atoll(argv[data->remaining.array[counter]]);
+ // only numbers are valid status codes.
+ if (f_is_digit(argv[data->remaining.array[counter]][0]) == f_false) {
+ status = f_false;
+ continue;
+ }
+
+ long long number = atoll(argv[data->remaining.array[counter]]);
+ if (number >= 0x10000 || number < 0) {
+ status = f_false;
+ continue;
+ }
- if (data->parameters[fss_status_code_parameter_context].result == f_console_result_found) {
- if (fll_fss_status_is_error(code)) {
- fss_status_code_delete_data(data);
- return f_true;
- }
+ code = (f_status) number;
+ true = f_status_is_error(code) && !f_status_is_warning(code);
+
+ if (status == f_none) {
+ status = f_true;
+ }
+
+ if (true) {
+ printf("%s\n", fl_status_string_true);
}
else {
- if (f_status_is_error(code)) {
- fss_status_code_delete_data(data);
- return f_true;
- }
+ printf("%s\n", fl_status_string_false);
}
} // for
}
-
- fss_status_code_delete_data(data);
- return f_false;
+ else {
+ status = f_false;
+ }
}
else if (data->parameters[fss_status_code_parameter_is_warning].result == f_console_result_found) {
if (data->remaining.used > 0) {
f_array_length counter = 0;
f_status code = f_none;
+ f_u_int true = 0;
for (; counter < data->remaining.used; counter++) {
- code = (f_status) atoll(argv[data->remaining.array[counter]]);
+ // only numbers are valid status codes.
+ if (f_is_digit(argv[data->remaining.array[counter]][0]) == f_false) {
+ status = f_false;
+ continue;
+ }
+
+ long long number = atoll(argv[data->remaining.array[counter]]);
+ if (number >= 0x10000 || number < 0) {
+ status = f_false;
+ continue;
+ }
+
+ code = (f_status) number;
+ true = f_status_is_warning(code) && !f_status_is_error(code);
+
+ if (status == f_none) {
+ status = f_true;
+ }
- if (data->parameters[fss_status_code_parameter_context].result == f_console_result_found) {
- if (fll_fss_status_is_warning(code)) {
- fss_status_code_delete_data(data);
- return f_true;
- }
+ if (true) {
+ printf("%s\n", fl_status_string_true);
}
else {
- if (f_status_is_warning(code)) {
- fss_status_code_delete_data(data);
- return f_true;
- }
+ printf("%s\n", fl_status_string_false);
}
} // for
}
-
- fss_status_code_delete_data(data);
- return f_false;
+ else {
+ status = f_false;
+ }
}
else if (data->parameters[fss_status_code_parameter_is_fine].result == f_console_result_found) {
if (data->remaining.used > 0) {
f_array_length counter = 0;
f_status code = f_none;
+ f_u_int true = 0;
for (; counter < data->remaining.used; counter++) {
- code = (f_status) atoll(argv[data->remaining.array[counter]]);
+ // only numbers are valid status codes.
+ if (f_is_digit(argv[data->remaining.array[counter]][0]) == f_false) {
+ status = f_false;
+ continue;
+ }
- if (data->parameters[fss_status_code_parameter_context].result == f_console_result_found) {
- if (fll_fss_status_is_fine(code)) {
- fss_status_code_delete_data(data);
- return f_true;
- }
+ long long number = atoll(argv[data->remaining.array[counter]]);
+ if (number >= 0x10000 || number < 0) {
+ status = f_false;
+ continue;
+ }
+
+ code = (f_status) number;
+ true = f_status_is_fine(code);
+
+ if (status == f_none) {
+ status = f_true;
+ }
+
+ if (true) {
+ printf("%s\n", fl_status_string_true);
}
else {
- if (f_status_is_fine(code)) {
- fss_status_code_delete_data(data);
- return f_true;
- }
+ printf("%s\n", fl_status_string_false);
}
} // for
}
-
- fss_status_code_delete_data(data);
- return f_false;
+ else {
+ status = f_false;
+ }
}
else if (data->parameters[fss_status_code_parameter_number].result == f_console_result_found) {
if (data->remaining.used > 0) {
f_array_length counter = 0;
f_status code = f_none;
+ f_status status2 = f_none;
for (; counter < data->remaining.used; counter++) {
- status = fll_status_from_string(argv[data->remaining.array[counter]], &code);
-
- if (status == f_invalid_data) {
- status = fll_fss_status_from_string(argv[data->remaining.array[counter]], &code);
+ // numbers are not valid status code strings.
+ if (f_is_digit(argv[data->remaining.array[counter]][0]) == f_true) {
+ status = f_false;
+ continue;
}
- if (f_status_is_error(status)) {
+ status2 = fll_status_from_string(argv[data->remaining.array[counter]], &code);
+
+ if (f_status_is_error(status2)) {
+ status = status2;
break;
}
- else {
- status = f_none;
+ else if (status2 == f_invalid_data) {
+ status = f_false;
+ continue;
+ }
+ else if (status == f_none) {
+ status = f_true;
}
printf("%u\n", code);
else {
status = f_false;
}
-
- fss_status_code_delete_data(data);
- return status;
}
else if (data->remaining.used > 0 || data->process_pipe) {
f_array_length counter = 0;
if (data->remaining.used > 0) {
for (; counter < data->remaining.used; counter++) {
- f_status code = (f_status) atoll(argv[data->remaining.array[counter]]);
+ // only numbers are valid status code.
+ if (f_is_digit(argv[data->remaining.array[counter]][0]) == f_false) {
+ status = f_false;
+ continue;
+ }
+
+ long long number = atoll(argv[data->remaining.array[counter]]);
+ if (number >= 0x10000 || number < 0) {
+ status = f_false;
+ continue;
+ }
+ else if (status == f_none) {
+ status = f_true;
+ }
+
+ f_status code = (f_status) number;
f_string string = 0;
if (fll_fss_status_to_string(code, &string) == f_none) {
printf("%s\n", string);
}
+ else {
+ status = f_false;
+ }
} // for
}
+ else {
+ status = f_false;
+ }
}
else {
fl_color_print_line(f_standard_error, data->context.error, data->context.reset, "ERROR: you failed to specify an error code.");
#include <string.h>
// fll-0 includes
+#include <level_0/conversion.h>
#include <level_0/console.h>
#include <level_0/pipe.h>
#include <level_0/print.h>
#define fss_status_code_short_is_fine "f"
#define fss_status_code_short_is_warning "w"
#define fss_status_code_short_is_error "e"
- #define fss_status_code_short_context "c"
#define fss_status_code_short_number "n"
#define fss_status_code_long_is_fine "is_fine"
#define fss_status_code_long_is_warning "is_warning"
#define fss_status_code_long_is_error "is_error"
- #define fss_status_code_long_context "context"
#define fss_status_code_long_number "number"
enum {
fss_status_code_parameter_is_fine,
fss_status_code_parameter_is_warning,
fss_status_code_parameter_is_error,
- fss_status_code_parameter_context,
fss_status_code_parameter_number,
};
f_console_parameter_initialize(fss_status_code_short_is_fine, fss_status_code_long_is_fine, 0, f_false, f_console_type_normal), \
f_console_parameter_initialize(fss_status_code_short_is_warning, fss_status_code_long_is_warning, 0, f_false, f_console_type_normal), \
f_console_parameter_initialize(fss_status_code_short_is_error, fss_status_code_long_is_error, 0, f_false, f_console_type_normal), \
- f_console_parameter_initialize(fss_status_code_short_context, fss_status_code_long_context, 0, f_false, f_console_type_normal), \
f_console_parameter_initialize(fss_status_code_short_number, fss_status_code_long_number, 0, f_false, f_console_type_normal), \
}
data.process_pipe = f_true;
}
- if (f_status_is_error(fss_status_code_main(argc, argv, &data))) {
+ f_status status = fss_status_code_main(argc, argv, &data);
+
+ if (f_status_is_error(status) || status == f_false) {
return 1;
}
data.process_pipe = f_true;
}
- if (f_status_is_error(status_code_main(argc, argv, &data))) {
+ f_status status = status_code_main(argc, argv, &data);
+
+ if (f_status_is_error(status) || status == f_false) {
return 1;
}
printf(" Returns true if the error code is an error.");
printf("\n %s", f_console_symbol_short_enable);
- fl_color_print(f_standard_output, data.context.standout, data.context.reset, status_code_short_context);
-
- printf(", %s", f_console_symbol_long_enable);
- fl_color_print(f_standard_output, data.context.standout, data.context.reset, status_code_long_context);
- printf(" Guess error state from context of error (ignores masks).");
-
- printf("\n %s", f_console_symbol_short_enable);
fl_color_print(f_standard_output, data.context.standout, data.context.reset, status_code_short_number);
printf(", %s", f_console_symbol_long_enable);
else if (data->parameters[status_code_parameter_is_error].result == f_console_result_found) {
if (data->remaining.used > 0) {
f_array_length counter = 0;
+
f_status code = f_none;
+ f_u_short true = 0;
for (; counter < data->remaining.used; counter++) {
- code = (f_status) atoll(argv[data->remaining.array[counter]]);
+ // only numbers are valid status codes.
+ if (f_is_digit(argv[data->remaining.array[counter]][0]) == f_false) {
+ status = f_false;
+ continue;
+ }
- if (data->parameters[status_code_parameter_context].result == f_console_result_found) {
- if (fl_status_is_error(code)) {
- status_code_delete_data(data);
- return f_true;
- }
+ long long number = atoll(argv[data->remaining.array[counter]]);
+ if (number >= 0x10000 || number < 0) {
+ status = f_false;
+ continue;
+ }
+
+ code = (f_status) number;
+ true = f_status_is_error(code) && !f_status_is_warning(code);
+
+ if (status == f_none) {
+ status = f_true;
+ }
+
+ if (true) {
+ printf("%s\n", fl_status_string_true);
}
else {
- if (f_status_is_error(code)) {
- status_code_delete_data(data);
- return f_true;
- }
+ printf("%s\n", fl_status_string_false);
}
} // for
}
-
- status_code_delete_data(data);
- return f_false;
+ else {
+ status = f_false;
+ }
}
else if (data->parameters[status_code_parameter_is_warning].result == f_console_result_found) {
if (data->remaining.used > 0) {
f_array_length counter = 0;
+
f_status code = f_none;
+ f_u_short true = 0;
for (; counter < data->remaining.used; counter++) {
- code = (f_status) atoll(argv[data->remaining.array[counter]]);
+ // only numbers are valid status codes.
+ if (f_is_digit(argv[data->remaining.array[counter]][0]) == f_false) {
+ status = f_false;
+ continue;
+ }
- if (data->parameters[status_code_parameter_context].result == f_console_result_found) {
- if (fl_status_is_warning(code)) {
- status_code_delete_data(data);
- return f_true;
- }
+ long long number = atoll(argv[data->remaining.array[counter]]);
+ if (number >= 0x10000 || number < 0) {
+ status = f_false;
+ continue;
+ }
+
+ code = (f_status) number;
+ true = f_status_is_warning(code) && !f_status_is_error(code);
+
+ if (status == f_none) {
+ status = f_true;
+ }
+
+ if (true) {
+ printf("%s\n", fl_status_string_true);
}
else {
- if (f_status_is_warning(code)) {
- status_code_delete_data(data);
- return f_true;
- }
+ printf("%s\n", fl_status_string_false);
}
} // for
}
-
- status_code_delete_data(data);
- return f_false;
+ else {
+ status = f_false;
+ }
}
else if (data->parameters[status_code_parameter_is_fine].result == f_console_result_found) {
if (data->remaining.used > 0) {
f_array_length counter = 0;
+
f_status code = f_none;
+ f_u_short true = 0;
for (; counter < data->remaining.used; counter++) {
- code = (f_status) atoll(argv[data->remaining.array[counter]]);
+ // only numbers are valid status codes.
+ if (f_is_digit(argv[data->remaining.array[counter]][0]) == f_false) {
+ status = f_false;
+ continue;
+ }
+
+ long long number = atoll(argv[data->remaining.array[counter]]);
+ if (number >= 0x10000 || number < 0) {
+ status = f_false;
+ continue;
+ }
+
+ code = (f_status) number;
+ true = f_status_is_fine(code);
+
+ if (status == f_none) {
+ status = f_true;
+ }
- if (data->parameters[status_code_parameter_context].result == f_console_result_found) {
- if (fl_status_is_fine(code)) {
- status_code_delete_data(data);
- return f_true;
- }
+ if (true) {
+ printf("%s\n", fl_status_string_true);
}
else {
- if (f_status_is_fine(code)) {
- status_code_delete_data(data);
- return f_true;
- }
+ printf("%s\n", fl_status_string_false);
}
} // for
}
-
- status_code_delete_data(data);
- return f_false;
+ else {
+ status = f_false;
+ }
}
else if (data->parameters[status_code_parameter_number].result == f_console_result_found) {
if (data->remaining.used > 0) {
f_array_length counter = 0;
f_status code = f_none;
+ f_status status2 = f_none;
for (; counter < data->remaining.used; counter++) {
- status = fll_status_from_string(argv[data->remaining.array[counter]], &code);
- if (f_status_is_error(status)) {
+ // numbers are not valid status code strings.
+ if (f_is_digit(argv[data->remaining.array[counter]][0]) == f_true) {
+ status = f_false;
+ continue;
+ }
+
+ status2 = fll_status_from_string(argv[data->remaining.array[counter]], &code);
+ if (f_status_is_error(status2)) {
+ status = status2;
break;
}
- else {
+ else if (status2 == f_invalid_data) {
+ status = f_false;
+ continue;
+ }
+ else if (status == f_none) {
status = f_true;
}
else {
status = f_false;
}
-
- status_code_delete_data(data);
- return status;
}
else if (data->remaining.used > 0 || data->process_pipe) {
f_array_length counter = 0;
if (data->remaining.used > 0) {
for (; counter < data->remaining.used; counter++) {
- f_status code = (f_status) atoll(argv[data->remaining.array[counter]]);
+ // only numbers are valid status code.
+ if (f_is_digit(argv[data->remaining.array[counter]][0]) == f_false) {
+ status = f_false;
+ continue;
+ }
+
+ long long number = atoll(argv[data->remaining.array[counter]]);
+ if (number >= 0x10000 || number < 0) {
+ status = f_false;
+ continue;
+ }
+ else if (status == f_none) {
+ status = f_true;
+ }
+
+ f_status code = (f_status) number;
f_string string = 0;
if (fl_status_to_string(code, &string) == f_none) {
printf("%s\n", string);
}
+ else {
+ status = f_false;
+ }
} // for
}
+ else {
+ status = f_false;
+ }
}
else {
fl_color_print_line(f_standard_error, data->context.error, data->context.reset, "ERROR: you failed to specify an error code.");
// fll-0 includes
#include <level_0/console.h>
+#include <level_0/conversion.h>
#include <level_0/pipe.h>
#include <level_0/print.h>
#include <level_0/strings.h>
#define status_code_short_is_fine "f"
#define status_code_short_is_warning "w"
#define status_code_short_is_error "e"
- #define status_code_short_context "c"
#define status_code_short_number "n"
#define status_code_long_is_fine "is_fine"
#define status_code_long_is_warning "is_warning"
#define status_code_long_is_error "is_error"
- #define status_code_long_context "context"
#define status_code_long_number "number"
enum {
status_code_parameter_is_fine,
status_code_parameter_is_warning,
status_code_parameter_is_error,
- status_code_parameter_context,
status_code_parameter_number,
};
f_console_parameter_initialize(status_code_short_is_fine, status_code_long_is_fine, 0, f_false, f_console_type_normal), \
f_console_parameter_initialize(status_code_short_is_warning, status_code_long_is_warning, 0, f_false, f_console_type_normal), \
f_console_parameter_initialize(status_code_short_is_error, status_code_long_is_error, 0, f_false, f_console_type_normal), \
- f_console_parameter_initialize(status_code_short_context, status_code_long_context, 0, f_false, f_console_type_normal), \
f_console_parameter_initialize(status_code_short_number, status_code_long_number, 0, f_false, f_console_type_normal), \
}
f_console
+f_conversion
f_status
f_pipe
f_print
projects / fll / commitdiff