native_support.c

Go to the documentation of this file.

/**
 * @file
 * @brief Collects shared low-level helpers for buffers, strings, path manipulation, file reads, and simple path predicates.
 */
 
#include "native_support.h"
 
#include <ctype.h>
#include <limits.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#ifdef _WIN32
#include <direct.h>
#include <io.h>
#include <sys/stat.h>
#define PHAROS_SUPPORT_PATH_SEP '\\'
#define pharos_support_getcwd _getcwd
#define pharos_support_access _access
#define pharos_support_stat _stat
#define pharos_support_strdup _strdup
#else
#include <unistd.h>
#include <sys/stat.h>
#define PHAROS_SUPPORT_PATH_SEP '/'
#define pharos_support_getcwd getcwd
#define pharos_support_access access
#define pharos_support_stat stat
#define pharos_support_strdup strdup
#endif
 
void buffer_init(Buffer *buffer) {
  buffer->data = NULL;
  buffer->len = 0;
  buffer->cap = 0;
}
 
void buffer_free(Buffer *buffer) {
  free(buffer->data);
  buffer->data = NULL;
  buffer->len = 0;
  buffer->cap = 0;
}
 
int buffer_reserve(Buffer *buffer, size_t needed) {
  char *next;
  size_t cap = buffer->cap == 0 ? 4096 : buffer->cap;
  if (needed <= buffer->cap) {
    return 0;
  }
  while (cap < needed) {
    if (cap > (SIZE_MAX / 2)) {
      return -1;
    }
    cap *= 2;
  }
  next = (char *)realloc(buffer->data, cap);
  if (next == NULL) {
    return -1;
  }
  buffer->data = next;
  buffer->cap = cap;
  return 0;
}
 
int buffer_append(Buffer *buffer, const void *data, size_t len) {
  if (buffer_reserve(buffer, buffer->len + len + 1) != 0) {
    return -1;
  }
  memcpy(buffer->data + buffer->len, data, len);
  buffer->len += len;
  buffer->data[buffer->len] = '\0';
  return 0;
}
 
char *dup_range(const char *start, size_t len) {
  char *copy = (char *)malloc(len + 1);
  if (copy == NULL) {
    return NULL;
  }
  memcpy(copy, start, len);
  copy[len] = '\0';
  return copy;
}
 
void trim_in_place(char *text) {
  char *start = text;
  char *end;
  if (text == NULL) {
    return;
  }
  while (*start != '\0' && isspace((unsigned char)*start)) {
    start++;
  }
  if (start != text) {
    memmove(text, start, strlen(start) + 1);
  }
  end = text + strlen(text);
  while (end > text && isspace((unsigned char)end[-1])) {
    end--;
  }
  *end = '\0';
}
 
int starts_with(const char *value, const char *prefix) {
  return strncmp(value, prefix, strlen(prefix)) == 0;
}
 
int streq(const char *a, const char *b) {
  return strcmp(a, b) == 0;
}
 
char *path_join(const char *left, const char *right) {
  size_t left_len;
  size_t right_len;
  int need_sep = 0;
  char *joined;
  if (left == NULL || left[0] == '\0') {
    return pharos_support_strdup(right);
  }
  if (right == NULL || right[0] == '\0') {
    return pharos_support_strdup(left);
  }
  left_len = strlen(left);
  right_len = strlen(right);
  if (left[left_len - 1] != PHAROS_SUPPORT_PATH_SEP) {
    need_sep = 1;
  }
  joined = (char *)malloc(left_len + right_len + need_sep + 1);
  if (joined == NULL) {
    return NULL;
  }
  memcpy(joined, left, left_len);
  if (need_sep) {
    joined[left_len] = PHAROS_SUPPORT_PATH_SEP;
    memcpy(joined + left_len + 1, right, right_len + 1);
  } else {
    memcpy(joined + left_len, right, right_len + 1);
  }
  return joined;
}
 
char *path_dirname(const char *path) {
  const char *slash;
  if (path == NULL) {
    return pharos_support_strdup(".");
  }
  slash = strrchr(path, PHAROS_SUPPORT_PATH_SEP);
#ifdef _WIN32
  {
    const char *alt = strrchr(path, '/');
    if (alt != NULL && (slash == NULL || alt > slash)) {
      slash = alt;
    }
  }
#endif
  if (slash == NULL) {
    return pharos_support_strdup(".");
  }
  if (slash == path) {
    return dup_range(path, 1);
  }
  return dup_range(path, (size_t)(slash - path));
}
 
int path_exists(const char *path) {
  return path != NULL && pharos_support_access(path, F_OK) == 0;
}
 
int path_is_directory(const char *path) {
#ifdef _WIN32
  struct _stat st;
#else
  struct stat st;
#endif
  if (path == NULL) {
    return 0;
  }
  if (pharos_support_stat(path, &st) != 0) {
    return 0;
  }
#ifdef _WIN32
  return (st.st_mode & _S_IFDIR) != 0;
#else
  return S_ISDIR(st.st_mode);
#endif
}
 
int path_is_writable(const char *path) {
  return path != NULL && pharos_support_access(path, W_OK) == 0;
}
 
char *path_canonicalize(const char *path) {
  Buffer buffer;
  const char *cursor;
  int absolute;
  if (path == NULL || path[0] == '\0') {
    return NULL;
  }
  absolute = path[0] == PHAROS_SUPPORT_PATH_SEP;
  buffer_init(&buffer);
  if (absolute) {
    char sep = PHAROS_SUPPORT_PATH_SEP;
    if (buffer_append(&buffer, &sep, 1) != 0) {
      buffer_free(&buffer);
      return NULL;
    }
  }
  cursor = path;
  while (*cursor != '\0') {
    const char *segment_start;
    const char *segment_end;
    size_t segment_len;
    char *previous;
    while (*cursor == PHAROS_SUPPORT_PATH_SEP) {
      cursor++;
    }
    if (*cursor == '\0') {
      break;
    }
    segment_start = cursor;
    while (*cursor != '\0' && *cursor != PHAROS_SUPPORT_PATH_SEP) {
      cursor++;
    }
    segment_end = cursor;
    segment_len = (size_t)(segment_end - segment_start);
    if (segment_len == 1 && segment_start[0] == '.') {
      continue;
    }
    if (segment_len == 2 && segment_start[0] == '.' && segment_start[1] == '.') {
      if (buffer.len > 0) {
        size_t trim_to = buffer.len;
        if (trim_to > 1 && buffer.data[trim_to - 1] == PHAROS_SUPPORT_PATH_SEP) {
          trim_to--;
        }
        while (trim_to > 0 && buffer.data[trim_to - 1] != PHAROS_SUPPORT_PATH_SEP) {
          trim_to--;
        }
        if (trim_to > 0) {
          if (absolute && trim_to == 1) {
            buffer.len = 1;
            buffer.data[1] = '\0';
          } else {
            buffer.len = trim_to > 0 ? trim_to - (absolute ? 0 : 1) : 0;
            if (buffer.len > 0 && buffer.data[buffer.len - 1] == PHAROS_SUPPORT_PATH_SEP && !(absolute && buffer.len == 1)) {
              buffer.len--;
            }
            buffer.data[buffer.len] = '\0';
          }
          continue;
        }
      }
      if (!absolute) {
        if (buffer.len > 0) {
          char sep = PHAROS_SUPPORT_PATH_SEP;
          if (buffer_append(&buffer, &sep, 1) != 0) {
            buffer_free(&buffer);
            return NULL;
          }
        }
        if (buffer_append(&buffer, segment_start, segment_len) != 0) {
          buffer_free(&buffer);
          return NULL;
        }
      }
      continue;
    }
    if (buffer.len > 0 && buffer.data[buffer.len - 1] != PHAROS_SUPPORT_PATH_SEP) {
      char sep = PHAROS_SUPPORT_PATH_SEP;
      if (buffer_append(&buffer, &sep, 1) != 0) {
        buffer_free(&buffer);
        return NULL;
      }
    }
    if (buffer_append(&buffer, segment_start, segment_len) != 0) {
      buffer_free(&buffer);
      return NULL;
    }
    previous = buffer.data;
    (void)previous;
  }
  if (buffer.data == NULL) {
    return absolute ? pharos_support_strdup("/") : pharos_support_strdup(".");
  }
  if (buffer.len == 0) {
    buffer_free(&buffer);
    return absolute ? pharos_support_strdup("/") : pharos_support_strdup(".");
  }
  return buffer.data;
}
 
char *resolve_relative_to(const char *base_dir, const char *value) {
  if (value == NULL || value[0] == '\0') {
    return NULL;
  }
#ifdef _WIN32
  if ((strlen(value) > 2 && value[1] == ':') || value[0] == '\\' || value[0] == '/') {
    return pharos_support_strdup(value);
  }
#else
  if (value[0] == '/') {
    return pharos_support_strdup(value);
  }
#endif
  return path_join(base_dir, value);
}
 
char *current_working_directory(void) {
  char stack_buf[PATH_MAX];
  if (pharos_support_getcwd(stack_buf, sizeof(stack_buf)) == NULL) {
    return pharos_support_strdup(".");
  }
  return pharos_support_strdup(stack_buf);
}
 
char *read_file_text(const char *path) {
  Buffer buffer;
  FILE *file;
  char chunk[4096];
  size_t bytes_read;
  buffer_init(&buffer);
  file = fopen(path, "rb");
  if (file == NULL) {
    return NULL;
  }
  while ((bytes_read = fread(chunk, 1, sizeof(chunk), file)) > 0) {
    if (buffer_append(&buffer, chunk, bytes_read) != 0) {
      fclose(file);
      buffer_free(&buffer);
      return NULL;
    }
  }
  fclose(file);
  return buffer.data;
}