Beginnings of a new, better portable FS shell with Haiku FS interface.

Doesn't do anything ATM, but already provides the required system
interface (VFS, caches, POSIX functions).


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20859 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/tools/fs_shell/KPath.cpp

@@ -0,0 +1,298 @@
+/*
+ * Copyright 2004-2007, Ingo Weinhold, [email protected].
+ * Distributed under the terms of the MIT License.
+ */
+
+/** A simple class wrapping a path. Has a fixed-sized buffer. */
+
+#include "KPath.h"
+
+#include <stdlib.h>
+
+#include "fssh_string.h"
+#include "vfs.h"
+
+
+// debugging
+#define TRACE(x) ;
+//#define TRACE(x) dprintf x
+
+
+KPath::KPath(fssh_size_t bufferSize)
+	:
+	fBuffer(NULL),
+	fBufferSize(0),
+	fPathLength(0),
+	fLocked(false)
+{
+	SetTo(NULL, bufferSize);
+}
+
+
+KPath::KPath(const char* path, bool normalize, fssh_size_t bufferSize)
+	:
+	fBuffer(NULL),
+	fBufferSize(0),
+	fPathLength(0),
+	fLocked(false)
+{
+	SetTo(path, normalize, bufferSize);
+}
+
+
+KPath::KPath(const KPath& other)
+	:
+	fBuffer(NULL),
+	fBufferSize(0),
+	fPathLength(0),
+	fLocked(false)
+{
+	*this = other;
+}
+
+
+KPath::~KPath()
+{
+	free(fBuffer);
+}
+
+
+fssh_status_t
+KPath::SetTo(const char* path, bool normalize, fssh_size_t bufferSize)
+{
+	if (bufferSize == 0)
+		bufferSize = FSSH_B_PATH_NAME_LENGTH;
+
+	// free the previous buffer, if the buffer size differs
+	if (fBuffer && fBufferSize != bufferSize) {
+		free(fBuffer);
+		fBuffer = NULL;
+		fBufferSize = 0;
+	}
+	fPathLength = 0;
+	fLocked = false;
+
+	// allocate buffer
+	if (!fBuffer)
+		fBuffer = (char*)malloc(bufferSize);
+	if (!fBuffer)
+		return FSSH_B_NO_MEMORY;
+	if (fBuffer) {
+		fBufferSize = bufferSize;
+		fBuffer[0] = '\0';
+	}
+	return SetPath(path, normalize);
+}
+
+
+fssh_status_t
+KPath::InitCheck() const
+{
+	return fBuffer ? FSSH_B_OK : FSSH_B_NO_MEMORY;
+}
+
+
+fssh_status_t
+KPath::SetPath(const char *path, bool normalize)
+{
+	if (!fBuffer)
+		return FSSH_B_NO_INIT;
+
+	if (path) {
+		if (normalize) {
+			// normalize path
+			fssh_status_t error = vfs_normalize_path(path, fBuffer, fBufferSize,
+				true);
+			if (error != FSSH_B_OK) {
+				SetPath(NULL);
+				return error;
+			}
+			fPathLength = fssh_strlen(fBuffer);
+		} else {
+			// don't normalize path
+			fssh_size_t length = fssh_strlen(path);
+			if (length >= fBufferSize)
+				return FSSH_B_BUFFER_OVERFLOW;
+
+			fssh_memcpy(fBuffer, path, length + 1);
+			fPathLength = length;
+			_ChopTrailingSlashes();
+		}
+	} else {
+		fBuffer[0] = '\0';
+		fPathLength = 0;
+	}
+	return FSSH_B_OK;
+}
+
+
+const char*
+KPath::Path() const
+{
+	return fBuffer;
+}
+
+
+char *
+KPath::LockBuffer()
+{
+	if (!fBuffer || fLocked)
+		return NULL;
+
+	fLocked = true;
+	return fBuffer;
+}
+
+
+void
+KPath::UnlockBuffer()
+{
+	if (!fLocked) {
+		TRACE(("KPath::UnlockBuffer(): ERROR: Buffer not locked!\n"));
+		return;
+	}
+	fLocked = false;
+	fPathLength = fssh_strnlen(fBuffer, fBufferSize);
+	if (fPathLength == fBufferSize) {
+		TRACE(("KPath::UnlockBuffer(): WARNING: Unterminated buffer!\n"));
+		fPathLength--;
+		fBuffer[fPathLength] = '\0';
+	}
+	_ChopTrailingSlashes();
+}
+
+
+const char *
+KPath::Leaf() const
+{
+	if (!fBuffer)
+		return NULL;
+
+	// only "/" has trailing slashes -- then we have to return the complete
+	// buffer, as we have to do in case there are no slashes at all
+	if (fPathLength != 1 || fBuffer[0] != '/') {
+		for (int32_t i = fPathLength - 1; i >= 0; i--) {
+			if (fBuffer[i] == '/')
+				return fBuffer + i + 1;
+		}
+	}
+	return fBuffer;
+}
+
+
+fssh_status_t
+KPath::ReplaceLeaf(const char *newLeaf)
+{
+	const char *leaf = Leaf();
+	if (!leaf)
+		return FSSH_B_NO_INIT;
+
+	int32_t leafIndex = leaf - fBuffer;
+	// chop off the current leaf (don't replace "/", though)
+	if (leafIndex != 0 || fBuffer[leafIndex - 1]) {
+		fBuffer[leafIndex] = '\0';
+		fPathLength = leafIndex;
+		_ChopTrailingSlashes();
+	}
+
+	// if a leaf was given, append it
+	if (newLeaf)
+		return Append(newLeaf);
+	return FSSH_B_OK;
+}
+
+
+fssh_status_t
+KPath::Append(const char *component, bool isComponent)
+{
+	// check initialization and parameter
+	if (!fBuffer)
+		return FSSH_B_NO_INIT;
+	if (!component)
+		return FSSH_B_BAD_VALUE;
+	if (fPathLength == 0)
+		return SetPath(component);
+
+	// get component length
+	fssh_size_t componentLength = fssh_strlen(component);
+	if (componentLength < 1)
+		return FSSH_B_OK;
+
+	// if our current path is empty, we just copy the supplied one
+	// compute the result path len
+	bool insertSlash = isComponent && fBuffer[fPathLength - 1] != '/'
+		&& component[0] != '/';
+	fssh_size_t resultPathLength = fPathLength + componentLength + (insertSlash ? 1 : 0);
+	if (resultPathLength >= fBufferSize)
+		return FSSH_B_BUFFER_OVERFLOW;
+
+	// compose the result path
+	if (insertSlash)
+		fBuffer[fPathLength++] = '/';
+	fssh_memcpy(fBuffer + fPathLength, component, componentLength + 1);
+	fPathLength = resultPathLength;
+	return FSSH_B_OK;
+}
+
+
+KPath&
+KPath::operator=(const KPath& other)
+{
+	SetTo(other.fBuffer, other.fBufferSize);
+	return *this;
+}
+
+
+KPath&
+KPath::operator=(const char* path)
+{
+	SetTo(path);
+	return *this;
+}
+
+
+bool
+KPath::operator==(const KPath& other) const
+{
+	if (!fBuffer)
+		return !other.fBuffer;
+
+	return (other.fBuffer
+		&& fPathLength == other.fPathLength
+		&& fssh_strcmp(fBuffer, other.fBuffer) == 0);
+}
+
+
+bool
+KPath::operator==(const char* path) const
+{
+	if (!fBuffer)
+		return (!path);
+
+	return path && !fssh_strcmp(fBuffer, path);
+}
+
+
+bool
+KPath::operator!=(const KPath& other) const
+{
+	return !(*this == other);
+}
+
+
+bool
+KPath::operator!=(const char* path) const
+{
+	return !(*this == path);
+}
+
+
+void
+KPath::_ChopTrailingSlashes()
+{
+	if (fBuffer) {
+		while (fPathLength > 1 && fBuffer[fPathLength - 1] == '/')
+			fBuffer[--fPathLength] = '\0';
+	}
+}
+