1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
/* By carefully stacking #includes here (even if WE don't really need them)
* we strive to make the thing actually compile. Git header files aren't very
* nice. Perl headers are one of the signs of the coming apocalypse. */
#include <ctype.h>
/* Ok, it hasn't been so bad so far. */
/* libgit interface */
#include "../cache.h"
#include "../exec_cmd.h"
/* XS and Perl interface */
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
static char *
report_xs(const char *prefix, const char *err, va_list params)
{
static char buf[4096];
strcpy(buf, prefix);
vsnprintf(buf + strlen(prefix), 4096 - strlen(prefix), err, params);
return buf;
}
static void NORETURN
die_xs(const char *err, va_list params)
{
char *str;
str = report_xs("fatal: ", err, params);
croak(str);
}
static void
error_xs(const char *err, va_list params)
{
char *str;
str = report_xs("error: ", err, params);
warn(str);
}
MODULE = Git PACKAGE = Git
PROTOTYPES: DISABLE
BOOT:
{
set_error_routine(error_xs);
set_die_routine(die_xs);
}
void
xs__call_gate(repoid, git_dir)
long repoid;
char *git_dir;
CODE:
{
static long last_repoid;
if (repoid != last_repoid) {
setup_git(git_dir,
getenv(DB_ENVIRONMENT),
getenv(INDEX_ENVIRONMENT),
getenv(GRAFT_ENVIRONMENT));
last_repoid = repoid;
}
}
char *
xs_version()
CODE:
{
RETVAL = GIT_VERSION;
}
OUTPUT:
RETVAL
char *
xs_exec_path()
CODE:
{
RETVAL = (char *)git_exec_path();
}
OUTPUT:
RETVAL
void
xs__execv_git_cmd(...)
CODE:
{
const char **argv;
int i;
argv = malloc(sizeof(const char *) * (items + 1));
if (!argv)
croak("malloc failed");
for (i = 0; i < items; i++)
argv[i] = strdup(SvPV_nolen(ST(i)));
argv[i] = NULL;
execv_git_cmd(argv);
for (i = 0; i < items; i++)
if (argv[i])
free((char *) argv[i]);
free((char **) argv);
}
SV *
xs_get_object(type, id)
char *type;
char *id;
CODE:
{
unsigned char sha1[20];
unsigned long size;
void *buf;
if (strlen(id) != 40 || get_sha1_hex(id, sha1) < 0)
XSRETURN_UNDEF;
buf = read_sha1_file(sha1, type, &size);
if (!buf)
XSRETURN_UNDEF;
RETVAL = newSVpvn(buf, size);
free(buf);
}
OUTPUT:
RETVAL
char *
xs_hash_object_pipe(type, fd)
char *type;
int fd;
CODE:
{
unsigned char sha1[20];
if (index_pipe(sha1, fd, type, 0))
croak("Unable to hash given filehandle");
RETVAL = sha1_to_hex(sha1);
}
OUTPUT:
RETVAL
char *
xs_hash_object_file(type, path)
char *type;
char *path;
CODE:
{
unsigned char sha1[20];
int fd = open(path, O_RDONLY);
struct stat st;
if (fd < 0 ||
fstat(fd, &st) < 0 ||
index_fd(sha1, fd, &st, 0, type))
croak("Unable to hash %s", path);
close(fd);
RETVAL = sha1_to_hex(sha1);
}
OUTPUT:
RETVAL
|
