Absolute ROOT relative

TODO:

Path like C:abc
means not absolute path
it's need the cwd to handling normalize

Author: lygstate

include/cpj.h

@@ -250,9 +250,9 @@ static inline cpj_size_t cpj_path_join_module(
  * @param path_style Style depending on the operating system. So this should
  * detect whether we should use windows or unix paths.
  * @param path The path which will be inspected.
- * @param length The output of the root length.
+ * @return The inspected root length of the path.
  */
-CPJ_PUBLIC void cpj_path_get_root(cpj_path_style_t path_style, const cpj_char_t *path, cpj_size_t *length);
+CPJ_PUBLIC cpj_size_t cpj_path_get_root(cpj_path_style_t path_style, const cpj_char_t *path);
 
 /**
  * @brief Changes the root of a path.
@@ -289,7 +289,10 @@ CPJ_PUBLIC cpj_size_t cpj_path_change_root(
  * @param path The path which will be checked.
  * @return Returns true if the path is absolute or false otherwise.
  */
-CPJ_PUBLIC bool cpj_path_is_absolute(cpj_path_style_t path_style, const cpj_char_t *path);
+static inline bool cpj_path_is_absolute(cpj_path_style_t path_style, const cpj_char_t *path)
+{
+  return cpj_path_get_root(path_style, path) > 0;
+}
 
 /**
  * @brief Determine whether the path is relative or not.
@@ -302,7 +305,10 @@ CPJ_PUBLIC bool cpj_path_is_absolute(cpj_path_style_t path_style, const cpj_char
  * @param path The path which will be checked.
  * @return Returns true if the path is relative or false otherwise.
  */
-CPJ_PUBLIC bool cpj_path_is_relative(cpj_path_style_t path_style, const cpj_char_t *path);
+static inline bool cpj_path_is_relative(cpj_path_style_t path_style, const cpj_char_t *path)
+{
+  return cpj_path_get_root(path_style, path) == 0;
+}
 
 /**
  * @brief Gets the basename of a file path.

src/cpj.c

@@ -84,16 +84,15 @@ static const cpj_char_t *cpj_path_find_next_stop(cpj_path_style_t path_style, co
   return c;
 } /* cpj_path_find_next_stop */
 
-static void cpj_path_get_root_windows(const cpj_char_t *path, cpj_size_t *length)
+static cpj_size_t cpj_path_get_root_windows(const cpj_char_t *path)
 {
   const cpj_char_t *c;
-
+  cpj_size_t length = 0;
   // We can not determine the root if this is an empty string. So we set the
   // root to NULL and the length to zero and cancel the whole thing.
   c = path;
-  *length = 0;
   if (!*c) {
-    return;
+    return length;
   }
 
   // Now we have to verify whether this is a windows network path (UNC), which
@@ -107,8 +106,8 @@ static void cpj_path_get_root_windows(const cpj_char_t *path, cpj_size_t *length
     if (!cpj_path_is_separator(CPJ_STYLE_WINDOWS, *c)) {
       // Okay, this is not a network path but we still use the backslash as a
       // root.
-      ++(*length);
-      return;
+      ++length;
+      return length;
     }
 
     // A device path is a path which starts with "\\." or "\\?". A device path
@@ -124,8 +123,8 @@ static void cpj_path_get_root_windows(const cpj_char_t *path, cpj_size_t *length
       // That's a device path, and the root must be either "\\.\" or "\\?\"
       // which is 4 characters long. (at least that's how Windows
       // GetFullPathName behaves.)
-      *length = 4;
-      return;
+      length = 4;
+      return length;
     }
 
     // We will grab anything up to the next stop. The next stop might be a '\0'
@@ -149,44 +148,37 @@ static void cpj_path_get_root_windows(const cpj_char_t *path, cpj_size_t *length
     }
 
     // Finally, calculate the size of the root.
-    *length = (cpj_size_t)(c - path);
-    return;
+    length = (cpj_size_t)(c - path);
+    return length;
   }
 
   // Move to the next and check whether this is a colon.
   if (*++c == ':') {
-    *length = 2;
+    length = 2;
 
     // Now check whether this is a backslash (or slash). If it is not, we could
     // assume that the next character is a '\0' if it is a valid path. However,
     // we will not assume that - since ':' is not valid in a path it must be a
     // mistake by the caller than. We will try to understand it anyway.
     if (cpj_path_is_separator(CPJ_STYLE_WINDOWS, *(++c))) {
-      *length = 3;
+      length = 3;
     }
   }
+  return length;
 } /* cpj_path_get_root_windows */
 
-static void cpj_path_get_root_unix(const cpj_char_t *path, cpj_size_t *length)
+static cpj_size_t cpj_path_get_root_unix(const cpj_char_t *path)
 {
   // The slash of the unix path represents the root. There is no root if there
   // is no slash.
-  if (cpj_path_is_separator(CPJ_STYLE_UNIX, *path)) {
-    *length = 1;
-  } else {
-    *length = 0;
-  }
+  return cpj_path_is_separator(CPJ_STYLE_UNIX, *path) ? 1 : 0;
 } /* cpj_path_get_root_unix */
 
-void cpj_path_get_root(cpj_path_style_t path_style, const cpj_char_t *path, cpj_size_t *length)
+cpj_size_t cpj_path_get_root(cpj_path_style_t path_style, const cpj_char_t *path)
 {
   // We use a different implementation here based on the configuration of the
   // library.
-  if (path_style == CPJ_STYLE_WINDOWS) {
-    cpj_path_get_root_windows(path, length);
-  } else {
-    cpj_path_get_root_unix(path, length);
-  }
+  return path_style == CPJ_STYLE_WINDOWS ? cpj_path_get_root_windows(path) : cpj_path_get_root_unix(path);
 } /* cpj_path_get_root */
 
 static cpj_char_t cpj_path_get_char(cpj_join_state_t *state, cpj_iterator_t *it)
@@ -204,7 +196,7 @@ static void cpj_path_update_root_length(cpj_join_state_t *state, cpj_iterator_t
 {
   state->path_total_size += state->path_list_p[it->list_pos].size;
   if (state->is_module || it->list_pos == 0) {
-    cpj_path_get_root(state->style, state->path_list_p[it->list_pos].ptr, &it->root_length);
+    it->root_length = cpj_path_get_root(state->style, state->path_list_p[it->list_pos].ptr);
   }
 } /* cpj_path_update_root_length */
 
@@ -992,8 +984,8 @@ cpj_size_t cpj_path_get_relative(
   // First we compare the roots of those two paths. If the roots are not equal
   // we can't continue, since there is no way to get a relative path from
   // different roots.
-  cpj_path_get_root(path_style, base_directory, &base_root_length);
-  cpj_path_get_root(path_style, path, &path_root_length);
+  base_root_length = cpj_path_get_root(path_style, base_directory);
+  path_root_length = cpj_path_get_root(path_style, path);
   if (base_root_length != path_root_length ||
       !cpj_path_is_string_equal(path_style, base_directory, path, base_root_length, path_root_length)) {
     cpj_path_terminate_output(buffer, buffer_size, pos);
@@ -1093,7 +1085,7 @@ cpj_size_t cpj_path_change_root(
 
   // First we need to determine the actual size of the root which we will
   // change.
-  cpj_path_get_root(path_style, path, &root_length);
+  root_length = cpj_path_get_root(path_style, path);
 
   // Now we determine the sizes of the new root and the path. We need that to
   // determine the size of the part after the root (the tail).
@@ -1118,24 +1110,6 @@ cpj_size_t cpj_path_change_root(
   return new_path_size;
 }
 
-bool cpj_path_is_absolute(cpj_path_style_t path_style, const cpj_char_t *path)
-{
-  cpj_size_t length;
-
-  // We grab the root of the path. This root does not include the first
-  // separator of a path.
-  cpj_path_get_root(path_style, path, &length);
-
-  // Now we can determine whether the root is absolute or not.
-  return cpj_path_is_root_absolute(path_style, path, length);
-}
-
-bool cpj_path_is_relative(cpj_path_style_t path_style, const cpj_char_t *path)
-{
-  // The path is relative if it is not absolute.
-  return !cpj_path_is_absolute(path_style, path);
-}
-
 void cpj_path_get_basename(
   cpj_path_style_t path_style, const cpj_char_t *path, const cpj_char_t **basename, cpj_size_t *length
 )
@@ -1176,7 +1150,7 @@ cpj_size_t cpj_path_change_basename(
 
     // So there is no segment in this path. First we grab the root and output
     // that. We are not going to modify the root in any way.
-    cpj_path_get_root(path_style, path, &root_size);
+    root_size = cpj_path_get_root(path_style, path);
     pos = cpj_path_output_sized(buffer, buffer_size, 0, path, root_size);
 
     // We have to trim the separators from the beginning of the new basename.
@@ -1282,7 +1256,7 @@ cpj_size_t cpj_path_change_extension(
     // So there is no segment in this path. First we grab the root and output
     // that. We are not going to modify the root in any way. If there is no
     // root, this will end up with a root size 0, and nothing will be written.
-    cpj_path_get_root(path_style, path, &root_size);
+    root_size = cpj_path_get_root(path_style, path);
     pos = cpj_path_output_sized(buffer, buffer_size, 0, path, root_size);
 
     // Add a dot if the submitted value doesn't have any.
@@ -1349,8 +1323,8 @@ cpj_path_get_intersection(cpj_path_style_t path_style, const cpj_char_t *path_ba
   // We first compare the two roots. We just return zero if they are not equal.
   // This will also happen to return zero if the paths are mixed relative and
   // absolute.
-  cpj_path_get_root(path_style, path_base, &base_root_length);
-  cpj_path_get_root(path_style, path_other, &other_root_length);
+  base_root_length = cpj_path_get_root(path_style, path_base);
+  other_root_length = cpj_path_get_root(path_style, path_other);
   if (!cpj_path_is_string_equal(path_style, path_base, path_other, base_root_length, other_root_length)) {
     return 0;
   }
@@ -1413,7 +1387,7 @@ bool cpj_path_get_first_segment(cpj_path_style_t path_style, const cpj_char_t *p
 
   // We skip the root since that's not part of the first segment. The root is
   // treated as a separate entity.
-  cpj_path_get_root(path_style, path, &length);
+  length = cpj_path_get_root(path_style, path);
   segments = path + length;
 
   // Now, after we skipped the root we can continue and find the actual segment
@@ -1585,7 +1559,7 @@ cpj_path_style_t cpj_path_guess_style(const cpj_char_t *path)
   // First we determine the root. Only windows roots can be longer than a single
   // slash, so if we can determine that it starts with something like "C:", we
   // know that this is a windows path.
-  cpj_path_get_root_windows(path, &root_length);
+  root_length = cpj_path_get_root_windows(path);
   if (root_length > 1) {
     return CPJ_STYLE_WINDOWS;
   }

test/root_test.c

@@ -103,7 +103,7 @@ int root_relative_windows(void)
 {
   cpj_size_t length;
 
-  cpj_path_get_root(CPJ_STYLE_WINDOWS, "..\\hello\\world.txt", &length);
+  length = cpj_path_get_root(CPJ_STYLE_WINDOWS, "..\\hello\\world.txt");
 
   if (length != 0) {
     return EXIT_FAILURE;
@@ -116,7 +116,7 @@ int root_relative_drive(void)
 {
   cpj_size_t length;
 
-  cpj_path_get_root(CPJ_STYLE_WINDOWS, "C:test.txt", &length);
+  length = cpj_path_get_root(CPJ_STYLE_WINDOWS, "C:test.txt");
 
   if (length != 2) {
     return EXIT_FAILURE;
@@ -129,7 +129,7 @@ int root_device_question_mark(void)
 {
   cpj_size_t length;
 
-  cpj_path_get_root(CPJ_STYLE_WINDOWS, "\\\\?\\mydevice\\test", &length);
+  length = cpj_path_get_root(CPJ_STYLE_WINDOWS, "\\\\?\\mydevice\\test");
 
   if (length != 4) {
     return EXIT_FAILURE;
@@ -142,7 +142,7 @@ int root_device_dot(void)
 {
   cpj_size_t length;
 
-  cpj_path_get_root(CPJ_STYLE_WINDOWS, "\\\\.\\mydevice\\test", &length);
+  length = cpj_path_get_root(CPJ_STYLE_WINDOWS, "\\\\.\\mydevice\\test");
 
   if (length != 4) {
     return EXIT_FAILURE;
@@ -155,7 +155,7 @@ int root_device_unc(void)
 {
   cpj_size_t length;
 
-  cpj_path_get_root(CPJ_STYLE_WINDOWS, "\\\\.\\UNC\\LOCALHOST\\c$\\temp\\test-file.txt", &length);
+  length = cpj_path_get_root(CPJ_STYLE_WINDOWS, "\\\\.\\UNC\\LOCALHOST\\c$\\temp\\test-file.txt");
 
   if (length != 4) {
     return EXIT_FAILURE;
@@ -168,7 +168,7 @@ int root_unc(void)
 {
   cpj_size_t length;
 
-  cpj_path_get_root(CPJ_STYLE_WINDOWS, "\\\\server\\folder\\data", &length);
+  length = cpj_path_get_root(CPJ_STYLE_WINDOWS, "\\\\server\\folder\\data");
 
   if (length != 16) {
     return EXIT_FAILURE;
@@ -181,7 +181,7 @@ int root_absolute_drive(void)
 {
   cpj_size_t length;
 
-  cpj_path_get_root(CPJ_STYLE_WINDOWS, "C:\\test.txt", &length);
+  length = cpj_path_get_root(CPJ_STYLE_WINDOWS, "C:\\test.txt");
 
   if (length != 3) {
     return EXIT_FAILURE;
@@ -194,7 +194,7 @@ int root_unix_drive(void)
 {
   cpj_size_t length;
 
-  cpj_path_get_root(CPJ_STYLE_UNIX, "C:\\test.txt", &length);
+  length = cpj_path_get_root(CPJ_STYLE_UNIX, "C:\\test.txt");
 
   if (length != 0) {
     return EXIT_FAILURE;
@@ -207,7 +207,7 @@ int root_unix_backslash(void)
 {
   cpj_size_t length;
 
-  cpj_path_get_root(CPJ_STYLE_UNIX, "\\folder\\", &length);
+  length = cpj_path_get_root(CPJ_STYLE_UNIX, "\\folder\\");
 
   if (length != 0) {
     return EXIT_FAILURE;
@@ -220,7 +220,7 @@ int root_windows_slash(void)
 {
   cpj_size_t length;
 
-  cpj_path_get_root(CPJ_STYLE_WINDOWS, "/test.txt", &length);
+  length = cpj_path_get_root(CPJ_STYLE_WINDOWS, "/test.txt");
 
   if (length != 1) {
     return EXIT_FAILURE;
@@ -233,7 +233,7 @@ int root_windows_backslash(void)
 {
   cpj_size_t length;
 
-  cpj_path_get_root(CPJ_STYLE_WINDOWS, "\\test.txt", &length);
+  length = cpj_path_get_root(CPJ_STYLE_WINDOWS, "\\test.txt");
 
   if (length != 1) {
     return EXIT_FAILURE;
@@ -246,7 +246,7 @@ int root_relative(void)
 {
   cpj_size_t length;
 
-  cpj_path_get_root(CPJ_STYLE_UNIX, "test.txt", &length);
+  length = cpj_path_get_root(CPJ_STYLE_UNIX, "test.txt");
 
   if (length != 0) {
     return EXIT_FAILURE;
@@ -259,7 +259,7 @@ int root_absolute(void)
 {
   cpj_size_t length;
 
-  cpj_path_get_root(CPJ_STYLE_UNIX, "/test.txt", &length);
+  length = cpj_path_get_root(CPJ_STYLE_UNIX, "/test.txt");
 
   if (length != 1) {
     return EXIT_FAILURE;