path.h

 
#ifndef LIB_LIBPATH_H
#define LIB_LIBPATH_H
 
#include <kernel/types.h>
 
#include <utils/compiler.h>
 
#include <stdbool.h>
#include <stddef.h>
 
#define LIBPATH_SEPARATOR '/'
 
typedef struct libpath_path {
    const char *path; 
    size_t len;       
} path_t;
 
#define NEW_PATH(_path, _len)          \
    (path_t)                           \
    {                                  \
        .path = (_path), .len = (_len) \
    }
 
#define NEW_DYNAMIC_PATH(_path) NEW_PATH((_path), strlen((_path)))
 
static inline bool path_is_absolute(const path_t *path)
{
    return path->len > 0 && path->path[0] == LIBPATH_SEPARATOR;
}
 
static inline bool path_is_empty(const path_t *path)
{
    return path->len == 0 || (path_is_absolute(path) && path->len == 1);
}
 
ssize_t path_load_parent(char *parent, const path_t *path, size_t size);
 
typedef struct libpath_segment {
    const char *start;  
    const char *end;    
    const path_t *path; 
 
    const char *next;
 
    const char *prev;
} path_segment_t;
 
#define DO_FOREACH_SEGMENT(_segment, _path, _body)   \
    do {                                             \
        path_segment_t _segment;                     \
        if (path_walk_first((_path), &(_segment))) { \
            do {                                     \
                _body;                               \
            } while (path_walk_next(&(_segment)));   \
        }                                            \
    } while (0)
 
static ALWAYS_INLINE bool path_segment_is_first(const path_segment_t *segment)
{
    return segment->prev == NULL;
}
 
static ALWAYS_INLINE bool path_segment_is_last(const path_segment_t *segment)
{
    return segment->next == NULL;
}
 
static ALWAYS_INLINE size_t path_segment_length(const path_segment_t *segment)
{
    if (segment->end == NULL) {
        // If this is the last segment of a path not terminated by a separator
        // We need to compute the length based on the original full path length
        return (segment->path->len - (segment->start - segment->path->path));
    }
 
    return segment->end - segment->start;
}
 
bool path_walk_first(const path_t *, path_segment_t *);
 
bool path_walk_last(const path_t *, path_segment_t *);
 
bool path_walk_next(path_segment_t *segment);
 
bool path_walk_prev(path_segment_t *segment);
 
bool path_segment_is(const char *, const path_segment_t *);
 
#endif /* LIB_LIBPATH_H */