string manipulation, file handling, and error reporting. More...

Functions
size_t	trim (char *s)
	Trims leading and trailing spaces from string s in place.
size_t	ssnprintf (char buf, size_t buf_size, const char format,...)
	ssnprintf was designed to be a safer alternative to snprintf.
int	str_to_args (char *argv, char arg_str, int max_args)
	Converts a string into an array of argument strings.
void	destroy_argv (int argc, char **argv)
	Deallocates memory allocated for argument strings in argv.
bool	str_to_lower (char *s)
	Converts a string to lowercase.
bool	str_to_upper (char *s)
	Converts a string to uppercase.
size_t	strnz__cpy (char d, const char s, size_t max_len)
	safer alternative to strncpy
size_t	strnz__cat (char d, const char s, size_t max_len)
	safer alternative to strncat
size_t	strz (char *s)
	Terminates string at new line or carriage return.
size_t	strnz (char *s, size_t max_len)
	terminates string at New Line, Carriage Return, or max_len
size_t	strnlf (char *s, size_t max_len)
	terminates string with line feed
char *	strnz_dup (char *s, size_t l)
	Allocates memory for and duplicates string s up to length l or until line feed or carriage return.
bool	str_subc (char d, char s, char ReplaceChr, char *Withstr, int l)
	Replaces "ReplaceChr" in "s" with "Withstr" in "d" won't copy more than "l" bytes to "d" Replaces all occurrences of a character in a string with another string, copying the result to a destination buffer.
bool	strnfill (char *s, char c, int n)
	Fills string s with character c n.
bool	strip_quotes (char *s)
	removes leading and trailing double quotes if present
bool	stripz_quotes (char *s)
	removes leading and trailing double quotes if present
bool	chrep (char *s, char old_chr, char new_chr)
	Replaces all occurrences of old_chr in s with new_chr in place.
int	a_toi (char s, bool a_toi_error)
	a safer alternative to atoi() for converting ASCII strings to integers.
size_t	strip_ansi (char d, char s)
	Strips ANSI SGR escape sequences (ending in 'm') from string s to d.
bool	normalize_file_spec (char *fs)
	replace backslashes with forward lashes
bool	file_spec_path (char fp, char fs)
	extracts the path component of a file specification
bool	file_spec_name (char fn, char fs)
	extracts the file name component of a file specification
double	str_to_double (char *s)
	converts string to double
bool	expand_tilde (char *path, int path_maxlen)
	Replace Leading Tilde With Home Directory.
bool	trim_path (char *dir)
	Trims trailing spaces and slashes from directory path in place.
bool	trim_ext (char buf, char filename)
	trims the file extension from "filename" and copies the result to "buf"
bool	base_name (char buf, char path)
	Returns the base name of a file specification.
bool	dir_name (char buf, char path)
	Returns the directory name of a file specification.
bool	verify_dir (char *spec, int imode)
	Verifies that the directory specified by "spec" exists and is accessible with the permissions specified by "imode".
bool	verify_file (char *in_spec, int imode)
	Verifies that the file specified by "in_spec" exists and is accessible with the permissions specified by "imode".
bool	locate_file_in_path (char file_spec, char file_name)
	Locates a file in the system PATH.
bool	lf_find (const char base_path, const char re, const char *ere, int max_depth, int flags)
	Find files in a directory matching a regular expression.
bool	lf_process (const char base_path, regex_t compiled_re, regex_t *compiled_ere, int depth, int max_depth, int flags)
	logic for lf_find()
bool	mk_dir (char *dir)
	If directory doesn't exist, make it.
size_t	canonicalize_file_spec (char *spec)
	Removes quotes and trims at first space.
bool	is_directory (const char *path)
	Checks if the given path is a directory.
bool	is_valid_regex (const char *pattern)
	Checks if the given regular expression pattern is valid.
char *	rep_substring (const char org_s, const char tgt_s, const char *rep_s)
	Replace all occurrences of "tgt_s" in "org_s" with "rep_s".

Detailed Description

string manipulation, file handling, and error reporting.

These functions provide common operations such as trimming strings, converting case, safely copying and concatenating strings, verifying file and directory access, and locating files in the system PATH. They are designed to be robust and handle edge cases gracefully, making them useful for a wide range of applications.

Function Documentation

◆ a_toi()

int a_toi	(	char *	s,
		bool *	a_toi_error )

a safer alternative to atoi() for converting ASCII strings to integers.

Parameters

s	is the input string
a_toi_error	is a pointer to a boolean that will be set to true if an error occurs during conversion, or false if the conversion is successful.

Note: accepts positive integers only.; sets a_toi_error to (-1) on error

Returns: converted integer value, or -1 if an error occurs

Definition at line 505 of file futil.c.

                                      {
    int rc = -1;
    *a_toi_error = false;
    errno = 0;
    if (s && *s != 0)
        rc = (int)strtol(s, nullptr, 10);
    if (rc < 0 || errno) {
        rc = -1;
        *a_toi_error = true;
    }
    return rc;
}

Referenced by parse_ansi_str().

Here is the caller graph for this function:

◆ base_name()

bool base_name	(	char *	buf,
		char *	path )

Returns the base name of a file specification.

Parameters

buf	- buffer to receive result
path	- file specification

Returns: true if successful

Note: The caller is responsible for ensuring that "buf" has enough space to receive the result.

Definition at line 775 of file futil.c.

                                      {
    if (!path || !*path || !buf)
        return false;
    char *s = path;
    char *d = buf;
    *d = '\0';
    while (*s) {
        if (*s == '/' || *s == '\\') {
            d = buf;
        } else {
            *d++ = *s;
        }
        s++;
    }
    *d = '\0';
    if (d == buf)
        return false;
    return true;

Referenced by build_prompt(), exec_objects(), form_process(), init_form_files(), init_pick_files(), main(), and view_init_input().

Here is the caller graph for this function:

◆ canonicalize_file_spec()

size_t canonicalize_file_spec ( char * spec )

Removes quotes and trims at first space.

Parameters

spec	- file specification to canonicalize

Returns: length of resulting string

Definition at line 1216 of file futil.c.

                                          {
    if (spec == nullptr || *spec == '\0')
        return 0;
    char tmp_s[MAXLEN];
    char *s;
    s = spec;
    char *d;
    d = tmp_s;
    int l = 0;
    while (*s != '\0') {
        if (*s == ' ')
            break;
        if (*s == '\"' || *s == '\'') {
            s++;
            continue;
            ;
        }
        *d++ = *s++;
        l++;
    }
    *d = '\0';
    strnz__cpy(spec, tmp_s, MAXLEN - 1);
    l = strlen(spec);
    return l;

References strnz__cpy().

Referenced by locate_file_in_path(), verify_file(), and verify_spec_arg().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ chrep()

bool chrep	(	char *	s,
		char	old_chr,
		char	new_chr )

Replaces all occurrences of old_chr in s with new_chr in place.

Parameters

s	- string to modify
old_chr	- character to replace
new_chr	- character to insert

Returns: true if successful or false if string s is null

Definition at line 486 of file futil.c.

                                                {
    if (s == nullptr)
        return false;
    while (*s != '\0') {
        if (*s == old_chr)
            *s = new_chr;
        s++;
    }
    return true;
}

Referenced by parse_menu_description().

Here is the caller graph for this function:

◆ destroy_argv()

void destroy_argv	(	int	argc,
		char **	argv )

Deallocates memory allocated for argument strings in argv.

Parameters

argc	- count of allocated vectors in argv
argv	- array of pointers to arguments

Note: the caller must ensure that argc accurately reflects the number of allocated strings in argv, and that argv is not null. After calling this function, the pointers in argv will be set to nullptr to prevent dangling pointers.

Definition at line 221 of file futil.c.

                                         {
    for (int i = 0; i < argc; i++) {
        if (argv[i] != nullptr) {
            free(argv[i]);
            argv[i] = nullptr;
        }
    }
}

Referenced by destroy_init(), destroy_view(), display_pick_help(), enter_file_spec(), exec_objects(), form_engine(), form_process(), init_pick(), menu_cmd_processor(), view_display_help(), and view_init_input().

Here is the caller graph for this function:

◆ dir_name()

bool dir_name	(	char *	buf,
		char *	path )

Returns the directory name of a file specification.

Parameters

buf	- buffer to receive result
path	- file specification

Returns: true if successful

Note: The caller is responsible for ensuring that "buf" has enough space to receive the result.

Definition at line 801 of file futil.c.

                                     {
    if (!path || !*path || !buf)
        return false;
    char tmp_str[MAXLEN];
    strnz__cpy(tmp_str, path, MAXLEN);
    char *s = tmp_str;
    while (*s++)
        ;
    while (tmp_str < --s) {
        if (*s == '/' || *s == '\\') {
            *s = '\0';
            break;
        }
    }
    while (tmp_str < --s && (*s == '/' || *s == '\\'))
        *s = '\0';
    char *d = buf;
    *d = '\0';
    s = tmp_str;
    while (*s) {
        *d++ = *s++;
    }
    *d = '\0';
    if (d == buf)
        return false;
    return true;

References strnz__cpy().

Here is the call graph for this function:

◆ expand_tilde()

bool expand_tilde	(	char *	path,
		int	path_maxlen )

Replace Leading Tilde With Home Directory.

Parameters

path	- path to expand
path_maxlen	- maximum length of path

Note: The caller is responsible for ensuring that "path" has enough space to receive the result, and that "path_maxlen" is sufficient to hold the result. This function does not perform any bounds checking on "path", so it is the caller's responsibility to ensure that it is valid and that "path_maxlen" is appropriate for the operation.

Returns: true if successful

Definition at line 684 of file futil.c.

                                               {
    if (path == nullptr || *path == '\0' || path_maxlen == 0)
        return false;
    char *e;
    char ts[MAXLEN];
    char *tp;
 
    if (!path || !*path || !path_maxlen)
        return false;
    tp = path;
    if (*tp == '~') {
        tp++;
        while (*tp == '/') {
            tp++;
        }
        e = getenv("HOME");
        if (e) {
            strnz__cpy(ts, e, path_maxlen - 1);
            strnz__cat(ts, "/", path_maxlen - 1);
            strnz__cat(ts, tp, path_maxlen - 1);
            strnz__cpy(path, ts, path_maxlen - 1);
        }
    }
    return true;

References strnz__cat(), and strnz__cpy().

Referenced by enter_file_spec(), mapp_initialization(), mk_dir(), parse_config(), verify_dir(), verify_file(), verify_spec_arg(), and view_init_input().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ file_spec_name()

bool file_spec_name	(	char *	fn,
		char *	fs )

extracts the file name component of a file specification

Parameters

fn	- name component to return
fs	- full file specification

Note: The caller is responsible for ensuring that "fn" has enough space to receive the result.

Definition at line 605 of file futil.c.

                                        {
    if (fs == nullptr || *fs == '\0' || fn == nullptr) {
        if (fn != nullptr)
            *fn = '\0';
        return false;
    }
    char *d, *l, *s;
    l = nullptr;
    s = fs;
    while (*s != '\0') {
        if (*s == '/')
            l = s;
        s++;
    }
    if (l == nullptr)
        s = fs;
    else
        s = ++l;
    d = fn;
    while (*s != '\0')
        *d++ = *s++;
    *d = '\0';
    return true;

◆ file_spec_path()

bool file_spec_path	(	char *	fp,
		char *	fs )

extracts the path component of a file specification

Parameters

fp	- path component to return
fs	- full file specification

Returns: true if successful

Note: The caller is responsible for ensuring that "fp" has enough space to receive the result.

Definition at line 578 of file futil.c.

                                        {
    if (fs == nullptr || *fs == '\0' || fp == nullptr) {
        if (fp != nullptr)
            *fp = '\0';
        return false;
    }
    char *d, *l, *s;
    s = fp;
    d = fs;
    l = nullptr;
    while (*s != '\0') {
        if (*s == '/')
            l = d;
        *d++ = *s++;
    }
    if (l == nullptr)
        *fp = '\0'; // no slash, so no path
    else
        *l = '\0';
    return true;

◆ is_directory()

bool is_directory ( const char * path )

Checks if the given path is a directory.

Parameters

path	- path to check

Returns: true if the path is a directory, false otherwise

Definition at line 1245 of file futil.c.

                                    {
    struct stat statbuf;
    if (stat(path, &statbuf) != 0) {
        return false;
    }
    return S_ISDIR(statbuf.st_mode);

Referenced by main().

Here is the caller graph for this function:

◆ is_valid_regex()

bool is_valid_regex ( const char * pattern )

Checks if the given regular expression pattern is valid.

Parameters

pattern - regular expression pattern to check

Returns: true if the pattern is valid, false otherwise

Definition at line 1256 of file futil.c.

                                         {
    regex_t regex;
    int ret = regcomp(&regex, pattern, REG_EXTENDED);
    regfree(&regex);
    return (ret == 0);

Referenced by main().

Here is the caller graph for this function:

◆ lf_find()

bool lf_find	(	const char *	base_path,
		const char *	re,
		const char *	ere,
		int	max_depth,
		int	flags )

Find files in a directory matching a regular expression.

Parameters

base_path	directory to search
ere	regular expression match to exclude
re	regular expression match to include
max_depth	depth of directories to scan
flags	search flags

See also: lf_process() for flag definitions return true if successful, false otherwise

Definition at line 977 of file futil.c.

                                       {
    int reti;
    regex_t compiled_re;
    regex_t compiled_ere;
    int REG_FLAGS = REG_EXTENDED;
    if (flags & LF_ICASE)
        REG_FLAGS |= REG_ICASE;
    if (flags & LF_REGEX) {
        reti = regcomp(&compiled_re, re, REG_FLAGS);
        if (reti) {
            ssnprintf(em0, MAXLEN - 1, "lf: \'%s\' Invalid pattern\n", re);
            ssnprintf(em1, MAXLEN - 1, "for example: \'.*\\.c$\'\n\n");
            regerror(reti, &compiled_re, em2, sizeof(em2));
            display_error(em0, em1, em2, nullptr);
            regfree(&compiled_re);
            return false;
        }
    }
    if (flags & LF_EXC_REGEX) {
        regcomp(&compiled_ere, "^$", REG_FLAGS);
        reti = regcomp(&compiled_ere, ere, REG_FLAGS);
        if (reti) {
            ssnprintf(em0, MAXLEN - 1, "lf: \'%s\' Invalid exclude pattern\n",
                      re);
            ssnprintf(em1, MAXLEN - 1, "for example: \'.*\\.c$\'\n\n");
            regerror(reti, &compiled_ere, em2, sizeof(em2));
            display_error(em0, em1, em2, nullptr);
            regfree(&compiled_ere);
            return false;
        }
    }
    reti =
        lf_process(base_path, &compiled_re, &compiled_ere, 0, max_depth, flags);
    if (flags &= LF_REGEX)
        regfree(&compiled_re);
    if (flags & LF_EXC_REGEX)
        regfree(&compiled_ere);
    if (reti)
        return false;
    return true;

References display_error(), em0, em1, em2, LF_EXC_REGEX, LF_ICASE, lf_process(), LF_REGEX, and ssnprintf().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lf_process()

bool lf_process	(	const char *	base_path,
		regex_t *	compiled_re,
		regex_t *	compiled_ere,
		int	depth,
		int	max_depth,
		int	flags )

logic for lf_find()

Parameters

base_path	directory to search
compiled_ere	compiled regular expression to exclude
compiled_re	compiled regular expression to include
depth	recursion counter
max_depth	how deep to descend into the directory structure
flags

Returns

true if successful, false otherwise

LF_ALL = 1,       List all files including hidden files
LF_ICASE = 2,     Ignore case in search
LF_EXC_REGEX = 4, Exclude files matching regular expression
LF_REGEX = 8,     Include files matching regular expression
LF_BLK = 256,
LF_CHR = 512,
LF_DIR = 1024,
LF_FIFO = 2048,
LF_LNK = 4096,
LF_REG = 8192,
LF_SOCK = 16384,
LF_UNKNOWN = 32768,
                  Include     Exclude
                 ----------  ----------
LF_BLK        1  0 00000001  7 11111110 block device
LF_CHR        2  1 00000010  6 11111101 character device
LF_DIR        4  2 00000100  5 11111011 directory
LF_FIFO       8  3 00001000  4 11110111 named pipe
LF_LNK       16  4 00010000  3 11101111 link
LF_REG       32  5 00100000  2 11011111 regular file
LF_SOCK      64  6 01000000  1 10111111 socket
LF_UNKNOWN  128  7 10000000  0 01111111 unknown

bool s_blk;
bool s_chr;
bool s_dir;
bool s_fifo;
bool s_lnk;
bool s_reg;
bool s_sock;
bool s_unknown;

Definition at line 1063 of file futil.c.

                                                                            {
    char tmp_str[MAXLEN];
    struct dirent *dir_st;
    DIR *dir;
    int REG_FLAGS = REG_EXTENDED;
    int reti;
    regmatch_t pmatch[1];
    char file_spec[1024];
    bool suppress;
    int f_include;
    int f_suppress;
    bool suppress_hidden = flags & LF_HIDE ? true : false;
    char bname[MAXLEN];
    if ((dir = opendir(base_path)) == 0)
        return false;
    while ((dir_st = readdir(dir)) != nullptr) {
        strnz__cpy(bname, dir_st->d_name, MAXLEN - 1);
        if (bname[0] == '.' && bname[1] == '\0')
            continue;
        else if (bname[0] == '.' && bname[1] == '.' && bname[2] == '\0')
            continue;
        else if (bname[0] == '.' && suppress_hidden)
            continue;
        f_suppress = 0;
        f_include = (flags >> 8) & 0xff;
        if (f_include)
            f_suppress = f_include ^ 0xff;
        bool s_blk = f_suppress & FT_BLK ? 1 : 0;
        bool s_chr = f_suppress & FT_CHR ? 1 : 0;
        bool s_dir = f_suppress & FT_DIR ? 1 : 0;
        bool s_fifo = f_suppress & FT_FIFO ? 1 : 0;
        bool s_lnk = f_suppress & FT_LNK ? 1 : 0;
        bool s_reg = f_suppress & FT_REG ? 1 : 0;
        bool s_sock = f_suppress & FT_SOCK ? 1 : 0;
        bool s_unknown = f_suppress & FT_UNKNOWN ? 1 : 0;
        suppress = false;
        switch (dir_st->d_type) {
        case DT_BLK:
            if (s_blk)
                suppress = true;
            break;
        case DT_CHR:
            if (s_chr)
                suppress = true;
            break;
        case DT_DIR:
            if (s_dir)
                suppress = true;
            break;
        case DT_FIFO:
            if (s_fifo)
                suppress = true;
            break;
        case DT_LNK:
            if (s_lnk)
                suppress = true;
            break;
        case DT_REG:
            if (s_reg)
                suppress = true;
            break;
        case DT_SOCK:
            if (s_sock)
                suppress = true;
            break;
        case DT_UNKNOWN:
            if (s_unknown)
                suppress = true;
            break;
        default:
            break;
        }
        if (dir_st->d_name[0] == '.' && dir_st->d_name[1] == '/')
            strnz__cpy(file_spec, &dir_st->d_name[2], MAXLEN - 1);
        else
            strnz__cpy(file_spec, dir_st->d_name, MAXLEN - 1);
        ssnprintf(file_spec, sizeof(file_spec), "%s/%s", base_path, bname);
        if (bname[0] == '.' && suppress_hidden)
            suppress = true;
        if (!suppress && (flags & LF_REGEX)) {
            reti = regexec(compiled_re, file_spec, compiled_re->re_nsub + 1,
                           pmatch, REG_FLAGS);
            if (reti == REG_NOMATCH) {
                suppress = true;
            } else if (reti) {
                char msgbuf[100];
                regerror(reti, compiled_re, msgbuf, sizeof(msgbuf));
                strnz__cpy(tmp_str, "Regex match failed: ", MAXLEN - 1);
                strnz__cat(tmp_str, msgbuf, MAXLEN - 1);
                Perror(tmp_str);
                return false;
            }
        }
        if (!suppress && (flags & LF_EXC_REGEX)) {
            reti = regexec(compiled_ere, file_spec, compiled_re->re_nsub + 1,
                           pmatch, REG_FLAGS);
            if (reti == 0)
                suppress = true;
            else if (reti == REG_NOMATCH)
                suppress = false;
            else if (reti) {
                char msgbuf[100];
                regerror(reti, compiled_re, msgbuf, sizeof(msgbuf));
                strnz__cpy(tmp_str, "Regex match failed: ", MAXLEN - 1);
                strnz__cat(tmp_str, msgbuf, MAXLEN - 1);
                Perror(tmp_str);
                return false;
            }
        }
 
        if (!suppress) {
            if (file_spec[0] == '.' && file_spec[1] == '/')
                printf("%s\n", &file_spec[2]);
            else
                printf("%s\n", file_spec);
        }
        if (max_depth == 0 ||
            (dir_st->d_type == DT_DIR && depth + 1 < max_depth)) {
            depth++;
            lf_process(file_spec, compiled_re, compiled_ere, depth, max_depth,
                       flags);
            depth--;
        }
    }
    closedir(dir);
    return true;

References FT_BLK, FT_CHR, FT_DIR, FT_FIFO, FT_LNK, FT_REG, FT_SOCK, FT_UNKNOWN, LF_EXC_REGEX, LF_HIDE, lf_process(), LF_REGEX, Perror(), ssnprintf(), strnz__cat(), and strnz__cpy().

Referenced by lf_find(), and lf_process().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ locate_file_in_path()

bool locate_file_in_path	(	char *	file_spec,
		char *	file_name )

Locates a file in the system PATH.

Parameters

file_spec	- buffer to receive located file specification
file_name	- name of file to locate

Returns: true if file is located

Note: file_spec must be large enough to receive the result

Definition at line 939 of file futil.c.

                                                           {
    if (file_name == nullptr || *file_name == '\0' || file_spec == nullptr)
        return false;
    char path[MAXLEN];
    char fn[MAXLEN];
    char *p, *fnp, *dir;
 
    canonicalize_file_spec(file_name);
    strnz__cpy(fn, file_name, MAXLEN - 1);
    fnp = fn;
    while (*fnp && *fnp != '/')
        fnp++;
    if (*fnp == '/')
        return false;
    if ((p = getenv("PATH")) == nullptr)
        return false;
    strnz__cpy(path, p, MAXLEN - 1);
    dir = strtok(path, ":");
    while (dir != nullptr) {
        strnz__cpy(file_spec, dir, MAXLEN - 1);
        strnz__cat(file_spec, "/", MAXLEN - 1);
        strnz__cat(file_spec, file_name, MAXLEN - 1);
        if (access(file_spec, F_OK) == 0) {
            return true;
        }
        dir = strtok(nullptr, ":");
    }
    return false;

References canonicalize_file_spec(), strnz__cat(), and strnz__cpy().

Referenced by init_form_files(), init_pick_files(), and verify_spec_arg().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ mk_dir()

bool mk_dir ( char * dir )

If directory doesn't exist, make it.

Parameters

dir	directory name

Returns: true if directory now exists or false otherwise

Directory does not exist and unable to create

Definition at line 1195 of file futil.c.

                       {
    expand_tilde(dir, MAXLEN - 1);
    if (!verify_dir(dir, S_WCOK | S_QUIET)) {
        if (!mkdir(dir, 0755)) {
            ssnprintf(em0, MAXLEN - 1, "%s, line: %d", __FILE__, __LINE__ - 2);
            strnz__cpy(em1, "mkdir ", MAXLEN - 1);
            strnz__cat(em1, dir, MAXLEN - 1);
            strnz__cat(em1, " failed", MAXLEN - 1);
            strerror_r(errno, em2, MAXLEN - 1);
            display_error(em0, em1, em2, nullptr);
            return false;
        }
        return true;
    }
    return true;

References display_error(), em0, em1, em2, expand_tilde(), ssnprintf(), strnz__cat(), strnz__cpy(), and verify_dir().

Referenced by enter_file_spec().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ normalize_file_spec()

bool normalize_file_spec ( char * fs )

replace backslashes with forward lashes

Parameters

fs	- file specification to normalize

Returns: true if successful, false if fs is nullptr or empty

Definition at line 561 of file futil.c.

                                   {
    if (fs == nullptr || *fs == '\0')
        return false;
    while (*fs != '\0') {
        if (*fs == '\\')
            *fs = '/';
        fs++;
    }
    return true;

◆ rep_substring()

char * rep_substring	(	const char *	org_s,
		const char *	tgt_s,
		const char *	rep_s )

Replace all occurrences of "tgt_s" in "org_s" with "rep_s".

Parameters

org_s	- original string
tgt_s	- target substring to replace
rep_s	- replacement substring

Returns: A pointer to the newly allocated string with replacements or a copy of the replacement string if original string is the same as target string This is a special case that allows for replacing the entire original string. If any parameter is nullptr, the function returns nullptr. If "tgt_s" is not found in "org_s", the function returns a copy of "org_s". If target substring is not found the function returns a copy of the original string.

Note: allocates memory for the return value, so the caller is responsible for freeing this memory when it is no longer needed to avoid memory leaks.; Does not modify the original string "org_s".; Assumes that "tgt_s" and "rep_s" are null-terminated strings. If they are not, the behavior is undefined.; Does not perform any bounds checking on the input strings, so it is the caller's responsibility to ensure that they are valid and that the resulting string does not exceed available memory.; Uses the standard library functions strlen, strstr, malloc, and strcpy, which may have their own limitations and behaviors that the caller should be aware of.; Does not handle overlapping occurrences of "tgt_s" in "org_s". If "tgt_s" can overlap with itself in "org_s", the behavior may be unexpected. The caller should ensure that "tgt_s" does not contain overlapping patterns to avoid this issue.; Does not handle cases where "tgt_s" is a substring of "rep_s", which could lead to unintended consequences if "tgt_s" appears in "rep_s". The caller should ensure that "tgt_s" and "rep_s" are distinct to avoid this issue.

Definition at line 1292 of file futil.c.

                                                                             {
    if (org_s == nullptr || tgt_s == nullptr || rep_s == nullptr)
        return nullptr;
    if (*org_s == '\0' || *tgt_s == '\0' || *rep_s == '\0')
        return nullptr;
    if (strstr(org_s, tgt_s) == nullptr)
        return strdup(org_s);
    if (strstr(rep_s, tgt_s) != nullptr)
        return nullptr;
    if (tgt_s == rep_s || tgt_s == org_s || rep_s == org_s)
        return strdup(org_s);
    if (strcmp(org_s, tgt_s) == 0)
        return strdup(rep_s);
    char *out_s, *ip, *tmp;
    int tgt_l = strlen(tgt_s);
    int rep_l = strlen(rep_s);
    int head_l;
    int n = 0;
    ip = (char *)org_s;
    while ((tmp = strstr(ip, tgt_s)) != nullptr) {
        n++;
        ip = tmp + tgt_l;
    }
    out_s = malloc(strlen(org_s) + (rep_l - tgt_l) * n + 1);
    if (!out_s) {
        return nullptr;
    }
    tmp = out_s;
    ip = (char *)org_s;
    while (n--) {
        char *p = strstr(ip, tgt_s);
        head_l = p - ip;
        strnz__cpy(tmp, ip, head_l);
        tmp += head_l;
        strnz__cpy(tmp, rep_s, MAXLEN - 1);
        tmp += rep_l;
        ip += head_l + tgt_l;
    }
    strnz__cpy(tmp, ip, MAXLEN - 1);
    return out_s;

References strnz__cpy().

Referenced by exec_objects().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ssnprintf()

size_t ssnprintf	(	char *	buf,
		size_t	buf_size,
		const char *	format,
			... )

ssnprintf was designed to be a safer alternative to snprintf.

It ensures that the buffer is not overflowed by taking the buffer size as a parameter and using vsnprintf internally. It also returns the number of characters that would have been written if enough space had been available, allowing the caller to detect truncation. This function is particularly useful in situations where the formatted string may exceed the buffer size, as it prevents buffer overflows and provides a way to handle such cases gracefully.

Parameters

buf	- buffer to receive formatted string
buf_size	- size of buffer
format	- printf-style format string
...	- arguments

Returns: number of characters that would have been written if enough space had been available

Definition at line 147 of file futil.c.

                                                                      {
    size_t n;
    va_list args;
 
    va_start(args, format);
    n = vsnprintf(buf, buf_size, format, args);
    va_end(args);
 
    return n;
}

Referenced by action_disposition(), answer_yn(), display_error(), display_line(), enter_file_spec(), fork_exec(), form_desc_error(), form_parse_desc(), form_process(), form_write(), get_clr_pair(), handle_signal(), init_view_boxwin(), init_view_full_screen(), lf_find(), lf_process(), lp(), mapp_initialization(), menu_engine(), mk_dir(), new_init(), new_pick(), new_view(), open_pick_win(), parse_menu_description(), Perror(), search(), set_chyron_key(), set_chyron_key_cp(), signal_handler(), verify_dir(), verify_file(), view_cmd_processor(), view_init_input(), wait_continue(), wait_mk_win(), waitpid_with_timeout(), and write_view_buffer().

Here is the caller graph for this function:

◆ str_subc()

bool str_subc	(	char *	d,
		char *	s,
		char	ReplaceChr,
		char *	Withstr,
		int	l )

Replaces "ReplaceChr" in "s" with "Withstr" in "d" won't copy more than "l" bytes to "d" Replaces all occurrences of a character in a string with another string, copying the result to a destination buffer.

Parameters

d	- destination string
s	- source string
ReplaceChr	- character to replace
Withstr	- string to insert
l	- maximum length to copy

Returns: true if successful, false if any parameter is invalid

This function ensures that the total length of the resulting string does not exceed the specified limit, and that the result is null-terminated. This function is useful for simple string substitutions where you want to replace a single character with a longer string, such as replacing spaces with underscores or tabs with spaces.

Note: The caller must ensure that "d" has enough space to receive the result, and that "l" is sufficient to hold the result. This function does not perform any bounds checking on "d" or "Withstr", so it is the caller's responsibility to ensure that they are valid and that "l" is appropriate for the operation.

Definition at line 415 of file futil.c.

                                                                       {
    char *e;
    if (s == nullptr || d == nullptr || Withstr == nullptr || l == 0) {
        if (d != nullptr && l > 0)
            *d = '\0';
        return false;
    }
    e = d + l;
    while (*s != '\0' && d < e) {
        if (*s == ReplaceChr) {
            while (*Withstr != '\0' && d < e)
                *d++ = *Withstr++;
            s++;
        } else
            *d++ = *s++;
    }
    *d = '\0';
    return true;
}

Referenced by view_cmd_processor().

Here is the caller graph for this function:

◆ str_to_args()

int str_to_args	(	char **	argv,
		char *	arg_str,
		int	max_args )

Converts a string into an array of argument strings.

Note: Handles quoted strings and escaped quotes, preserving text inside quotes as individual arguments. It has been in service for many years without problems.

Parameters

argv	- array of pointers to arguments
arg_str	- string containing arguments
max_args	- maximum number of arguments to parse

Returns: argc, a count of allocated vectors in argv

Note: the caller is responsible for deallocating the strings in argv

Definition at line 167 of file futil.c.

                                                          {
    if (arg_str == nullptr || *arg_str == '\0')
        return 0;
    int argc = 0;
    char *p = arg_str;
    char tmp_str[MAXLEN];
    int in_quotes = 0;
    char *d = tmp_str;
 
    while (*p != '\0' && argc < max_args) {
        while (isspace((unsigned char)*p))
            p++;
        if (*p == '\0')
            break;
        if (*p == '"') {
            in_quotes = 1;
            p++;
        }
        while (*p != '\0') {
            if (in_quotes) {
                if (*p == '\\' && *(p + 1) == '"') {
                    *d++ = '"';
                    p += 2;
                } else if (*p == '"') {
                    *d++ = '\0';
                    p++;
                    in_quotes = 0;
                    break;
                } else
                    *d++ = *p++;
            } else {
                if (isspace((unsigned char)*p)) {
                    *d++ = '\0';
                    p++;
                    break;
                } else
                    *d++ = *p++;
            }
        }
        *d = '\0';
        d = tmp_str;
        argv[argc++] = strdup(tmp_str);
    }
    argv[argc] = nullptr;
    return argc;
}

Referenced by enter_file_spec(), exec_objects(), form_process(), init_pick(), menu_cmd_processor(), and view_init_input().

Here is the caller graph for this function:

◆ str_to_double()

double str_to_double ( char * s )

converts string to double

Parameters

s	- string to convert

Returns: converted double value, or 0.0 if s is nullptr, empty, or invalid

Note: The caller must ensure that the string is a valid representation of a double before calling this function.

Definition at line 637 of file futil.c.

                              {
    char *e;
    double d;
 
    if (!s || !*s)
        return false;
    d = strtod(s, &e);
    return d;

Referenced by parse_config().

Here is the caller graph for this function:

◆ str_to_lower()

bool str_to_lower ( char * s )

Converts a string to lowercase.

Parameters

s	- string to convert

Returns: true if successful, false if s is nullptr or empty

Definition at line 233 of file futil.c.

                           {
    if (s == nullptr || *s == '\0')
        return false;
    while (*s != '\0') {
        if (*s >= 'A' && *s <= 'Z')
            *s = *s + 'a' - 'A';
        s++;
    }
    return true;
}

Referenced by clr_name_to_idx(), and form_parse_desc().

Here is the caller graph for this function:

◆ str_to_upper()

bool str_to_upper ( char * s )

Converts a string to uppercase.

Parameters

s	- string to convert

Returns: true if successful, false if s is nullptr or empty

Definition at line 247 of file futil.c.

                           {
    if (s == nullptr || *s == '\0')
        return false;
    while (*s != '\0') {
        if (*s >= 'a' && *s <= 'z')
            *s = *s + 'A' - 'a';
        s++;
    }
    return true;
}

◆ strip_ansi()

size_t strip_ansi	(	char *	d,
		char *	s )

Strips ANSI SGR escape sequences (ending in 'm') from string s to d.

Parameters

d	Destination string
s	Source string

Returns: Length of stripped string
char dest[1024];

char src[] = "\033[31mThis is red text\033[0m

size_t len = strip_ansi(dest, src);

Result: dest = "This is red text", len = 17

@example stripansi.c

Note: Only handles SGR sequences ending in 'm' or 'K'; Skips non-ASCII characters; The caller must ensure that d has enough space to hold the stripped string; This function does not allocate memory; it assumes d is pre-allocated; This function processes the entire string until the null terminator; This function does not modify the source string s

Definition at line 537 of file futil.c.

                                    {
    size_t l = 0;
    while (*s) {
        if (*s == '\033') {
            while (*s && *s != 'm' && *s != 'K')
                s++;
            if (*s == 'm' || *s == 'K')
                s++;
            continue;
        } else {
            if ((unsigned char)*s <= 127) {
                *d++ = *s++;
                l++;
            } else
                s++;
        }
    }
    *d = '\0';
    return l;

Referenced by main(), and write_view_buffer().

Here is the caller graph for this function:

◆ strip_quotes()

bool strip_quotes ( char * s )

removes leading and trailing double quotes if present

Parameters

s	- string to strip quotes from

Returns: true if successful, false if s is nullptr or empty

Definition at line 454 of file futil.c.

                           {
    if (s == nullptr)
        return false;
    int l = strlen(s);
    if (l > 1 && s[l - 1] == '\"') {
        memmove(s, s + 1, l - 2);
        s[l - 2] = '\0';
    }
    return true;
}

Referenced by init_form_files(), and init_view_files().

Here is the caller graph for this function:

◆ stripz_quotes()

bool stripz_quotes ( char * s )

removes leading and trailing double quotes if present

Parameters

s	- string to strip quotes from

Returns: true if quotes were removed

Note: Same as STRIP_QUOTES but returns true if quotes were removed

Definition at line 469 of file futil.c.

                            {
    if (s == nullptr || strlen(s) < 2)
        return false;
    int l = strlen(s);
    if (l > 1 && s[0] == '\"' && s[l - 1] == '\"') {
        memmove(s, s + 1, l - 2);
        s[l - 2] = '\0';
        return true;
    }
    return false;
}

Referenced by verify_spec_arg().

Here is the caller graph for this function:

◆ strnfill()

bool strnfill	(	char *	s,
		char	c,
		int	n )

Fills string s with character c n.

Parameters

s	- string to fill
c	- character to fill with
n	- number of characters to fill

Returns: true if successful, false if s is nullptr or n is non-positive

Definition at line 440 of file futil.c.

                                      {
    if (s == nullptr || n <= 0)
        return false;
    char *e;
    e = s + n;
    while (s < e)
        *s++ = c;
    *s = '\0';
    return true;
}

Referenced by form_display_fields().

Here is the caller graph for this function:

◆ strnlf()

size_t strnlf	(	char *	s,
		size_t	max_len )

terminates string with line feed

Parameters

s	string to terminate
max_len	maximum length to scan

Returns: length of resulting string

Definition at line 358 of file futil.c.

                                       {
    char *e;
    size_t len = 0;
    if (s == nullptr || *s == '\0' || max_len == 0)
        return 0;
    e = s + max_len;
    while (*s != '\0' && *s != '\n' && *s != '\r' && s < e) {
        s++;
        len++;
    }
    *s++ = '\n';
    len++;
    *s = '\0';
    return (len);
}

Referenced by write_view_buffer().

Here is the caller graph for this function:

◆ strnz()

size_t strnz	(	char *	s,
		size_t	max_len )

terminates string at New Line, Carriage Return, or max_len

Note: The use case is to ensure that strings read from files or user input do not contain embedded newlines or carriage returns.

Parameters

s	string to terminate
max_len	- maximum length to scan

Returns: length of resulting string

Definition at line 340 of file futil.c.

                                      {
    char *e;
    size_t len = 0;
    if (s == nullptr || *s == '\0' || max_len == 0)
        return 0;
    e = s + max_len;
    while (*s != '\0' && *s != '\n' && *s != '\r' && s < e) {
        s++;
        len++;
    }
    *s = '\0';
    return (len);
}

Referenced by answer_yn(), display_error(), enter_file_spec(), form_display_fields(), form_display_screen(), form_fmt_field(), and pick_engine().

Here is the caller graph for this function:

◆ strnz__cat()

size_t strnz__cat	(	char *	d,
		const char *	s,
		size_t	max_len )

safer alternative to strncat

Note: It appends string s to d, ensuring that the total length of d does not exceed max_len, and that the resulting string is null-terminated. It also treats newline and carriage return characters as string terminators, preventing them from being included in the result. This is particularly useful when concatenating user input or file data, where embedded newlines could cause issues.

Parameters

d	- destination string
s	- source string
max_len	- maximum length to copy

Returns: length of resulting string

Definition at line 298 of file futil.c.

                                                          {
    char *e;
    size_t len = 0;
    if (s == nullptr || d == nullptr || max_len == 0) {
        if (d != nullptr && max_len > 0)
            *d = '\0';
        return 0;
    }
    e = d + max_len;
    while (*d != '\0' && *d != '\n' && *d != '\r' && d < e) {
        d++;
        len++;
    }
    while (*s != '\0' && *s != '\n' && *s != '\r' && d < e) {
        *d++ = *s++;
        len++;
    }
    *d = '\0';
    return len;
}

Referenced by build_prompt(), derive_file_spec(), display_pick_help(), enter_file_spec(), exec_objects(), expand_tilde(), file_spec_parts(), form_display_screen(), form_engine(), form_exec_cmd(), form_parse_desc(), form_process(), form_read_data(), form_write(), init_form(), init_menu_files(), init_pick(), init_view_files(), lf_process(), locate_file_in_path(), menu_cmd_processor(), mk_dir(), open_curses(), output_objects(), parse_menu_description(), popup_ckeys(), search(), verify_spec_arg(), view_cmd_processor(), view_display_help(), view_init_input(), whence(), write_config(), and write_view_buffer().

Here is the caller graph for this function:

◆ strnz__cpy()

size_t strnz__cpy	(	char *	d,
		const char *	s,
		size_t	max_len )

safer alternative to strncpy

copies string s to d, ensuring that the total length of d does not exceed max_len, and that the resulting string is null-terminated. It also treats newline and carriage return characters as string terminators, preventing them from being included in the result. This is particularly useful when copying user input or file data, where embedded newlines could cause issues.

Parameters

d	- destination string
s	- source string
max_len	- maximum length to copy

Returns: length of resulting string

Definition at line 269 of file futil.c.

                                                          {
    char *e;
    size_t len = 0;
    if (s == nullptr || d == nullptr || max_len == 0) {
        if (d != nullptr && max_len > 0)
            *d = '\0';
        return 0;
    }
    e = d + max_len;
    while (*s != '\0' && *s != '\n' && *s != '\r' && d < e) {
        *d++ = *s++;
        len++;
    }
    *d = '\0';
    return len;
}

Referenced by answer_yn(), build_prompt(), canonicalize_file_spec(), derive_file_spec(), dir_name(), display_error(), display_pick_help(), display_prompt(), enter_file_spec(), exec_objects(), expand_tilde(), file_spec_parts(), form_desc_error(), form_display_screen(), form_engine(), form_exec_cmd(), form_fmt_field(), form_parse_desc(), form_process(), form_read_data(), form_write(), get_cmd_arg(), handle_signal(), init_form(), init_form_files(), init_menu_files(), init_pick(), init_pick_files(), init_view_boxwin(), init_view_files(), lf_process(), locate_file_in_path(), main(), mapp_initialization(), menu_cmd_processor(), mk_dir(), new_form(), open_curses(), output_objects(), parse_config(), parse_menu_description(), Perror(), popup_ckeys(), rep_substring(), save_object(), search(), verify_dir(), verify_file(), verify_spec_arg(), view_cmd_processor(), view_display_help(), view_file(), view_init_input(), whence(), write_config(), and write_view_buffer().

Here is the caller graph for this function:

◆ strnz_dup()

char * strnz_dup	(	char *	s,
		size_t	l )

Allocates memory for and duplicates string s up to length l or until line feed or carriage return.

Parameters

s	- string to duplicate
l	- maximum length to copy

Returns: pointer to allocated memory

Definition at line 379 of file futil.c.

                                   {
    char *p, *rs, *e;
    size_t m;
    if (s == nullptr || *s == '\0' || l == 0)
        return nullptr;
    for (p = s, m = 1; *p != '\0'; p++, m++)
        ;
    rs = p = (char *)malloc(m);
    if (rs != nullptr) {
        e = rs + l;
        while (*s != '\0' && *s != '\n' && *s != '\r' && p < e)
            *p++ = *s++;
        *p = '\0';
    }
    return rs;
}

Referenced by new_view().

Here is the caller graph for this function:

◆ strz()

size_t strz ( char * s )

Terminates string at new line or carriage return.

Parameters

s	string to terminate

Definition at line 322 of file futil.c.

                     {
    size_t l = 0;
    if (s == nullptr || *s == '\0')
        return 0;
    while (*s != '\0' && *s != '\n' && *s != '\r') {
        s++;
        l++;
    }
    *s = '\0';
    return l;
}

◆ trim()

size_t trim ( char * s )

Trims leading and trailing spaces from string s in place.

Parameters

s	- string to trim

Returns: length of trimmed string

Definition at line 118 of file futil.c.

                     {
    if (s == nullptr || *s == '\0')
        return 0;
    char *p = s;
    char *d = s;
    while (*p == ' ')
        p++;
    while (*p != '\0')
        *d++ = *p++;
    while (*(d - 1) == ' ' && d > s)
        d--;
    *d = '\0';
    return (size_t)(d - s);
}

Referenced by form_fmt_field(), form_parse_desc(), left_justify(), menu_cmd_processor(), parse_menu_description(), and right_justify().

Here is the caller graph for this function:

◆ trim_ext()

bool trim_ext	(	char *	buf,
		char *	filename )

trims the file extension from "filename" and copies the result to "buf"

Parameters

buf	- buffer to receive result
filename	- filename to trim

Note: The caller is responsible for ensuring that "buf" has enough space to receive the result.

Definition at line 741 of file futil.c.

                                         {
    if (!filename || !*filename || !buf)
        return false;
    char *s = filename;
    char *d = buf;
    *d = '\0';
    while (*s)
        s++;
    while (filename < --s) {
        if (*s == '.') {
            break;
        }
    }
    if (*s != '.') {
        while (*filename)
            *d++ = *filename++;
    } else {
        while (filename < s) {
            *d++ = *filename++;
        }
    }
    *d = '\0';
    if (d == buf)
        return false;
    return true;

◆ trim_path()

bool trim_path ( char * dir )

Trims trailing spaces and slashes from directory path in place.

Parameters

dir	- directory path to trim

Returns: true if successful

Definition at line 713 of file futil.c.

                          {
    if (!dir)
        return false;
    char *p;
 
    if (!dir || !*dir)
        return false;
    p = dir;
    while (*p++ != '\0') {
        if (*p == ' ' || *p == '\t' || *p == '\n') {
            *p = '\0';
            break;
        }
    }
    --p;
    while (--p > dir && *p == '/') {
        if (*(p - 1) != '~')
            *p = '\0';
    }
    return true;

Referenced by derive_file_spec().

Here is the caller graph for this function:

◆ verify_dir()

bool verify_dir	(	char *	spec,
		int	imode )

Verifies that the directory specified by "spec" exists and is accessible with the permissions specified by "imode".

Parameters

spec	- directory specification
imode	- access mode F_OK - existence R_OK - read W_OK - Write X_OK - Execute S_WCOK - Write or Create S_QUIET - Suppress Error Messages

Note: S_WCOK and S_QUIET are stripped before calling faccessat

Returns: true if successful

Definition at line 841 of file futil.c.

                                       {
    if (spec == nullptr || *spec == '\0')
        return false;
    expand_tilde(spec, MAXLEN);
    struct stat sb;
    errno = 0;
    src_line = 0;
    int mode = imode & ~(S_WCOK | S_QUIET);
    if (faccessat(AT_FDCWD, spec, mode, AT_EACCESS) != 0) {
        src_line = __LINE__ - 2;
        src_name = __FILE__;
        strnz__cpy(fn, "faccessat", MAXLEN - 1);
    } else {
        if (fstatat(AT_FDCWD, spec, &sb, 0) != 0) {
            src_line = __LINE__ - 1;
            src_name = __FILE__;
            strnz__cpy(fn, "fstatat", MAXLEN - 1);
        } else {
            if ((sb.st_mode & S_IFMT) != S_IFDIR) {
                src_line = __LINE__ - 1;
                src_name = __FILE__;
                strnz__cpy(fn, "verify_file", MAXLEN - 1);
                strnz__cpy(em2, "Not a regular file.", MAXLEN - 1);
            }
        }
    }
    if (src_line != 0) {
        if (!(mode & S_QUIET)) {
            ssnprintf(em0, MAXLEN - 1, "%s failed in %s at line %d", fn,
                      src_name, src_line);
            strnz__cpy(em1, spec, MAXLEN - 1);
            strnz__cpy(em3, "Check the file", MAXLEN - 1);
            display_error(em0, em1, em2, em3);
        }
        return false;
    }
    return true;

References display_error(), em0, em1, em2, em3, expand_tilde(), fn, src_line, src_name, ssnprintf(), and strnz__cpy().

Referenced by mapp_initialization(), mk_dir(), and verify_spec_arg().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ verify_file()

bool verify_file	(	char *	in_spec,
		int	imode )

Verifies that the file specified by "in_spec" exists and is accessible with the permissions specified by "imode".

Parameters

in_spec	- directory specification
imode	- access mode F_OK - existence R_OK - read W_OK - Write X_OK - Execute S_WCOK - Write or Create S_QUIET - Suppress Error Messages

Note: S_WCOK and S_QUIET are stripped before calling faccessat

Returns: true if successful

Definition at line 892 of file futil.c.

                                           {
    if (in_spec == nullptr || *in_spec == '\0')
        return false;
    struct stat sb;
    char spec[MAXLEN];
    strnz__cpy(spec, in_spec, MAXLEN - 1);
    int mode = imode & ~(S_WCOK | S_QUIET);
    errno = 0;
    src_line = 0;
    canonicalize_file_spec(spec);
    expand_tilde(spec, MAXLEN);
    if ((faccessat(AT_FDCWD, spec, mode, AT_EACCESS)) != 0) {
        src_line = __LINE__ - 1;
        src_name = __FILE__;
        strnz__cpy(fn, "faccessat", MAXLEN - 1);
    } else {
        if ((fstatat(AT_FDCWD, spec, &sb, 0)) != 0) {
            src_line = __LINE__ - 1;
            src_name = __FILE__;
            strnz__cpy(fn, "fstatat", MAXLEN - 1);
        } else {
            if ((sb.st_mode & S_IFMT) != S_IFREG) {
                src_line = __LINE__ - 1;
                src_name = __FILE__;
                strnz__cpy(fn, "verify_file", MAXLEN - 1);
                strnz__cpy(em2, "Not a regular file.", MAXLEN - 1);
            }
        }
    }
    if (src_line != 0) {
        if (imode & S_QUIET)
            return false;
        ssnprintf(em0, MAXLEN - 1, "%s failed in %s at line %d", fn, src_name,
                  src_line);
        strnz__cpy(em1, spec, MAXLEN - 1);
        strnz__cpy(em3, "Check the file", MAXLEN - 1);
        display_error(em0, em1, em2, em3);
        return false;
    }
    return true;

References canonicalize_file_spec(), display_error(), em0, em1, em2, em3, expand_tilde(), fn, src_line, src_name, ssnprintf(), and strnz__cpy().

Referenced by verify_spec_arg().

Here is the call graph for this function:

Here is the caller graph for this function:

Functions

Detailed Description

Function Documentation

◆ a_toi()

◆ base_name()

◆ canonicalize_file_spec()

◆ chrep()

◆ destroy_argv()

◆ dir_name()

◆ expand_tilde()

◆ file_spec_name()

◆ file_spec_path()

◆ is_directory()

◆ is_valid_regex()

◆ lf_find()

◆ lf_process()

◆ locate_file_in_path()

◆ mk_dir()

◆ normalize_file_spec()

◆ rep_substring()

◆ ssnprintf()

◆ str_subc()

◆ str_to_args()

◆ str_to_double()

◆ str_to_lower()

◆ str_to_upper()

◆ strip_ansi()

◆ strip_quotes()

◆ stripz_quotes()

◆ strnfill()

◆ strnlf()

◆ strnz()

◆ strnz__cat()

◆ strnz__cpy()

◆ strnz_dup()

◆ strz()

◆ trim()

◆ trim_ext()

◆ trim_path()

◆ verify_dir()

◆ verify_file()