git-compat.h

#ifndef GIT_COMPAT_H
#define GIT_COMPAT_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include <assert.h>

/*
 * Minimal compatibility header to compile git's graph.c standalone.
 * This stubs out the Git internals with simplified versions.
 */

/* ============== Memory allocation macros ============== */

#define ALLOC_ARRAY(x, n) ((x) = malloc(sizeof(*(x)) * (n)))
#define REALLOC_ARRAY(x, n) ((x) = realloc((x), sizeof(*(x)) * (n)))
#define COPY_ARRAY(dst, src, n) memcpy(dst, src, sizeof(*(dst)) * (n))
#define MOVE_ARRAY(dst, src, n) memmove(dst, src, sizeof(*(dst)) * (n))
#define CALLOC_ARRAY(x, n) ((x) = calloc((n), sizeof(*(x))))
#define SWAP(a, b) do { \
	void *_swap_tmp = malloc(sizeof(a)); \
	memcpy(_swap_tmp, &(a), sizeof(a)); \
	memcpy(&(a), &(b), sizeof(a)); \
	memcpy(&(b), _swap_tmp, sizeof(a)); \
	free(_swap_tmp); \
} while(0)

#define FREE_AND_NULL(p) do { free(p); (p) = NULL; } while(0)

/* ============== Object identity ============== */

#define GIT_MAX_RAWSZ 32
#define GIT_SHA1_RAWSZ 20

struct object_id {
	unsigned char hash[GIT_MAX_RAWSZ];
};

static inline int oideq(const struct object_id *a, const struct object_id *b)
{
	return memcmp(a->hash, b->hash, GIT_SHA1_RAWSZ) == 0;
}

/* ============== Object flags ============== */

#define FLAG_BITS 28

/* Flag bits used by graph.c */
#define BOUNDARY    (1u << 1)
#define CHILD_SHOWN (1u << 0)
#define UNINTERESTING (1u << 2)
#define TREESAME    (1u << 3)

struct object {
	unsigned parsed : 1;
	unsigned type : 3;
	unsigned flags : FLAG_BITS;
	struct object_id oid;
};

/* ============== Commit structures ============== */

struct commit_list {
	struct commit *item;
	struct commit_list *next;
};

struct commit {
	struct object object;
	unsigned long date;
	struct commit_list *parents;
	void *maybe_tree;  /* unused, but keeps struct similar */
	unsigned int index;
};

/* Helper to build parent list */
static inline struct commit_list *commit_list_append(struct commit *commit,
						     struct commit_list **tail)
{
	struct commit_list *node = malloc(sizeof(struct commit_list));
	node->item = commit;
	node->next = NULL;
	*tail = node;
	return node;
}

static inline void free_commit_list(struct commit_list *list)
{
	while (list) {
		struct commit_list *next = list->next;
		free(list);
		list = next;
	}
}

/* ============== Diff options (minimal) ============== */

struct diff_options {
	FILE *file;
	const char *line_prefix;
	int use_color;
	int line_termination;
	const char *(*output_prefix)(struct diff_options *opt, void *data);
	void *output_prefix_data;
};

/* ============== Rev info (minimal) ============== */

struct rev_info {
	struct diff_options diffopt;
	void *repo;
	int boundary;
	int first_parent_only;
	/* Add other fields as needed */
};

/* ============== Commit action (filtering) ============== */

enum commit_action {
	commit_ignore = 0,
	commit_show = 1,
	commit_error = 2
};

/*
 * Stub: always show all commits.
 * In real Git this filters based on revision options.
 */
static inline enum commit_action get_commit_action(struct rev_info *revs,
						   struct commit *commit)
{
	(void)revs;
	(void)commit;
	return commit_show;
}

/* ============== Revision mark ============== */

/*
 * Returns the character to display for this commit.
 * In real Git this varies based on boundary/cherry-pick status.
 */
static inline const char *get_revision_mark(struct rev_info *revs,
					    struct commit *commit)
{
	(void)revs;
	if (commit->object.flags & BOUNDARY)
		return "-";
	return "*";
}

/* ============== Color support ============== */

#define COLOR_MAXLEN 75

#define GIT_COLOR_NORMAL    ""
#define GIT_COLOR_RESET     "\033[0m"
#define GIT_COLOR_RED       "\033[31m"
#define GIT_COLOR_GREEN     "\033[32m"
#define GIT_COLOR_YELLOW    "\033[33m"
#define GIT_COLOR_BLUE      "\033[34m"
#define GIT_COLOR_MAGENTA   "\033[35m"
#define GIT_COLOR_CYAN      "\033[36m"
#define GIT_COLOR_BOLD_RED  "\033[1;31m"

/* Default column colors for graph branches */
static const char *column_colors_ansi[] = {
	GIT_COLOR_RED,
	GIT_COLOR_GREEN,
	GIT_COLOR_YELLOW,
	GIT_COLOR_BLUE,
	GIT_COLOR_MAGENTA,
	GIT_COLOR_CYAN,
	GIT_COLOR_RESET,
};

#define column_colors_ansi_max (sizeof(column_colors_ansi) / sizeof(column_colors_ansi[0]) - 1)

/* Color preference: -1 = auto, 0 = never, 1 = always */
static inline int want_color(int var)
{
	/* Return 0 to disable colors, 1 to enable */
	return var > 0;
}

static inline int color_parse_mem(const char *value, int len, char *dst)
{
	(void)value;
	(void)len;
	(void)dst;
	return -1;  /* Fail: don't support custom color parsing */
}

/* ============== String utilities ============== */

static inline char *xstrdup(const char *s)
{
	char *ret = strdup(s);
	if (!ret) {
		fprintf(stderr, "Out of memory\n");
		exit(1);
	}
	return ret;
}

static inline void *xmalloc(size_t size)
{
	void *ret = malloc(size);
	if (!ret && size) {
		fprintf(stderr, "Out of memory\n");
		exit(1);
	}
	return ret;
}

static inline void *xrealloc(void *ptr, size_t size)
{
	void *ret = realloc(ptr, size);
	if (!ret && size) {
		fprintf(stderr, "Out of memory\n");
		exit(1);
	}
	return ret;
}

static inline char *xstrndup(const char *s, size_t n)
{
	char *ret = strndup(s, n);
	if (!ret) {
		fprintf(stderr, "Out of memory\n");
		exit(1);
	}
	return ret;
}

/* strchrnul - find char or end of string */
static inline char *git_strchrnul(const char *s, int c)
{
	while (*s && *s != c)
		s++;
	return (char *)s;
}
#define strchrnul git_strchrnul

/* ============== Gettext stub ============== */

#define _(s) (s)
#define N_(s) (s)

/* ============== Warning/error output ============== */

static inline void warning(const char *fmt, ...)
{
	va_list ap;
	fprintf(stderr, "warning: ");
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);
	fprintf(stderr, "\n");
}

static inline void die(const char *fmt, ...)
{
	va_list ap;
	fprintf(stderr, "fatal: ");
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);
	fprintf(stderr, "\n");
	exit(1);
}

/* ============== strvec (string vector) ============== */

struct strvec {
	const char **v;
	size_t nr;
	size_t alloc;
};

#define STRVEC_INIT { NULL, 0, 0 }

static inline void strvec_init(struct strvec *sv)
{
	sv->v = NULL;
	sv->nr = 0;
	sv->alloc = 0;
}

static inline void strvec_push(struct strvec *sv, const char *s)
{
	if (sv->nr + 1 >= sv->alloc) {
		sv->alloc = sv->alloc ? sv->alloc * 2 : 8;
		sv->v = xrealloc(sv->v, sv->alloc * sizeof(char *));
	}
	sv->v[sv->nr++] = xstrdup(s);
	sv->v[sv->nr] = NULL;
}

static inline void strvec_clear(struct strvec *sv)
{
	for (size_t i = 0; i < sv->nr; i++)
		free((char *)sv->v[i]);
	free(sv->v);
	strvec_init(sv);
}

/* ============== Config stubs ============== */

/* Stub out git config reading */
static inline int git_config_get_string(const char *key, char **value)
{
	(void)key;
	(void)value;
	return 1;  /* Not found */
}

static inline int repo_config_get_string(const void *repo, const char *key, char **value)
{
	(void)repo;
	return git_config_get_string(key, value);
}

#endif /* GIT_COMPAT_H */