whence.c File Reference

Find the full path of a file in the directories specified by the. More...

#include <argp.h>
#include <cm.h>
#include <fcntl.h>
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <unistd.h>

Include dependency graph for whence.c:

Go to the source code of this file.

Enumerations
enum	WhenceFlags { WH_ALL = 1 , WH_VERBOSE = 2 }

Functions
void	ABEND (char *pgmid, int rc, char *err_msg)
	Exit the program with an error message.
int	file_spec_parts (char *file_spec, char *file_path, char *file_name)
	Split a file specification into directory and file name components.
int	main (int argc, char **argv)
int	next_path (char *dp, char **sp)
	Extract the next directory path from the PATH string.
void	normalend ()
	Exit the program successfully.
void	whence (char *file_spec_p, int flags)
	Find the full path of a file in the directories specified by the PATH environment variable.

Variables
const char *	argp_program_bug_address = "billxwaller@gmail.com"
const char *	argp_program_version = CM_VERSION
char *	file_name [MAXLEN+1]
char *	path_p
char	path_s [MAXLEN]
int	wh_flags = 0

Detailed Description

Find the full path of a file in the directories specified by the.

Author

Bill Waller Copyright (c) 2025 MIT License billx.nosp@m.wall.nosp@m.er@gm.nosp@m.ail..nosp@m.com

Date

2026-02-09

Definition in file whence.c.

Enumeration Type Documentation

WhenceFlags

enum WhenceFlags

Enumerator
WH_ALL
WH_VERBOSE

Definition at line 32 of file whence.c.

{ WH_ALL = 1, WH_VERBOSE = 2 } WhenceFlags;

Function Documentation

ABEND()

void ABEND	(	char *	pgmid,
		int	rc,
		char *	err_msg )

Exit the program with an error message.

Parameters

pgmid	The name of the program
rc	The return code to exit with
err_msg	The error message to display

This function is called to exit the program with an error status. It prints the program name, return code, and error message to the standard error stream, and then exits with the specified return code.

Definition at line 236 of file whence.c.

                                               {
    fprintf(stderr, "%s; error %d; %s\n", pgmid, rc, err_msg);
    exit(EXIT_FAILURE);
}

file_spec_parts()

int file_spec_parts	(	char *	file_spec,
		char *	file_path,
		char *	file_name )

Split a file specification into directory and file name components.

Parameters

file_spec	The full file specification to split
file_path	A buffer to store the extracted directory path
file_name	A buffer to store the extracted file name

Returns

0 on success

This function takes a file specification, checks if it is a directory, and if so, it sets the file path accordingly. If the file specification is empty, it defaults to the current directory. Otherwise, it splits the file specification into the directory and file name components based on the last occurrence of a slash ('/').

Definition at line 175 of file whence.c.

                                                                       {
    int i, last_slash;
    char tmp_file_spec[PATH_MAX];
    int file_spec_l;
    struct stat stat_struct;
 
    if (stat(file_spec, &stat_struct) != -1)
        if ((stat_struct.st_mode & S_IFMT) == S_IFDIR) {
            if (file_spec[strlen(file_path)] != '/')
                strnz__cat(file_spec, "/", MAXLEN - 1);
            strnz__cpy(file_path, file_spec, MAXLEN - 1);
            file_name[0] = '\0';
            return (0);
        }
    if (strlen(file_spec) == 0) {
        strnz__cpy(file_spec, "./", MAXLEN - 1);
        file_name[0] = '\0';
        return (0);
    }
    strnz__cpy(tmp_file_spec, file_spec, MAXLEN - 1);
    last_slash = -1;
    file_spec_l = strlen(tmp_file_spec);
    if (file_spec_l > 0) {
        i = 0;
        while (i < file_spec_l && tmp_file_spec[i] != '\0') {
            if (tmp_file_spec[i] == '/') {
                last_slash = i;
                break;
            }
            i++;
        }
    }
    if (last_slash < 0) {
        strnz__cpy(file_path, "./", MAXLEN - 1);
        if (strcmp(file_spec, ".") == 0)
            file_name[0] = '\0';
        else
            strnz__cpy(file_name, tmp_file_spec, MAXLEN - 1);
        strnz__cpy(file_spec, file_path, MAXLEN - 1);
        strnz__cat(file_spec, file_name, MAXLEN - 1);
    } else {
        tmp_file_spec[last_slash] = '\0';
        strnz__cpy(file_path, tmp_file_spec, MAXLEN - 1);
        strnz__cat(file_path, "/", MAXLEN - 1);
        if (last_slash < file_spec_l)
            last_slash++;
        strnz__cpy(file_name, tmp_file_spec + last_slash, MAXLEN - 1);
    }
    return (0);
}

References strnz__cat(), and strnz__cpy().

Referenced by whence().

Here is the call graph for this function:

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char **	argv )

Definition at line 77 of file whence.c.

                                {
    struct wh_opts wh_opts = {0};
    wh_opts.flags = 0;
    wh_opts.argv[0] = nullptr;
 
    argp_parse(&argp, argc, argv, 0, 0, &wh_opts);
    path_p = getenv("PATH");
    if (path_p == nullptr)
        ABEND(argv[0], 0, "PATH environment variable not set");
    if (wh_opts.flags & WH_VERBOSE)
        printf("%s\n", path_p);
    while (optind < argc) {
        whence(wh_opts.argv[optind++], wh_opts.flags);
    }
    normalend();
}

References ABEND(), normalend(), path_p, WH_VERBOSE, and whence().

Here is the call graph for this function:

next_path()

int next_path	(	char *	dp,
		char **	sp )

Extract the next directory path from the PATH string.

Parameters

dp	A buffer to store the extracted directory path
sp	A pointer to the current position in the PATH string

Returns

The length of the extracted directory path

This function takes a buffer and a pointer to the current position in the PATH string, and extracts the next directory path. If the next character in the PATH string is a colon, it treats it as an empty path and uses the current working directory. Otherwise, it copies characters until it reaches a colon or the end of the string, and returns the length of the extracted path.

Definition at line 146 of file whence.c.

                                   {
    int dl;
 
    if (**sp == ':') {
        (*sp)++;
        getcwd(dp, PATH_MAX);
        return (strlen(dp));
    } else {
        dl = 0;
        while (**sp != '\0' && **sp != '\n' && **sp != '\r' && **sp != ':') {
            *dp++ = *(*sp)++;
            dl++;
        }
        *dp = '\0';
        if (**sp == ':' && *++(*sp) == '\0')
            (*sp)--;
        return (dl);
    }
}

Referenced by whence().

Here is the caller graph for this function:

normalend()

void normalend

(

)

Exit the program successfully.

This function is called to exit the program with a success status. It simply calls the exit function with EXIT_SUCCESS.

Definition at line 228 of file whence.c.

{ exit(EXIT_SUCCESS); }

Referenced by main().

Here is the caller graph for this function:

whence()

void whence	(	char *	file_spec_p,
		int	flags )

Find the full path of a file in the directories specified by the PATH environment variable.

Parameters

file_spec_p	The file specification to search for
flags	Flags to control the behavior of the search (e.g., verbose mode, list all matches)

This function takes a file specification, extracts the directory and file name components, and searches through the directories specified in the PATH environment variable to find matches. It prints the full path of each match found, and if verbose mode is enabled, it also indicates whether each attempted path was found or not.

Definition at line 103 of file whence.c.

                                          {
    char file_spec[PATH_MAX];
    char file_dir[PATH_MAX];
    char file_name[PATH_MAX];
    char try_spec[PATH_MAX];
    char try_dir[PATH_MAX];
    int path_l;
    struct stat stat_struct;
 
    strnz__cpy(file_spec, file_spec_p, MAXLEN - 1);
    strnz__cpy(path_s, path_p, MAXLEN - 1);
    file_spec_parts(file_spec, file_dir, file_name);
    path_p = path_s;
    path_l = next_path(try_dir, &path_p);
    while (path_l != 0) {
        strnz__cpy(try_spec, try_dir, MAXLEN - 1);
        if (try_spec[path_l] != '/')
            strnz__cat(try_spec, "/", MAXLEN - 1);
        strnz__cat(try_spec, file_name, MAXLEN - 1);
        if (flags & WH_VERBOSE) {
            if (stat(try_spec, &stat_struct) == -1)
                printf("-      %s\n", try_spec);
            else
                printf("found  %s\n", try_spec);
        } else if (stat(try_spec, &stat_struct) == 0) {
            printf("%s\n", try_spec);
            if (!(flags & WH_ALL))
                return;
        }
        path_l = next_path(try_dir, &path_p);
    }
}

References file_spec_parts(), next_path(), path_p, path_s, strnz__cat(), strnz__cpy(), WH_ALL, and WH_VERBOSE.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

argp_program_bug_address

const char* argp_program_bug_address = "billxwaller@gmail.com"

Definition at line 35 of file whence.c.

argp_program_version

const char* argp_program_version = CM_VERSION

Definition at line 34 of file whence.c.

file_name

char* file_name[MAXLEN+1]

Definition at line 25 of file whence.c.

path_p

char* path_p

Definition at line 23 of file whence.c.

Referenced by main(), and whence().

path_s

char path_s[MAXLEN]

Definition at line 24 of file whence.c.

Referenced by whence().

wh_flags

int wh_flags = 0

Definition at line 33 of file whence.c.