This primarily puts all of the status code handling in alphabetic order.
The length sizes are updated accordingly.
Be consistent with S at the end of things, whereas S is not the traditional grammatical use but instead implies a set of.
Use the base F_* disable defines instead of using new ones for each level when they are specific to the F_* status codes.
Add additional comment documentation.
Any issues observed resulting from the refactor were also fixed during this change.
case 0x30: *number = 0; break;
case 0x31: *number = 1; break;
default:
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
return F_none;
case 0x38: *number = 8; break;
case 0x39: *number = 9; break;
default:
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
return F_none;
case 0x61: *decimal = 10; break;
case 0x62: *decimal = 11; break;
default:
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
return F_none;
case 0x65: *decimal = 14; break;
case 0x66: *decimal = 15; break;
default:
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
return F_none;
case 0x36: *number = 6; break;
case 0x37: *number = 7; break;
default:
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
return F_none;
}
}
else if (string[i] != '\0') {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
} // for
}
}
else if (string[i] != '\0') {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
} // for
}
}
else if (string[i] != '\0') {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
} // for
}
}
else if (string[i] != '\0') {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
} // for
}
}
else if (string[i] != '\0') {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
} // for
}
}
else if (string[i] != '\0') {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
} // for
}
}
else if (string[i] != '\0') {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
} // for
}
}
else if (string[i] != '\0') {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
} // for
}
}
else if (string[i] != '\0') {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
} // for
}
}
else if (string[i] != '\0') {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
} // for
continue;
}
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
}
else {
}
}
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
if (string[i] == 0x30) {
offset += 2;
}
else {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
break;
offset++;
}
else {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
}
offset++;
}
else {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
}
break;
}
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
} // for
if (mode == 0) {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
f_string_range location_offset = f_string_range_initialize;
continue;
}
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
}
else {
}
}
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
if (string[i] == 0x30) {
offset += 2;
}
else {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
break;
break;
}
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
} // for
if (mode == 0) {
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
f_string_range location_offset = f_string_range_initialize;
return F_status_set_error(F_number_positive);
}
- return F_status_set_error(F_number_invalid);
+ return F_status_set_error(F_number);
}
return status;
*
* @return
* F_none if character was converted to a binary.
- * F_number_invalid (with error bit) if no conversion was made due to non-binary values being found.
+ * F_number (with error bit) if no conversion was made due to non-binary values being found.
* F_parameter (with error bit) if a parameter is invalid.
*/
#ifndef _di_f_conversion_character_to_binary_
*
* @return
* F_none if character was converted to a decimal.
- * F_number_invalid (with error bit) if no conversion was made due to non-decimal values being found.
+ * F_number (with error bit) if no conversion was made due to non-decimal values being found.
* F_parameter (with error bit) if a parameter is invalid.
*/
#ifndef _di_f_conversion_character_to_decimal_
*
* @return
* F_none if character was converted to a duodecimal.
- * F_number_invalid (with error bit) if no conversion was made due to non-duodecimal values being found.
+ * F_number (with error bit) if no conversion was made due to non-duodecimal values being found.
* F_parameter (with error bit) if a parameter is invalid.
*/
#ifndef _di_f_conversion_character_to_duodecimal_
*
* @return
* F_none if character was converted to a hexidecimal.
- * F_number_invalid (with error bit) if no conversion was made due to non-hexidecimal values being found.
+ * F_number (with error bit) if no conversion was made due to non-hexidecimal values being found.
* F_parameter (with error bit) if a parameter is invalid.
*/
#ifndef _di_f_conversion_character_to_hexidecimal_
*
* @return
* F_none if character was converted to a hexidecimal.
- * F_number_invalid (with error bit) if no conversion was made due to non-hexidecimal values being found.
+ * F_number (with error bit) if no conversion was made due to non-hexidecimal values being found.
* F_parameter (with error bit) if a parameter is invalid.
*/
#ifndef _di_f_conversion_character_to_octal_
*
* @return
* F_none if the binary string was converted to an signed long.
- * F_number_invalid (with error bit) if no conversion was made due to non-binary values being found.
+ * F_number (with error bit) if no conversion was made due to non-binary values being found.
* F_parameter (with error bit) if a parameter is invalid.
* F_number_overflow (with error bit) on integer overflow.
* F_number_underflow (with error bit) on integer underflow.
*
* @return
* F_none if the binary string was converted to an unsigned long.
- * F_number_invalid (with error bit) if no conversion was made due to non-binary values being found.
+ * F_number (with error bit) if no conversion was made due to non-binary values being found.
* F_parameter (with error bit) if a parameter is invalid.
* F_number_overflow (with error bit) on integer overflow.
*/
*
* @return
* F_none if the decimal string was converted to an signed long.
- * F_number_invalid (with error bit) if no conversion was made due to non-decimal values being found.
+ * F_number (with error bit) if no conversion was made due to non-decimal values being found.
* F_parameter (with error bit) if a parameter is invalid.
* F_number_overflow (with error bit) on integer overflow.
* F_number_underflow (with error bit) on integer underflow.
*
* @return
* F_none if the decimal string was converted to an unsigned long.
- * F_number_invalid (with error bit) if no conversion was made due to non-decimal values being found.
+ * F_number (with error bit) if no conversion was made due to non-decimal values being found.
* F_parameter (with error bit) if a parameter is invalid.
* F_number_overflow (with error bit) on integer overflow.
*/
*
* @return
* F_none if the duodecimal string was converted to an signed long.
- * F_number_invalid (with error bit) if no conversion was made due to non-duodecimal values being found.
+ * F_number (with error bit) if no conversion was made due to non-duodecimal values being found.
* F_parameter (with error bit) if a parameter is invalid.
* F_number_overflow (with error bit) on integer overflow.
* F_number_underflow (with error bit) on integer underflow.
*
* @return
* F_none if the duodecimal string was converted to an unsigned long.
- * F_number_invalid (with error bit) if no conversion was made due to non-duodecimal values being found.
+ * F_number (with error bit) if no conversion was made due to non-duodecimal values being found.
* F_parameter (with error bit) if a parameter is invalid.
* F_number_overflow (with error bit) on integer overflow.
*/
*
* @return
* F_none if the hexidecimal string was converted to an signed long.
- * F_number_invalid (with error bit) if no conversion was made due to non-hexidecimal values being found.
+ * F_number (with error bit) if no conversion was made due to non-hexidecimal values being found.
* F_parameter (with error bit) if a parameter is invalid.
* F_number_overflow (with error bit) on integer overflow.
* F_number_underflow (with error bit) on integer underflow.
*
* @return
* F_none if the hexidecimal string was converted to an unsigned long.
- * F_number_invalid (with error bit) if no conversion was made due to non-hexidecimal values being found.
+ * F_number (with error bit) if no conversion was made due to non-hexidecimal values being found.
* F_parameter (with error bit) if a parameter is invalid.
* F_number_overflow (with error bit) on integer overflow.
*/
*
* @return
* F_none if the octal string was converted to an signed long.
- * F_number_invalid (with error bit) if no conversion was made due to non-octal values being found.
+ * F_number (with error bit) if no conversion was made due to non-octal values being found.
* F_parameter (with error bit) if a parameter is invalid.
* F_number_overflow (with error bit) on integer overflow.
*/
*
* @return
* F_none if the octal string was converted to an unsigned long.
- * F_number_invalid (with error bit) if no conversion was made due to non-octal values being found.
+ * F_number (with error bit) if no conversion was made due to non-octal values being found.
* F_parameter (with error bit) if a parameter is invalid.
* F_number_overflow (with error bit) on integer overflow.
*/
* F_none on success.
* F_data_not (with error bit) if string starts with a null (length is 0).
* F_parameter (with error bit) if a parameter is invalid.
- * F_number_invalid (with error bit) if parameter is not a number.
+ * F_number (with error bit) if parameter is not a number.
* F_number_overflow (with error bit) on integer overflow.
* F_number_underflow (with error bit) on integer underflow.
* F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
* F_none on success.
* F_data_not (with error bit) if string starts with a null (length is 0).
* F_parameter (with error bit) if a parameter is invalid.
- * F_number_invalid (with error bit) if parameter is not a number.
+ * F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_positive (with error bit) on positive value (has a +, such as '+1', when only '1' is valid here).
* F_number_overflow (with error bit) on integer overflow.
f_return_status f_directory_create(const f_string path, const mode_t mode) {
if (mkdir(path, mode) < 0) {
if (errno == EACCES) return F_status_set_error(F_access_denied);
- if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_blocks);
+ if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_block);
if (errno == EEXIST) return F_status_set_error(F_file_found);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (mkdirat(at_id, path, mode) < 0) {
if (errno == EACCES) return F_status_set_error(F_access_denied);
- if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_blocks);
+ if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_block);
if (errno == EEXIST) return F_status_set_error(F_file_found);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (errno == EPERM) return F_status_set_error(F_prohibited);
if (errno == EROFS) return F_status_set_error(F_read_only);
if (errno == EOVERFLOW) return F_status_set_error(F_number_overflow);
- if (errno == EMFILE) return F_status_set_error(F_file_descriptors_max);
+ if (errno == EMFILE) return F_status_set_error(F_file_descriptor_max);
if (errno == ENFILE) return F_status_set_error(F_file_open_max);
if (errno == EINVAL) return F_status_set_error(F_parameter);
if (errno == EPERM) return F_status_set_error(F_prohibited);
if (errno == EROFS) return F_status_set_error(F_read_only);
if (errno == EOVERFLOW) return F_status_set_error(F_number_overflow);
- if (errno == EMFILE) return F_status_set_error(F_file_descriptors_max);
+ if (errno == EMFILE) return F_status_set_error(F_file_descriptor_max);
if (errno == ENFILE) return F_status_set_error(F_file_open_max);
if (errno == EINVAL) return F_status_set_error(F_parameter);
* F_prohibited (with error bit) if filesystem does not allow for removing.
* F_read_only (with error bit) if file is read-only.
* F_failure (with error bit) for any other (mkdir()) error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
* F_file_found (with error bit) of a directory aleady exists at the path.
* F_name (with error bit) on path name error.
* F_prohibited (with error bit) if filesystem does not allow for removing.
* F_read_only (with error bit) if file is read-only.
* F_failure (with error bit) for any other (mkdir()) error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
* F_file_found (with error bit) of a directory aleady exists at the path.
* F_name (with error bit) on path name error.
* F_read_only (with error bit) if file is read-only.
* F_failure (with error bit) for any other (unlink()) error.
* F_number_overflow (with error bit) on integer overflow.
- * F_file_descriptors_max (with error bit) if max file descriptors was reached.
+ * F_file_descriptor_max (with error bit) if max file descriptors was reached.
* F_file_open_max (with error bit) too many open files.
*
* @see nftw()
if (link(target, point) < 0) {
if (errno == EACCES) return F_status_set_error(F_access_denied);
- if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_blocks);
+ if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_block);
if (errno == EEXIST) return F_status_set_error(F_file_found);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (linkat(at_id_target, target, at_id_point, point, flags) < 0) {
if (errno == EACCES) return F_status_set_error(F_access_denied);
- if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_blocks);
+ if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_block);
if (errno == EEXIST) return F_status_set_error(F_file_found);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
* F_prohibited (with error bit) if filesystem does not allow for removing.
* F_read_only (with error bit) if file is read-only.
* F_failure (with error bit) for any other (mkdir()) error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
* F_file_found (with error bit) of a directory aleady exists at the path.
* F_name (with error bit) on path name error.
* F_prohibited (with error bit) if filesystem does not allow for removing.
* F_read_only (with error bit) if file is read-only.
* F_failure (with error bit) for any other (mkdir()) error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
* F_file_found (with error bit) of a directory aleady exists at the path.
* F_name (with error bit) on path name error.
* F_file_descriptor (with error bit) if file descriptor is invalid.
* F_interrupted (with error bit) if interrupt was received.
* F_input_output (with error bit) on I/O error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
* F_file_synchronize (with error bit) on flush failure.
* F_file_close (with error bit) if fclose() failed for any other reason.
* F_prohibited (with error bit) if filesystem does not allow for removing.
* F_read_only (with error bit) if file is read-only.
* F_failure (with error bit) for any other (mkdir()) error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
* F_file_found (with error bit) of a directory aleady exists at the path.
* F_name (with error bit) on path name error.
* F_prohibited (with error bit) if filesystem does not allow for removing.
* F_read_only (with error bit) if file is read-only.
* F_failure (with error bit) for any other (mkdir()) error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
* F_file_found (with error bit) of a directory aleady exists at the path.
* F_name (with error bit) on path name error.
* F_parameter (with error bit) if a parameter is invalid.
* F_file_descriptor (with error bit) if file descriptor is invalid.
* F_input_output (with error bit) on I/O error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
* F_unsupported (with error bit) if the file system or file type does not support flushing.
* F_failure (with error bit) on any other failure.
if (errno == EINTR) return F_status_set_error(F_interrupted);
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == ENOSPC) return F_status_set_error(F_space_not);
- if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_blocks);
+ if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_block);
return F_status_set_error(F_file_close);
}
if (errno == EIO) return F_status_set_error(F_input_output);
if (errno == ENOSPC) return F_status_set_error(F_space_not);
if (errno == EROFS) return F_status_set_error(F_unsupported);
- if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_blocks);
+ if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_block);
return F_status_set_error(F_failure);
}
if (symlink(target, point) < 0) {
if (errno == EACCES) return F_status_set_error(F_access_denied);
- if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_blocks);
+ if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_block);
if (errno == EEXIST) return F_status_set_error(F_file_found);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (symlinkat(target, at_id, point) < 0) {
if (errno == EACCES) return F_status_set_error(F_access_denied);
- if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_blocks);
+ if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_block);
if (errno == EEXIST) return F_status_set_error(F_file_found);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (file->id < 0) {
if (errno == EACCES) return F_status_set_error(F_access_denied);
- if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_blocks);
+ if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_block);
if (errno == EEXIST) return F_status_set_error(F_file_found);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
if (file->id < 0) {
if (errno == EACCES) return F_status_set_error(F_access_denied);
- if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_blocks);
+ if (errno == EDQUOT) return F_status_set_error(F_filesystem_quota_block);
if (errno == EEXIST) return F_status_set_error(F_file_found);
if (errno == ENAMETOOLONG) return F_status_set_error(F_name);
if (errno == EFAULT) return F_status_set_error(F_buffer);
* F_file_descriptor (with error bit) if file descriptor is invalid.
* F_interrupted (with error bit) if interrupt was received.
* F_input_output (with error bit) on I/O error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_filesystem_quota_reached (with error bit) quota reached of filesystem is out of space.
* F_file_synchronize (with error bit) on flush failure.
* F_file_close (with error bit) if fclose() failed for any other reason.
* F_prohibited (with error bit) if filesystem does not allow for removing.
* F_read_only (with error bit) if file is read-only.
* F_failure (with error bit) for any other (mkdir()) error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
* F_file_found (with error bit) of a directory aleady exists at the path.
* F_name (with error bit) on path name error.
* F_prohibited (with error bit) if filesystem does not allow for removing.
* F_read_only (with error bit) if file is read-only.
* F_failure (with error bit) for any other (mkdir()) error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_filesystem_quota_reached (with error bit) quota reached of filesystem is out of space.
* F_file_found (with error bit) of a directory aleady exists at the path.
* F_name (with error bit) on path name error.
* F_prohibited (with error bit) if filesystem does not allow for removing.
* F_read_only (with error bit) if file is read-only.
* F_failure (with error bit) for any other (mkdir()) error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_filesystem_quota_reached (with error bit) quota reached of filesystem is out of space.
* F_file_found (with error bit) of a directory aleady exists at the path.
* F_name (with error bit) on path name error.
* F_parameter (with error bit) if a parameter is invalid.
* F_file_descriptor (with error bit) if file descriptor is invalid.
* F_input_output (with error bit) on I/O error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_space_not (with error bit) if filesystem is out of space (or filesystem quota is reached).
* F_unsupported (with error bit) if the file system or file type does not support flushing.
* F_failure (with error bit) on any other failure.
* All standard/core status codes.
*
* The code F_status_code_last is intended to be used as the starting point for anything extending this and povided its own status codes.
+ *
+ * Most codes are sorted alphabetically, within their respective groups.
+ * There are special case codes that are expected to be in specific positions.
+ * 1) F_false, must always evaluate to 0.
+ * 2) F_true, must always evaluate to 1 and will conflict with F_signal_hangup.
+ * 3) All f_signal_*, these numbers must map directly to the standard signal codes.
+ * 4) f_none, this is intended to be the default return code and the return code representing the standard start code.
+ * 5) F_status_code_last, this is intended to designate the last code provided by level_0 status project.
+ * All code sets started by another project (such as FSS status codes) must start at this number + 1 with a code start map.
*/
#ifndef _di_F_status_codes_
enum {
- #ifndef _di_F_status_booleans_
+ #ifndef _di_F_status_boolean_
F_false = 0,
F_true,
- #endif // _di_F_status_booleans_
+ #endif // _di_F_status_boolean_
- #ifndef _di_F_status_signals_
+ #ifndef _di_F_status_signal_
F_signal_hangup = 1,
F_signal_interrupt,
F_signal_quit,
F_signal_trap,
F_signal_abort,
F_signal_bus_error,
- F_signal_floating_point_exception,
+ F_signal_floating_point_error,
F_signal_kill, // unblockable
F_signal_user_1,
F_signal_segmentation_fault,
F_signal_reserved_62,
F_signal_reserved_63,
F_signal_reserved_64,
- #endif // _di_F_status_signals_
+ #endif // _di_F_status_signal_
+ // Start at 197 to allow compatibility with the reserved bash return codes (keep in mind fss return codes can be larger than 255).
#ifndef _di_F_status_basic_
- F_none = 197, // Start at 197 to allow compatibility with the reserved bash return codes (keep in mind fss return codes can be larger than 255).
+ F_none = 197,
+ F_address,
F_block,
+ F_bound_out,
+ F_connected_not,
F_critical,
- F_exist_not,
+ F_descriptor,
+ F_device,
F_dummy,
- F_input,
- F_output,
- F_input_output,
+ F_eof,
+ F_eol,
+ F_eos,
+ F_exist_not,
F_failure,
+ F_fork,
F_incomplete,
+ F_input,
+ F_input_output,
F_interrupted,
+ F_invalid,
+ F_output,
+ F_link,
F_loop,
F_maybe,
- F_connected_not,
- F_data_not,
- F_space_not,
- F_bound_out,
F_memory_out,
- F_prohibited,
- F_read_only,
- F_unknown,
- F_unsupported,
- F_warn,
- F_write_only,
- F_utf,
- F_invalid,
F_name,
F_parameter,
- F_syntax,
- F_data,
- F_file,
- F_descriptor,
- F_socket,
- F_device,
- F_link,
F_pipe,
- F_address,
F_port,
- F_value,
F_process,
- F_fork,
F_process_too_many,
+ F_prohibited,
+ F_read_only,
+ F_socket,
+ F_space_not,
+ F_stop,
+ F_syntax,
+ F_unknown,
+ F_unsupported,
+ F_utf,
+ F_value,
+ F_warn,
+ F_write_only,
#endif // _di_F_status_basic_
#ifndef _di_F_status_busy_
F_unavailable_socket,
#endif // _di_F_status_unavailable_
- #ifndef _di_F_status_digits_
+ #ifndef _di_F_status_number_
+ F_number,
F_number_decimal,
F_number_divide_by_zero,
- F_number_invalid,
F_number_negative,
F_number_overflow,
F_number_positive,
F_number_underflow,
F_number_whole,
F_number_zero,
- #endif // _di_F_status_digits_
+ #endif // _di_F_status_number_
#ifndef _di_F_status_buffer_
F_buffer,
F_buffer_too_small,
F_buffer_too_large,
- F_eof,
- F_eol,
- F_eos,
- F_stop,
F_incomplete_utf,
F_incomplete_utf_block,
F_incomplete_utf_eof,
F_none_eol,
F_none_eos,
F_none_stop,
- F_data_block_no,
- F_data_no_eof,
- F_data_no_eol,
- F_data_no_eos,
- F_data_no_stop,
+ F_data,
+ F_data_not,
+ F_data_not_block,
+ F_data_not_eof,
+ F_data_not_eol,
+ F_data_not_eos,
+ F_data_not_stop,
F_string_too_small,
F_string_too_large,
F_unterminated,
#endif // _di_F_status_memory_
#ifndef _di_F_status_file_
- F_file_closed,
- F_file_error,
+ F_file,
F_file_allocation,
F_file_close,
+ F_file_closed,
F_file_deallocation,
F_file_descriptor,
+ F_file_descriptor_max,
+ F_file_empty,
+ F_file_error,
F_file_flush,
+ F_file_found,
+ F_file_found_not,
F_file_open,
+ F_file_open_max,
+ F_file_open_not,
F_file_purge,
F_file_read,
F_file_reallocation,
F_file_seek,
F_file_stat,
F_file_synchronize,
- F_file_write,
- F_file_empty,
- F_file_found,
F_file_type_block,
F_file_type_character,
F_file_type_directory,
- F_file_type_file,
F_file_type_link,
- F_file_type_pipe,
- F_file_type_socket,
- F_file_type_unknown,
- F_file_found_not,
- F_file_open_not,
F_file_type_not_block,
F_file_type_not_character,
F_file_type_not_directory,
- F_file_type_not_file,
F_file_type_not_link,
F_file_type_not_pipe,
+ F_file_type_not_regular,
F_file_type_not_socket,
F_file_type_not_unknown,
- F_file_not_utf,
- F_file_descriptors_max,
- F_file_open_max,
+ F_file_type_pipe,
+ F_file_type_regular,
+ F_file_type_socket,
+ F_file_type_unknown,
F_file_utf,
+ F_file_utf_not,
+ F_file_write,
#endif // _di_F_status_file_
#ifndef _di_F_status_filesystem_
F_filesystem,
- F_filesystem_quota_blocks,
+ F_filesystem_quota_block,
F_filesystem_quota_reached,
#endif // _di_F_status_filesystem_
#ifndef _di_F_status_directory_
F_directory,
F_directory_close,
+ F_directory_closed,
F_directory_descriptor,
+ F_directory_empty,
+ F_directory_found,
+ F_directory_found_not,
F_directory_flush,
F_directory_link_max,
F_directory_open,
+ F_directory_open_not,
F_directory_purge,
F_directory_read,
F_directory_stream,
F_directory_synchronize,
F_directory_unsupported,
- F_directory_write,
- F_directory_closed,
- F_directory_empty,
- F_directory_found,
- F_directory_not_found,
- F_directory_not_open,
- F_directory_utf_not,
F_directory_utf,
+ F_directory_utf_not,
+ F_directory_write,
#endif // _di_F_status_directory_
#ifndef _di_F_status_socket_
- F_socket_connection_client,
- F_socket_connection_target,
+ F_socket_connect_client,
+ F_socket_connect_target,
F_socket_receive,
F_socket_send,
#endif // _di_F_status_socket_
#ifndef _di_F_status_compare_
- F_than_less,
F_equal_to,
F_equal_to_not,
F_than_greater,
+ F_than_less,
#endif // _di_F_status_compare_
#ifndef _di_F_status_access_
* F_none on success.
* F_data_not (with error bit) if string starts wth a null (length is 0).
* F_parameter (with error bit) if a parameter is invalid.
- * F_number_invalid (with error bit) if parameter is not a number.
+ * F_number (with error bit) if parameter is not a number.
* F_number_overflow (with error bit) on integer overflow.
* F_number_underflow (with error bit) on integer underflow.
* F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
* F_none on success.
* F_data_not (with error bit) if string starts wth a null (length is 0).
* F_parameter (with error bit) if a parameter is invalid.
- * F_number_invalid (with error bit) if parameter is not a number.
+ * F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_overflow (with error bit) on integer overflow.
* F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
* F_prohibited (with error bit) if filesystem does not allow for removing.
* F_read_only (with error bit) if file is read-only.
* F_failure (with error bit) for any other (mkdir()) error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_filesystem_quota_reached (with error bit) quota reached of filesystem is out of space.
* F_file_found (with error bit) of a directory aleady exists at the path.
* F_name (with error bit) on path name error.
* F_prohibited (with error bit) if filesystem does not allow for removing.
* F_read_only (with error bit) if file is read-only.
* F_failure (with error bit) for any other (mkdir()) error.
- * F_filesystem_quota_blocks (with error bit) if filesystem's disk blocks or inodes are exhausted.
+ * F_filesystem_quota_block (with error bit) if filesystem's disk blocks or inodes are exhausted.
* F_filesystem_quota_reached (with error bit) quota reached of filesystem is out of space.
* F_file_found (with error bit) of a directory aleady exists at the path.
* F_name (with error bit) on path name error.
* F_directory_descriptor (with error bit) on directory file descriptor error.
* F_directory_stream (with error bit) on directory stream error.
* F_directory_unsupported (with error bit) on directory file descriptor not supported.
- * F_file_descriptors_max (with error bit) if max file descriptors was reached.
+ * F_file_descriptor_max (with error bit) if max file descriptors was reached.
* F_file_open_max (with error bit) too many open files.
*
* @see alphasort()
return F_status_set_error(F_memory_out);
}
else if (errno == EMFILE) {
- return F_status_set_error(F_file_descriptors_max);
+ return F_status_set_error(F_file_descriptor_max);
}
else if (errno == ENFILE) {
return F_status_set_error(F_file_open_max);
return F_status_set_error(F_directory);
}
else if (errno == ENOENT) {
- return F_status_set_error(F_directory_not_found);
+ return F_status_set_error(F_directory_found_not);
}
else if (errno == EACCES) {
return F_status_set_error(F_access_denied);
* F_directory_descriptor (with error bit) on directory file descriptor error.
* F_directory_stream (with error bit) on directory stream error.
* F_directory_unsupported (with error bit) on directory file descriptor not supported.
- * F_file_descriptors_max (with error bit) if max file descriptors was reached.
+ * F_file_descriptor_max (with error bit) if max file descriptors was reached.
* F_file_open_max (with error bit) too many open files.
*
* @see fl_directory_list()
f_string_lengths delimits = f_string_lengths_initialize;
fl_fss_skip_past_space(*buffer, location);
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
// return found nothing if this line only contains whitespace and delimit placeholders
if (buffer->string[location->start] == f_fss_basic_close) {
// ignore all comment lines
if (buffer->string[location->start] == f_fss_comment) {
- fl_macro_fss_object_seek_till_newline((*buffer), (*location), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_seek_till_newline((*buffer), (*location), delimits, F_data_not_eos, F_data_not_stop)
status = fl_fss_increment_buffer(*buffer, location, 1);
if (F_status_is_error(status)) return status;
if (F_status_is_error(status)) return status;
} // while
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
f_macro_string_lengths_delete_simple(delimits);
} // while
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
f_macro_string_lengths_delete_simple(delimits);
if (F_status_is_error(status)) return status;
} // while
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
f_macro_string_lengths_delete_simple(delimits);
fl_macro_fss_skip_past_delimit_placeholders(object, (*location))
if (location->start > location->stop) {
- return F_data_no_stop;
+ return F_data_not_stop;
}
else if (location->start >= object.used) {
- return F_data_no_eos;
+ return F_data_not_eos;
}
start_position = location->start;
* FL_fss_found_object_not on success and no object was found (start location is after character designating this is not an object).
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_none_eos on success after reaching the end of the buffer (a valid object is not yet confirmed).
- * F_data_no_stop no data found after reaching stopping point (essentially only comments are found).
- * F_data_no_eos no objects found after reaching the end of the buffer (essentially only comments are found).
+ * F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
+ * F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* FL_fss_found_content_not on success and no content was found (start location is after character designating this is not a content).
* F_none_stop on success after reaching stopping point (a valid content is not yet confirmed).
* F_none_eos on success after reaching the end of the buffer (a valid content is not yet confirmed).
- * F_data_no_stop no data found after reaching stopping point (essentially only comments are found).
- * F_data_no_eos no content found after reaching the end of the buffer (essentially only comments are found).
+ * F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
+ * F_data_not_eos no content found after reaching the end of the buffer (essentially only comments are found).
* F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
f_string_lengths delimits = f_string_lengths_initialize;
fl_fss_skip_past_space(*buffer, location);
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
// return found nothing if this line only contains whitespace and delimit placeholders.
if (buffer->string[location->start] == f_string_eol) {
// ignore all comment lines.
if (buffer->string[location->start] == f_fss_comment) {
- fl_macro_fss_object_seek_till_newline((*buffer), (*location), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_seek_till_newline((*buffer), (*location), delimits, F_data_not_eos, F_data_not_stop)
status = fl_fss_increment_buffer(*buffer, location, 1);
if (F_status_is_error(status)) return status;
if (F_status_is_error(status)) return status;
} // while
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
if (buffer->string[location->start] == f_fss_basic_list_open) {
f_string_length stop_point = location->start - 1;
if (F_status_is_error(status)) return status;
} // while
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
if (buffer->string[location->start] == f_string_eol) {
f_string_length start = location->start;
if (F_status_is_error(status)) return status;
} // while
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
status = fl_fss_increment_buffer(*buffer, location, 1);
if (F_status_is_error(status)) return status;
fl_macro_fss_content_delimited_return_on_overflow((*buffer), (*location), (*found), delimits, F_none_eos, F_none_stop)
}
else {
- fl_macro_fss_content_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_content_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
}
if (buffer->string[location->start] == f_fss_basic_list_open) {
fl_macro_fss_content_delimited_return_on_overflow((*buffer), (*location), (*found), delimits, F_none_eos, F_none_stop)
}
else {
- fl_macro_fss_content_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_content_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
}
if (buffer->string[location->start] == f_string_eol) {
fl_macro_fss_content_delimited_return_on_overflow((*buffer), (*location), (*found), delimits, F_none_eos, F_none_stop)
}
else {
- fl_macro_fss_content_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_content_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
}
if (buffer->string[location->start] == f_string_eol) {
return FL_fss_found_content;
}
- fl_macro_fss_content_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_content_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
return FL_fss_found_content_not;
}
fl_macro_fss_skip_past_delimit_placeholders(object, (*location))
if (location->start > location->stop) {
- return F_data_no_stop;
+ return F_data_not_stop;
}
else if (location->start >= object.used) {
- return F_data_no_eos;
+ return F_data_not_eos;
}
start_position = location->start;
}
else if (object.string[location->start] == f_string_eol) {
if (buffer_position.stop == buffer_position.start) {
- return F_data_no_eol;
+ return F_data_not_eol;
}
break;
fl_macro_fss_skip_past_delimit_placeholders(content, (*location))
if (location->start > location->stop) {
- return F_data_no_stop;
+ return F_data_not_stop;
}
else if (location->start >= content.used) {
- return F_data_no_eos;
+ return F_data_not_eos;
}
start_position = location->start;
* FL_fss_found_object_not on success and no object was found (start location is after character designating this is not an object).
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_none_eos on success after reaching the end of the buffer (a valid object is not yet confirmed).
- * F_data_no_stop no data found after reaching stopping point (essentially only comments are found).
- * F_data_no_eos no objects found after reaching the end of the buffer (essentially only comments are found).
+ * F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
+ * F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* FL_fss_found_content_not on success and no content was found (start location is after character designating this is not a content).
* F_none_stop on success after reaching stopping point (a valid content is not yet confirmed).
* F_none_eos on success after reaching the end of the buffer (a valid content is not yet confirmed).
- * F_data_no_stop no data found after reaching stopping point (essentially only comments are found).
- * F_data_no_eos no content found after reaching the end of the buffer (essentially only comments are found).
+ * F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
+ * F_data_not_eos no content found after reaching the end of the buffer (essentially only comments are found).
* F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
- * F_data_no_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
f_string_lengths delimits = f_string_lengths_initialize;
fl_fss_skip_past_space(*buffer, location);
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
// return found nothing if this line only contains whitespace and delimit placeholders
if (buffer->string[location->start] == f_fss_extended_close) {
// ignore all comment lines
if (buffer->string[location->start] == f_fss_comment) {
- fl_macro_fss_object_seek_till_newline((*buffer), (*location), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_seek_till_newline((*buffer), (*location), delimits, F_data_not_eos, F_data_not_stop)
status = fl_fss_increment_buffer(*buffer, location, 1);
if (F_status_is_error(status)) return status;
if (F_status_is_error(status)) return status;
} // while
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
status = fl_fss_increment_buffer(*buffer, location, 1);
if (F_status_is_error(status)) return status;
if (F_status_is_error(status)) return status;
} // while
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
status = fl_fss_increment_buffer(*buffer, location, 1);
if (F_status_is_error(status)) return status;
if (F_status_is_error(status)) return status;
} // while
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
status = fl_fss_increment_buffer(*buffer, location, 1);
if (F_status_is_error(status)) return status;
fl_macro_fss_skip_past_delimit_placeholders(object, (*location))
if (location->start > location->stop) {
- return F_data_no_stop;
+ return F_data_not_stop;
}
else if (location->start >= object.used) {
- return F_data_no_eos;
+ return F_data_not_eos;
}
start_position = location->start;
fl_macro_fss_skip_past_delimit_placeholders(content, (*location))
if (location->start > location->stop) {
- return F_data_no_stop;
+ return F_data_not_stop;
}
else if (location->start >= content.used) {
- return F_data_no_eos;
+ return F_data_not_eos;
}
start_position = location->start;
* FL_fss_found_object_not on success and no object was found (start location is after character designating this is not an object).
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_none_eos on success after reaching the end of the buffer (a valid object is not yet confirmed).
- * F_data_no_stop no data found after reaching stopping point (essentially only comments are found).
- * F_data_no_eos no objects found after reaching the end of the buffer (essentially only comments are found).
+ * F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
+ * F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* FL_fss_found_content_not on success and no content was found (start location is after character designating this is not a content).
* F_none_stop on success after reaching stopping point (a valid content is not yet confirmed).
* F_none_eos on success after reaching the end of the buffer (a valid content is not yet confirmed).
- * F_data_no_stop no data found after reaching stopping point (essentially only comments are found).
- * F_data_no_eos no content found after reaching the end of the buffer (essentially only comments are found).
+ * F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
+ * F_data_not_eos no content found after reaching the end of the buffer (essentially only comments are found).
* F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
f_string_lengths delimits = f_string_lengths_initialize;
fl_fss_skip_past_space(*buffer, location);
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
// return found nothing if this line only contains whitespace and delimit placeholders.
if (buffer->string[location->start] == f_string_eol) {
// ignore all comment lines.
if (buffer->string[location->start] == f_fss_comment) {
- fl_macro_fss_object_seek_till_newline((*buffer), (*location), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_seek_till_newline((*buffer), (*location), delimits, F_data_not_eos, F_data_not_stop)
status = fl_fss_increment_buffer(*buffer, location, 1);
if (F_status_is_error(status)) return status;
if (F_status_is_error(status)) return status;
} // while
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
if (buffer->string[location->start] == f_fss_extended_list_open) {
f_string_length stop_point = location->start - 1;
if (F_status_is_error(status)) return status;
} // while
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
if (buffer->string[location->start] == f_string_eol) {
f_string_length start = location->start;
if (F_status_is_error(status)) return status;
} // while
- fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_object_return_on_overflow((*buffer), (*location), (*found), delimits, F_data_not_eos, F_data_not_stop)
status = fl_fss_increment_buffer(*buffer, location, 1);
if (F_status_is_error(status)) return status;
fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_unterminated_nest_eos, F_unterminated_nest_stop)
}
else {
- fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_data_not_eos, F_data_not_stop)
}
// All slashes for an open are delimited (because it could represent a slash in the object name).
fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_unterminated_nest_eos, F_unterminated_nest_stop)
}
else {
- fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_data_not_eos, F_data_not_stop)
}
// this is a valid object open/close that has been delimited, save the slash delimit positions.
fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_unterminated_nest_eos, F_unterminated_nest_stop)
}
else {
- fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_data_not_eos, F_data_not_stop)
}
if (buffer->string[location->start] == f_string_eol) {
fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_unterminated_nest_eos, F_unterminated_nest_stop)
}
else {
- fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_data_not_eos, F_data_not_stop)
}
}
}
fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_unterminated_nest_eos, F_unterminated_nest_stop)
}
else {
- fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_data_not_eos, F_data_not_stop)
}
if (buffer->string[location->start] == f_string_eol) {
fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_unterminated_nest_eos, F_unterminated_nest_stop)
}
else {
- fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_data_no_eos, F_data_no_stop)
+ fl_macro_fss_nest_return_on_overflow((*buffer), (*location), (*found), delimits, positions_start, objects, F_data_not_eos, F_data_not_stop)
}
}
}
fl_macro_fss_skip_past_delimit_placeholders(object, (*location))
if (location->start > location->stop) {
- return F_data_no_stop;
+ return F_data_not_stop;
}
else if (location->start >= object.used) {
- return F_data_no_eos;
+ return F_data_not_eos;
}
start_position = location->start;
}
else if (object.string[location->start] == f_string_eol) {
if (buffer_position.stop == buffer_position.start) {
- return F_data_no_eol;
+ return F_data_not_eol;
}
break;
fl_macro_fss_skip_past_delimit_placeholders(content, (*location))
if (location->start > location->stop) {
- return F_data_no_stop;
+ return F_data_not_stop;
}
else if (location->start >= content.used) {
- return F_data_no_eos;
+ return F_data_not_eos;
}
start_position = location->start;
* FL_fss_found_object_not on success and no object was found (start location is after character designating this is not an object).
* F_none_stop on success after reaching stopping point (a valid object is not yet confirmed).
* F_none_eos on success after reaching the end of the buffer (a valid object is not yet confirmed).
- * F_data_no_stop no data found after reaching stopping point (essentially only comments are found).
- * F_data_no_eos no objects found after reaching the end of the buffer (essentially only comments are found).
+ * F_data_not_stop no data found after reaching stopping point (essentially only comments are found).
+ * F_data_not_eos no objects found after reaching the end of the buffer (essentially only comments are found).
* F_incomplete_utf_stop (with error bit) if the stop location is reached before the complete UTF-8 character can be processed.
* F_incomplete_utf_eos (with error bit) if the end of buffer is reached before the complete UTF-8 character can be processed.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
- * F_data_no_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
i += width;
} // while
- return F_data_no_eos;
+ return F_data_not_eos;
}
#endif // !defined(_di_fl_unserialize_simple_find_) || !defined(_di_fl_unserialize_simple_get_)
* @return
* F_none on success.
* F_none_eos on success at end of string.
- * F_data_no_eos if end of string reached before index was reached.
+ * F_data_not_eos if end of string reached before index was reached.
* F_incomplete_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed.
* F_parameter (with error bit) if a parameter is invalid.
*/
if (F_status_is_error(status)) return status;
- if (status == F_data_no_eos) {
+ if (status == F_data_not_eos) {
dynamic->used = 0;
return status;
}
* @return
* F_none on success.
* F_none_eos on success at end of string.
- * F_data_no_eos if end of string reached before index was reached.
+ * F_data_not_eos if end of string reached before index was reached.
* F_incomplete_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed.
* F_parameter (with error bit) if a parameter is invalid.
*/
* @return
* F_none on success.
* F_none_eos on success at end of string.
- * F_data_no_eos if end of string reached before index was reached (dynamic->used is set to 0).
+ * F_data_not_eos if end of string reached before index was reached (dynamic->used is set to 0).
* F_incomplete_utf_eos (with error bit) if end of string is reached before a complete UTF-8 character can be processed.
* F_parameter (with error bit) if a parameter is invalid.
* F_memory_reallocation (with error bit) on memory reallocation error.
return F_address;
}
else if (errno == ENOTDIR) {
- return F_directory_not_found;
+ return F_directory_found_not;
}
else if (errno == ENOMEM) {
return F_memory_out;
f_status unmasked_code = F_status_set_fine(code);
switch (unmasked_code) {
- #ifndef _di_fl_status_booleans_
+ #ifndef _di_F_status_boolean_
case F_false:
- *string = fl_status_string_false;
- break;
+ *string = FL_status_string_false; break;
case F_true:
- *string = fl_status_string_true;
+ *string = FL_status_string_true;
break;
- #endif // _di_fl_status_booleans_
+ #endif // _di_F_status_boolean_
- #ifndef _di_fl_status_signals_
+ #ifndef _di_F_status_signal_
// F_signal_hangup is not used because it has the same code as F_true.
case F_signal_interrupt:
- *string = fl_status_string_signal_interrupt;
+ *string = FL_status_string_signal_interrupt;
break;
case F_signal_quit:
- *string = fl_status_string_signal_quit;
+ *string = FL_status_string_signal_quit;
break;
case F_signal_illegal:
- *string = fl_status_string_signal_illegal;
+ *string = FL_status_string_signal_illegal;
break;
case F_signal_trap:
- *string = fl_status_string_signal_trap;
+ *string = FL_status_string_signal_trap;
break;
case F_signal_abort:
- *string = fl_status_string_signal_abort;
+ *string = FL_status_string_signal_abort;
break;
case F_signal_bus_error:
- *string = fl_status_string_signal_bus_error;
+ *string = FL_status_string_signal_bus_error;
break;
- case F_signal_floating_point_exception:
- *string = fl_status_string_signal_floating_point_exception;
+ case F_signal_floating_point_error:
+ *string = FL_status_string_signal_floating_point_error;
break;
case F_signal_kill:
- *string = fl_status_string_signal_kill;
+ *string = FL_status_string_signal_kill;
break;
case F_signal_user_1:
- *string = fl_status_string_signal_user_1;
+ *string = FL_status_string_signal_user_1;
break;
case F_signal_segmentation_fault:
- *string = fl_status_string_signal_segmentation_fault;
+ *string = FL_status_string_signal_segmentation_fault;
break;
case F_signal_user_2:
- *string = fl_status_string_signal_user_2;
+ *string = FL_status_string_signal_user_2;
break;
case F_signal_broken_pipe:
- *string = fl_status_string_signal_broken_pipe;
+ *string = FL_status_string_signal_broken_pipe;
break;
case F_signal_alarm_clock:
- *string = fl_status_string_signal_alarm_clock;
+ *string = FL_status_string_signal_alarm_clock;
break;
case F_signal_termination:
- *string = fl_status_string_signal_termination;
+ *string = FL_status_string_signal_termination;
break;
case F_signal_stack_fault:
- *string = fl_status_string_signal_stack_fault;
+ *string = FL_status_string_signal_stack_fault;
break;
case F_signal_child:
- *string = fl_status_string_signal_child;
+ *string = FL_status_string_signal_child;
break;
case F_signal_continue:
- *string = fl_status_string_signal_continue;
+ *string = FL_status_string_signal_continue;
break;
case F_signal_stop:
- *string = fl_status_string_signal_stop;
+ *string = FL_status_string_signal_stop;
break;
case F_signal_keyboard_stop:
- *string = fl_status_string_signal_keyboard_stop;
+ *string = FL_status_string_signal_keyboard_stop;
break;
case F_signal_tty_in:
- *string = fl_status_string_signal_tty_in;
+ *string = FL_status_string_signal_tty_in;
break;
case F_signal_tty_out:
- *string = fl_status_string_signal_tty_out;
+ *string = FL_status_string_signal_tty_out;
break;
case F_signal_urgent:
- *string = fl_status_string_signal_urgent;
+ *string = FL_status_string_signal_urgent;
break;
case F_signal_cpu_limit:
- *string = fl_status_string_signal_cpu_limit;
+ *string = FL_status_string_signal_cpu_limit;
break;
case F_signal_file_size_limit:
- *string = fl_status_string_signal_file_size_limit;
+ *string = FL_status_string_signal_file_size_limit;
break;
case F_signal_virtual_alarm_clock:
- *string = fl_status_string_signal_virtual_alarm_clock;
+ *string = FL_status_string_signal_virtual_alarm_clock;
break;
case F_signal_profile_alarm_clock:
- *string = fl_status_string_signal_profile_alarm_clock;
+ *string = FL_status_string_signal_profile_alarm_clock;
break;
case F_signal_window_size_change:
- *string = fl_status_string_signal_window_size_change;
+ *string = FL_status_string_signal_window_size_change;
break;
case F_signal_pollable_event:
- *string = fl_status_string_signal_pollable_event;
+ *string = FL_status_string_signal_pollable_event;
break;
case F_signal_power_failure:
- *string = fl_status_string_signal_power_failure;
+ *string = FL_status_string_signal_power_failure;
break;
case F_signal_bad_system_call:
- *string = fl_status_string_signal_bad_system_call;
+ *string = FL_status_string_signal_bad_system_call;
break;
case F_signal_reserved_32:
- *string = fl_status_string_signal_reserved_32;
+ *string = FL_status_string_signal_reserved_32;
break;
case F_signal_reserved_33:
- *string = fl_status_string_signal_reserved_33;
+ *string = FL_status_string_signal_reserved_33;
break;
case F_signal_reserved_34:
- *string = fl_status_string_signal_reserved_34;
+ *string = FL_status_string_signal_reserved_34;
break;
case F_signal_reserved_35:
- *string = fl_status_string_signal_reserved_35;
+ *string = FL_status_string_signal_reserved_35;
break;
case F_signal_reserved_36:
- *string = fl_status_string_signal_reserved_36;
+ *string = FL_status_string_signal_reserved_36;
break;
case F_signal_reserved_37:
- *string = fl_status_string_signal_reserved_37;
+ *string = FL_status_string_signal_reserved_37;
break;
case F_signal_reserved_38:
- *string = fl_status_string_signal_reserved_38;
+ *string = FL_status_string_signal_reserved_38;
break;
case F_signal_reserved_39:
- *string = fl_status_string_signal_reserved_39;
+ *string = FL_status_string_signal_reserved_39;
break;
case F_signal_reserved_40:
- *string = fl_status_string_signal_reserved_40;
+ *string = FL_status_string_signal_reserved_40;
break;
case F_signal_reserved_41:
- *string = fl_status_string_signal_reserved_41;
+ *string = FL_status_string_signal_reserved_41;
break;
case F_signal_reserved_42:
- *string = fl_status_string_signal_reserved_42;
+ *string = FL_status_string_signal_reserved_42;
break;
case F_signal_reserved_43:
- *string = fl_status_string_signal_reserved_43;
+ *string = FL_status_string_signal_reserved_43;
break;
case F_signal_reserved_44:
- *string = fl_status_string_signal_reserved_44;
+ *string = FL_status_string_signal_reserved_44;
break;
case F_signal_reserved_45:
- *string = fl_status_string_signal_reserved_45;
+ *string = FL_status_string_signal_reserved_45;
break;
case F_signal_reserved_46:
- *string = fl_status_string_signal_reserved_46;
+ *string = FL_status_string_signal_reserved_46;
break;
case F_signal_reserved_47:
- *string = fl_status_string_signal_reserved_47;
+ *string = FL_status_string_signal_reserved_47;
break;
case F_signal_reserved_48:
- *string = fl_status_string_signal_reserved_48;
+ *string = FL_status_string_signal_reserved_48;
break;
case F_signal_reserved_49:
- *string = fl_status_string_signal_reserved_49;
+ *string = FL_status_string_signal_reserved_49;
break;
case F_signal_reserved_50:
- *string = fl_status_string_signal_reserved_50;
+ *string = FL_status_string_signal_reserved_50;
break;
case F_signal_reserved_51:
- *string = fl_status_string_signal_reserved_51;
+ *string = FL_status_string_signal_reserved_51;
break;
case F_signal_reserved_52:
- *string = fl_status_string_signal_reserved_52;
+ *string = FL_status_string_signal_reserved_52;
break;
case F_signal_reserved_53:
- *string = fl_status_string_signal_reserved_53;
+ *string = FL_status_string_signal_reserved_53;
break;
case F_signal_reserved_54:
- *string = fl_status_string_signal_reserved_54;
+ *string = FL_status_string_signal_reserved_54;
break;
case F_signal_reserved_55:
- *string = fl_status_string_signal_reserved_55;
+ *string = FL_status_string_signal_reserved_55;
break;
case F_signal_reserved_56:
- *string = fl_status_string_signal_reserved_56;
+ *string = FL_status_string_signal_reserved_56;
break;
case F_signal_reserved_57:
- *string = fl_status_string_signal_reserved_57;
+ *string = FL_status_string_signal_reserved_57;
break;
case F_signal_reserved_58:
- *string = fl_status_string_signal_reserved_58;
+ *string = FL_status_string_signal_reserved_58;
break;
case F_signal_reserved_59:
- *string = fl_status_string_signal_reserved_59;
+ *string = FL_status_string_signal_reserved_59;
break;
case F_signal_reserved_60:
- *string = fl_status_string_signal_reserved_60;
+ *string = FL_status_string_signal_reserved_60;
break;
case F_signal_reserved_61:
- *string = fl_status_string_signal_reserved_61;
+ *string = FL_status_string_signal_reserved_61;
break;
case F_signal_reserved_62:
- *string = fl_status_string_signal_reserved_62;
+ *string = FL_status_string_signal_reserved_62;
break;
case F_signal_reserved_63:
- *string = fl_status_string_signal_reserved_63;
+ *string = FL_status_string_signal_reserved_63;
break;
case F_signal_reserved_64:
- *string = fl_status_string_signal_reserved_64;
+ *string = FL_status_string_signal_reserved_64;
break;
- #endif // _di_fl_status_signals_
+ #endif // _di_F_status_signal_
- #ifndef _di_fl_status_basic_
+ #ifndef _di_F_status_basic_
case F_none:
- *string = fl_status_string_none;
+ *string = FL_status_string_none;
break;
- case F_maybe:
- *string = fl_status_string_maybe;
+ case F_address:
+ *string = FL_status_string_address;
break;
- case F_dummy:
- *string = fl_status_string_dummy;
+ case F_block:
+ *string = FL_status_string_block;
break;
- case F_warn:
- *string = fl_status_string_warn;
+ case F_bound_out:
+ *string = FL_status_string_bound_out;
break;
- case F_block:
- *string = fl_status_string_block;
+ case F_connected_not:
+ *string = FL_status_string_connected_not;
break;
case F_critical:
- *string = fl_status_string_critical;
+ *string = FL_status_string_critical;
break;
- case F_unknown:
- *string = fl_status_string_unknown;
+ case F_descriptor:
+ *string = FL_status_string_descriptor;
break;
- case F_unsupported:
- *string = fl_status_string_unsupported;
+ case F_device:
+ *string = FL_status_string_device;
break;
- case F_data_not:
- *string = fl_status_string_no_data;
+ case F_dummy:
+ *string = FL_status_string_dummy;
break;
- case F_space_not:
- *string = fl_status_string_no_space;
+ case F_eof:
+ *string = FL_status_string_eof;
break;
- case F_bound_out:
- *string = fl_status_string_bound_out;
+ case F_eol:
+ *string = FL_status_string_eol;
break;
- case F_memory_out:
- *string = fl_status_string_memory_out;
+ case F_eos:
+ *string = FL_status_string_eos;
break;
- case F_prohibited:
- *string = fl_status_string_prohibited;
+ case F_exist_not:
+ *string = FL_status_string_exist_not;
break;
- case F_read_only:
- *string = fl_status_string_read_only;
+ case F_failure:
+ *string = FL_status_string_failure;
break;
- case F_input:
- *string = fl_status_string_input;
+ case F_fork:
+ *string = FL_status_string_fork;
break;
- case F_output:
- *string = fl_status_string_output;
+ case F_incomplete:
+ *string = FL_status_string_incomplete;
+ break;
+ case F_input:
+ *string = FL_status_string_input;
break;
case F_input_output:
- *string = fl_status_string_input_output;
+ *string = FL_status_string_input_output;
break;
- case F_exist_not:
- *string = fl_status_string_exist_not;
+ case F_interrupted:
+ *string = FL_status_string_interrupted;
break;
- case F_connected_not:
- *string = fl_status_string_connected_not;
+ case F_invalid:
+ *string = FL_status_string_invalid;
break;
- case F_failure:
- *string = fl_status_string_failure;
+ case F_output:
+ *string = FL_status_string_output;
break;
- case F_interrupted:
- *string = fl_status_string_interrupted;
+ case F_link:
+ *string = FL_status_string_link;
break;
case F_loop:
- *string = fl_status_string_loop;
- break;
- case F_incomplete:
- *string = fl_status_string_incomplete;
+ *string = FL_status_string_loop;
break;
- case F_write_only:
- *string = fl_status_string_write_only;
+ case F_maybe:
+ *string = FL_status_string_maybe;
break;
- #endif // _di_fl_status_basic_
-
- #ifndef _di_fl_status_invalid_
- case F_invalid:
- *string = fl_status_string_invalid;
+ case F_memory_out:
+ *string = FL_status_string_memory_out;
break;
case F_name:
- *string = fl_status_string_name;
+ *string = FL_status_string_name;
break;
case F_parameter:
- *string = fl_status_string_parameter;
+ *string = FL_status_string_parameter;
break;
- case F_syntax:
- *string = fl_status_string_syntax;
+ case F_pipe:
+ *string = FL_status_string_pipe;
break;
- case F_data:
- *string = fl_status_string_data;
+ case F_port:
+ *string = FL_status_string_port;
break;
- case F_descriptor:
- *string = fl_status_string_descriptor;
+ case F_process:
+ *string = FL_status_string_process;
break;
- case F_socket:
- *string = fl_status_string_socket;
+ case F_process_too_many:
+ *string = FL_status_string_process_too_many;
break;
- case F_device:
- *string = fl_status_string_device;
+ case F_prohibited:
+ *string = FL_status_string_prohibited;
break;
- case F_link:
- *string = fl_status_string_link;
+ case F_read_only:
+ *string = FL_status_string_read_only;
break;
- case F_pipe:
- *string = fl_status_string_pipe;
+ case F_socket:
+ *string = FL_status_string_socket;
break;
- case F_address:
- *string = fl_status_string_address;
+ case F_space_not:
+ *string = FL_status_string_space_not;
break;
- case F_port:
- *string = fl_status_string_port;
+ case F_stop:
+ *string = FL_status_string_stop;
break;
- case F_value:
- *string = fl_status_string_value;
+ case F_syntax:
+ *string = FL_status_string_syntax;
break;
- case F_buffer:
- *string = fl_status_string_buffer;
+ case F_unknown:
+ *string = FL_status_string_unknown;
break;
- case F_process:
- *string = fl_status_string_process;
+ case F_unsupported:
+ *string = FL_status_string_unsupported;
break;
case F_utf:
- *string = fl_status_string_utf;
- break;
- case F_eof:
- *string = fl_status_string_eof;
+ *string = FL_status_string_utf;
break;
- case F_eol:
- *string = fl_status_string_eol;
+ case F_value:
+ *string = FL_status_string_value;
break;
- case F_eos:
- *string = fl_status_string_eos;
+ case F_warn:
+ *string = FL_status_string_warn;
break;
- case F_stop:
- *string = fl_status_string_stop;
+ case F_write_only:
+ *string = FL_status_string_write_only;
break;
- #endif // _di_fl_status_invalid_
+ #endif // _di_F_status_basic_
- #ifndef _di_fl_status_busy_
+ #ifndef _di_F_status_busy_
case F_busy:
- *string = fl_status_string_busy;
+ *string = FL_status_string_busy;
break;
case F_busy_address:
- *string = fl_status_string_busy_address;
- break;
- case F_busy_port:
- *string = fl_status_string_busy_port;
+ *string = FL_status_string_busy_address;
break;
- case F_busy_socket:
- *string = fl_status_string_busy_socket;
+ case F_busy_buffer:
+ *string = FL_status_string_busy_buffer;
break;
case F_busy_device:
- *string = fl_status_string_busy_device;
+ *string = FL_status_string_busy_device;
break;
case F_busy_pipe:
- *string = fl_status_string_busy_pipe;
+ *string = FL_status_string_busy_pipe;
break;
- case F_busy_buffer:
- *string = fl_status_string_busy_buffer;
+ case F_busy_port:
+ *string = FL_status_string_busy_port;
break;
case F_busy_process:
- *string = fl_status_string_busy_process;
+ *string = FL_status_string_busy_process;
+ break;
+ case F_busy_socket:
+ *string = FL_status_string_busy_socket;
break;
- #endif // _di_fl_status_busy_
+ #endif // _di_F_status_busy_
- #ifndef _di_fl_status_unavailable_
+ #ifndef _di_F_status_unavailable_
case F_unavailable:
- *string = fl_status_string_unavailable;
+ *string = FL_status_string_unavailable;
break;
case F_unavailable_address:
- *string = fl_status_string_unavailable_address;
- break;
- case F_unavailable_port:
- *string = fl_status_string_unavailable_port;
+ *string = FL_status_string_unavailable_address;
break;
- case F_unavailable_socket:
- *string = fl_status_string_unavailable_socket;
+ case F_unavailable_buffer:
+ *string = FL_status_string_unavailable_buffer;
break;
case F_unavailable_device:
- *string = fl_status_string_unavailable_device;
+ *string = FL_status_string_unavailable_device;
break;
case F_unavailable_pipe:
- *string = fl_status_string_unavailable_pipe;
+ *string = FL_status_string_unavailable_pipe;
break;
- case F_unavailable_buffer:
- *string = fl_status_string_unavailable_buffer;
+ case F_unavailable_port:
+ *string = FL_status_string_unavailable_port;
break;
case F_unavailable_process:
- *string = fl_status_string_unavailable_process;
+ *string = FL_status_string_unavailable_process;
+ break;
+ case F_unavailable_socket:
+ *string = FL_status_string_unavailable_socket;
break;
- #endif // _di_fl_status_unavailable_
+ #endif // _di_F_status_unavailable_
- #ifndef _di_fl_status_digits_
- case F_number_underflow:
- *string = fl_status_string_underflow;
+ #ifndef _di_F_status_number_
+ case F_number:
+ *string = FL_status_string_number;
break;
- case F_number_overflow:
- *string = fl_status_string_overflow;
+ case F_number_decimal:
+ *string = FL_status_string_number_decimal;
break;
case F_number_divide_by_zero:
- *string = fl_status_string_divide_by_zero;
+ *string = FL_status_string_number_divide_by_zero;
break;
case F_number_negative:
- *string = fl_status_string_negative_number;
+ *string = FL_status_string_number_negative;
break;
- case F_number_positive:
- *string = fl_status_string_positive_number;
+ case F_number_overflow:
+ *string = FL_status_string_number_overflow;
break;
- case F_number_zero:
- *string = fl_status_string_zero_number;
+ case F_number_positive:
+ *string = FL_status_string_number_positive;
break;
- case F_number_decimal:
- *string = fl_status_string_decimal_number;
+ case F_number_underflow:
+ *string = FL_status_string_number_underflow;
break;
case F_number_whole:
- *string = fl_status_string_whole_number;
+ *string = FL_status_string_number_whole;
break;
- case F_number_invalid:
- *string = fl_status_string_number;
+ case F_number_zero:
+ *string = FL_status_string_number_zero;
break;
- #endif // _di_fl_status_digits_
+ #endif // _di_F_status_number_
- #ifndef _di_fl_status_buffers_
- case F_data_no_eof:
- *string = fl_status_string_data_no_eof;
+ #ifndef _di_F_status_buffers_
+ case F_buffer:
+ *string = FL_status_string_buffer;
+ break;
+ case F_buffer_too_small:
+ *string = FL_status_string_buffer_too_small;
break;
- case F_data_no_eol:
- *string = fl_status_string_data_no_eol;
+ case F_buffer_too_large:
+ *string = FL_status_string_buffer_too_large;
break;
- case F_data_no_eos:
- *string = fl_status_string_data_no_eos;
+ case F_incomplete_utf:
+ *string = FL_status_string_incomplete_utf;
break;
- case F_data_no_stop:
- *string = fl_status_string_data_no_stop;
+ case F_incomplete_utf_block:
+ *string = FL_status_string_incomplete_utf_block;
break;
- case F_data_block_no:
- *string = fl_status_string_data_no_block;
+ case F_incomplete_utf_eof:
+ *string = FL_status_string_incomplete_utf_eof;
+ break;
+ case F_incomplete_utf_eol:
+ *string = FL_status_string_incomplete_utf_eol;
+ break;
+ case F_incomplete_utf_eos:
+ *string = FL_status_string_incomplete_utf_eos;
+ break;
+ case F_incomplete_utf_stop:
+ *string = FL_status_string_incomplete_utf_stop;
+ break;
+ case F_none_block:
+ *string = FL_status_string_none_block;
break;
case F_none_eof:
- *string = fl_status_string_none_eof;
+ *string = FL_status_string_none_eof;
break;
case F_none_eol:
- *string = fl_status_string_none_eol;
+ *string = FL_status_string_none_eol;
break;
case F_none_eos:
- *string = fl_status_string_none_eos;
+ *string = FL_status_string_none_eos;
break;
case F_none_stop:
- *string = fl_status_string_none_stop;
+ *string = FL_status_string_none_stop;
break;
- case F_none_block:
- *string = fl_status_string_none_block;
+ case F_data:
+ *string = FL_status_string_data;
break;
- case F_buffer_too_small:
- *string = fl_status_string_buffer_too_small;
+ case F_data_not:
+ *string = FL_status_string_data_not;
break;
- case F_buffer_too_large:
- *string = fl_status_string_buffer_too_large;
+ case F_data_not_block:
+ *string = FL_status_string_data_not_block;
+ break;
+ case F_data_not_eof:
+ *string = FL_status_string_data_not_eof;
+ break;
+ case F_data_not_eol:
+ *string = FL_status_string_data_not_eol;
+ break;
+ case F_data_not_eos:
+ *string = FL_status_string_data_not_eos;
+ break;
+ case F_data_not_stop:
+ *string = FL_status_string_data_not_stop;
break;
case F_string_too_small:
- *string = fl_status_string_string_too_small;
+ *string = FL_status_string_string_too_small;
break;
case F_string_too_large:
- *string = fl_status_string_string_too_large;
+ *string = FL_status_string_string_too_large;
break;
case F_unterminated:
- *string = fl_status_string_unterminated;
+ *string = FL_status_string_unterminated;
+ break;
+ case F_unterminated_block:
+ *string = FL_status_string_unterminated_block;
break;
case F_unterminated_eof:
- *string = fl_status_string_unterminated_eof;
+ *string = FL_status_string_unterminated_eof;
break;
case F_unterminated_eol:
- *string = fl_status_string_unterminated_eol;
+ *string = FL_status_string_unterminated_eol;
break;
case F_unterminated_eos:
- *string = fl_status_string_unterminated_eos;
+ *string = FL_status_string_unterminated_eos;
break;
case F_unterminated_stop:
- *string = fl_status_string_unterminated_stop;
- break;
- case F_unterminated_block:
- *string = fl_status_string_unterminated_block;
+ *string = FL_status_string_unterminated_stop;
break;
case F_unterminated_group:
- *string = fl_status_string_unterminated_group;
+ *string = FL_status_string_unterminated_group;
+ break;
+ case F_unterminated_group_block:
+ *string = FL_status_string_unterminated_group_block;
break;
case F_unterminated_group_eof:
- *string = fl_status_string_unterminated_group_on_eof;
+ *string = FL_status_string_unterminated_group_eof;
break;
case F_unterminated_group_eol:
- *string = fl_status_string_unterminated_group_on_eol;
+ *string = FL_status_string_unterminated_group_eol;
break;
case F_unterminated_group_eos:
- *string = fl_status_string_unterminated_group_on_eos;
+ *string = FL_status_string_unterminated_group_eos;
break;
case F_unterminated_group_stop:
- *string = fl_status_string_unterminated_group_on_stop;
- break;
- case F_unterminated_group_block:
- *string = fl_status_string_unterminated_group_on_block;
+ *string = FL_status_string_unterminated_group_stop;
break;
case F_unterminated_nest:
- *string = fl_status_string_unterminated_nest;
+ *string = FL_status_string_unterminated_nest;
+ break;
+ case F_unterminated_nest_block:
+ *string = FL_status_string_unterminated_nest_block;
break;
case F_unterminated_nest_eof:
- *string = fl_status_string_unterminated_nest_eof;
+ *string = FL_status_string_unterminated_nest_eof;
break;
case F_unterminated_nest_eol:
- *string = fl_status_string_unterminated_nest_eol;
+ *string = FL_status_string_unterminated_nest_eol;
break;
case F_unterminated_nest_eos:
- *string = fl_status_string_unterminated_nest_eos;
+ *string = FL_status_string_unterminated_nest_eos;
break;
case F_unterminated_nest_stop:
- *string = fl_status_string_unterminated_nest_stop;
- break;
- case F_unterminated_nest_block:
- *string = fl_status_string_unterminated_nest_block;
- break;
- case F_incomplete_utf:
- *string = fl_status_string_incomplete_utf;
+ *string = FL_status_string_unterminated_nest_stop;
break;
- case F_incomplete_utf_eof:
- *string = fl_status_string_incomplete_utf_on_eof;
- break;
- case F_incomplete_utf_eol:
- *string = fl_status_string_incomplete_utf_on_eol;
- break;
- case F_incomplete_utf_eos:
- *string = fl_status_string_incomplete_utf_on_eos;
- break;
- case F_incomplete_utf_stop:
- *string = fl_status_string_incomplete_utf_on_stop;
- break;
- case F_incomplete_utf_block:
- *string = fl_status_string_incomplete_utf_on_block;
- break;
- #endif // _di_fl_status_buffers_
+ #endif // _di_F_status_buffers_
- #ifndef _di_fl_status_allocation_
+ #ifndef _di_F_status_allocation_
case F_memory_allocation:
- *string = fl_status_string_memory_allocation;
- break;
- case F_memory_reallocation:
- *string = fl_status_string_memory_reallocation;
+ *string = FL_status_string_memory_allocation;
break;
case F_memory_deallocation:
- *string = fl_status_string_memory_deallocation;
+ *string = FL_status_string_memory_deallocation;
break;
- #endif // _di_fl_status_allocation_
+ case F_memory_reallocation:
+ *string = FL_status_string_memory_reallocation;
+ break;
+ #endif // _di_F_status_allocation_
- #ifndef _di_fl_status_fork_
- case F_fork:
- *string = fl_status_string_fork;
+ #ifndef _di_F_status_file_
+ case F_file:
+ *string = FL_status_string_file;
break;
- case F_process_too_many:
- *string = fl_status_string_process_too_many;
+ case F_file_allocation:
+ *string = FL_status_string_file_allocation;
+ break;
+ case F_file_close:
+ *string = FL_status_string_file_close;
break;
- #endif // _di_fl_status_fork_
-
- #ifndef _di_fl_status_file_
case F_file_closed:
- *string = fl_status_string_file_closed;
+ *string = FL_status_string_file_closed;
break;
- case F_file_seek:
- *string = fl_status_string_file_seek;
+ case F_file_deallocation:
+ *string = FL_status_string_file_deallocation;
break;
- case F_file_read:
- *string = fl_status_string_file_read;
+ case F_file_descriptor:
+ *string = FL_status_string_file_descriptor;
break;
- case F_file_write:
- *string = fl_status_string_file_write;
+ case F_file_descriptor_max:
+ *string = FL_status_string_file_descriptor_max;
+ break;
+ case F_file_empty:
+ *string = FL_status_string_file_empty;
break;
case F_file_flush:
- *string = fl_status_string_file_flush;
+ *string = FL_status_string_file_flush;
break;
- case F_file_purge:
- *string = fl_status_string_file_purge;
+ case F_file_found:
+ *string = FL_status_string_file_found;
+ break;
+ case F_file_found_not:
+ *string = FL_status_string_file_found_not;
break;
case F_file_open:
- *string = fl_status_string_file_open;
+ *string = FL_status_string_file_open;
break;
- case F_file_close:
- *string = fl_status_string_file_close;
+ case F_file_open_max:
+ *string = FL_status_string_file_open_max;
break;
- case F_file_synchronize:
- *string = fl_status_string_file_synchronize;
+ case F_file_open_not:
+ *string = FL_status_string_file_open_not;
break;
- case F_file_descriptor:
- *string = fl_status_string_file_descriptor;
+ case F_file_purge:
+ *string = FL_status_string_file_purge;
break;
- case F_file_found_not:
- *string = fl_status_string_file_found_not;
+ case F_file_read:
+ *string = FL_status_string_file_read;
break;
- case F_file_empty:
- *string = fl_status_string_file_empty;
+ case F_file_reallocation:
+ *string = FL_status_string_file_reallocation;
break;
- case F_file_found:
- *string = fl_status_string_file_found;
+ case F_file_seek:
+ *string = FL_status_string_file_seek;
+ break;
+ case F_file_stat:
+ *string = FL_status_string_file_stat;
+ break;
+ case F_file_synchronize:
+ *string = FL_status_string_file_synchronize;
break;
case F_file_type_block:
- *string = fl_status_string_file_type_block;
+ *string = FL_status_string_file_type_block;
break;
case F_file_type_character:
- *string = fl_status_string_file_type_character;
+ *string = FL_status_string_file_type_character;
break;
case F_file_type_directory:
- *string = fl_status_string_file_type_directory;
- break;
- case F_file_type_file:
- *string = fl_status_string_file_type_file;
+ *string = FL_status_string_file_type_directory;
break;
case F_file_type_link:
- *string = fl_status_string_file_type_link;
- break;
- case F_file_type_pipe:
- *string = fl_status_string_file_type_pipe;
- break;
- case F_file_type_socket:
- *string = fl_status_string_file_type_socket;
- break;
- case F_file_type_unknown:
- *string = fl_status_string_file_type_unknown;
- break;
- case F_file_open_not:
- *string = fl_status_string_file_open_not;
- break;
- case F_file_type_not_block:
- *string = fl_status_string_file_type_not_block;
+ *string = FL_status_string_file_type_link;
break;
case F_file_type_not_character:
- *string = fl_status_string_file_type_not_character;
+ *string = FL_status_string_file_type_not_character;
break;
case F_file_type_not_directory:
- *string = fl_status_string_file_not_type_directory;
- break;
- case F_file_type_not_file:
- *string = fl_status_string_file_not_type_file;
+ *string = FL_status_string_file_type_not_directory;
break;
case F_file_type_not_link:
- *string = fl_status_string_file_not_type_link;
+ *string = FL_status_string_file_type_not_link;
break;
case F_file_type_not_pipe:
- *string = fl_status_string_file_not_type_pipe;
+ *string = FL_status_string_file_type_not_pipe;
+ break;
+ case F_file_type_not_regular:
+ *string = FL_status_string_file_type_not_regular;
break;
case F_file_type_not_socket:
- *string = fl_status_string_file_not_type_socket;
+ *string = FL_status_string_file_type_not_socket;
break;
case F_file_type_not_unknown:
- *string = fl_status_string_file_not_type_unknown;
- break;
- case F_file_allocation:
- *string = fl_status_string_file_allocation;
- break;
- case F_file_reallocation:
- *string = fl_status_string_file_reallocation;
+ *string = FL_status_string_file_type_not_unknown;
break;
- case F_file_deallocation:
- *string = fl_status_string_file_deallocation;
+ case F_file_type_pipe:
+ *string = FL_status_string_file_type_pipe;
break;
- case F_file_stat:
- *string = fl_status_string_file_stat;
+ case F_file_type_regular:
+ *string = FL_status_string_file_type_regular;
break;
- case F_file_error:
- *string = fl_status_string_file;
+ case F_file_type_socket:
+ *string = FL_status_string_file_type_socket;
break;
- case F_file_not_utf:
- *string = fl_status_string_file_not_utf;
+ case F_file_type_unknown:
+ *string = FL_status_string_file_type_unknown;
break;
- case F_file_descriptors_max:
- *string = fl_status_string_file_descriptors_max;
+ case F_file_utf:
+ *string = FL_status_string_file_utf;
break;
- case F_file_open_max:
- *string = fl_status_string_file_open_max;
+ case F_file_utf_not:
+ *string = FL_status_string_file_utf_not;
break;
- case F_file_utf:
- *string = fl_status_string_file_utf;
+ case F_file_write:
+ *string = FL_status_string_file_write;
break;
- #endif // _di_fl_status_file_
+ #endif // _di_F_status_file_
- #ifndef _di_f_status_filesystem_
+ #ifndef _di_F_status_filesystem_
case F_filesystem:
- *string = fl_status_string_filesystem_error;
+ *string = FL_status_string_filesystem;
break;
- case F_filesystem_quota_blocks:
- *string = fl_status_string_filesystem_quota_blocks;
+ case F_filesystem_quota_block:
+ *string = FL_status_string_filesystem_quota_block;
break;
case F_filesystem_quota_reached:
- *string = fl_status_string_filesystem_quota_reached;
+ *string = FL_status_string_filesystem_quota_reached;
break;
- #endif // _di_f_status_filesystem_
+ #endif // _di_F_status_filesystem_
- #ifndef _di_fl_status_directory_
- case F_directory_read:
- *string = fl_status_string_directory_read;
- break;
- case F_directory_write:
- *string = fl_status_string_directory_write;
- break;
- case F_directory_flush:
- *string = fl_status_string_directory_flush;
- break;
- case F_directory_link_max:
- *string = fl_status_string_directory_link_max;
- break;
- case F_directory_purge:
- *string = fl_status_string_directory_purge;
- break;
- case F_directory_open:
- *string = fl_status_string_directory_open;
+ #ifndef _di_F_status_directory_
+ case F_directory:
+ *string = FL_status_string_directory;
break;
case F_directory_close:
- *string = fl_status_string_directory_close;
+ *string = FL_status_string_directory_close;
break;
- case F_directory_synchronize:
- *string = fl_status_string_directory_synchronize;
+ case F_directory_closed:
+ *string = FL_status_string_directory_closed;
break;
case F_directory_descriptor:
- *string = fl_status_string_directory_descriptor;
- break;
- case F_directory_closed:
- *string = fl_status_string_directory_closed;
+ *string =FL_status_string_directory_descriptor;
break;
case F_directory_empty:
- *string = fl_status_string_directory_empty;
+ *string = FL_status_string_directory_empty;
break;
case F_directory_found:
- *string = fl_status_string_directory_found;
+ *string = FL_status_string_directory_found;
break;
- case F_directory_not_found:
- *string = fl_status_string_directory_not_found;
+ case F_directory_found_not:
+ *string = FL_status_string_directory_found_not;
break;
- case F_directory_not_open:
- *string = fl_status_string_directory_not_open;
+ case F_directory_flush:
+ *string = FL_status_string_directory_flush;
break;
- case F_directory:
- *string = fl_status_string_directory;
+ case F_directory_link_max:
+ *string = FL_status_string_directory_link_max;
break;
- case F_directory_utf_not:
- *string = fl_status_string_directory_not_utf;
+ case F_directory_open:
+ *string = FL_status_string_directory_open;
break;
- case F_directory_unsupported:
- *string = fl_status_string_directory_unsupported;
+ case F_directory_open_not:
+ *string = FL_status_string_directory_open_not;
+ break;
+ case F_directory_purge:
+ *string = FL_status_string_directory_purge;
+ break;
+ case F_directory_read:
+ *string = FL_status_string_directory_read;
break;
case F_directory_stream:
- *string = fl_status_string_directory_stream;
+ *string = FL_status_string_directory_stream;
+ break;
+ case F_directory_synchronize:
+ *string = FL_status_string_directory_synchronize;
+ break;
+ case F_directory_unsupported:
+ *string = FL_status_string_directory_unsupported;
break;
case F_directory_utf:
- *string = fl_status_string_directory_utf;
+ *string = FL_status_string_directory_utf;
break;
- #endif // _di_fl_status_directory_
+ case F_directory_utf_not:
+ *string = FL_status_string_directory_utf_not;
+ break;
+ case F_directory_write:
+ *string = FL_status_string_directory_utf_not;
+ break;
+ #endif // _di_F_status_directory_
- #ifndef _di_fl_status_socket_
- case F_socket_connection_client:
- *string = fl_status_string_socket_connection_client;
+ #ifndef _di_F_status_socket_
+ case F_socket_connect_client:
+ *string = FL_status_string_socket_client;
break;
- case F_socket_connection_target:
- *string = fl_status_string_socket_connection_target;
+ case F_socket_connect_target:
+ *string = FL_status_string_socket_target;
break;
case F_socket_receive:
- *string = fl_status_string_socket_receive;
+ *string = FL_status_string_socket_receive;
break;
case F_socket_send:
- *string = fl_status_string_socket_send;
+ *string = FL_status_string_socket_send;
break;
- #endif // _di_fl_status_socket_
+ #endif // _di_F_status_socket_
- #ifndef _di_fll_error_non_
- case F_than_less:
- *string = fl_status_string_than_less;
- break;
+ #ifndef _di_F_error_compare_
case F_equal_to:
- *string = fl_status_string_equal_to;
+ *string = FL_status_string_equal_to;
break;
case F_equal_to_not:
- *string = fl_status_string_equal_to_not;
+ *string = FL_status_string_equal_to_not;
break;
case F_than_greater:
- *string = fl_status_string_than_greater;
+ *string = FL_status_string_than_greater;
+ break;
+ case F_than_less:
+ *string = FL_status_string_than_less;
break;
- #endif // _di_fl_status_non_
+ #endif // _di_F_status_compare_
- #ifndef _di_fl_status_access_denied_
+ #ifndef _di_F_status_access_denied_
case F_access_denied:
- *string = fl_status_string_access_denied;
+ *string = FL_status_string_access_denied;
break;
case F_access_denied_user:
- *string = fl_status_string_access_denied_user;
+ *string = FL_status_string_access_denied_user;
break;
case F_access_denied_group:
- *string = fl_status_string_access_denied_group;
+ *string = FL_status_string_access_denied_group;
break;
case F_access_denied_world:
- *string = fl_status_string_access_denied_world;
+ *string = FL_status_string_access_denied_world;
break;
case F_access_denied_read:
- *string = fl_status_string_access_denied_read;
+ *string = FL_status_string_access_denied_read;
break;
case F_access_denied_write:
- *string = fl_status_string_access_denied_write;
+ *string = FL_status_string_access_denied_write;
break;
case F_access_denied_execute:
- *string = fl_status_string_access_denied_execute;
+ *string = FL_status_string_access_denied_execute;
break;
case F_access_denied_super:
- *string = fl_status_string_access_denied_super;
+ *string = FL_status_string_access_denied_super;
break;
- #endif // _di_fl_status_access_denied_
+ #endif // _di_F_status_access_denied_
case F_status_code_last:
- *string = fl_status_string_status_code_last;
+ *string = FL_status_string_status_code_last;
break;
default:
extern "C" {
#endif
-#ifndef _di_fl_status_string_
- #ifndef _di_fl_status_booleans_
- #define fl_status_string_false "F_false"
- #define fl_status_string_false_length 7
-
- #define fl_status_string_true "F_true"
- #define fl_status_string_true_length 6
- #endif // _di_fl_status_booleans_
-
- #ifndef _di_fl_status_signals_
- #define fl_status_string_signal_hangup "F_signal_hangup"
- #define fl_status_string_signal_hangup_length 15
-
- #define fl_status_string_signal_interrupt "F_signal_interrupt"
- #define fl_status_string_signal_interrupt_length 18
-
- #define fl_status_string_signal_quit "F_signal_quit"
- #define fl_status_string_signal_quit_length 13
-
- #define fl_status_string_signal_illegal "F_signal_illegal"
- #define fl_status_string_signal_illegal_length 16
-
- #define fl_status_string_signal_trap "F_signal_trap"
- #define fl_status_string_signal_trap_length 13
-
- #define fl_status_string_signal_abort "F_signal_abort"
- #define fl_status_string_signal_abort_length 14
-
- #define fl_status_string_signal_bus_error "F_signal_bus_error"
- #define fl_status_string_signal_bus_error_length 17
-
- #define fl_status_string_signal_floating_point_exception "F_signal_floating_point_exception"
- #define fl_status_string_signal_floating_point_exception_length 33
-
- #define fl_status_string_signal_kill "F_signal_kill"
- #define fl_status_string_signal_kill_length 13
-
- #define fl_status_string_signal_user_1 "F_signal_user_1"
- #define fl_status_string_signal_user_1_length 15
-
- #define fl_status_string_signal_segmentation_fault "F_signal_segmentation_fault"
- #define fl_status_string_signal_segmentation_fault_length 27
-
- #define fl_status_string_signal_user_2 "F_signal_user_2"
- #define fl_status_string_signal_user_2_length 15
-
- #define fl_status_string_signal_broken_pipe "F_signal_broken_pipe"
- #define fl_status_string_signal_broken_pipe_length 20
-
- #define fl_status_string_signal_alarm_clock "F_signal_alarm_clock"
- #define fl_status_string_signal_alarm_clock_length 20
-
- #define fl_status_string_signal_termination "F_signal_termination"
- #define fl_status_string_signal_termination_length 20
-
- #define fl_status_string_signal_stack_fault "F_signal_stack_fault"
- #define fl_status_string_signal_stack_fault_length 20
-
- #define fl_status_string_signal_child "F_signal_child"
- #define fl_status_string_signal_child_length 14
-
- #define fl_status_string_signal_continue "F_signal_continue"
- #define fl_status_string_signal_continue_length 17
-
- #define fl_status_string_signal_stop "F_signal_stop"
- #define fl_status_string_signal_stop_length 13
-
- #define fl_status_string_signal_keyboard_stop "F_signal_keyboard_stop"
- #define fl_status_string_signal_keyboard_stop_length 22
-
- #define fl_status_string_signal_tty_in "F_signal_tty_in"
- #define fl_status_string_signal_tty_in_length 15
-
- #define fl_status_string_signal_tty_out "F_signal_tty_out"
- #define fl_status_string_signal_tty_out_length 16
-
- #define fl_status_string_signal_urgent "F_signal_urgent"
- #define fl_status_string_signal_urgent_length 15
-
- #define fl_status_string_signal_cpu_limit "F_signal_cpu_limit"
- #define fl_status_string_signal_cpu_limit_length 18
-
- #define fl_status_string_signal_file_size_limit "F_signal_file_size_limit"
- #define fl_status_string_signal_file_size_limit_length 24
-
- #define fl_status_string_signal_virtual_alarm_clock "F_signal_virtual_alarm_clock"
- #define fl_status_string_signal_virtual_alarm_clock_length 28
-
- #define fl_status_string_signal_profile_alarm_clock "F_signal_profile_alarm_clock"
- #define fl_status_string_signal_profile_alarm_clock_length 28
-
- #define fl_status_string_signal_window_size_change "F_signal_window_size_change"
- #define fl_status_string_signal_window_size_change_length 27
-
- #define fl_status_string_signal_pollable_event "F_signal_pollable_event"
- #define fl_status_string_signal_pollable_event_length 23
-
- #define fl_status_string_signal_power_failure "F_signal_power_failure"
- #define fl_status_string_signal_power_failure_length 22
-
- #define fl_status_string_signal_bad_system_call "F_signal_bad_system_call"
- #define fl_status_string_signal_bad_system_call_length 24
-
- #define fl_status_string_signal_reserved_32 "F_signal_reserved_32"
- #define fl_status_string_signal_reserved_32_length 20
-
- #define fl_status_string_signal_reserved_33 "F_signal_reserved_33"
- #define fl_status_string_signal_reserved_33_length 20
-
- #define fl_status_string_signal_reserved_34 "F_signal_reserved_34"
- #define fl_status_string_signal_reserved_34_length 20
-
- #define fl_status_string_signal_reserved_35 "F_signal_reserved_35"
- #define fl_status_string_signal_reserved_35_length 20
-
- #define fl_status_string_signal_reserved_36 "F_signal_reserved_36"
- #define fl_status_string_signal_reserved_36_length 20
-
- #define fl_status_string_signal_reserved_37 "F_signal_reserved_37"
- #define fl_status_string_signal_reserved_37_length 20
-
- #define fl_status_string_signal_reserved_38 "F_signal_reserved_38"
- #define fl_status_string_signal_reserved_38_length 20
-
- #define fl_status_string_signal_reserved_39 "F_signal_reserved_39"
- #define fl_status_string_signal_reserved_39_length 20
-
- #define fl_status_string_signal_reserved_40 "F_signal_reserved_40"
- #define fl_status_string_signal_reserved_40_length 20
-
- #define fl_status_string_signal_reserved_41 "F_signal_reserved_41"
- #define fl_status_string_signal_reserved_41_length 20
-
- #define fl_status_string_signal_reserved_42 "F_signal_reserved_42"
- #define fl_status_string_signal_reserved_42_length 20
-
- #define fl_status_string_signal_reserved_43 "F_signal_reserved_43"
- #define fl_status_string_signal_reserved_43_length 20
-
- #define fl_status_string_signal_reserved_44 "F_signal_reserved_44"
- #define fl_status_string_signal_reserved_44_length 20
-
- #define fl_status_string_signal_reserved_45 "F_signal_reserved_45"
- #define fl_status_string_signal_reserved_45_length 20
-
- #define fl_status_string_signal_reserved_46 "F_signal_reserved_46"
- #define fl_status_string_signal_reserved_46_length 20
-
- #define fl_status_string_signal_reserved_47 "F_signal_reserved_47"
- #define fl_status_string_signal_reserved_47_length 20
-
- #define fl_status_string_signal_reserved_48 "F_signal_reserved_48"
- #define fl_status_string_signal_reserved_48_length 20
-
- #define fl_status_string_signal_reserved_49 "F_signal_reserved_49"
- #define fl_status_string_signal_reserved_49_length 20
-
- #define fl_status_string_signal_reserved_50 "F_signal_reserved_50"
- #define fl_status_string_signal_reserved_50_length 20
-
- #define fl_status_string_signal_reserved_51 "F_signal_reserved_51"
- #define fl_status_string_signal_reserved_51_length 20
-
- #define fl_status_string_signal_reserved_52 "F_signal_reserved_52"
- #define fl_status_string_signal_reserved_52_length 20
-
- #define fl_status_string_signal_reserved_53 "F_signal_reserved_53"
- #define fl_status_string_signal_reserved_53_length 20
-
- #define fl_status_string_signal_reserved_54 "F_signal_reserved_54"
- #define fl_status_string_signal_reserved_54_length 20
-
- #define fl_status_string_signal_reserved_55 "F_signal_reserved_55"
- #define fl_status_string_signal_reserved_55_length 20
-
- #define fl_status_string_signal_reserved_56 "F_signal_reserved_56"
- #define fl_status_string_signal_reserved_56_length 20
-
- #define fl_status_string_signal_reserved_57 "F_signal_reserved_57"
- #define fl_status_string_signal_reserved_57_length 20
-
- #define fl_status_string_signal_reserved_58 "F_signal_reserved_58"
- #define fl_status_string_signal_reserved_58_length 20
-
- #define fl_status_string_signal_reserved_59 "F_signal_reserved_59"
- #define fl_status_string_signal_reserved_59_length 20
-
- #define fl_status_string_signal_reserved_60 "F_signal_reserved_60"
- #define fl_status_string_signal_reserved_60_length 20
-
- #define fl_status_string_signal_reserved_61 "F_signal_reserved_61"
- #define fl_status_string_signal_reserved_61_length 20
-
- #define fl_status_string_signal_reserved_62 "F_signal_reserved_62"
- #define fl_status_string_signal_reserved_62_length 20
-
- #define fl_status_string_signal_reserved_63 "F_signal_reserved_63"
- #define fl_status_string_signal_reserved_63_length 20
-
- #define fl_status_string_signal_reserved_64 "F_signal_reserved_64"
- #define fl_status_string_signal_reserved_64_length 20
- #endif // _di_fl_status_signals_
-
- #ifndef _di_fl_status_basic_
- #define fl_status_string_none "F_none"
- #define fl_status_string_none_length 6
-
- #define fl_status_string_maybe "F_maybe"
- #define fl_status_string_maybe_length 7
-
- #define fl_status_string_dummy "F_dummy"
- #define fl_status_string_dummy_length 7
-
- #define fl_status_string_warn "F_warn"
- #define fl_status_string_warn_length 6
-
- #define fl_status_string_block "F_block"
- #define fl_status_string_block_length 7
-
- #define fl_status_string_critical "F_critical"
- #define fl_status_string_critical_length 10
-
- #define fl_status_string_unknown "F_unknown"
- #define fl_status_string_unknown_length 9
-
- #define fl_status_string_unsupported "F_unsupported"
- #define fl_status_string_unsupported_length 13
-
- #define fl_status_string_no_data "F_data_not"
- #define fl_status_string_no_data_length 10
-
- #define fl_status_string_no_space "F_space_not"
- #define fl_status_string_no_space_length 11
-
- #define fl_status_string_bound_out "F_bound_out"
- #define fl_status_string_bound_out_length 11
-
- #define fl_status_string_memory_out "F_memory_out"
- #define fl_status_string_memory_out_length 12
-
- #define fl_status_string_prohibited "F_prohibited"
- #define fl_status_string_prohibited_length 12
-
- #define fl_status_string_read_only "F_read_only"
- #define fl_status_string_read_only_length 11
-
- #define fl_status_string_input "F_input"
- #define fl_status_string_input_length 7
-
- #define fl_status_string_output "F_output"
- #define fl_status_string_output_length 8
-
- #define fl_status_string_input_output "F_input_output"
- #define fl_status_string_input_output_length 14
-
- #define fl_status_string_exist_not "F_exist_not"
- #define fl_status_string_exist_not_length 11
-
- #define fl_status_string_connected_not "F_connected_not"
- #define fl_status_string_connected_not_length 15
-
- #define fl_status_string_failure "F_failure"
- #define fl_status_string_failure_length 9
-
- #define fl_status_string_interrupted "F_interrupted"
- #define fl_status_string_interrupted_length 13
-
- #define fl_status_string_loop "F_loop"
- #define fl_status_string_loop_length 6
-
- #define fl_status_string_incomplete "F_incomplete"
- #define fl_status_string_incomplete_length 12
-
- #define fl_status_string_write_only "F_write_only"
- #define fl_status_string_write_only_length 12
- #endif // _di_fl_status_basic_
-
- #ifndef _di_fl_status_invalid_
- #define fl_status_string_invalid "F_invalid"
- #define fl_status_string_length 9
-
- #define fl_status_string_name "F_name"
- #define fl_status_string_name_length 6
-
- #define fl_status_string_parameter "F_parameter"
- #define fl_status_string_parameter_length 11
-
- #define fl_status_string_syntax "F_syntax"
- #define fl_status_string_syntax_length 8
-
- #define fl_status_string_data "F_data"
- #define fl_status_string_data_length 6
-
- #define fl_status_string_descriptor "F_descriptor"
- #define fl_status_string_descriptor_length 12
-
- #define fl_status_string_socket "F_socket"
- #define fl_status_string_socket_length 8
-
- #define fl_status_string_device "F_device"
- #define fl_status_string_device_length 8
-
- #define fl_status_string_link "F_link"
- #define fl_status_string_link_length 6
-
- #define fl_status_string_pipe "F_pipe"
- #define fl_status_string_pipe_length 6
-
- #define fl_status_string_address "F_address"
- #define fl_status_string_address_length 9
-
- #define fl_status_string_port "F_port"
- #define fl_status_string_port_length 6
-
- #define fl_status_string_value "F_value"
- #define fl_status_string_value_length 7
-
- #define fl_status_string_buffer "F_buffer"
- #define fl_status_string_buffer_length 8
-
- #define fl_status_string_process "F_process"
- #define fl_status_string_process_length 9
-
- #define fl_status_string_utf "F_utf"
- #define fl_status_string_utf_length 5
-
- #define fl_status_string_eof "F_eof"
- #define fl_status_string_eof_length 5
-
- #define fl_status_string_eol "F_eol"
- #define fl_status_string_eol_length 5
-
- #define fl_status_string_eos "F_eos"
- #define fl_status_string_eos_length 5
-
- #define fl_status_string_stop "F_stop"
- #define fl_status_string_stop_length 6
- #endif // _di_fl_status_invalid_
-
- #ifndef _di_fl_status_busy_
- #define fl_status_string_busy "F_busy"
- #define fl_status_string_busy_length 6
-
- #define fl_status_string_busy_address "F_busy_address"
- #define fl_status_string_busy_address_length 14
-
- #define fl_status_string_busy_port "F_busy_port"
- #define fl_status_string_busy_port_length 11
-
- #define fl_status_string_busy_socket "F_busy_socket"
- #define fl_status_string_busy_socket_length 13
-
- #define fl_status_string_busy_device "F_busy_device"
- #define fl_status_string_busy_device_length 13
-
- #define fl_status_string_busy_pipe "F_busy_pipe"
- #define fl_status_string_busy_pipe_length 11
-
- #define fl_status_string_busy_buffer "F_busy_buffer"
- #define fl_status_string_busy_buffer_length 13
-
- #define fl_status_string_busy_process "F_busy_process"
- #define fl_status_string_busy_process_length 14
- #endif // _di_fl_status_busy_
-
- #ifndef _di_fl_status_unavailable_
- #define fl_status_string_unavailable "F_unavailable"
- #define fl_status_string_unavailable_length 13
-
- #define fl_status_string_unavailable_address "F_unavailable_address"
- #define fl_status_string_unavailable_address_length 21
-
- #define fl_status_string_unavailable_port "F_unavailable_port"
- #define fl_status_string_unavailable_port_length 18
-
- #define fl_status_string_unavailable_socket "F_unavailable_socket"
- #define fl_status_string_unavailable_socket_length 20
-
- #define fl_status_string_unavailable_device "F_unavailable_device"
- #define fl_status_string_unavailable_device_length 20
-
- #define fl_status_string_unavailable_pipe "F_unavailable_pipe"
- #define fl_status_string_unavailable_pipe_length 18
-
- #define fl_status_string_unavailable_buffer "F_unavailable_buffer"
- #define fl_status_string_unavailable_buffer_length 20
-
- #define fl_status_string_unavailable_process "F_unavailable_process"
- #define fl_status_string_unavailable_process_length 21
- #endif // _di_fl_status_unavailable_
-
- #ifndef _di_fl_status_digits_
- #define fl_status_string_underflow "F_number_underflow"
- #define fl_status_string_underflow_length 18
-
- #define fl_status_string_overflow "F_number_overflow"
- #define fl_status_string_overflow_length 17
-
- #define fl_status_string_divide_by_zero "F_number_divide_by_zero"
- #define fl_status_string_divide_by_zero_length 23
-
- #define fl_status_string_negative_number "F_number_negative"
- #define fl_status_string_negative_number_length 17
-
- #define fl_status_string_positive_number "F_number_positive"
- #define fl_status_string_positive_number_length 17
-
- #define fl_status_string_zero_number "F_number_zero"
- #define fl_status_string_zero_number_length 13
-
- #define fl_status_string_decimal_number "F_number_decimal"
- #define fl_status_string_decimal_number_length 16
-
- #define fl_status_string_whole_number "F_number_whole"
- #define fl_status_string_whole_number_length 14
-
- #define fl_status_string_number "F_number_invalid"
- #define fl_status_string_number_length 16
- #endif // _di_fl_status_digits_
-
- #ifndef _di_fl_status_buffers_
- #define fl_status_string_data_no_eof "F_data_no_eof"
- #define fl_status_string_data_no_eof_length 13
-
- #define fl_status_string_data_no_eol "F_data_no_eol"
- #define fl_status_string_data_no_eol_length 13
-
- #define fl_status_string_data_no_eos "F_data_no_eos"
- #define fl_status_string_data_no_eos_length 13
-
- #define fl_status_string_none_eof "F_none_eof"
- #define fl_status_string_none_eof_length 10
-
- #define fl_status_string_data_no_stop "F_data_no_stop"
- #define fl_status_string_data_no_stop_length 14
-
- #define fl_status_string_data_no_block "F_data_block_no"
- #define fl_status_string_data_no_block_length 15
-
- #define fl_status_string_none_eol "F_none_eol"
- #define fl_status_string_none_eol_length 10
-
- #define fl_status_string_none_eos "F_none_eos"
- #define fl_status_string_none_eos_length 10
-
- #define fl_status_string_none_stop "F_none_stop"
- #define fl_status_string_none_stop_length 11
-
- #define fl_status_string_none_block "F_none_block"
- #define fl_status_string_none_block_length 12
-
- #define fl_status_string_eof "F_eof"
- #define fl_status_string_eof_length 5
-
- #define fl_status_string_eol "F_eol"
- #define fl_status_string_eol_length 5
-
- #define fl_status_string_error_on_eos "F_eos"
- #define fl_status_string_error_on_eos_length 5
-
- #define fl_status_string_stop "F_stop"
- #define fl_status_string_stop_length 6
-
- #define fl_status_string_block "F_block"
- #define fl_status_string_block_length 7
-
- #define fl_status_string_buffer_too_small "F_buffer_too_small"
- #define fl_status_string_buffer_too_small_length 18
-
- #define fl_status_string_buffer_too_large "F_buffer_too_large"
- #define fl_status_string_buffer_too_large_length 18
-
- #define fl_status_string_string_too_small "F_string_too_small"
- #define fl_status_string_string_too_small_length 18
-
- #define fl_status_string_string_too_large "F_string_too_large"
- #define fl_status_string_string_too_large_length 18
-
- #define fl_status_string_unterminated "F_unterminated"
- #define fl_status_string_unterminated_length 14
-
- #define fl_status_string_unterminated_eof "F_unterminated_eof"
- #define fl_status_string_unterminated_eof_length 18
-
- #define fl_status_string_unterminated_eol "F_unterminated_eol"
- #define fl_status_string_unterminated_eol_length 18
-
- #define fl_status_string_unterminated_eos "F_unterminated_eos"
- #define fl_status_string_unterminated_eos_length 18
-
- #define fl_status_string_unterminated_stop "F_unterminated_stop"
- #define fl_status_string_unterminated_stop_length 19
-
- #define fl_status_string_unterminated_block "F_unterminated_block"
- #define fl_status_string_unterminated_block_length 20
-
- #define fl_status_string_unterminated_group "F_unterminated_group"
- #define fl_status_string_unterminated_group_length 20
-
- #define fl_status_string_unterminated_group_on_eof "F_unterminated_group_eof"
- #define fl_status_string_unterminated_group_on_eof_length 24
-
- #define fl_status_string_unterminated_group_on_eol "F_unterminated_group_eol"
- #define fl_status_string_unterminated_group_on_eol_length 24
-
- #define fl_status_string_unterminated_group_on_eos "F_unterminated_group_eos"
- #define fl_status_string_unterminated_group_on_eos_length 24
-
- #define fl_status_string_unterminated_group_on_stop "F_unterminated_group_stop"
- #define fl_status_string_unterminated_group_on_stop_length 25
-
- #define fl_status_string_unterminated_group_on_block "F_unterminated_group_block"
- #define fl_status_string_unterminated_group_on_block_length 26
-
- #define fl_status_string_unterminated_nest "F_unterminated_nest"
- #define fl_status_string_unterminated_nest_length 19
-
- #define fl_status_string_unterminated_nest_eof "F_unterminated_nest_eof"
- #define fl_status_string_unterminated_nest_eof_length 23
-
- #define fl_status_string_unterminated_nest_eol "F_unterminated_nest_eol"
- #define fl_status_string_unterminated_nest_eol_length 23
-
- #define fl_status_string_unterminated_nest_eos "F_unterminated_nest_eos"
- #define fl_status_string_unterminated_nest_eos_length 23
-
- #define fl_status_string_unterminated_nest_stop "F_unterminated_nest_stop"
- #define fl_status_string_unterminated_nest_stop_length 24
-
- #define fl_status_string_unterminated_nest_block "F_unterminated_nest_block"
- #define fl_status_string_unterminated_nest_block_length 25
-
- #define fl_status_string_incomplete_utf "F_incomplete_utf"
- #define fl_status_string_incomplete_utf_length 16
-
- #define fl_status_string_incomplete_utf_on_eof "F_incomplete_utf_eof"
- #define fl_status_string_incomplete_utf_on_eof_length 20
-
- #define fl_status_string_incomplete_utf_on_eol "F_incomplete_utf_eol"
- #define fl_status_string_incomplete_utf_on_eol_length 20
-
- #define fl_status_string_incomplete_utf_on_eos "F_incomplete_utf_eos"
- #define fl_status_string_incomplete_utf_on_eos_length 20
-
- #define fl_status_string_incomplete_utf_on_stop "F_incomplete_utf_stop"
- #define fl_status_string_incomplete_utf_on_stop_length 21
-
- #define fl_status_string_incomplete_utf_on_block "F_incomplete_utf_block"
- #define fl_status_string_incomplete_utf_on_block_length 22
- #endif // _di_fl_status_buffers_
-
- #ifndef _di_fl_status_allocation_
- #define fl_status_string_memory_allocation "F_memory_allocation"
- #define fl_status_string_memory_deallocation "F_memory_deallocation"
- #define fl_status_string_memory_reallocation "F_memory_reallocation"
-
- #define fl_status_string_memory_allocation_length 19
- #define fl_status_string_memory_deallocation_length 21
- #define fl_status_string_memory_reallocation_length 21
-
- #endif // _di_fl_status_allocation_
-
- #ifndef _di_fl_status_fork_
- #define fl_status_string_fork "F_fork"
- #define fl_status_string_process_too_many "F_process_too_many"
-
- #define fl_status_string_fork_length 6
- #define fl_status_string_process_too_many_length 20
- #endif // _di_fl_status_fork_
-
- #ifndef _di_fl_status_file_
- #define fl_status_string_file "F_file"
- #define fl_status_string_file_length 6
-
- #define fl_status_string_file_closed "F_file_closed"
- #define fl_status_string_file_closed_length 13
-
- #define fl_status_string_file_seek "F_file_seek"
- #define fl_status_string_file_seek_length 11
-
- #define fl_status_string_file_read "F_file_read"
- #define fl_status_string_file_read_length 11
-
- #define fl_status_string_file_write "F_file_write"
- #define fl_status_string_file_write_length 12
-
- #define fl_status_string_file_flush "F_file_flush"
- #define fl_status_string_file_flush_length 12
-
- #define fl_status_string_file_purge "F_file_purge"
- #define fl_status_string_file_purge_length 12
-
- #define fl_status_string_file_open "F_file_open"
- #define fl_status_string_file_open_length 11
-
- #define fl_status_string_file_close "F_file_close"
- #define fl_status_string_file_close_length 12
-
- #define fl_status_string_file_synchronize "F_file_synchronize"
- #define fl_status_string_file_synchronize_length 18
-
- #define fl_status_string_file_descriptor "F_file_descriptor"
- #define fl_status_string_file_descriptor_length 17
-
- #define fl_status_string_file_found_not "F_file_found_not"
- #define fl_status_string_file_found_not_length 16
-
- #define fl_status_string_file_empty "F_file_empty"
- #define fl_status_string_file_empty_length 12
-
- #define fl_status_string_file_found "F_file_found"
- #define fl_status_string_file_found_length 12
-
- #define fl_status_string_file_type_block "F_file_type_block"
- #define fl_status_string_file_type_block_length 17
-
- #define fl_status_string_file_type_character "F_file_type_character"
- #define fl_status_string_file_type_character_length 21
-
- #define fl_status_string_file_type_directory "F_file_type_directory"
- #define fl_status_string_file_type_directory_length 21
-
- #define fl_status_string_file_type_file "F_file_type_file"
- #define fl_status_string_file_type_file_length 16
-
- #define fl_status_string_file_type_link "F_file_type_link"
- #define fl_status_string_file_type_link_length 16
-
- #define fl_status_string_file_type_pipe "F_file_type_pipe"
- #define fl_status_string_file_type_pipe_length 16
-
- #define fl_status_string_file_type_socket "F_file_type_socket"
- #define fl_status_string_file_type_socket_length 18
-
- #define fl_status_string_file_type_unknown "F_file_type_unknown"
- #define fl_status_string_file_type_unknown_length 19
-
- #define fl_status_string_file_open_not "F_file_open_not"
- #define fl_status_string_file_open_not_length 15
-
- #define fl_status_string_file_type_not_block "F_file_type_not_block"
- #define fl_status_string_file_type_not_block_length 21
-
- #define fl_status_string_file_type_not_character "F_file_type_not_character"
- #define fl_status_string_file_type_not_character_length 25
-
- #define fl_status_string_file_not_type_directory "F_file_type_not_directory"
- #define fl_status_string_file_not_type_directory_length 25
-
- #define fl_status_string_file_not_type_file "F_file_type_not_file"
- #define fl_status_string_file_not_type_file_length 20
-
- #define fl_status_string_file_not_type_link "F_file_type_not_link"
- #define fl_status_string_file_not_type_link_length 20
-
- #define fl_status_string_file_not_type_pipe "F_file_type_not_pipe"
- #define fl_status_string_file_not_type_pipe_length 20
-
- #define fl_status_string_file_not_type_socket "F_file_type_not_socket"
- #define fl_status_string_file_not_type_socket_length 22
-
- #define fl_status_string_file_not_type_unknown "F_file_type_not_unknown"
- #define fl_status_string_file_not_type_unknown_length 23
-
- #define fl_status_string_file_allocation "F_file_allocation"
- #define fl_status_string_file_allocation_length 17
-
- #define fl_status_string_file_reallocation "F_file_reallocation"
- #define fl_status_string_file_reallocation_length 19
-
- #define fl_status_string_file_deallocation "F_file_deallocation"
- #define fl_status_string_file_deallocation_length 19
-
- #define fl_status_string_file_stat "F_file_stat"
- #define fl_status_string_file_stat_length 11
-
- #define fl_status_string_file_not_utf "F_file_not_utf"
- #define fl_status_string_file_not_utf_length 14
-
- #define fl_status_string_file_descriptors_max "F_file_descriptors_max"
- #define fl_status_string_file_descriptors_max_length 22
-
- #define fl_status_string_file_open_max "F_file_open_max"
- #define fl_status_string_file_open_max_length 15
-
- #define fl_status_string_file_utf "F_file_utf"
- #define fl_status_string_file_utf_length 10
- #endif // _di_fl_status_file_
-
- #ifndef _di_f_status_filesystem_
- #define fl_status_string_filesystem_error "F_filesystem"
- #define fl_status_string_filesystem_error_length 18
-
- #define fl_status_string_filesystem_quota_blocks "F_filesystem_quota_blocks"
- #define fl_status_string_filesystem_quota_blocks_length 25
-
- #define fl_status_string_filesystem_quota_reached "F_filesystem_quota_reached"
- #define fl_status_string_filesystem_quota_reached_length 26
- #endif // _di_f_status_filesystem_
-
- #ifndef _di_fl_status_directory_
- #define fl_status_string_directory_closed "F_directory_closed"
- #define fl_status_string_directory_closed_length 18
-
- #define fl_status_string_directory_read "F_directory_read"
- #define fl_status_string_directory_read_length 16
-
- #define fl_status_string_directory_write "F_directory_write"
- #define fl_status_string_directory_write_length 17
-
- #define fl_status_string_directory_flush "F_directory_flush"
- #define fl_status_string_directory_flush_length 17
-
- #define fl_status_string_directory_link_max "F_directory_link_max"
- #define fl_status_string_directory_link_max_length 20
-
- #define fl_status_string_directory_purge "F_directory_purge"
- #define fl_status_string_directory_purge_length 17
-
- #define fl_status_string_directory_open "F_directory_open"
- #define fl_status_string_directory_open_length 16
-
- #define fl_status_string_directory_close "F_directory_close"
- #define fl_status_string_directory_close_length 17
-
- #define fl_status_string_directory_synchronize "F_directory_synchronize"
- #define fl_status_string_directory_synchronize_length 23
-
- #define fl_status_string_directory_descriptor "F_directory_descriptor"
- #define fl_status_string_directory_descriptor_length 22
-
- #define fl_status_string_directory_empty "F_directory_empty"
- #define fl_status_string_directory_empty_length 17
-
- #define fl_status_string_directory_found "F_directory_found"
- #define fl_status_string_directory_found_length 17
-
- #define fl_status_string_directory_not_found "F_directory_not_found"
- #define fl_status_string_directory_not_found_length 21
-
- #define fl_status_string_directory_not_open "F_directory_not_open"
- #define fl_status_string_directory_not_open_length 20
-
- #define fl_status_string_directory "F_directory"
- #define fl_status_string_directory_length 11
-
- #define fl_status_string_directory_not_utf "F_directory_utf_not"
- #define fl_status_string_directory_not_utf_length 19
-
- #define fl_status_string_directory_unsupported "F_directory_unsupported"
- #define fl_status_string_directory_unsupported_length 23
-
- #define fl_status_string_directory_stream "F_directory_stream"
- #define fl_status_string_directory_stream_length 18
-
- #define fl_status_string_directory_utf "F_directory_utf"
- #define fl_status_string_directory_utf_length 15
- #endif // _di_fl_status_directory_
-
- #ifndef _di_fl_status_socket_
- #define fl_status_string_socket_connection_client "F_socket_connection_client"
- #define fl_status_string_socket_connection_client_length 26
-
- #define fl_status_string_socket_connection_target "F_socket_connection_target"
- #define fl_status_string_socket_connection_target_length 26
-
- #define fl_status_string_socket_receive "F_socket_receive"
- #define fl_status_string_socket_receive_length 16
-
- #define fl_status_string_socket_send "F_socket_send"
- #define fl_status_string_socket_send_length 13
- #endif // _di_fl_status_socket_
-
- #ifndef _di_fl_status_non_
- #define fl_status_string_than_less "F_than_less"
- #define fl_status_string_than_less_length 11
-
- #define fl_status_string_equal_to "F_equal_to"
- #define fl_status_string_equal_to_length 10
-
- #define fl_status_string_equal_to_not "F_equal_to_not"
- #define fl_status_string_equal_to_not_length 14
-
- #define fl_status_string_than_greater "F_than_greater"
- #define fl_status_string_than_greater_length 14
- #endif // _di_fl_status_non_
-
- #ifndef _di_fl_status_access_denied_
- #define fl_status_string_access_denied "F_access_denied"
- #define fl_status_string_access_denied_length 15
-
- #define fl_status_string_access_denied_user "F_access_denied_user"
- #define fl_status_string_access_denied_user_length 20
-
- #define fl_status_string_access_denied_group "F_access_denied_group"
- #define fl_status_string_access_denied_group_length 21
-
- #define fl_status_string_access_denied_world "F_access_denied_world"
- #define fl_status_string_access_denied_world_length 21
-
- #define fl_status_string_access_denied_read "F_access_denied_read"
- #define fl_status_string_access_denied_read_length 20
-
- #define fl_status_string_access_denied_write "F_access_denied_write"
- #define fl_status_string_access_denied_write_length 21
-
- #define fl_status_string_access_denied_execute "F_access_denied_execute"
- #define fl_status_string_access_denied_execute_length 23
-
- #define fl_status_string_access_denied_super "F_access_denied_super"
- #define fl_status_string_access_denied_super_length 21
- #endif // _di_fl_status_access_denied_
-
- #define fl_status_string_status_code_last "F_status_code_last"
- #define fl_status_string_status_code_last_length 17
-#endif // _di_fl_status_string_
+#ifndef _di_FL_status_string_
+ #ifndef _di_F_status_boolean_
+ #define FL_status_string_false "F_false"
+ #define FL_status_string_true "F_true"
+
+ #define FL_status_string_false_length 7
+ #define FL_status_string_true_length 6
+ #endif // _di_F_status_boolean_
+
+ #ifndef _di_F_status_signal_
+ #define FL_status_string_signal_hangup "F_signal_hangup"
+ #define FL_status_string_signal_interrupt "F_signal_interrupt"
+ #define FL_status_string_signal_quit "F_signal_quit"
+ #define FL_status_string_signal_illegal "F_signal_illegal"
+ #define FL_status_string_signal_trap "F_signal_trap"
+ #define FL_status_string_signal_abort "F_signal_abort"
+ #define FL_status_string_signal_bus_error "F_signal_bus_error"
+ #define FL_status_string_signal_floating_point_error "F_signal_floating_point_error"
+ #define FL_status_string_signal_kill "F_signal_kill"
+ #define FL_status_string_signal_user_1 "F_signal_user_1"
+ #define FL_status_string_signal_segmentation_fault "F_signal_segmentation_fault"
+ #define FL_status_string_signal_user_2 "F_signal_user_2"
+ #define FL_status_string_signal_broken_pipe "F_signal_broken_pipe"
+ #define FL_status_string_signal_alarm_clock "F_signal_alarm_clock"
+ #define FL_status_string_signal_termination "F_signal_termination"
+ #define FL_status_string_signal_stack_fault "F_signal_stack_fault"
+ #define FL_status_string_signal_child "F_signal_child"
+ #define FL_status_string_signal_continue "F_signal_continue"
+ #define FL_status_string_signal_stop "F_signal_stop"
+ #define FL_status_string_signal_keyboard_stop "F_signal_keyboard_stop"
+ #define FL_status_string_signal_tty_in "F_signal_tty_in"
+ #define FL_status_string_signal_tty_out "F_signal_tty_out"
+ #define FL_status_string_signal_urgent "F_signal_urgent"
+ #define FL_status_string_signal_cpu_limit "F_signal_cpu_limit"
+ #define FL_status_string_signal_file_size_limit "F_signal_file_size_limit"
+ #define FL_status_string_signal_virtual_alarm_clock "F_signal_virtual_alarm_clock"
+ #define FL_status_string_signal_profile_alarm_clock "F_signal_profile_alarm_clock"
+ #define FL_status_string_signal_window_size_change "F_signal_window_size_change"
+ #define FL_status_string_signal_pollable_event "F_signal_pollable_event"
+ #define FL_status_string_signal_power_failure "F_signal_power_failure"
+ #define FL_status_string_signal_bad_system_call "F_signal_bad_system_call"
+ #define FL_status_string_signal_reserved_32 "F_signal_reserved_32"
+ #define FL_status_string_signal_reserved_33 "F_signal_reserved_33"
+ #define FL_status_string_signal_reserved_34 "F_signal_reserved_34"
+ #define FL_status_string_signal_reserved_35 "F_signal_reserved_35"
+ #define FL_status_string_signal_reserved_36 "F_signal_reserved_36"
+ #define FL_status_string_signal_reserved_37 "F_signal_reserved_37"
+ #define FL_status_string_signal_reserved_38 "F_signal_reserved_38"
+ #define FL_status_string_signal_reserved_39 "F_signal_reserved_39"
+ #define FL_status_string_signal_reserved_40 "F_signal_reserved_40"
+ #define FL_status_string_signal_reserved_41 "F_signal_reserved_41"
+ #define FL_status_string_signal_reserved_42 "F_signal_reserved_42"
+ #define FL_status_string_signal_reserved_43 "F_signal_reserved_43"
+ #define FL_status_string_signal_reserved_44 "F_signal_reserved_44"
+ #define FL_status_string_signal_reserved_45 "F_signal_reserved_45"
+ #define FL_status_string_signal_reserved_46 "F_signal_reserved_46"
+ #define FL_status_string_signal_reserved_47 "F_signal_reserved_47"
+ #define FL_status_string_signal_reserved_48 "F_signal_reserved_48"
+ #define FL_status_string_signal_reserved_49 "F_signal_reserved_49"
+ #define FL_status_string_signal_reserved_50 "F_signal_reserved_50"
+ #define FL_status_string_signal_reserved_51 "F_signal_reserved_51"
+ #define FL_status_string_signal_reserved_52 "F_signal_reserved_52"
+ #define FL_status_string_signal_reserved_53 "F_signal_reserved_53"
+ #define FL_status_string_signal_reserved_54 "F_signal_reserved_54"
+ #define FL_status_string_signal_reserved_55 "F_signal_reserved_55"
+ #define FL_status_string_signal_reserved_56 "F_signal_reserved_56"
+ #define FL_status_string_signal_reserved_57 "F_signal_reserved_57"
+ #define FL_status_string_signal_reserved_58 "F_signal_reserved_58"
+ #define FL_status_string_signal_reserved_59 "F_signal_reserved_59"
+ #define FL_status_string_signal_reserved_60 "F_signal_reserved_60"
+ #define FL_status_string_signal_reserved_61 "F_signal_reserved_61"
+ #define FL_status_string_signal_reserved_62 "F_signal_reserved_62"
+ #define FL_status_string_signal_reserved_63 "F_signal_reserved_63"
+ #define FL_status_string_signal_reserved_64 "F_signal_reserved_64"
+
+ #define FL_status_string_signal_hangup_length 15
+ #define FL_status_string_signal_interrupt_length 18
+ #define FL_status_string_signal_quit_length 13
+ #define FL_status_string_signal_illegal_length 16
+ #define FL_status_string_signal_trap_length 13
+ #define FL_status_string_signal_abort_length 14
+ #define FL_status_string_signal_bus_error_length 17
+ #define FL_status_string_signal_floating_point_error_length 33
+ #define FL_status_string_signal_kill_length 13
+ #define FL_status_string_signal_user_1_length 15
+ #define FL_status_string_signal_segmentation_fault_length 27
+ #define FL_status_string_signal_user_2_length 15
+ #define FL_status_string_signal_broken_pipe_length 20
+ #define FL_status_string_signal_alarm_clock_length 20
+ #define FL_status_string_signal_termination_length 20
+ #define FL_status_string_signal_stack_fault_length 20
+ #define FL_status_string_signal_child_length 14
+ #define FL_status_string_signal_continue_length 17
+ #define FL_status_string_signal_stop_length 13
+ #define FL_status_string_signal_keyboard_stop_length 22
+ #define FL_status_string_signal_tty_in_length 15
+ #define FL_status_string_signal_tty_out_length 16
+ #define FL_status_string_signal_urgent_length 15
+ #define FL_status_string_signal_cpu_limit_length 18
+ #define FL_status_string_signal_file_size_limit_length 24
+ #define FL_status_string_signal_virtual_alarm_clock_length 28
+ #define FL_status_string_signal_profile_alarm_clock_length 28
+ #define FL_status_string_signal_window_size_change_length 27
+ #define FL_status_string_signal_pollable_event_length 23
+ #define FL_status_string_signal_power_failure_length 22
+ #define FL_status_string_signal_bad_system_call_length 24
+ #define FL_status_string_signal_reserved_32_length 20
+ #define FL_status_string_signal_reserved_33_length 20
+ #define FL_status_string_signal_reserved_34_length 20
+ #define FL_status_string_signal_reserved_35_length 20
+ #define FL_status_string_signal_reserved_36_length 20
+ #define FL_status_string_signal_reserved_37_length 20
+ #define FL_status_string_signal_reserved_38_length 20
+ #define FL_status_string_signal_reserved_39_length 20
+ #define FL_status_string_signal_reserved_40_length 20
+ #define FL_status_string_signal_reserved_41_length 20
+ #define FL_status_string_signal_reserved_42_length 20
+ #define FL_status_string_signal_reserved_43_length 20
+ #define FL_status_string_signal_reserved_44_length 20
+ #define FL_status_string_signal_reserved_45_length 20
+ #define FL_status_string_signal_reserved_46_length 20
+ #define FL_status_string_signal_reserved_47_length 20
+ #define FL_status_string_signal_reserved_48_length 20
+ #define FL_status_string_signal_reserved_49_length 20
+ #define FL_status_string_signal_reserved_50_length 20
+ #define FL_status_string_signal_reserved_51_length 20
+ #define FL_status_string_signal_reserved_52_length 20
+ #define FL_status_string_signal_reserved_53_length 20
+ #define FL_status_string_signal_reserved_54_length 20
+ #define FL_status_string_signal_reserved_55_length 20
+ #define FL_status_string_signal_reserved_56_length 20
+ #define FL_status_string_signal_reserved_57_length 20
+ #define FL_status_string_signal_reserved_58_length 20
+ #define FL_status_string_signal_reserved_59_length 20
+ #define FL_status_string_signal_reserved_60_length 20
+ #define FL_status_string_signal_reserved_61_length 20
+ #define FL_status_string_signal_reserved_62_length 20
+ #define FL_status_string_signal_reserved_63_length 20
+ #define FL_status_string_signal_reserved_64_length 20
+ #endif // _di_F_status_signal_
+
+ #ifndef _di_F_status_basic_
+ #define FL_status_string_none "F_none"
+ #define FL_status_string_address "F_address"
+ #define FL_status_string_block "F_block"
+ #define FL_status_string_bound_out "F_bound_out"
+ #define FL_status_string_connected_not "F_connected_not"
+ #define FL_status_string_critical "F_critical"
+ #define FL_status_string_descriptor "F_descriptor"
+ #define FL_status_string_device "F_device"
+ #define FL_status_string_dummy "F_dummy"
+ #define FL_status_string_eof "F_eof"
+ #define FL_status_string_eol "F_eol"
+ #define FL_status_string_eos "F_eos"
+ #define FL_status_string_exist_not "F_exist_not"
+ #define FL_status_string_failure "F_failure"
+ #define FL_status_string_fork "F_fork"
+ #define FL_status_string_incomplete "F_incomplete"
+ #define FL_status_string_input "F_input"
+ #define FL_status_string_input_output "F_input_output"
+ #define FL_status_string_interrupted "F_interrupted"
+ #define FL_status_string_invalid "F_invalid"
+ #define FL_status_string_output "F_output"
+ #define FL_status_string_link "F_link"
+ #define FL_status_string_loop "F_loop"
+ #define FL_status_string_maybe "F_maybe"
+ #define FL_status_string_memory_out "F_memory_out"
+ #define FL_status_string_name "F_name"
+ #define FL_status_string_parameter "F_parameter"
+ #define FL_status_string_pipe "F_pipe"
+ #define FL_status_string_port "F_port"
+ #define FL_status_string_process "F_process"
+ #define FL_status_string_process_too_many "F_process_too_many"
+ #define FL_status_string_prohibited "F_prohibited"
+ #define FL_status_string_read_only "F_read_only"
+ #define FL_status_string_socket "F_socket"
+ #define FL_status_string_space_not "F_space_not"
+ #define FL_status_string_stop "F_stop"
+ #define FL_status_string_syntax "F_syntax"
+ #define FL_status_string_unknown "F_unknown"
+ #define FL_status_string_unsupported "F_unsupported"
+ #define FL_status_string_utf "F_utf"
+ #define FL_status_string_value "F_value"
+ #define FL_status_string_warn "F_warn"
+ #define FL_status_string_write_only "F_write_only"
+
+ #define FL_status_string_none_length 6
+ #define FL_status_string_address_length 9
+ #define FL_status_string_block_length 7
+ #define FL_status_string_bound_out_length 11
+ #define FL_status_string_connected_not_length 15
+ #define FL_status_string_critical_length 10
+ #define FL_status_string_descriptor_length 12
+ #define FL_status_string_device_length 8
+ #define FL_status_string_dummy_length 7
+ #define FL_status_string_eof_length 5
+ #define FL_status_string_eol_length 5
+ #define FL_status_string_eos_length 5
+ #define FL_status_string_exist_not_length 11
+ #define FL_status_string_failure_length 9
+ #define FL_status_string_fork_length 6
+ #define FL_status_string_incomplete_length 12
+ #define FL_status_string_input_length 7
+ #define FL_status_string_input_output_length 14
+ #define FL_status_string_interrupted_length 13
+ #define FL_status_string_invalid_length 9
+ #define FL_status_string_output_length 8
+ #define FL_status_string_link_length 6
+ #define FL_status_string_loop_length 6
+ #define FL_status_string_maybe_length 7
+ #define FL_status_string_memory_out_length 12
+ #define FL_status_string_name_length 6
+ #define FL_status_string_parameter_length 11
+ #define FL_status_string_pipe_length 6
+ #define FL_status_string_port_length 6
+ #define FL_status_string_process_length 9
+ #define FL_status_string_process_too_many_length 18
+ #define FL_status_string_prohibited_length 12
+ #define FL_status_string_read_only_length 11
+ #define FL_status_string_socket_length 8
+ #define FL_status_string_space_not_length 11
+ #define FL_status_string_stop_length 6
+ #define FL_status_string_syntax_length 8
+ #define FL_status_string_unknown_length 9
+ #define FL_status_string_unsupported_length 13
+ #define FL_status_string_utf_length 5
+ #define FL_status_string_value_length 7
+ #define FL_status_string_warn_length 6
+ #define FL_status_string_write_only_length 12
+ #endif // _di_F_status_basic_
+
+ #ifndef _di_F_status_busy_
+ #define FL_status_string_busy "F_busy"
+ #define FL_status_string_busy_address "F_busy_address"
+ #define FL_status_string_busy_buffer "F_busy_buffer"
+ #define FL_status_string_busy_device "F_busy_device"
+ #define FL_status_string_busy_pipe "F_busy_pipe"
+ #define FL_status_string_busy_port "F_busy_port"
+ #define FL_status_string_busy_process "F_busy_process"
+ #define FL_status_string_busy_socket "F_busy_socket"
+
+ #define FL_status_string_busy_length 6
+ #define FL_status_string_busy_address_length 14
+ #define FL_status_string_busy_buffer_length 13
+ #define FL_status_string_busy_device_length 13
+ #define FL_status_string_busy_pipe_length 11
+ #define FL_status_string_busy_port_length 11
+ #define FL_status_string_busy_process_length 14
+ #define FL_status_string_busy_socket_length 13
+ #endif // _di_F_status_busy_
+
+ #ifndef _di_F_status_unavailable_
+ #define FL_status_string_unavailable "F_unavailable"
+ #define FL_status_string_unavailable_address "F_unavailable_address"
+ #define FL_status_string_unavailable_buffer "F_unavailable_buffer"
+ #define FL_status_string_unavailable_device "F_unavailable_device"
+ #define FL_status_string_unavailable_pipe "F_unavailable_pipe"
+ #define FL_status_string_unavailable_port "F_unavailable_port"
+ #define FL_status_string_unavailable_process "F_unavailable_process"
+ #define FL_status_string_unavailable_socket "F_unavailable_socket"
+
+ #define FL_status_string_unavailable_length 13
+ #define FL_status_string_unavailable_address_length 21
+ #define FL_status_string_unavailable_buffer_length 20
+ #define FL_status_string_unavailable_device_length 20
+ #define FL_status_string_unavailable_pipe_length 18
+ #define FL_status_string_unavailable_port_length 18
+ #define FL_status_string_unavailable_process_length 21
+ #define FL_status_string_unavailable_socket_length 20
+ #endif // _di_F_status_unavailable_
+
+ #ifndef _di_F_status_number_
+ #define FL_status_string_number "F_number"
+ #define FL_status_string_number_decimal "F_number_decimal"
+ #define FL_status_string_number_divide_by_zero "F_number_divide_by_zero"
+ #define FL_status_string_number_negative "F_number_negative"
+ #define FL_status_string_number_overflow "F_number_overflow"
+ #define FL_status_string_number_positive "F_number_positive"
+ #define FL_status_string_number_underflow "F_number_underflow"
+ #define FL_status_string_number_whole "F_number_whole"
+ #define FL_status_string_number_zero "F_number_zero"
+
+ #define FL_status_string_number_length 8
+ #define FL_status_string_number_decimal_length 16
+ #define FL_status_string_number_divide_by_zero_length 23
+ #define FL_status_string_number_negative_length 17
+ #define FL_status_string_number_overflow_length 17
+ #define FL_status_string_number_positive_length 17
+ #define FL_status_string_number_underflow_length 18
+ #define FL_status_string_number_whole_length 14
+ #define FL_status_string_number_zero_length 13
+ #endif // _di_F_status_number_
+
+ #ifndef _di_F_status_buffer_
+ #define FL_status_string_buffer "F_buffer"
+ #define FL_status_string_buffer_too_small "F_buffer_too_small"
+ #define FL_status_string_buffer_too_large "F_buffer_too_large"
+ #define FL_status_string_incomplete_utf "F_incomplete_utf"
+ #define FL_status_string_incomplete_utf_block "F_incomplete_utf_block"
+ #define FL_status_string_incomplete_utf_eof "F_incomplete_utf_eof"
+ #define FL_status_string_incomplete_utf_eol "F_incomplete_utf_eol"
+ #define FL_status_string_incomplete_utf_eos "F_incomplete_utf_eos"
+ #define FL_status_string_incomplete_utf_stop "F_incomplete_utf_stop"
+ #define FL_status_string_none_block "F_none_block"
+ #define FL_status_string_none_eof "F_none_eof"
+ #define FL_status_string_none_eol "F_none_eol"
+ #define FL_status_string_none_eos "F_none_eos"
+ #define FL_status_string_none_stop "F_none_stop"
+ #define FL_status_string_data "F_data"
+ #define FL_status_string_data_not "F_data_not"
+ #define FL_status_string_data_not_block "F_data_not_block"
+ #define FL_status_string_data_not_eof "F_data_not_eof"
+ #define FL_status_string_data_not_eol "F_data_not_eol"
+ #define FL_status_string_data_not_eos "F_data_not_eos"
+ #define FL_status_string_data_not_stop "F_data_not_stop"
+ #define FL_status_string_string_too_small "F_string_too_small"
+ #define FL_status_string_string_too_large "F_string_too_large"
+ #define FL_status_string_unterminated "F_unterminated"
+ #define FL_status_string_unterminated_block "F_unterminated_block"
+ #define FL_status_string_unterminated_eof "F_unterminated_eof"
+ #define FL_status_string_unterminated_eol "F_unterminated_eol"
+ #define FL_status_string_unterminated_eos "F_unterminated_eos"
+ #define FL_status_string_unterminated_stop "F_unterminated_stop"
+ #define FL_status_string_unterminated_group "F_unterminated_group"
+ #define FL_status_string_unterminated_group_block "F_unterminated_group_block"
+ #define FL_status_string_unterminated_group_eof "F_unterminated_group_eof"
+ #define FL_status_string_unterminated_group_eol "F_unterminated_group_eol"
+ #define FL_status_string_unterminated_group_eos "F_unterminated_group_eos"
+ #define FL_status_string_unterminated_group_stop "F_unterminated_group_stop"
+ #define FL_status_string_unterminated_nest "F_unterminated_nest"
+ #define FL_status_string_unterminated_nest_block "F_unterminated_nest_block"
+ #define FL_status_string_unterminated_nest_eof "F_unterminated_nest_eof"
+ #define FL_status_string_unterminated_nest_eol "F_unterminated_nest_eol"
+ #define FL_status_string_unterminated_nest_eos "F_unterminated_nest_eos"
+ #define FL_status_string_unterminated_nest_stop "F_unterminated_nest_stop"
+
+ #define FL_status_string_buffer_length 8
+ #define FL_status_string_buffer_too_small_length 18
+ #define FL_status_string_buffer_too_large_length 18
+ #define FL_status_string_incomplete_utf_length 16
+ #define FL_status_string_incomplete_utf_block_length 22
+ #define FL_status_string_incomplete_utf_eof_length 20
+ #define FL_status_string_incomplete_utf_eol_length 20
+ #define FL_status_string_incomplete_utf_eos_length 20
+ #define FL_status_string_incomplete_utf_stop_length 21
+ #define FL_status_string_none_block_length 12
+ #define FL_status_string_none_eof_length 10
+ #define FL_status_string_none_eol_length 10
+ #define FL_status_string_none_eos_length 10
+ #define FL_status_string_none_stop_length 11
+ #define FL_status_string_data_length 6
+ #define FL_status_string_data_not_length 10
+ #define FL_status_string_data_not_block_length 16
+ #define FL_status_string_data_not_eof_length 14
+ #define FL_status_string_data_not_eol_length 14
+ #define FL_status_string_data_not_eos_length 14
+ #define FL_status_string_data_not_stop_length 15
+ #define FL_status_string_string_too_small_length 18
+ #define FL_status_string_string_too_large_length 18
+ #define FL_status_string_unterminated_length 14
+ #define FL_status_string_unterminated_block_length 20
+ #define FL_status_string_unterminated_eof_length 18
+ #define FL_status_string_unterminated_eol_length 18
+ #define FL_status_string_unterminated_eos_length 18
+ #define FL_status_string_unterminated_stop_length 19
+ #define FL_status_string_unterminated_group_length 20
+ #define FL_status_string_unterminated_group_block_length 26
+ #define FL_status_string_unterminated_group_eof_length 23
+ #define FL_status_string_unterminated_group_eol_length 23
+ #define FL_status_string_unterminated_group_eos_length 23
+ #define FL_status_string_unterminated_group_stop_length 24
+ #define FL_status_string_unterminated_nest_length 19
+ #define FL_status_string_unterminated_nest_block_length 24
+ #define FL_status_string_unterminated_nest_eof_length 23
+ #define FL_status_string_unterminated_nest_eol_length 23
+ #define FL_status_string_unterminated_nest_eos_length 23
+ #define FL_status_string_unterminated_nest_stop_length 24
+ #endif // _di_F_status_buffer_
+
+ #ifndef _di_F_status_memory_
+ #define FL_status_string_memory_allocation "F_memory_allocation"
+ #define FL_status_string_memory_deallocation "F_memory_deallocation"
+ #define FL_status_string_memory_reallocation "F_memory_reallocation"
+
+ #define FL_status_string_memory_allocation_length 19
+ #define FL_status_string_memory_deallocation_length 21
+ #define FL_status_string_memory_reallocation_length 21
+
+ #endif // _di_F_status_memory_
+
+ #ifndef _di_F_status_file_
+ #define FL_status_string_file "F_file"
+ #define FL_status_string_file_allocation "F_file_allocation"
+ #define FL_status_string_file_close "F_file_close"
+ #define FL_status_string_file_closed "F_file_closed"
+ #define FL_status_string_file_deallocation "F_file_deallocation"
+ #define FL_status_string_file_descriptor "F_file_descriptor"
+ #define FL_status_string_file_descriptor_max "F_file_descriptor_max"
+ #define FL_status_string_file_empty "F_file_empty"
+ #define FL_status_string_file_flush "F_file_flush"
+ #define FL_status_string_file_found "F_file_found"
+ #define FL_status_string_file_found_not "F_file_found_not"
+ #define FL_status_string_file_open "F_file_open"
+ #define FL_status_string_file_open_max "F_file_open_max"
+ #define FL_status_string_file_open_not "F_file_open_not"
+ #define FL_status_string_file_purge "F_file_purge"
+ #define FL_status_string_file_read "F_file_read"
+ #define FL_status_string_file_reallocation "F_file_reallocation"
+ #define FL_status_string_file_seek "F_file_seek"
+ #define FL_status_string_file_stat "F_file_stat"
+ #define FL_status_string_file_synchronize "F_file_synchronize"
+ #define FL_status_string_file_type_block "F_file_type_block"
+ #define FL_status_string_file_type_character "F_file_type_character"
+ #define FL_status_string_file_type_directory "F_file_type_directory"
+ #define FL_status_string_file_type_link "F_file_type_link"
+ #define FL_status_string_file_type_not_block "F_file_type_not_block"
+ #define FL_status_string_file_type_not_character "F_file_type_not_character"
+ #define FL_status_string_file_type_not_directory "F_file_type_not_directory"
+ #define FL_status_string_file_type_not_link "F_file_type_not_link"
+ #define FL_status_string_file_type_not_pipe "F_file_type_not_pipe"
+ #define FL_status_string_file_type_not_regular "F_file_type_not_regular"
+ #define FL_status_string_file_type_not_socket "F_file_type_not_socket"
+ #define FL_status_string_file_type_not_unknown "F_file_type_not_unknown"
+ #define FL_status_string_file_type_pipe "F_file_type_pipe"
+ #define FL_status_string_file_type_regular "F_file_type_regular"
+ #define FL_status_string_file_type_socket "F_file_type_socket"
+ #define FL_status_string_file_type_unknown "F_file_type_unknown"
+ #define FL_status_string_file_utf "F_file_utf"
+ #define FL_status_string_file_utf_not "F_file_utf_not"
+ #define FL_status_string_file_write "F_file_write"
+
+ #define FL_status_string_file_length 6
+ #define FL_status_string_file_allocation_length 17
+ #define FL_status_string_file_close_length 12
+ #define FL_status_string_file_closed_length 13
+ #define FL_status_string_file_deallocation_length 19
+ #define FL_status_string_file_descriptor_length 17
+ #define FL_status_string_file_descriptor_max_length 21
+ #define FL_status_string_file_empty_length 12
+ #define FL_status_string_file_flush_length 12
+ #define FL_status_string_file_found_length 12
+ #define FL_status_string_file_found_not_length 16
+ #define FL_status_string_file_open_length 11
+ #define FL_status_string_file_open_max_length 15
+ #define FL_status_string_file_open_not_length 15
+ #define FL_status_string_file_purge_length 12
+ #define FL_status_string_file_read_length 11
+ #define FL_status_string_file_reallocation_length 19
+ #define FL_status_string_file_seek_length 11
+ #define FL_status_string_file_stat_length 11
+ #define FL_status_string_file_synchronize_length 18
+ #define FL_status_string_file_type_block_length 17
+ #define FL_status_string_file_type_character_length 21
+ #define FL_status_string_file_type_directory_length 21
+ #define FL_status_string_file_type_link_length 16
+ #define FL_status_string_file_type_not_block_length 21
+ #define FL_status_string_file_type_not_character_length 25
+ #define FL_status_string_file_type_not_directory_length 25
+ #define FL_status_string_file_type_not_link_length 20
+ #define FL_status_string_file_type_not_pipe_length 20
+ #define FL_status_string_file_type_not_regular_length 23
+ #define FL_status_string_file_type_not_socket_length 22
+ #define FL_status_string_file_type_not_unknown_length 23
+ #define FL_status_string_file_type_pipe_length 16
+ #define FL_status_string_file_type_regular_length 19
+ #define FL_status_string_file_type_socket_length 18
+ #define FL_status_string_file_type_unknown_length 19
+ #define FL_status_string_file_utf_length 10
+ #define FL_status_string_file_utf_not_length 14
+ #define FL_status_string_file_write_length 12
+ #endif // _di_F_status_file_
+
+ #ifndef _di_F_status_filesystem_
+ #define FL_status_string_filesystem "F_filesystem"
+ #define FL_status_string_filesystem_quota_block "F_filesystem_quota_block"
+ #define FL_status_string_filesystem_quota_reached "F_filesystem_quota_reached"
+
+ #define FL_status_string_filesystem_length 12
+ #define FL_status_string_filesystem_quota_block_length 24
+ #define FL_status_string_filesystem_quota_reached_length 26
+ #endif // _di_F_status_filesystem_
+
+ #ifndef _di_F_status_directory_
+ #define FL_status_string_directory "F_directory"
+ #define FL_status_string_directory_close "F_directory_close"
+ #define FL_status_string_directory_closed "F_directory_closed"
+ #define FL_status_string_directory_descriptor "F_directory_descriptor"
+ #define FL_status_string_directory_empty "F_directory_empty"
+ #define FL_status_string_directory_found "F_directory_found"
+ #define FL_status_string_directory_found_not "F_directory_found_not"
+ #define FL_status_string_directory_flush "F_directory_flush"
+ #define FL_status_string_directory_link_max "F_directory_link_max"
+ #define FL_status_string_directory_open "F_directory_open"
+ #define FL_status_string_directory_open_not "F_directory_open_not"
+ #define FL_status_string_directory_purge "F_directory_purge"
+ #define FL_status_string_directory_read "F_directory_read"
+ #define FL_status_string_directory_stream "F_directory_stream"
+ #define FL_status_string_directory_synchronize "F_directory_synchronize"
+ #define FL_status_string_directory_unsupported "F_directory_unsupported"
+ #define FL_status_string_directory_utf "F_directory_utf"
+ #define FL_status_string_directory_utf_not "F_directory_utf_not"
+ #define FL_status_string_directory_write "F_directory_write"
+
+ #define FL_status_string_directory_length 11
+ #define FL_status_string_directory_close_length 17
+ #define FL_status_string_directory_closed_length 18
+ #define FL_status_string_directory_descriptor_length 22
+ #define FL_status_string_directory_empty_length 17
+ #define FL_status_string_directory_found_length 17
+ #define FL_status_string_directory_found_not_length 21
+ #define FL_status_string_directory_flush_length 17
+ #define FL_status_string_directory_link_max_length 20
+ #define FL_status_string_directory_open_length 16
+ #define FL_status_string_directory_open_not_length 20
+ #define FL_status_string_directory_purge_length 17
+ #define FL_status_string_directory_read_length 16
+ #define FL_status_string_directory_stream_length 18
+ #define FL_status_string_directory_synchronize_length 23
+ #define FL_status_string_directory_unsupported_length 23
+ #define FL_status_string_directory_utf_length 15
+ #define FL_status_string_directory_utf_not_length 19
+ #define FL_status_string_directory_write_length 17
+ #endif // _di_F_status_directory_
+
+ #ifndef _di_F_status_socket_
+ #define FL_status_string_socket_client "F_socket_connect_client"
+ #define FL_status_string_socket_target "F_socket_connect_target"
+ #define FL_status_string_socket_receive "F_socket_receive"
+ #define FL_status_string_socket_send "F_socket_send"
+
+ #define FL_status_string_socket_client_length 23
+ #define FL_status_string_socket_target_length 23
+ #define FL_status_string_socket_receive_length 16
+ #define FL_status_string_socket_send_length 13
+ #endif // _di_F_status_socket_
+
+ #ifndef _di_F_status_compare_
+ #define FL_status_string_equal_to "F_equal_to"
+ #define FL_status_string_equal_to_not "F_equal_to_not"
+ #define FL_status_string_than_greater "F_than_greater"
+ #define FL_status_string_than_less "F_than_less"
+
+ #define FL_status_string_equal_to_length 10
+ #define FL_status_string_equal_to_not_length 14
+ #define FL_status_string_than_greater_length 14
+ #define FL_status_string_than_less_length 11
+ #endif // _di_F_status_compare_
+
+ #ifndef _di_F_status_access_denied_
+ #define FL_status_string_access_denied "F_access_denied"
+ #define FL_status_string_access_denied_user "F_access_denied_user"
+ #define FL_status_string_access_denied_group "F_access_denied_group"
+ #define FL_status_string_access_denied_world "F_access_denied_world"
+ #define FL_status_string_access_denied_read "F_access_denied_read"
+ #define FL_status_string_access_denied_write "F_access_denied_write"
+ #define FL_status_string_access_denied_execute "F_access_denied_execute"
+ #define FL_status_string_access_denied_super "F_access_denied_super"
+
+ #define FL_status_string_access_denied_length 15
+ #define FL_status_string_access_denied_user_length 20
+ #define FL_status_string_access_denied_group_length 21
+ #define FL_status_string_access_denied_world_length 21
+ #define FL_status_string_access_denied_read_length 20
+ #define FL_status_string_access_denied_write_length 21
+ #define FL_status_string_access_denied_execute_length 23
+ #define FL_status_string_access_denied_super_length 21
+ #endif // _di_F_status_access_denied_
+
+ #define FL_status_string_status_code_last "F_status_code_last"
+
+ #define FL_status_string_status_code_last_length 18
+#endif // _di_FL_status_string_
/**
* Convert status codes to their string representation.
}
else {
if (range->start >= buffer->used) {
- return F_data_no_eos;
+ return F_data_not_eos;
}
- return F_data_no_stop;
+ return F_data_not_stop;
}
}
contents->used++;
return status;
}
- else if (status == F_data_no_eos || status == F_data_no_stop) {
+ else if (status == F_data_not_eos || status == F_data_not_stop) {
// If at least some valid object was found, then return F_none equivelents.
if (objects->used > initial_used) {
- if (status == F_data_no_eos) return F_none_eos;
- if (status == F_data_no_stop) return F_none_stop;
+ if (status == F_data_not_eos) return F_none_eos;
+ if (status == F_data_not_stop) return F_none_stop;
}
return status;
status = fl_fss_basic_object_write(buffer, object, &range);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return status;
}
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
- * F_data_no_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
}
else {
if (location->start >= buffer->used) {
- return F_data_no_eos;
+ return F_data_not_eos;
}
- return F_data_no_stop;
+ return F_data_not_stop;
}
}
contents->used++;
return status;
}
- else if (status == F_data_no_eos || status == F_data_no_stop) {
+ else if (status == F_data_not_eos || status == F_data_not_stop) {
// If at least some valid object was found, then return F_none equivalents.
if (objects->used > initial_used) {
- if (status == F_data_no_eos) return F_none_eos;
- if (status == F_data_no_stop) return F_none_stop;
+ if (status == F_data_not_eos) return F_none_eos;
+ if (status == F_data_not_stop) return F_none_stop;
}
return status;
status = fl_fss_basic_list_object_write(object, &range, buffer);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return status;
}
range.stop = contents.array[0].used - 1;
status = fl_fss_basic_list_content_write(contents.array[0], &range, buffer);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return status;
}
}
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
- * F_data_no_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
}
else {
if (location->start >= buffer->used) {
- return F_data_no_eos;
+ return F_data_not_eos;
}
- return F_data_no_stop;
+ return F_data_not_stop;
}
}
contents->used++;
return status;
}
- else if (status == F_data_no_eos || status == F_data_no_stop) {
+ else if (status == F_data_not_eos || status == F_data_not_stop) {
// If at least some valid object was found, then return F_none equivelents.
if (objects->used > initial_used) {
- if (status == F_data_no_eos) return F_none_eos;
- if (status == F_data_no_stop) return F_none_stop;
+ if (status == F_data_not_eos) return F_none_eos;
+ if (status == F_data_not_stop) return F_none_stop;
}
return status;
status = fl_fss_extended_object_write(object, &range, buffer);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return status;
}
range.stop = contents.array[current].used - 1;
status = fl_fss_extended_content_write(contents.array[current], &range, buffer);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return status;
}
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
- * F_data_no_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
}
else {
if (location->start >= buffer->used) {
- return F_data_no_eos;
+ return F_data_not_eos;
}
- return F_data_no_stop;
+ return F_data_not_stop;
}
}
if (status == F_none_eos || status == F_none_stop) {
return status;
}
- else if (status == F_data_no_eos || status == F_data_no_stop) {
+ else if (status == F_data_not_eos || status == F_data_not_stop) {
// If at least some valid object was found, then return F_none equivalents.
if (nest->depth[0].used > initial_used) {
- if (status == F_data_no_eos) return F_none_eos;
- if (status == F_data_no_stop) return F_none_stop;
+ if (status == F_data_not_eos) return F_none_eos;
+ if (status == F_data_not_stop) return F_none_stop;
}
return status;
else if (status == F_unterminated_eos || status == F_unterminated_stop || status == F_unterminated_nest_eos || status == F_unterminated_nest_stop) {
// If at least some valid object was found, then return F_none equivalents.
if (nest->depth[0].used > initial_used) {
- if (status == F_data_no_eos) return F_none_eos;
- if (status == F_data_no_stop) return F_none_stop;
+ if (status == F_data_not_eos) return F_none_eos;
+ if (status == F_data_not_stop) return F_none_stop;
}
return status;
status = fl_fss_extended_list_object_write(object, &range, buffer);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return status;
}
range.stop = contents.array[0].used - 1;
status = fl_fss_extended_list_content_write(contents.array[0], &range, buffer);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return status;
}
}
* F_none on success (both valid object and valid content found with start location is at end of content).
* F_none_stop on success after reaching stopping point (both valid object and valid content found with start location is at stop point).
* F_none_eos on success after reaching the end of the buffer (both valid object and valid content found with start location is at end of buffer).
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
- * F_data_no_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_eol if there is no data to write and EOL was reached (@todo: review related code and detemine what this is doing).
* FL_fss_found_object_content_not on success and object was found but no content was found (start location is at end of object).
* F_unterminated_eos (with error bit) if end of buffer is reached before a closing bracket is found (object was found).
* F_unterminated_stop (with error bit) if stop location is reached before a closing bracket is found (object was found).
* F_none on success.
* F_none_stop on success after reaching stopping point .
* F_none_eos on success after reaching the end of the buffer.
- * F_data_no_stop no data to write due start location being greater than stop location.
- * F_data_no_eos no data to write due start location being greater than or equal to buffer size.
+ * F_data_not_stop no data to write due start location being greater than stop location.
+ * F_data_not_eos no data to write due start location being greater than or equal to buffer size.
* F_incomplete_utf (with error bit) is returned on failure to read/process a UTF-8 character due to the character being potentially incomplete.
* F_utf (with error bit) is returned on failure to read/process a UTF-8 character.
* F_memory_reallocation (with error bit) on reallocation error.
#endif // _di_fll_fss_status_basic_
#ifndef _di_f_status_buffers_
- case F_data_no_eof:
+ case F_data_not_eof:
return F_true;
- case F_data_no_eos:
+ case F_data_not_eos:
return F_true;
- case F_data_no_stop:
+ case F_data_not_stop:
return F_true;
case F_none_eof:
return F_true;
return F_true;
#endif // _di_fll_fss_status_basic_
- #ifndef _di_fll_error_non_
+ #ifndef _di_F_error_compare_
case F_than_less:
return F_true;
case F_equal_to:
return status;
}
- #ifndef _di_fll_status_booleans_
- if (fl_string_compare(string, fl_status_string_false, length, fl_status_string_false_length) == F_equal_to) {
+ #ifndef _di_F_status_boolean_
+ if (fl_string_compare(string, FL_status_string_false, length, FL_status_string_false_length) == F_equal_to) {
*code = F_false;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_true, length, fl_status_string_true_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_true, length, FL_status_string_true_length) == F_equal_to) {
*code = F_true;
return F_none;
}
- #endif // _di_fll_status_booleans_
+ #endif // _di_F_status_boolean_
- #ifndef _di_fll_status_signals_
- if (fl_string_compare(string, fl_status_string_signal_hangup, length, fl_status_string_signal_hangup_length) == F_equal_to) {
+ #ifndef _di_F_status_signal_
+ if (fl_string_compare(string, FL_status_string_signal_hangup, length, FL_status_string_signal_hangup_length) == F_equal_to) {
*code = F_signal_hangup;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_interrupt, length, fl_status_string_signal_interrupt_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_interrupt, length, FL_status_string_signal_interrupt_length) == F_equal_to) {
*code = F_signal_interrupt;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_quit, length, fl_status_string_signal_quit_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_quit, length, FL_status_string_signal_quit_length) == F_equal_to) {
*code = F_signal_quit;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_illegal, length, fl_status_string_signal_illegal_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_illegal, length, FL_status_string_signal_illegal_length) == F_equal_to) {
*code = F_signal_illegal;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_trap, length, fl_status_string_signal_trap_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_trap, length, FL_status_string_signal_trap_length) == F_equal_to) {
*code = F_signal_trap;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_abort, length, fl_status_string_signal_abort_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_abort, length, FL_status_string_signal_abort_length) == F_equal_to) {
*code = F_signal_abort;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_bus_error, length, fl_status_string_signal_bus_error_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_bus_error, length, FL_status_string_signal_bus_error_length) == F_equal_to) {
*code = F_signal_bus_error;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_floating_point_exception, length, fl_status_string_signal_floating_point_exception_length) == F_equal_to) {
- *code = F_signal_floating_point_exception;
+ if (fl_string_compare(string, FL_status_string_signal_floating_point_error, length, FL_status_string_signal_floating_point_error_length) == F_equal_to) {
+ *code = F_signal_floating_point_error;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_kill, length, fl_status_string_signal_kill_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_kill, length, FL_status_string_signal_kill_length) == F_equal_to) {
*code = F_signal_kill;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_user_1, length, fl_status_string_signal_user_1_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_user_1, length, FL_status_string_signal_user_1_length) == F_equal_to) {
*code = F_signal_user_1;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_segmentation_fault, length, fl_status_string_signal_segmentation_fault_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_segmentation_fault, length, FL_status_string_signal_segmentation_fault_length) == F_equal_to) {
*code = F_signal_segmentation_fault;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_user_2, length, fl_status_string_signal_user_2_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_user_2, length, FL_status_string_signal_user_2_length) == F_equal_to) {
*code = F_signal_user_2;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_broken_pipe, length, fl_status_string_signal_broken_pipe_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_broken_pipe, length, FL_status_string_signal_broken_pipe_length) == F_equal_to) {
*code = F_signal_broken_pipe;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_alarm_clock, length, fl_status_string_signal_alarm_clock_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_alarm_clock, length, FL_status_string_signal_alarm_clock_length) == F_equal_to) {
*code = F_signal_alarm_clock;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_termination, length, fl_status_string_signal_termination_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_termination, length, FL_status_string_signal_termination_length) == F_equal_to) {
*code = F_signal_termination;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_stack_fault, length, fl_status_string_signal_stack_fault_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_stack_fault, length, FL_status_string_signal_stack_fault_length) == F_equal_to) {
*code = F_signal_stack_fault;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_child, length, fl_status_string_signal_child_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_child, length, FL_status_string_signal_child_length) == F_equal_to) {
*code = F_signal_child;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_continue, length, fl_status_string_signal_continue_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_continue, length, FL_status_string_signal_continue_length) == F_equal_to) {
*code = F_signal_continue;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_stop, length, fl_status_string_signal_stop_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_stop, length, FL_status_string_signal_stop_length) == F_equal_to) {
*code = F_signal_stop;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_keyboard_stop, length, fl_status_string_signal_keyboard_stop_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_keyboard_stop, length, FL_status_string_signal_keyboard_stop_length) == F_equal_to) {
*code = F_signal_keyboard_stop;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_tty_in, length, fl_status_string_signal_tty_in_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_tty_in, length, FL_status_string_signal_tty_in_length) == F_equal_to) {
*code = F_signal_tty_in;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_tty_out, length, fl_status_string_signal_tty_out_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_tty_out, length, FL_status_string_signal_tty_out_length) == F_equal_to) {
*code = F_signal_tty_out;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_urgent, length, fl_status_string_signal_urgent_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_urgent, length, FL_status_string_signal_urgent_length) == F_equal_to) {
*code = F_signal_urgent;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_cpu_limit, length, fl_status_string_signal_cpu_limit_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_cpu_limit, length, FL_status_string_signal_cpu_limit_length) == F_equal_to) {
*code = F_signal_cpu_limit;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_file_size_limit, length, fl_status_string_signal_file_size_limit_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_file_size_limit, length, FL_status_string_signal_file_size_limit_length) == F_equal_to) {
*code = F_signal_file_size_limit;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_virtual_alarm_clock, length, fl_status_string_signal_virtual_alarm_clock_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_virtual_alarm_clock, length, FL_status_string_signal_virtual_alarm_clock_length) == F_equal_to) {
*code = F_signal_virtual_alarm_clock;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_profile_alarm_clock, length, fl_status_string_signal_profile_alarm_clock_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_profile_alarm_clock, length, FL_status_string_signal_profile_alarm_clock_length) == F_equal_to) {
*code = F_signal_profile_alarm_clock;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_window_size_change, length, fl_status_string_signal_window_size_change_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_window_size_change, length, FL_status_string_signal_window_size_change_length) == F_equal_to) {
*code = F_signal_window_size_change;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_pollable_event, length, fl_status_string_signal_pollable_event_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_pollable_event, length, FL_status_string_signal_pollable_event_length) == F_equal_to) {
*code = F_signal_pollable_event;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_power_failure, length, fl_status_string_signal_power_failure_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_power_failure, length, FL_status_string_signal_power_failure_length) == F_equal_to) {
*code = F_signal_power_failure;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_bad_system_call, length, fl_status_string_signal_bad_system_call_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_bad_system_call, length, FL_status_string_signal_bad_system_call_length) == F_equal_to) {
*code = F_signal_bad_system_call;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_32, length, fl_status_string_signal_reserved_32_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_32, length, FL_status_string_signal_reserved_32_length) == F_equal_to) {
*code = F_signal_reserved_32;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_33, length, fl_status_string_signal_reserved_33_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_33, length, FL_status_string_signal_reserved_33_length) == F_equal_to) {
*code = F_signal_reserved_33;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_34, length, fl_status_string_signal_reserved_34_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_34, length, FL_status_string_signal_reserved_34_length) == F_equal_to) {
*code = F_signal_reserved_34;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_35, length, fl_status_string_signal_reserved_35_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_35, length, FL_status_string_signal_reserved_35_length) == F_equal_to) {
*code = F_signal_reserved_35;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_36, length, fl_status_string_signal_reserved_36_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_36, length, FL_status_string_signal_reserved_36_length) == F_equal_to) {
*code = F_signal_reserved_36;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_37, length, fl_status_string_signal_reserved_37_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_37, length, FL_status_string_signal_reserved_37_length) == F_equal_to) {
*code = F_signal_reserved_37;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_38, length, fl_status_string_signal_reserved_38_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_38, length, FL_status_string_signal_reserved_38_length) == F_equal_to) {
*code = F_signal_reserved_38;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_39, length, fl_status_string_signal_reserved_39_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_39, length, FL_status_string_signal_reserved_39_length) == F_equal_to) {
*code = F_signal_reserved_39;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_40, length, fl_status_string_signal_reserved_40_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_40, length, FL_status_string_signal_reserved_40_length) == F_equal_to) {
*code = F_signal_reserved_40;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_41, length, fl_status_string_signal_reserved_41_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_41, length, FL_status_string_signal_reserved_41_length) == F_equal_to) {
*code = F_signal_reserved_41;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_42, length, fl_status_string_signal_reserved_42_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_42, length, FL_status_string_signal_reserved_42_length) == F_equal_to) {
*code = F_signal_reserved_42;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_43, length, fl_status_string_signal_reserved_43_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_43, length, FL_status_string_signal_reserved_43_length) == F_equal_to) {
*code = F_signal_reserved_43;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_44, length, fl_status_string_signal_reserved_44_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_44, length, FL_status_string_signal_reserved_44_length) == F_equal_to) {
*code = F_signal_reserved_44;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_45, length, fl_status_string_signal_reserved_45_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_45, length, FL_status_string_signal_reserved_45_length) == F_equal_to) {
*code = F_signal_reserved_45;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_46, length, fl_status_string_signal_reserved_46_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_46, length, FL_status_string_signal_reserved_46_length) == F_equal_to) {
*code = F_signal_reserved_46;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_47, length, fl_status_string_signal_reserved_47_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_47, length, FL_status_string_signal_reserved_47_length) == F_equal_to) {
*code = F_signal_reserved_47;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_48, length, fl_status_string_signal_reserved_48_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_48, length, FL_status_string_signal_reserved_48_length) == F_equal_to) {
*code = F_signal_reserved_48;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_49, length, fl_status_string_signal_reserved_49_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_49, length, FL_status_string_signal_reserved_49_length) == F_equal_to) {
*code = F_signal_reserved_49;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_50, length, fl_status_string_signal_reserved_50_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_50, length, FL_status_string_signal_reserved_50_length) == F_equal_to) {
*code = F_signal_reserved_50;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_51, length, fl_status_string_signal_reserved_51_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_51, length, FL_status_string_signal_reserved_51_length) == F_equal_to) {
*code = F_signal_reserved_51;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_52, length, fl_status_string_signal_reserved_52_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_52, length, FL_status_string_signal_reserved_52_length) == F_equal_to) {
*code = F_signal_reserved_52;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_53, length, fl_status_string_signal_reserved_53_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_53, length, FL_status_string_signal_reserved_53_length) == F_equal_to) {
*code = F_signal_reserved_53;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_54, length, fl_status_string_signal_reserved_54_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_54, length, FL_status_string_signal_reserved_54_length) == F_equal_to) {
*code = F_signal_reserved_54;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_55, length, fl_status_string_signal_reserved_55_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_55, length, FL_status_string_signal_reserved_55_length) == F_equal_to) {
*code = F_signal_reserved_55;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_56, length, fl_status_string_signal_reserved_56_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_56, length, FL_status_string_signal_reserved_56_length) == F_equal_to) {
*code = F_signal_reserved_56;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_57, length, fl_status_string_signal_reserved_57_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_57, length, FL_status_string_signal_reserved_57_length) == F_equal_to) {
*code = F_signal_reserved_57;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_58, length, fl_status_string_signal_reserved_58_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_58, length, FL_status_string_signal_reserved_58_length) == F_equal_to) {
*code = F_signal_reserved_58;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_59, length, fl_status_string_signal_reserved_59_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_59, length, FL_status_string_signal_reserved_59_length) == F_equal_to) {
*code = F_signal_reserved_59;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_60, length, fl_status_string_signal_reserved_60_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_60, length, FL_status_string_signal_reserved_60_length) == F_equal_to) {
*code = F_signal_reserved_60;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_61, length, fl_status_string_signal_reserved_61_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_61, length, FL_status_string_signal_reserved_61_length) == F_equal_to) {
*code = F_signal_reserved_61;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_62, length, fl_status_string_signal_reserved_62_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_62, length, FL_status_string_signal_reserved_62_length) == F_equal_to) {
*code = F_signal_reserved_62;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_63, length, fl_status_string_signal_reserved_63_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_63, length, FL_status_string_signal_reserved_63_length) == F_equal_to) {
*code = F_signal_reserved_63;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_signal_reserved_64, length, fl_status_string_signal_reserved_64_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_signal_reserved_64, length, FL_status_string_signal_reserved_64_length) == F_equal_to) {
*code = F_signal_reserved_64;
return F_none;
}
- #endif // _di_fll_status_signals_
+ #endif // _di_F_status_signal_
- #ifndef _di_fll_status_basic_
- if (fl_string_compare(string, fl_status_string_none, length, fl_status_string_none_length) == F_equal_to) {
+ #ifndef _di_F_status_basic_
+ if (fl_string_compare(string, FL_status_string_none, length, FL_status_string_none_length) == F_equal_to) {
*code = F_none;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_maybe, length, fl_status_string_maybe_length) == F_equal_to) {
- *code = F_maybe;
+ if (fl_string_compare(string, FL_status_string_address, length, FL_status_string_address_length) == F_equal_to) {
+ *code = F_address;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_dummy, length, fl_status_string_dummy_length) == F_equal_to) {
- *code = F_dummy;
+ if (fl_string_compare(string, FL_status_string_block, length, FL_status_string_block_length) == F_equal_to) {
+ *code = F_block;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_warn, length, fl_status_string_warn_length) == F_equal_to) {
- *code = F_warn;
+ if (fl_string_compare(string, FL_status_string_bound_out, length, FL_status_string_bound_out_length) == F_equal_to) {
+ *code = F_bound_out;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_block, length, fl_status_string_block_length) == F_equal_to) {
- *code = F_block;
+ if (fl_string_compare(string, FL_status_string_connected_not, length, FL_status_string_connected_not_length) == F_equal_to) {
+ *code = F_connected_not;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_critical, length, fl_status_string_critical_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_critical, length, FL_status_string_critical_length) == F_equal_to) {
*code = F_critical;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unknown, length, fl_status_string_unknown_length) == F_equal_to) {
- *code = F_unknown;
+ if (fl_string_compare(string, FL_status_string_descriptor, length, FL_status_string_descriptor_length) == F_equal_to) {
+ *code = F_descriptor;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unsupported, length, fl_status_string_unsupported_length) == F_equal_to) {
- *code = F_unsupported;
+ if (fl_string_compare(string, FL_status_string_device, length, FL_status_string_device_length) == F_equal_to) {
+ *code = F_device;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_no_data, length, fl_status_string_no_data_length) == F_equal_to) {
- *code = F_data_not;
+ if (fl_string_compare(string, FL_status_string_dummy, length, FL_status_string_dummy_length) == F_equal_to) {
+ *code = F_dummy;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_no_space, length, fl_status_string_no_space_length) == F_equal_to) {
- *code = F_space_not;
+ if (fl_string_compare(string, FL_status_string_eof, length, FL_status_string_eof_length) == F_equal_to) {
+ *code = F_eof;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_bound_out, length, fl_status_string_bound_out_length) == F_equal_to) {
- *code = F_bound_out;
+ if (fl_string_compare(string, FL_status_string_eol, length, FL_status_string_eol_length) == F_equal_to) {
+ *code = F_eol;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_memory_out, length, fl_status_string_memory_out_length) == F_equal_to) {
- *code = F_memory_out;
+ if (fl_string_compare(string, FL_status_string_eos, length, FL_status_string_eos_length) == F_equal_to) {
+ *code = F_eos;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_prohibited, length, fl_status_string_prohibited_length) == F_equal_to) {
- *code = F_prohibited;
+ if (fl_string_compare(string, FL_status_string_exist_not, length, FL_status_string_exist_not_length) == F_equal_to) {
+ *code = F_exist_not;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_read_only, length, fl_status_string_read_only_length) == F_equal_to) {
- *code = F_read_only;
+ if (fl_string_compare(string, FL_status_string_failure, length, FL_status_string_failure_length) == F_equal_to) {
+ *code = F_failure;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_input, length, fl_status_string_input_length) == F_equal_to) {
- *code = F_input;
+ if (fl_string_compare(string, FL_status_string_fork, length, FL_status_string_fork_length) == F_equal_to) {
+ *code = F_fork;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_output, length, fl_status_string_output_length) == F_equal_to) {
- *code = F_output;
+ if (fl_string_compare(string, FL_status_string_incomplete, length, FL_status_string_incomplete_length) == F_equal_to) {
+ *code = F_incomplete;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_input_output, length, fl_status_string_input_output_length) == F_equal_to) {
- *code = F_input_output;
+ if (fl_string_compare(string, FL_status_string_input, length, FL_status_string_input_length) == F_equal_to) {
+ *code = F_input;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_exist_not, length, fl_status_string_exist_not_length) == F_equal_to) {
- *code = F_exist_not;
+ if (fl_string_compare(string, FL_status_string_input_output, length, FL_status_string_input_output_length) == F_equal_to) {
+ *code = F_input_output;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_connected_not, length, fl_status_string_connected_not_length) == F_equal_to) {
- *code = F_connected_not;
+ if (fl_string_compare(string, FL_status_string_interrupted, length, FL_status_string_interrupted_length) == F_equal_to) {
+ *code = F_interrupted;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_failure, length, fl_status_string_failure_length) == F_equal_to) {
- *code = F_failure;
+ if (fl_string_compare(string, FL_status_string_invalid, length, FL_status_string_invalid_length) == F_equal_to) {
+ *code = F_invalid;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_interrupted, length, fl_status_string_interrupted_length) == F_equal_to) {
- *code = F_interrupted;
+ if (fl_string_compare(string, FL_status_string_output, length, FL_status_string_output_length) == F_equal_to) {
+ *code = F_output;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_loop, length, fl_status_string_loop_length) == F_equal_to) {
- *code = F_loop;
+ if (fl_string_compare(string, FL_status_string_link, length, FL_status_string_link_length) == F_equal_to) {
+ *code = F_link;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_incomplete, length, fl_status_string_incomplete_length) == F_equal_to) {
- *code = F_incomplete;
+ if (fl_string_compare(string, FL_status_string_loop, length, FL_status_string_loop_length) == F_equal_to) {
+ *code = F_loop;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_write_only, length, fl_status_string_write_only_length) == F_equal_to) {
- *code = F_write_only;
+ if (fl_string_compare(string, FL_status_string_maybe, length, FL_status_string_maybe_length) == F_equal_to) {
+ *code = F_maybe;
return F_none;
}
- #endif // _di_fll_status_basic_
- #ifndef _di_fll_status_invalid_
- if (fl_string_compare(string, fl_status_string_invalid, length, fl_status_string_length) == F_equal_to) {
- *code = F_invalid;
+ if (fl_string_compare(string, FL_status_string_memory_out, length, FL_status_string_memory_out_length) == F_equal_to) {
+ *code = F_memory_out;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_name, length, fl_status_string_name_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_name, length, FL_status_string_name_length) == F_equal_to) {
*code = F_name;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_parameter, length, fl_status_string_parameter_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_parameter, length, FL_status_string_parameter_length) == F_equal_to) {
*code = F_parameter;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_syntax, length, fl_status_string_syntax_length) == F_equal_to) {
- *code = F_syntax;
+ if (fl_string_compare(string, FL_status_string_pipe, length, FL_status_string_pipe_length) == F_equal_to) {
+ *code = F_pipe;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_data, length, fl_status_string_data_length) == F_equal_to) {
- *code = F_data;
+ if (fl_string_compare(string, FL_status_string_port, length, FL_status_string_port_length) == F_equal_to) {
+ *code = F_port;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_descriptor, length, fl_status_string_descriptor_length) == F_equal_to) {
- *code = F_descriptor;
+ if (fl_string_compare(string, FL_status_string_process, length, FL_status_string_process_length) == F_equal_to) {
+ *code = F_process;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_socket, length, fl_status_string_socket_length) == F_equal_to) {
- *code = F_socket;
+ if (fl_string_compare(string, FL_status_string_process_too_many, length, FL_status_string_process_too_many_length) == F_equal_to) {
+ *code = F_process_too_many;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_device, length, fl_status_string_device_length) == F_equal_to) {
- *code = F_device;
+ if (fl_string_compare(string, FL_status_string_prohibited, length, FL_status_string_prohibited_length) == F_equal_to) {
+ *code = F_prohibited;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_link, length, fl_status_string_link_length) == F_equal_to) {
- *code = F_link;
+ if (fl_string_compare(string, FL_status_string_read_only, length, FL_status_string_read_only_length) == F_equal_to) {
+ *code = F_read_only;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_pipe, length, fl_status_string_pipe_length) == F_equal_to) {
- *code = F_pipe;
+ if (fl_string_compare(string, FL_status_string_socket, length, FL_status_string_socket_length) == F_equal_to) {
+ *code = F_socket;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_address, length, fl_status_string_address_length) == F_equal_to) {
- *code = F_address;
+ if (fl_string_compare(string, FL_status_string_space_not, length, FL_status_string_space_not_length) == F_equal_to) {
+ *code = F_space_not;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_port, length, fl_status_string_port_length) == F_equal_to) {
- *code = F_port;
+ if (fl_string_compare(string, FL_status_string_stop, length, FL_status_string_stop_length) == F_equal_to) {
+ *code = F_stop;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_value, length, fl_status_string_value_length) == F_equal_to) {
- *code = F_value;
+ if (fl_string_compare(string, FL_status_string_syntax, length, FL_status_string_syntax_length) == F_equal_to) {
+ *code = F_syntax;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_buffer, length, fl_status_string_buffer_length) == F_equal_to) {
- *code = F_buffer;
+ if (fl_string_compare(string, FL_status_string_unknown, length, FL_status_string_unknown_length) == F_equal_to) {
+ *code = F_unknown;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_process, length, fl_status_string_process_length) == F_equal_to) {
- *code = F_process;
+ if (fl_string_compare(string, FL_status_string_unsupported, length, FL_status_string_unsupported_length) == F_equal_to) {
+ *code = F_unsupported;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_utf, length, fl_status_string_utf_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_utf, length, FL_status_string_utf_length) == F_equal_to) {
*code = F_utf;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_eof, length, fl_status_string_eof_length) == F_equal_to) {
- *code = F_eof;
- return F_none;
- }
-
- if (fl_string_compare(string, fl_status_string_eol, length, fl_status_string_eol_length) == F_equal_to) {
- *code = F_eol;
+ if (fl_string_compare(string, FL_status_string_value, length, FL_status_string_value_length) == F_equal_to) {
+ *code = F_value;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_eos, length, fl_status_string_eos_length) == F_equal_to) {
- *code = F_eos;
+ if (fl_string_compare(string, FL_status_string_warn, length, FL_status_string_warn_length) == F_equal_to) {
+ *code = F_warn;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_stop, length, fl_status_string_stop_length) == F_equal_to) {
- *code = F_stop;
+ if (fl_string_compare(string, FL_status_string_write_only, length, FL_status_string_write_only_length) == F_equal_to) {
+ *code = F_write_only;
return F_none;
}
- #endif // _di_fll_status_invalid_
+ #endif // _di_F_status_basic_
- #ifndef _di_fll_status_busy_
- if (fl_string_compare(string, fl_status_string_busy, length, fl_status_string_busy_length) == F_equal_to) {
+ #ifndef _di_F_status_busy_
+ if (fl_string_compare(string, FL_status_string_busy, length, FL_status_string_busy_length) == F_equal_to) {
*code = F_busy;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_busy_address, length, fl_status_string_busy_address_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_busy_address, length, FL_status_string_busy_address_length) == F_equal_to) {
*code = F_busy_address;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_busy_port, length, fl_status_string_busy_port_length) == F_equal_to) {
- *code = F_busy_port;
- return F_none;
- }
-
- if (fl_string_compare(string, fl_status_string_busy_socket, length, fl_status_string_busy_socket_length) == F_equal_to) {
- *code = F_busy_socket;
+ if (fl_string_compare(string, FL_status_string_busy_buffer, length, FL_status_string_busy_buffer_length) == F_equal_to) {
+ *code = F_busy_buffer;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_busy_device, length, fl_status_string_busy_device_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_busy_device, length, FL_status_string_busy_device_length) == F_equal_to) {
*code = F_busy_device;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_busy_pipe, length, fl_status_string_busy_pipe_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_busy_pipe, length, FL_status_string_busy_pipe_length) == F_equal_to) {
*code = F_busy_pipe;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_busy_buffer, length, fl_status_string_busy_buffer_length) == F_equal_to) {
- *code = F_busy_buffer;
+ if (fl_string_compare(string, FL_status_string_busy_port, length, FL_status_string_busy_port_length) == F_equal_to) {
+ *code = F_busy_port;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_busy_process, length, fl_status_string_busy_process_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_busy_process, length, FL_status_string_busy_process_length) == F_equal_to) {
*code = F_busy_process;
return F_none;
}
- #endif // _di_fll_status_busy_
- #ifndef _di_fll_status_unavailable_
- if (fl_string_compare(string, fl_status_string_unavailable, length, fl_status_string_unavailable_length) == F_equal_to) {
- *code = F_unavailable;
+ if (fl_string_compare(string, FL_status_string_busy_socket, length, FL_status_string_busy_socket_length) == F_equal_to) {
+ *code = F_busy_socket;
return F_none;
}
+ #endif // _di_F_status_busy_
- if (fl_string_compare(string, fl_status_string_unavailable_address, length, fl_status_string_unavailable_address_length) == F_equal_to) {
- *code = F_unavailable_address;
+ #ifndef _di_F_status_unavailable_
+ if (fl_string_compare(string, FL_status_string_unavailable, length, FL_status_string_unavailable_length) == F_equal_to) {
+ *code = F_unavailable;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unavailable_port, length, fl_status_string_unavailable_port_length) == F_equal_to) {
- *code = F_unavailable_port;
+ if (fl_string_compare(string, FL_status_string_unavailable_address, length, FL_status_string_unavailable_address_length) == F_equal_to) {
+ *code = F_unavailable_address;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unavailable_socket, length, fl_status_string_unavailable_socket_length) == F_equal_to) {
- *code = F_unavailable_socket;
+ if (fl_string_compare(string, FL_status_string_unavailable_buffer, length, FL_status_string_unavailable_buffer_length) == F_equal_to) {
+ *code = F_unavailable_buffer;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unavailable_device, length, fl_status_string_unavailable_device_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unavailable_device, length, FL_status_string_unavailable_device_length) == F_equal_to) {
*code = F_unavailable_device;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unavailable_pipe, length, fl_status_string_unavailable_pipe_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unavailable_pipe, length, FL_status_string_unavailable_pipe_length) == F_equal_to) {
*code = F_unavailable_pipe;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unavailable_buffer, length, fl_status_string_unavailable_buffer_length) == F_equal_to) {
- *code = F_unavailable_buffer;
+ if (fl_string_compare(string, FL_status_string_unavailable_port, length, FL_status_string_unavailable_port_length) == F_equal_to) {
+ *code = F_unavailable_port;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unavailable_process, length, fl_status_string_unavailable_process_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unavailable_process, length, FL_status_string_unavailable_process_length) == F_equal_to) {
*code = F_unavailable_process;
return F_none;
}
- #endif // _di_fll_status_unavailable_
- #ifndef _di_fll_status_digits_
- if (fl_string_compare(string, fl_status_string_underflow, length, fl_status_string_underflow_length) == F_equal_to) {
- *code = F_number_underflow;
+ if (fl_string_compare(string, FL_status_string_unavailable_socket, length, FL_status_string_unavailable_socket_length) == F_equal_to) {
+ *code = F_unavailable_socket;
return F_none;
}
+ #endif // _di_F_status_unavailable_
- if (fl_string_compare(string, fl_status_string_overflow, length, fl_status_string_overflow_length) == F_equal_to) {
- *code = F_number_overflow;
+ #ifndef _di_F_status_number_
+ if (fl_string_compare(string, FL_status_string_number, length, FL_status_string_number_length) == F_equal_to) {
+ *code = F_number;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_divide_by_zero, length, fl_status_string_divide_by_zero_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_number_decimal, length, FL_status_string_number_decimal_length) == F_equal_to) {
+ *code = F_number_decimal;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_number_divide_by_zero, length, FL_status_string_number_divide_by_zero_length) == F_equal_to) {
*code = F_number_divide_by_zero;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_negative_number, length, fl_status_string_negative_number_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_number_negative, length, FL_status_string_number_negative_length) == F_equal_to) {
*code = F_number_negative;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_positive_number, length, fl_status_string_positive_number_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_number_overflow, length, FL_status_string_number_overflow_length) == F_equal_to) {
+ *code = F_number_overflow;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_number_positive, length, FL_status_string_number_positive_length) == F_equal_to) {
*code = F_number_positive;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_zero_number, length, fl_status_string_zero_number_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_number_underflow, length, FL_status_string_number_underflow_length) == F_equal_to) {
+ *code = F_number_underflow;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_number_whole, length, FL_status_string_number_whole_length) == F_equal_to) {
+ *code = F_number_whole;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_number_zero, length, FL_status_string_number_zero_length) == F_equal_to) {
*code = F_number_zero;
return F_none;
}
+ #endif // _di_F_status_number_
- if (fl_string_compare(string, fl_status_string_decimal_number, length, fl_status_string_decimal_number_length) == F_equal_to) {
- *code = F_number_decimal;
+ #ifndef _di_F_status_buffer_
+ if (fl_string_compare(string, FL_status_string_buffer, length, FL_status_string_buffer_length) == F_equal_to) {
+ *code = F_buffer;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_whole_number, length, fl_status_string_whole_number_length) == F_equal_to) {
- *code = F_number_whole;
+ if (fl_string_compare(string, FL_status_string_buffer_too_small, length, FL_status_string_buffer_too_small_length) == F_equal_to) {
+ *code = F_buffer_too_small;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_buffer_too_large, length, FL_status_string_buffer_too_large_length) == F_equal_to) {
+ *code = F_buffer_too_large;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_incomplete_utf, length, FL_status_string_incomplete_utf_length) == F_equal_to) {
+ *code = F_incomplete_utf;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_number, length, fl_status_string_number_length) == F_equal_to) {
- *code = F_number_invalid;
+ if (fl_string_compare(string, FL_status_string_incomplete_utf_block, length, FL_status_string_incomplete_utf_block_length) == F_equal_to) {
+ *code = F_incomplete_utf_block;
return F_none;
}
- #endif // _di_fll_status_digits_
- #ifndef _di_fll_status_buffers_
- if (fl_string_compare(string, fl_status_string_data_no_eof, length, fl_status_string_data_no_eof_length) == F_equal_to) {
- *code = F_data_no_eof;
+ if (fl_string_compare(string, FL_status_string_incomplete_utf_eof, length, FL_status_string_incomplete_utf_eof_length) == F_equal_to) {
+ *code = F_incomplete_utf_eof;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_data_no_eol, length, fl_status_string_data_no_eol_length) == F_equal_to) {
- *code = F_data_no_eol;
+ if (fl_string_compare(string, FL_status_string_incomplete_utf_eol, length, FL_status_string_incomplete_utf_eol_length) == F_equal_to) {
+ *code = F_incomplete_utf_eol;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_data_no_eos, length, fl_status_string_data_no_eos_length) == F_equal_to) {
- *code = F_data_no_eos;
+ if (fl_string_compare(string, FL_status_string_incomplete_utf_eos, length, FL_status_string_incomplete_utf_eos_length) == F_equal_to) {
+ *code = F_incomplete_utf_eos;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_data_no_stop, length, fl_status_string_data_no_stop_length) == F_equal_to) {
- *code = F_data_no_stop;
+ if (fl_string_compare(string, FL_status_string_incomplete_utf_stop, length, FL_status_string_incomplete_utf_stop_length) == F_equal_to) {
+ *code = F_incomplete_utf_stop;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_data_no_block, length, fl_status_string_data_no_block_length) == F_equal_to) {
- *code = F_data_block_no;
+ if (fl_string_compare(string, FL_status_string_none_block, length, FL_status_string_none_block_length) == F_equal_to) {
+ *code = F_none_block;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_none_eof, length, fl_status_string_none_eof_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_none_eof, length, FL_status_string_none_eof_length) == F_equal_to) {
*code = F_none_eof;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_none_eol, length, fl_status_string_none_eol_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_none_eol, length, FL_status_string_none_eol_length) == F_equal_to) {
*code = F_none_eol;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_none_eos, length, fl_status_string_none_eos_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_none_eos, length, FL_status_string_none_eos_length) == F_equal_to) {
*code = F_none_eos;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_none_stop, length, fl_status_string_none_stop_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_none_stop, length, FL_status_string_none_stop_length) == F_equal_to) {
*code = F_none_stop;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_none_block, length, fl_status_string_none_block_length) == F_equal_to) {
- *code = F_none_block;
- return F_none;
- }
-
- if (fl_string_compare(string, fl_status_string_eof, length, fl_status_string_eof_length) == F_equal_to) {
- *code = F_eof;
+ if (fl_string_compare(string, FL_status_string_data, length, FL_status_string_data_length) == F_equal_to) {
+ *code = F_data;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_eol, length, fl_status_string_eol_length) == F_equal_to) {
- *code = F_eol;
+ if (fl_string_compare(string, FL_status_string_data_not, length, FL_status_string_data_not_length) == F_equal_to) {
+ *code = F_data_not;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_error_on_eos, length, fl_status_string_error_on_eos_length) == F_equal_to) {
- *code = F_eos;
+ if (fl_string_compare(string, FL_status_string_data_not_block, length, FL_status_string_data_not_block_length) == F_equal_to) {
+ *code = F_data_not_block;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_stop, length, fl_status_string_stop_length) == F_equal_to) {
- *code = F_stop;
+ if (fl_string_compare(string, FL_status_string_data_not_eof, length, FL_status_string_data_not_eof_length) == F_equal_to) {
+ *code = F_data_not_eof;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_block, length, fl_status_string_block_length) == F_equal_to) {
- *code = F_block;
+ if (fl_string_compare(string, FL_status_string_data_not_eol, length, FL_status_string_data_not_eol_length) == F_equal_to) {
+ *code = F_data_not_eol;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_buffer_too_small, length, fl_status_string_buffer_too_small_length) == F_equal_to) {
- *code = F_buffer_too_small;
+ if (fl_string_compare(string, FL_status_string_data_not_eos, length, FL_status_string_data_not_eos_length) == F_equal_to) {
+ *code = F_data_not_eos;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_buffer_too_large, length, fl_status_string_buffer_too_large_length) == F_equal_to) {
- *code = F_buffer_too_large;
+ if (fl_string_compare(string, FL_status_string_data_not_stop, length, FL_status_string_data_not_stop_length) == F_equal_to) {
+ *code = F_data_not_stop;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_string_too_small, length, fl_status_string_string_too_small_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_string_too_small, length, FL_status_string_string_too_small_length) == F_equal_to) {
*code = F_string_too_small;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_string_too_large, length, fl_status_string_string_too_large_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_string_too_large, length, FL_status_string_string_too_large_length) == F_equal_to) {
*code = F_string_too_large;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated, length, fl_status_string_unterminated_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unterminated, length, FL_status_string_unterminated_length) == F_equal_to) {
*code = F_unterminated;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_eof, length, fl_status_string_unterminated_eof_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unterminated_block, length, FL_status_string_unterminated_block_length) == F_equal_to) {
+ *code = F_unterminated_block;
+ return F_none;
+ }
+
+ if (fl_string_compare(string, FL_status_string_unterminated_eof, length, FL_status_string_unterminated_eof_length) == F_equal_to) {
*code = F_unterminated_eof;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_eol, length, fl_status_string_unterminated_eol_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unterminated_eol, length, FL_status_string_unterminated_eol_length) == F_equal_to) {
*code = F_unterminated_eol;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_eos, length, fl_status_string_unterminated_eos_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unterminated_eos, length, FL_status_string_unterminated_eos_length) == F_equal_to) {
*code = F_unterminated_eos;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_stop, length, fl_status_string_unterminated_stop_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unterminated_stop, length, FL_status_string_unterminated_stop_length) == F_equal_to) {
*code = F_unterminated_stop;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_block, length, fl_status_string_unterminated_block_length) == F_equal_to) {
- *code = F_unterminated_block;
+ if (fl_string_compare(string, FL_status_string_unterminated_group, length, FL_status_string_unterminated_group_length) == F_equal_to) {
+ *code = F_unterminated_group;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_group, length, fl_status_string_unterminated_group_length) == F_equal_to) {
- *code = F_unterminated_group;
+ if (fl_string_compare(string, FL_status_string_unterminated_group_block, length, FL_status_string_unterminated_group_block_length) == F_equal_to) {
+ *code = F_unterminated_group_block;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_group_on_eof, length, fl_status_string_unterminated_group_on_eof_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unterminated_group_eof, length, FL_status_string_unterminated_group_eof_length) == F_equal_to) {
*code = F_unterminated_group_eof;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_group_on_eol, length, fl_status_string_unterminated_group_on_eol_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unterminated_group_eol, length, FL_status_string_unterminated_group_eol_length) == F_equal_to) {
*code = F_unterminated_group_eol;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_group_on_eos, length, fl_status_string_unterminated_group_on_eos_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unterminated_group_eos, length, FL_status_string_unterminated_group_eos_length) == F_equal_to) {
*code = F_unterminated_group_eos;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_group_on_stop, length, fl_status_string_unterminated_group_on_stop_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unterminated_group_stop, length, FL_status_string_unterminated_group_stop_length) == F_equal_to) {
*code = F_unterminated_group_stop;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_group_on_block, length, fl_status_string_unterminated_group_on_block_length) == F_equal_to) {
- *code = F_unterminated_group_block;
+ if (fl_string_compare(string, FL_status_string_unterminated_nest, length, FL_status_string_unterminated_nest_length) == F_equal_to) {
+ *code = F_unterminated_nest;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_nest, length, fl_status_string_unterminated_nest_length) == F_equal_to) {
- *code = F_unterminated_nest;
+ if (fl_string_compare(string, FL_status_string_unterminated_nest_block, length, FL_status_string_unterminated_nest_block_length) == F_equal_to) {
+ *code = F_unterminated_nest_block;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_nest_eof, length, fl_status_string_unterminated_nest_eof_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unterminated_nest_eof, length, FL_status_string_unterminated_nest_eof_length) == F_equal_to) {
*code = F_unterminated_nest_eof;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_nest_eol, length, fl_status_string_unterminated_nest_eol_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unterminated_nest_eol, length, FL_status_string_unterminated_nest_eol_length) == F_equal_to) {
*code = F_unterminated_nest_eol;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_nest_eos, length, fl_status_string_unterminated_nest_eos_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unterminated_nest_eos, length, FL_status_string_unterminated_nest_eos_length) == F_equal_to) {
*code = F_unterminated_nest_eos;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_unterminated_nest_stop, length, fl_status_string_unterminated_nest_stop_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_unterminated_nest_stop, length, FL_status_string_unterminated_nest_stop_length) == F_equal_to) {
*code = F_unterminated_nest_stop;
return F_none;
}
+ #endif // _di_F_status_buffer_
- if (fl_string_compare(string, fl_status_string_unterminated_nest_block, length, fl_status_string_unterminated_nest_block_length) == F_equal_to) {
- *code = F_unterminated_nest_block;
+ #ifndef _di_F_status_memory_
+ if (fl_string_compare(string, FL_status_string_memory_allocation, length, FL_status_string_memory_allocation_length) == F_equal_to) {
+ *code = F_memory_allocation;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_incomplete_utf, length, fl_status_string_incomplete_utf_length) == F_equal_to) {
- *code = F_incomplete_utf;
+ if (fl_string_compare(string, FL_status_string_memory_deallocation, length, FL_status_string_memory_deallocation_length) == F_equal_to) {
+ *code = F_memory_deallocation;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_incomplete_utf_on_eof, length, fl_status_string_incomplete_utf_on_eof_length) == F_equal_to) {
- *code = F_incomplete_utf_eof;
+ if (fl_string_compare(string, FL_status_string_memory_reallocation, length, FL_status_string_memory_reallocation_length) == F_equal_to) {
+ *code = F_memory_reallocation;
return F_none;
}
+ #endif // _di_F_status_memory_
- if (fl_string_compare(string, fl_status_string_incomplete_utf_on_eol, length, fl_status_string_incomplete_utf_on_eol_length) == F_equal_to) {
- *code = F_incomplete_utf_eol;
+ #ifndef _di_F_status_file_
+ if (fl_string_compare(string, FL_status_string_file, length, FL_status_string_file_length) == F_equal_to) {
+ *code = F_file;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_incomplete_utf_on_eos, length, fl_status_string_incomplete_utf_on_eos_length) == F_equal_to) {
- *code = F_incomplete_utf_eos;
+ if (fl_string_compare(string, FL_status_string_file_allocation, length, FL_status_string_file_allocation_length) == F_equal_to) {
+ *code = F_file_allocation;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_incomplete_utf_on_stop, length, fl_status_string_incomplete_utf_on_stop_length) == F_equal_to) {
- *code = F_incomplete_utf_stop;
+ if (fl_string_compare(string, FL_status_string_file_close, length, FL_status_string_file_close_length) == F_equal_to) {
+ *code = F_file_close;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_incomplete_utf_on_block, length, fl_status_string_incomplete_utf_on_block_length) == F_equal_to) {
- *code = F_incomplete_utf_block;
+ if (fl_string_compare(string, FL_status_string_file_closed, length, FL_status_string_file_closed_length) == F_equal_to) {
+ *code = F_file_closed;
return F_none;
}
- #endif // _di_fll_status_buffers_
- #ifndef _di_fll_status_allocation_
- if (fl_string_compare(string, fl_status_string_memory_allocation, length, fl_status_string_memory_allocation_length) == F_equal_to) {
- *code = F_memory_allocation;
+ if (fl_string_compare(string, FL_status_string_file_deallocation, length, FL_status_string_file_deallocation_length) == F_equal_to) {
+ *code = F_file_deallocation;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_memory_reallocation, length, fl_status_string_memory_reallocation_length) == F_equal_to) {
- *code = F_memory_reallocation;
+ if (fl_string_compare(string, FL_status_string_file_descriptor, length, FL_status_string_file_descriptor_length) == F_equal_to) {
+ *code = F_file_descriptor;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_memory_deallocation, length, fl_status_string_memory_deallocation_length) == F_equal_to) {
- *code = F_memory_deallocation;
+ if (fl_string_compare(string, FL_status_string_file_descriptor_max, length, FL_status_string_file_descriptor_max_length) == F_equal_to) {
+ *code = F_file_descriptor_max;
return F_none;
}
- #endif // _di_fll_status_allocation_
- #ifndef _di_fll_status_fork_
- if (fl_string_compare(string, fl_status_string_fork, length, fl_status_string_fork_length) == F_equal_to) {
- *code = F_fork;
+ if (fl_string_compare(string, FL_status_string_file_empty, length, FL_status_string_file_empty_length) == F_equal_to) {
+ *code = F_file_empty;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_process_too_many, length, fl_status_string_process_too_many_length) == F_equal_to) {
- *code = F_process_too_many;
+ if (fl_string_compare(string, FL_status_string_file_flush, length, FL_status_string_file_flush_length) == F_equal_to) {
+ *code = F_file_flush;
return F_none;
}
- #endif // _di_fll_status_fork_
- #ifndef _di_fll_status_file_
- if (fl_string_compare(string, fl_status_string_file_closed, length, fl_status_string_file_closed_length) == F_equal_to) {
- *code = F_file_closed;
+ if (fl_string_compare(string, FL_status_string_file_found, length, FL_status_string_file_found_length) == F_equal_to) {
+ *code = F_file_found;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_seek, length, fl_status_string_file_seek_length) == F_equal_to) {
- *code = F_file_seek;
+ if (fl_string_compare(string, FL_status_string_file_found_not, length, FL_status_string_file_found_not_length) == F_equal_to) {
+ *code = F_file_found_not;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_read, length, fl_status_string_file_read_length) == F_equal_to) {
- *code = F_file_read;
+ if (fl_string_compare(string, FL_status_string_file_open, length, FL_status_string_file_open_length) == F_equal_to) {
+ *code = F_file_open;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_write, length, fl_status_string_file_write_length) == F_equal_to) {
- *code = F_file_write;
+ if (fl_string_compare(string, FL_status_string_file_open_max, length, FL_status_string_file_open_max_length) == F_equal_to) {
+ *code = F_file_open_max;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_flush, length, fl_status_string_file_flush_length) == F_equal_to) {
- *code = F_file_flush;
+ if (fl_string_compare(string, FL_status_string_file_open_not, length, FL_status_string_file_open_not_length) == F_equal_to) {
+ *code = F_file_open_not;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_purge, length, fl_status_string_file_purge_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_file_purge, length, FL_status_string_file_purge_length) == F_equal_to) {
*code = F_file_purge;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_open, length, fl_status_string_file_open_length) == F_equal_to) {
- *code = F_file_open;
- return F_none;
- }
-
- if (fl_string_compare(string, fl_status_string_file_close, length, fl_status_string_file_close_length) == F_equal_to) {
- *code = F_file_close;
- return F_none;
- }
-
- if (fl_string_compare(string, fl_status_string_file_synchronize, length, fl_status_string_file_synchronize_length) == F_equal_to) {
- *code = F_file_synchronize;
+ if (fl_string_compare(string, FL_status_string_file_read, length, FL_status_string_file_read_length) == F_equal_to) {
+ *code = F_file_read;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_descriptor, length, fl_status_string_file_descriptor_length) == F_equal_to) {
- *code = F_file_descriptor;
+ if (fl_string_compare(string, FL_status_string_file_reallocation, length, FL_status_string_file_reallocation_length) == F_equal_to) {
+ *code = F_file_reallocation;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_found_not, length, fl_status_string_file_found_not_length) == F_equal_to) {
- *code = F_file_found_not;
+ if (fl_string_compare(string, FL_status_string_file_seek, length, FL_status_string_file_seek_length) == F_equal_to) {
+ *code = F_file_seek;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_empty, length, fl_status_string_file_empty_length) == F_equal_to) {
- *code = F_file_empty;
+ if (fl_string_compare(string, FL_status_string_file_stat, length, FL_status_string_file_stat_length) == F_equal_to) {
+ *code = F_file_stat;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_found, length, fl_status_string_file_found_length) == F_equal_to) {
- *code = F_file_found;
+ if (fl_string_compare(string, FL_status_string_file_synchronize, length, FL_status_string_file_synchronize_length) == F_equal_to) {
+ *code = F_file_synchronize;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_type_block, length, fl_status_string_file_type_block_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_file_type_block, length, FL_status_string_file_type_block_length) == F_equal_to) {
*code = F_file_type_block;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_type_character, length, fl_status_string_file_type_character_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_file_type_character, length, FL_status_string_file_type_character_length) == F_equal_to) {
*code = F_file_type_character;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_type_directory, length, fl_status_string_file_type_directory_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_file_type_directory, length, FL_status_string_file_type_directory_length) == F_equal_to) {
*code = F_file_type_directory;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_type_file, length, fl_status_string_file_type_file_length) == F_equal_to) {
- *code = F_file_type_file;
- return F_none;
- }
-
- if (fl_string_compare(string, fl_status_string_file_type_link, length, fl_status_string_file_type_link_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_file_type_link, length, FL_status_string_file_type_link_length) == F_equal_to) {
*code = F_file_type_link;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_type_pipe, length, fl_status_string_file_type_pipe_length) == F_equal_to) {
- *code = F_file_type_pipe;
- return F_none;
- }
-
- if (fl_string_compare(string, fl_status_string_file_type_socket, length, fl_status_string_file_type_socket_length) == F_equal_to) {
- *code = F_file_type_socket;
- return F_none;
- }
-
- if (fl_string_compare(string, fl_status_string_file_type_unknown, length, fl_status_string_file_type_unknown_length) == F_equal_to) {
- *code = F_file_type_unknown;
- return F_none;
- }
-
- if (fl_string_compare(string, fl_status_string_file_open_not, length, fl_status_string_file_open_not_length) == F_equal_to) {
- *code = F_file_open_not;
- return F_none;
- }
-
- if (fl_string_compare(string, fl_status_string_file_type_not_block, length, fl_status_string_file_type_not_block_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_file_type_not_block, length, FL_status_string_file_type_not_block_length) == F_equal_to) {
*code = F_file_type_not_block;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_type_not_character, length, fl_status_string_file_type_not_character_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_file_type_not_character, length, FL_status_string_file_type_not_character_length) == F_equal_to) {
*code = F_file_type_not_character;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_not_type_directory, length, fl_status_string_file_not_type_directory_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_file_type_not_directory, length, FL_status_string_file_type_not_directory_length) == F_equal_to) {
*code = F_file_type_not_directory;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_not_type_file, length, fl_status_string_file_not_type_file_length) == F_equal_to) {
- *code = F_file_type_not_file;
- return F_none;
- }
-
- if (fl_string_compare(string, fl_status_string_file_not_type_link, length, fl_status_string_file_not_type_link_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_file_type_not_link, length, FL_status_string_file_type_not_link_length) == F_equal_to) {
*code = F_file_type_not_link;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_not_type_pipe, length, fl_status_string_file_not_type_pipe_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_file_type_not_pipe, length, FL_status_string_file_type_not_pipe_length) == F_equal_to) {
*code = F_file_type_not_pipe;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_not_type_socket, length, fl_status_string_file_not_type_socket_length) == F_equal_to) {
- *code = F_file_type_not_socket;
+ if (fl_string_compare(string, FL_status_string_file_type_not_regular, length, FL_status_string_file_type_not_regular_length) == F_equal_to) {
+ *code = F_file_type_not_regular;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_not_type_unknown, length, fl_status_string_file_not_type_unknown_length) == F_equal_to) {
- *code = F_file_type_not_unknown;
- return F_none;
- }
-
- if (fl_string_compare(string, fl_status_string_file_allocation, length, fl_status_string_file_allocation_length) == F_equal_to) {
- *code = F_file_allocation;
+ if (fl_string_compare(string, FL_status_string_file_type_not_socket, length, FL_status_string_file_type_not_socket_length) == F_equal_to) {
+ *code = F_file_type_not_socket;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_reallocation, length, fl_status_string_file_reallocation_length) == F_equal_to) {
- *code = F_file_reallocation;
+ if (fl_string_compare(string, FL_status_string_file_type_not_unknown, length, FL_status_string_file_type_not_unknown_length) == F_equal_to) {
+ *code = F_file_type_not_unknown;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_deallocation, length, fl_status_string_file_deallocation_length) == F_equal_to) {
- *code = F_file_deallocation;
+ if (fl_string_compare(string, FL_status_string_file_type_pipe, length, FL_status_string_file_type_pipe_length) == F_equal_to) {
+ *code = F_file_type_pipe;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_stat, length, fl_status_string_file_stat_length) == F_equal_to) {
- *code = F_file_stat;
+ if (fl_string_compare(string, FL_status_string_file_type_regular, length, FL_status_string_file_type_regular_length) == F_equal_to) {
+ *code = F_file_type_regular;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file, length, fl_status_string_file_length) == F_equal_to) {
- *code = F_file_error;
+ if (fl_string_compare(string, FL_status_string_file_type_socket, length, FL_status_string_file_type_socket_length) == F_equal_to) {
+ *code = F_file_type_socket;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_not_utf, length, fl_status_string_file_not_utf_length) == F_equal_to) {
- *code = F_file_not_utf;
+ if (fl_string_compare(string, FL_status_string_file_type_unknown, length, FL_status_string_file_type_unknown_length) == F_equal_to) {
+ *code = F_file_type_unknown;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_descriptors_max, length, fl_status_string_file_descriptors_max_length) == F_equal_to) {
- *code = F_file_descriptors_max;
+ if (fl_string_compare(string, FL_status_string_file_utf, length, FL_status_string_file_utf_length) == F_equal_to) {
+ *code = F_file_utf;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_open_max, length, fl_status_string_file_open_max_length) == F_equal_to) {
- *code = F_file_open_max;
+ if (fl_string_compare(string, FL_status_string_file_utf_not, length, FL_status_string_file_utf_not_length) == F_equal_to) {
+ *code = F_file_utf_not;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_file_utf, length, fl_status_string_file_utf_length) == F_equal_to) {
- *code = F_file_utf;
+ if (fl_string_compare(string, FL_status_string_file_write, length, FL_status_string_file_write_length) == F_equal_to) {
+ *code = F_file_write;
return F_none;
}
- #endif // _di_fll_status_file_
+ #endif // _di_F_status_file_
- #ifndef _di_f_status_filesystem_
- if (fl_string_compare(string, fl_status_string_filesystem_error, length, fl_status_string_filesystem_error_length) == F_equal_to) {
+ #ifndef _di_F_status_filesystem_
+ if (fl_string_compare(string, FL_status_string_filesystem, length, FL_status_string_filesystem_length) == F_equal_to) {
*code = F_filesystem;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_filesystem_quota_blocks, length, fl_status_string_filesystem_quota_blocks_length) == F_equal_to) {
- *code = F_filesystem_quota_blocks;
+ if (fl_string_compare(string, FL_status_string_filesystem_quota_block, length, FL_status_string_filesystem_quota_block_length) == F_equal_to) {
+ *code = F_filesystem_quota_block;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_filesystem_quota_reached, length, fl_status_string_filesystem_quota_reached_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_filesystem_quota_reached, length, FL_status_string_filesystem_quota_reached_length) == F_equal_to) {
*code = F_filesystem_quota_reached;
return F_none;
}
- #endif // _di_f_status_filesystem_
+ #endif // _di_F_status_filesystem_
- #ifndef _di_fll_status_directory_
- if (fl_string_compare(string, fl_status_string_directory_closed, length, fl_status_string_directory_closed_length) == F_equal_to) {
- *code = F_directory_closed;
+ #ifndef _di_F_status_directory_
+ if (fl_string_compare(string, FL_status_string_directory, length, FL_status_string_directory_length) == F_equal_to) {
+ *code = F_directory;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_read, length, fl_status_string_directory_read_length) == F_equal_to) {
- *code = F_directory_read;
+ if (fl_string_compare(string, FL_status_string_directory_close, length, FL_status_string_directory_close_length) == F_equal_to) {
+ *code = F_directory_close;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_write, length, fl_status_string_directory_write_length) == F_equal_to) {
- *code = F_directory_write;
+ if (fl_string_compare(string, FL_status_string_directory_closed, length, FL_status_string_directory_closed_length) == F_equal_to) {
+ *code = F_directory_closed;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_flush, length, fl_status_string_directory_flush_length) == F_equal_to) {
- *code = F_directory_flush;
+ if (fl_string_compare(string, FL_status_string_directory_descriptor, length, FL_status_string_directory_descriptor_length) == F_equal_to) {
+ *code = F_directory_descriptor;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_link_max, length, fl_status_string_directory_link_max_length) == F_equal_to) {
- *code = F_directory_link_max;
+ if (fl_string_compare(string, FL_status_string_directory_empty, length, FL_status_string_directory_empty_length) == F_equal_to) {
+ *code = F_directory_empty;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_purge, length, fl_status_string_directory_purge_length) == F_equal_to) {
- *code = F_directory_purge;
+ if (fl_string_compare(string, FL_status_string_directory_found, length, FL_status_string_directory_found_length) == F_equal_to) {
+ *code = F_directory_found;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_open, length, fl_status_string_directory_open_length) == F_equal_to) {
- *code = F_directory_open;
+ if (fl_string_compare(string, FL_status_string_directory_found_not, length, FL_status_string_directory_found_not_length) == F_equal_to) {
+ *code = F_directory_found_not;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_close, length, fl_status_string_directory_close_length) == F_equal_to) {
- *code = F_directory_close;
+ if (fl_string_compare(string, FL_status_string_directory_flush, length, FL_status_string_directory_flush_length) == F_equal_to) {
+ *code = F_directory_flush;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_synchronize, length, fl_status_string_directory_synchronize_length) == F_equal_to) {
- *code = F_directory_synchronize;
+ if (fl_string_compare(string, FL_status_string_directory_link_max, length, FL_status_string_directory_link_max_length) == F_equal_to) {
+ *code = F_directory_link_max;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_descriptor, length, fl_status_string_directory_descriptor_length) == F_equal_to) {
- *code = F_directory_descriptor;
+ if (fl_string_compare(string, FL_status_string_directory_open, length, FL_status_string_directory_open_length) == F_equal_to) {
+ *code = F_directory_open;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_found, length, fl_status_string_directory_found_length) == F_equal_to) {
- *code = F_directory_found;
+ if (fl_string_compare(string, FL_status_string_directory_open_not, length, FL_status_string_directory_open_not_length) == F_equal_to) {
+ *code = F_directory_open_not;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_empty, length, fl_status_string_directory_empty_length) == F_equal_to) {
- *code = F_directory_empty;
+ if (fl_string_compare(string, FL_status_string_directory_purge, length, FL_status_string_directory_purge_length) == F_equal_to) {
+ *code = F_directory_purge;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_not_found, length, fl_status_string_directory_not_found_length) == F_equal_to) {
- *code = F_directory_not_found;
+ if (fl_string_compare(string, FL_status_string_directory_read, length, FL_status_string_directory_read_length) == F_equal_to) {
+ *code = F_directory_read;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_not_open, length, fl_status_string_directory_not_open_length) == F_equal_to) {
- *code = F_directory_not_open;
+ if (fl_string_compare(string, FL_status_string_directory_stream, length, FL_status_string_directory_stream_length) == F_equal_to) {
+ *code = F_directory_stream;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory, length, fl_status_string_directory_length) == F_equal_to) {
- *code = F_directory;
+ if (fl_string_compare(string, FL_status_string_directory_synchronize, length, FL_status_string_directory_synchronize_length) == F_equal_to) {
+ *code = F_directory_synchronize;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_not_utf, length, fl_status_string_directory_not_utf_length) == F_equal_to) {
- *code = F_directory_utf_not;
+ if (fl_string_compare(string, FL_status_string_directory_unsupported, length, FL_status_string_directory_unsupported_length) == F_equal_to) {
+ *code = F_directory_unsupported;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_unsupported, length, fl_status_string_directory_unsupported_length) == F_equal_to) {
- *code = F_directory_unsupported;
+ if (fl_string_compare(string, FL_status_string_directory_utf, length, FL_status_string_directory_utf_length) == F_equal_to) {
+ *code = F_directory_utf;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_stream, length, fl_status_string_directory_stream_length) == F_equal_to) {
- *code = F_directory_stream;
+ if (fl_string_compare(string, FL_status_string_directory_utf_not, length, FL_status_string_directory_utf_not_length) == F_equal_to) {
+ *code = F_directory_utf_not;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_directory_utf, length, fl_status_string_directory_utf_length) == F_equal_to) {
- *code = F_directory_utf;
+ if (fl_string_compare(string, FL_status_string_directory_write, length, FL_status_string_directory_write_length) == F_equal_to) {
+ *code = F_directory_write;
return F_none;
}
- #endif // _di_fll_status_directory_
+ #endif // _di_F_status_directory_
- #ifndef _di_fll_status_socket_
- if (fl_string_compare(string, fl_status_string_socket_connection_client, length, fl_status_string_socket_connection_client_length) == F_equal_to) {
- *code = F_socket_connection_client;
+ #ifndef _di_F_status_socket_
+ if (fl_string_compare(string, FL_status_string_socket_client, length, FL_status_string_socket_client_length) == F_equal_to) {
+ *code = F_socket_connect_client;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_socket_connection_target, length, fl_status_string_socket_connection_target_length) == F_equal_to) {
- *code = F_socket_connection_target;
+ if (fl_string_compare(string, FL_status_string_socket_target, length, FL_status_string_socket_target_length) == F_equal_to) {
+ *code = F_socket_connect_target;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_socket_receive, length, fl_status_string_socket_receive_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_socket_receive, length, FL_status_string_socket_receive_length) == F_equal_to) {
*code = F_socket_receive;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_socket_send, length, fl_status_string_socket_send_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_socket_send, length, FL_status_string_socket_send_length) == F_equal_to) {
*code = F_socket_send;
return F_none;
}
- #endif // _di_fll_status_socket_
-
- #ifndef _di_fll_status_non_
- if (fl_string_compare(string, fl_status_string_than_less, length, fl_status_string_than_less_length) == F_equal_to) {
- *code = F_than_less;
- return F_none;
- }
+ #endif // _di_F_status_socket_
- if (fl_string_compare(string, fl_status_string_equal_to, length, fl_status_string_equal_to_length) == F_equal_to) {
+ #ifndef _di_F_status_compare_
+ if (fl_string_compare(string, FL_status_string_equal_to, length, FL_status_string_equal_to_length) == F_equal_to) {
*code = F_equal_to;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_equal_to_not, length, fl_status_string_equal_to_not_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_equal_to_not, length, FL_status_string_equal_to_not_length) == F_equal_to) {
*code = F_equal_to_not;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_than_greater, length, fl_status_string_than_greater_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_than_greater, length, FL_status_string_than_greater_length) == F_equal_to) {
*code = F_than_greater;
return F_none;
}
- #endif // _di_fll_status_non_
- #ifndef _di_fll_status_access_denied_
- if (fl_string_compare(string, fl_status_string_access_denied, length, fl_status_string_access_denied_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_than_less, length, FL_status_string_than_less_length) == F_equal_to) {
+ *code = F_than_less;
+ return F_none;
+ }
+ #endif // _di_F_status_compare_
+
+ #ifndef _di_F_status_access_denied_
+ if (fl_string_compare(string, FL_status_string_access_denied, length, FL_status_string_access_denied_length) == F_equal_to) {
*code = F_access_denied;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_access_denied_user, length, fl_status_string_access_denied_user_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_access_denied_user, length, FL_status_string_access_denied_user_length) == F_equal_to) {
*code = F_access_denied_user;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_access_denied_group, length, fl_status_string_access_denied_group_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_access_denied_group, length, FL_status_string_access_denied_group_length) == F_equal_to) {
*code = F_access_denied_group;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_access_denied_world, length, fl_status_string_access_denied_world_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_access_denied_world, length, FL_status_string_access_denied_world_length) == F_equal_to) {
*code = F_access_denied_world;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_access_denied_read, length, fl_status_string_access_denied_read_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_access_denied_read, length, FL_status_string_access_denied_read_length) == F_equal_to) {
*code = F_access_denied_read;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_access_denied_write, length, fl_status_string_access_denied_write_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_access_denied_write, length, FL_status_string_access_denied_write_length) == F_equal_to) {
*code = F_access_denied_write;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_access_denied_execute, length, fl_status_string_access_denied_execute_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_access_denied_execute, length, FL_status_string_access_denied_execute_length) == F_equal_to) {
*code = F_access_denied_execute;
return F_none;
}
- if (fl_string_compare(string, fl_status_string_access_denied_super, length, fl_status_string_access_denied_super_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_access_denied_super, length, FL_status_string_access_denied_super_length) == F_equal_to) {
*code = F_access_denied_super;
return F_none;
}
- #endif // _di_fll_status_access_denied_
+ #endif // _di_F_status_access_denied_
- if (fl_string_compare(string, fl_status_string_status_code_last, length, fl_status_string_status_code_last_length) == F_equal_to) {
+ if (fl_string_compare(string, FL_status_string_status_code_last, length, FL_status_string_status_code_last_length) == F_equal_to) {
*code = F_status_code_last;
return F_none;
}
}
if (is_file) {
- if (status == F_directory_not_found) {
+ if (status == F_directory_found_not) {
if (verbosity != fake_verbosity_quiet) {
fprintf(f_type_error, "%c", f_string_eol);
fl_color_print(f_type_error, context.error, context.reset, "ERROR: failed to %s %s '", operation, file_or_directory);
}
}
else {
- if (status == F_directory_not_found) {
+ if (status == F_directory_found_not) {
if (verbosity != fake_verbosity_quiet) {
fprintf(f_type_error, "%c", f_string_eol);
fl_color_print(f_type_error, context.error, context.reset, "ERROR: failed to %s %s '", operation, file_or_directory);
status = f_file_stat(parameters_value[i]->string, F_true, &directory_stat);
- if (status == F_status_set_error(F_file_found_not)) status = F_status_set_error(F_directory_not_found);
+ if (status == F_status_set_error(F_file_found_not)) status = F_status_set_error(F_directory_found_not);
if (F_status_is_error(status)) {
- if (F_status_set_fine(status) != F_directory_not_found || parameters_required[i]) {
+ if (F_status_set_fine(status) != F_directory_found_not || parameters_required[i]) {
fake_print_error_file(data.context, data.verbosity, F_status_set_fine(status), "f_file_stat", parameters_value[i]->string, "access", F_false, F_true);
return status;
}
fl_color_print(f_type_error, data.context.notable, data.context.reset, "%s%s", f_console_symbol_long_enable, parameters_name[i]);
fl_color_print_line(f_type_error, data.context.error, data.context.reset, "' was found.");
- return F_status_set_error(F_directory_not_found);
+ return F_status_set_error(F_directory_found_not);
}
} // for
if (status == F_parameter) {
fl_color_print_line(f_type_error, data.context.error, data.context.reset, "INTERNAL ERROR: Invalid parameter when calling fll_fss_basic_read() for the file '%.*s'", file_path.used, file_path.string);
}
- else if (status == F_data_no_eos || status == F_data_not || status == F_data_no_stop) {
+ else if (status == F_data_not_eos || status == F_data_not || status == F_data_not_stop) {
// empty files are to be silently ignored
}
else if (status == F_memory_allocation || status == F_memory_reallocation) {
if (status == F_parameter) {
fl_color_print_line(f_type_error, data->context.error, data->context.reset, "INTERNAL ERROR: Invalid parameter when calling fll_fss_basic_list_read() for the file '%s'.", filename);
}
- else if (status == F_data_no_eos || status == F_data_not || status == F_data_no_stop) {
+ else if (status == F_data_not_eos || status == F_data_not || status == F_data_not_stop) {
fl_color_print_line(f_type_error, data->context.error, data->context.reset, "ERROR: No relevant data was found within the file '%s'.", filename);
}
else if (status == F_memory_allocation || status == F_memory_reallocation) {
fl_color_print(f_type_error, context.notable, context.reset, "%s()", function_name);
fl_color_print_line(f_type_error, context.error, context.reset, ".");
}
- else if (status == F_number_invalid) {
+ else if (status == F_number) {
fl_color_print(f_type_error, context.error, context.reset, "ERROR: The argument '");
fl_color_print(f_type_error, context.notable, context.reset, "%s", argument);
fl_color_print(f_type_error, context.error, context.reset, "' is not a valid number for the parameter '");
return F_status_set_error(status);
}
- else if (status == F_data_no_stop || status == F_data_no_eos) {
+ else if (status == F_data_not_stop || status == F_data_not_eos) {
// Clear buffers, then attempt the next file.
f_macro_fss_contents_delete_simple(data->contents);
f_macro_fss_objects_delete_simple(data->objects);
if (object) {
status = fl_fss_basic_list_object_write(input, &range, &buffer);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos || status == F_data_no_eol) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos || status == F_data_not_eol) {
return F_status_set_error(status);
}
}
else {
status = fl_fss_basic_list_content_write(input, &range, &buffer);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos || status == F_data_no_eol) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos || status == F_data_not_eol) {
return F_status_set_error(status);
}
}
if (object) {
status = fl_fss_basic_list_object_write(input, &range, &buffer);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos || status == F_data_no_eol) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos || status == F_data_not_eol) {
return F_status_set_error(status);
}
}
else {
status = fl_fss_basic_list_content_write(input, &range, &buffer);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos || status == F_data_no_eol) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos || status == F_data_not_eol) {
return F_status_set_error(status);
}
}
fl_color_print(f_type_error, context.notable, context.reset, "%s()", function_name);
fl_color_print_line(f_type_error, context.error, context.reset, ".");
}
- else if (status == F_number_invalid) {
+ else if (status == F_number) {
fl_color_print(f_type_error, context.error, context.reset, "ERROR: The argument '");
fl_color_print(f_type_error, context.notable, context.reset, "%s", argument);
fl_color_print(f_type_error, context.error, context.reset, "' is not a valid number for the parameter '");
return F_status_set_error(status);
}
- else if (status == F_data_no_stop || status == F_data_no_eos) {
+ else if (status == F_data_not_stop || status == F_data_not_eos) {
// Clear buffers, then attempt the next file.
f_macro_fss_contents_delete_simple(data->contents);
f_macro_fss_objects_delete_simple(data->objects);
if (object) {
status = fl_fss_basic_object_write(&buffer, input, &range);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return F_status_set_error(status);
}
}
else {
status = fl_fss_basic_content_write(&buffer, input, &range);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return F_status_set_error(status);
}
}
if (object) {
status = fl_fss_basic_object_write(&buffer, input, &range);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return F_status_set_error(status);
}
}
else {
status = fl_fss_basic_content_write(&buffer, input, &range);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return F_status_set_error(status);
}
}
fl_color_print(f_type_error, context.notable, context.reset, "%s()", function_name);
fl_color_print_line(f_type_error, context.error, context.reset, ".");
}
- else if (status == F_number_invalid) {
+ else if (status == F_number) {
fl_color_print(f_type_error, context.error, context.reset, "ERROR: The argument '");
fl_color_print(f_type_error, context.notable, context.reset, "%s", argument);
fl_color_print(f_type_error, context.error, context.reset, "' is not a valid number for the parameter '");
return F_status_set_error(status);
}
- else if (status == F_data_no_stop || status == F_data_no_eos) {
+ else if (status == F_data_not_stop || status == F_data_not_eos) {
// Clear buffers, then attempt the next file.
f_macro_fss_nest_delete_simple(data->nest);
f_macro_string_dynamic_delete_simple(data->buffer);
fl_color_print(f_type_error, context.notable, context.reset, "%s()", function_name);
fl_color_print_line(f_type_error, context.error, context.reset, ".");
}
- else if (status == F_number_invalid) {
+ else if (status == F_number) {
fl_color_print(f_type_error, context.error, context.reset, "ERROR: The argument '");
fl_color_print(f_type_error, context.notable, context.reset, "%s", argument);
fl_color_print(f_type_error, context.error, context.reset, "' is not a valid number for the parameter '");
return F_status_set_error(status);
}
- else if (status == F_data_no_stop || status == F_data_no_eos) {
+ else if (status == F_data_not_stop || status == F_data_not_eos) {
// Clear buffers, then attempt the next file.
f_macro_fss_contents_delete_simple(data->contents);
f_macro_fss_objects_delete_simple(data->objects);
if (object) {
status = fl_fss_extended_object_write(input, &range, &buffer);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return F_status_set_error(status);
}
}
else {
status = fl_fss_extended_content_write(input, &range, &buffer);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return F_status_set_error(status);
}
status = fl_fss_extended_object_write(input, &range, &buffer);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return F_status_set_error(status);
}
}
status = fl_fss_extended_content_write(input, &range, &buffer);
- if (F_status_is_error(status) || status == F_data_no_stop || status == F_data_no_eos) {
+ if (F_status_is_error(status) || status == F_data_not_stop || status == F_data_not_eos) {
return F_status_set_error(status);
}
if (data.parameters[fss_status_code_parameter_is_error].result == f_console_result_found) {
if (F_status_is_error(number)) {
- printf("%s\n", fl_status_string_true);
+ printf("%s\n", FL_status_string_true);
}
else {
- printf("%s\n", fl_status_string_false);
+ printf("%s\n", FL_status_string_false);
}
}
else if (data.parameters[fss_status_code_parameter_is_warning].result == f_console_result_found) {
if (F_status_is_warning(number)) {
- printf("%s\n", fl_status_string_true);
+ printf("%s\n", FL_status_string_true);
}
else {
- printf("%s\n", fl_status_string_false);
+ printf("%s\n", FL_status_string_false);
}
}
else if (data.parameters[fss_status_code_parameter_is_fine].result == f_console_result_found) {
if (F_status_is_fine(number)) {
- printf("%s\n", fl_status_string_true);
+ printf("%s\n", FL_status_string_true);
}
else {
- printf("%s\n", fl_status_string_false);
+ printf("%s\n", FL_status_string_false);
}
}
* F_none on success.
* F_data_not (with error bit) if string starts wth a null (length is 0).
* F_parameter (with error bit) if a parameter is invalid.
- * F_number_invalid (with error bit) if parameter is not a number.
+ * F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_overflow (with error bit) on integer overflow.
* F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
* F_none on success.
* F_data_not (with error bit) if string starts wth a null (length is 0).
* F_parameter (with error bit) if a parameter is invalid.
- * F_number_invalid (with error bit) if parameter is not a number.
+ * F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_overflow (with error bit) on integer overflow.
* F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
* F_none on success.
* F_data_not (with error bit) if string starts wth a null (length is 0).
* F_parameter (with error bit) if a parameter is invalid.
- * F_number_invalid (with error bit) if parameter is not a number.
+ * F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_overflow (with error bit) on integer overflow.
* F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
if (status == F_parameter) {
fl_color_print_line(f_type_error, data.context.error, data.context.reset, "INTERNAL ERROR: Invalid parameter when calling fll_fss_basic_list_read() for the file '%s'.", filename);
- } else if (status == F_data_no_eos || status == F_data_not || status == F_data_no_stop) {
+ } else if (status == F_data_not_eos || status == F_data_not || status == F_data_not_stop) {
fl_color_print_line(f_type_error, data.context.error, data.context.reset, "ERROR: No relevant data was found within the file '%s'.", filename);
} else if (status == F_memory_allocation || status == F_memory_reallocation) {
fl_color_print_line(f_type_error, data.context.error, data.context.reset, "CRITICAL ERROR: Unable to allocate memory.");
if (status == F_parameter) {
fl_color_print_line(f_type_error, data.context.error, data.context.reset, "INTERNAL ERROR: Invalid parameter when calling fll_fss_basic_list_read() for the file '%s'.", init_rule_core_file);
- } else if (status == F_data_no_eos || status == F_data_not || status == F_data_no_stop) {
+ } else if (status == F_data_not_eos || status == F_data_not || status == F_data_not_stop) {
fl_color_print_line(f_type_error, data.context.error, data.context.reset, "ERROR: No relevant data was found within the file '%s'.", init_rule_core_file);
} else if (status == F_memory_allocation || status == F_memory_reallocation) {
fl_color_print_line(f_type_error, data.context.error, data.context.reset, "CRITICAL ERROR: Unable to allocate memory.");
if (data.parameters[status_code_parameter_is_error].result == f_console_result_found) {
if (F_status_is_error(number)) {
- printf("%s\n", fl_status_string_true);
+ printf("%s\n", FL_status_string_true);
}
else {
- printf("%s\n", fl_status_string_false);
+ printf("%s\n", FL_status_string_false);
}
}
else if (data.parameters[status_code_parameter_is_warning].result == f_console_result_found) {
if (F_status_is_warning(number)) {
- printf("%s\n", fl_status_string_true);
+ printf("%s\n", FL_status_string_true);
}
else {
- printf("%s\n", fl_status_string_false);
+ printf("%s\n", FL_status_string_false);
}
}
else if (data.parameters[status_code_parameter_is_fine].result == f_console_result_found) {
if (F_status_is_fine(number)) {
- printf("%s\n", fl_status_string_true);
+ printf("%s\n", FL_status_string_true);
}
else {
- printf("%s\n", fl_status_string_false);
+ printf("%s\n", FL_status_string_false);
}
}
* F_none on success.
* F_data_not (with error bit) if string starts wth a null (length is 0).
* F_parameter (with error bit) if a parameter is invalid.
- * F_number_invalid (with error bit) if parameter is not a number.
+ * F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_overflow (with error bit) on integer overflow.
* F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
* F_none on success.
* F_data_not (with error bit) if string starts wth a null (length is 0).
* F_parameter (with error bit) if a parameter is invalid.
- * F_number_invalid (with error bit) if parameter is not a number.
+ * F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_overflow (with error bit) on integer overflow.
* F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
* F_none on success.
* F_data_not (with error bit) if string starts wth a null (length is 0).
* F_parameter (with error bit) if a parameter is invalid.
- * F_number_invalid (with error bit) if parameter is not a number.
+ * F_number (with error bit) if parameter is not a number.
* F_number_negative (with error bit) on negative value.
* F_number_overflow (with error bit) on integer overflow.
* F_incomplete_utf (with error bit) if an incomplete UTF-8 fragment is found.
projects / fll / commitdiff