{{ title }} |
30 | 31 | |
|---|---|
|
37 |
38 | ¶
39 |
40 | {{{ docs }}}
41 | |
42 |
43 | {{{ code }}} |
45 |
Get a read-only buffer with the raw content of a blob.
\n", func[:description] 126 | assert_equal 'const void *', func[:return][:type] 127 | assert_equal ' the pointer; NULL if the blob has no contents', func[:return][:comment] 128 | assert_equal 84, func[:line] 129 | assert_equal 84, func[:lineto] 130 | assert_equal 'blob.h', func[:file] 131 | assert_equal 'git_blob *blob',func[:argline] 132 | assert_equal 'blob', func[:args][0][:name] 133 | assert_equal 'git_blob *', func[:args][0][:type] 134 | assert_equal 'pointer to the blob', func[:args][0][:comment] 135 | end 136 | 137 | def test_can_parse_defined_functions 138 | func = @data[:functions]['git_tree_lookup'] 139 | assert_equal 'int', func[:return][:type] 140 | assert_equal ' 0 on success; error code otherwise', func[:return][:comment] 141 | assert_equal 50, func[:line] 142 | assert_equal 'tree.h', func[:file] 143 | assert_equal 'id', func[:args][2][:name] 144 | assert_equal 'const git_oid *', func[:args][2][:type] 145 | assert_equal 'identity of the tree to locate.', func[:args][2][:comment] 146 | end 147 | 148 | def test_can_parse_function_cast_args 149 | func = @data[:functions]['git_reference_listcb'] 150 | assert_equal 'int', func[:return][:type] 151 | assert_equal ' 0 on success; error code otherwise', func[:return][:comment] 152 | assert_equal 321, func[:line] 153 | assert_equal 'refs.h', func[:file] 154 | assert_equal 'repo', func[:args][0][:name] 155 | assert_equal 'git_repository *', func[:args][0][:type] 156 | assert_equal 'list_flags', func[:args][1][:name] 157 | assert_equal 'unsigned int', func[:args][1][:type] 158 | assert_equal 'callback', func[:args][2][:name] 159 | assert_equal 'int (*)(const char *, void *)', func[:args][2][:type] 160 | assert_equal 'Function which will be called for every listed ref', func[:args][2][:comment] 161 | expect_comment =<<-EOF 162 |The listed references may be filtered by type, or using
163 | a bitwise OR of several types. Use the magic value
164 | GIT_REF_LISTALL to obtain all references, including
165 | packed ones.
The callback function will be called for each of the references
168 | in the repository, and will receive the name of the reference and
169 | the payload value passed to this method.
This contains extra options for git_repository_init_ext that enable
179 | additional initialization features. The fields are:
Create a new commit in the repository using git_object\n instances as parameters.
83 | * The resulting string is "aa/...", where "aa" is the first two 84 | * hex digitis of the oid and "..." is the remaining 38 digits. 85 | * 86 | * @param str output hex string; must be pointing at the start of 87 | * the hex sequence and have at least the number of bytes 88 | * needed for an oid encoded in hex (41 bytes). Only the 89 | * oid digits are written; a '\\0' terminator must be added 90 | * by the caller if it is required. 91 | * @param oid oid structure to format. 92 | */ 93 | GIT_EXTERN(void) git_oid_pathfmt(char *str, const git_oid *oid); 94 | 95 | /** 96 | * Format a gid_oid into a newly allocated c-string. 97 | * @param oid the oid structure to format 98 | * @return the c-string; NULL if memory is exhausted. Caller must 99 | * deallocate the string with free(). 100 | */ 101 | GIT_EXTERN(char *) git_oid_allocfmt(const git_oid *oid); 102 | 103 | /** 104 | * Format a git_oid into a buffer as a hex format c-string. 105 | *
106 | * If the buffer is smaller than GIT_OID_HEXSZ+1, then the resulting
107 | * oid c-string will be truncated to n-1 characters. If there are
108 | * any input parameter errors (out == NULL, n == 0, oid == NULL),
109 | * then a pointer to an empty string is returned, so that the return
110 | * value can always be printed.
111 | *
112 | * @param out the buffer into which the oid string is output.
113 | * @param n the size of the out buffer.
114 | * @param oid the oid structure to format.
115 | * @return the out buffer pointer, assuming no input parameter
116 | * errors, otherwise a pointer to an empty string.
117 | */
118 | GIT_EXTERN(char *) git_oid_to_string(char *out, size_t n, const git_oid *oid);
119 |
120 | /**
121 | * Copy an oid from one structure to another.
122 | * @param out oid structure the result is written into.
123 | * @param src oid structure to copy from.
124 | */
125 | GIT_EXTERN(void) git_oid_cpy(git_oid *out, const git_oid *src);
126 |
127 | /**
128 | * Compare two oid structures.
129 | * @param a first oid structure.
130 | * @param b second oid structure.
131 | * @return <0, 0, >0 if a < b, a == b, a > b.
132 | */
133 | GIT_EXTERN(int) git_oid_cmp(const git_oid *a, const git_oid *b);
134 |
135 | /**
136 | * OID Shortener object
137 | */
138 | typedef struct git_oid_shorten git_oid_shorten;
139 |
140 | /**
141 | * Create a new OID shortener.
142 | *
143 | * The OID shortener is used to process a list of OIDs
144 | * in text form and return the shortest length that would
145 | * uniquely identify all of them.
146 | *
147 | * E.g. look at the result of `git log --abbrev`.
148 | *
149 | * @param min_length The minimal length for all identifiers,
150 | * which will be used even if shorter OIDs would still
151 | * be unique.
152 | * @return a `git_oid_shorten` instance, NULL if OOM
153 | */
154 | git_oid_shorten *git_oid_shorten_new(size_t min_length);
155 |
156 | /**
157 | * Add a new OID to set of shortened OIDs and calculate
158 | * the minimal length to uniquely identify all the OIDs in
159 | * the set.
160 | *
161 | * The OID is expected to be a 40-char hexadecimal string.
162 | * The OID is owned by the user and will not be modified
163 | * or freed.
164 | *
165 | * For performance reasons, there is a hard-limit of how many
166 | * OIDs can be added to a single set (around ~22000, assuming
167 | * a mostly randomized distribution), which should be enough
168 | * for any kind of program, and keeps the algorithm fast and
169 | * memory-efficient.
170 | *
171 | * Attempting to add more than those OIDs will result in a
172 | * GIT_ENOMEM error
173 | *
174 | * @param os a `git_oid_shorten` instance
175 | * @param text_oid an OID in text form
176 | * @return the minimal length to uniquely identify all OIDs
177 | * added so far to the set; or an error code (<0) if an
178 | * error occurs.
179 | */
180 | int git_oid_shorten_add(git_oid_shorten *os, const char *text_oid);
181 |
182 | /**
183 | * Free an OID shortener instance
184 | *
185 | * @param os a `git_oid_shorten` instance
186 | */
187 | void git_oid_shorten_free(git_oid_shorten *os);
188 |
189 | /** @} */
190 | GIT_END_DECL
191 | #endif
192 |
--------------------------------------------------------------------------------
/test/fixtures/git2/refs.h:
--------------------------------------------------------------------------------
1 | /*
2 | * This file is free software; you can redistribute it and/or modify
3 | * it under the terms of the GNU General Public License, version 2,
4 | * as published by the Free Software Foundation.
5 | *
6 | * In addition to the permissions in the GNU General Public License,
7 | * the authors give you unlimited permission to link the compiled
8 | * version of this file into combinations with other programs,
9 | * and to distribute those combinations without any restriction
10 | * coming from the use of this file. (The General Public License
11 | * restrictions do apply in other respects; for example, they cover
12 | * modification of the file, and distribution when not linked into
13 | * a combined executable.)
14 | *
15 | * This file is distributed in the hope that it will be useful, but
16 | * WITHOUT ANY WARRANTY; without even the implied warranty of
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 | * General Public License for more details.
19 | *
20 | * You should have received a copy of the GNU General Public License
21 | * along with this program; see the file COPYING. If not, write to
22 | * the Free Software Foundation, 51 Franklin Street, Fifth Floor,
23 | * Boston, MA 02110-1301, USA.
24 | */
25 | #ifndef INCLUDE_git_refs_h__
26 | #define INCLUDE_git_refs_h__
27 |
28 | #include "common.h"
29 | #include "types.h"
30 | #include "oid.h"
31 |
32 | /**
33 | * @file git2/refs.h
34 | * @brief Git reference management routines
35 | * @defgroup git_reference Git reference management routines
36 | * @ingroup Git
37 | * @{
38 | */
39 | GIT_BEGIN_DECL
40 |
41 | /**
42 | * Lookup a reference by its name in a repository.
43 | *
44 | * The generated reference is owned by the repository and
45 | * should not be freed by the user.
46 | *
47 | * @param reference_out pointer to the looked-up reference
48 | * @param repo the repository to look up the reference
49 | * @param name the long name for the reference (e.g. HEAD, ref/heads/master, refs/tags/v0.1.0, ...)
50 | * @return 0 on success; error code otherwise
51 | */
52 | GIT_EXTERN(int) git_reference_lookup(git_reference **reference_out, git_repository *repo, const char *name);
53 |
54 | /**
55 | * Create a new symbolic reference.
56 | *
57 | * The reference will be created in the repository and written
58 | * to the disk.
59 | *
60 | * This reference is owned by the repository and shall not
61 | * be free'd by the user.
62 | *
63 | * @param ref_out Pointer to the newly created reference
64 | * @param repo Repository where that reference will live
65 | * @param name The name of the reference
66 | * @param target The target of the reference
67 | * @return 0 on success; error code otherwise
68 | */
69 | GIT_EXTERN(int) git_reference_create_symbolic(git_reference **ref_out, git_repository *repo, const char *name, const char *target);
70 |
71 | /**
72 | * Create a new symbolic reference, overwriting an existing one with
73 | * the same name, if it exists.
74 | *
75 | * If the new reference isn't a symbolic one, any pointers to the old
76 | * reference become invalid.
77 | *
78 | * The reference will be created in the repository and written
79 | * to the disk.
80 | *
81 | * This reference is owned by the repository and shall not
82 | * be free'd by the user.
83 | *
84 | * @param ref_out Pointer to the newly created reference
85 | * @param repo Repository where that reference will live
86 | * @param name The name of the reference
87 | * @param target The target of the reference
88 | * @return 0 on success; error code otherwise
89 | */
90 | GIT_EXTERN(int) git_reference_create_symbolic_f(git_reference **ref_out, git_repository *repo, const char *name, const char *target);
91 |
92 | /**
93 | * Create a new object id reference.
94 | *
95 | * The reference will be created in the repository and written
96 | * to the disk.
97 | *
98 | * This reference is owned by the repository and shall not
99 | * be free'd by the user.
100 | *
101 | * @param ref_out Pointer to the newly created reference
102 | * @param repo Repository where that reference will live
103 | * @param name The name of the reference
104 | * @param id The object id pointed to by the reference.
105 | * @return 0 on success; error code otherwise
106 | */
107 | GIT_EXTERN(int) git_reference_create_oid(git_reference **ref_out, git_repository *repo, const char *name, const git_oid *id);
108 |
109 | /**
110 | * Create a new object id reference, overwriting an existing one with
111 | * the same name, if it exists.
112 | *
113 | * If the new reference isn't an object id one, any pointers to the
114 | * old reference become invalid.
115 | *
116 | * The reference will be created in the repository and written
117 | * to the disk.
118 | *
119 | * This reference is owned by the repository and shall not
120 | * be free'd by the user.
121 | *
122 | * @param ref_out Pointer to the newly created reference
123 | * @param repo Repository where that reference will live
124 | * @param name The name of the reference
125 | * @param id The object id pointed to by the reference.
126 | * @return 0 on success; error code otherwise
127 | */
128 | GIT_EXTERN(int) git_reference_create_oid_f(git_reference **ref_out, git_repository *repo, const char *name, const git_oid *id);
129 |
130 | /**
131 | * Get the OID pointed to by a reference.
132 | *
133 | * Only available if the reference is direct (i.e. not symbolic)
134 | *
135 | * @param ref The reference
136 | * @return a pointer to the oid if available, NULL otherwise
137 | */
138 | GIT_EXTERN(const git_oid *) git_reference_oid(git_reference *ref);
139 |
140 | /**
141 | * Get full name to the reference pointed by this reference
142 | *
143 | * Only available if the reference is symbolic
144 | *
145 | * @param ref The reference
146 | * @return a pointer to the name if available, NULL otherwise
147 | */
148 | GIT_EXTERN(const char *) git_reference_target(git_reference *ref);
149 |
150 | /**
151 | * Get the type of a reference
152 | *
153 | * Either direct (GIT_REF_OID) or symbolic (GIT_REF_SYMBOLIC)
154 | *
155 | * @param ref The reference
156 | * @return the type
157 | */
158 | GIT_EXTERN(git_rtype) git_reference_type(git_reference *ref);
159 |
160 | /**
161 | * Get the full name of a reference
162 | *
163 | * @param ref The reference
164 | * @return the full name for the ref
165 | */
166 | GIT_EXTERN(const char *) git_reference_name(git_reference *ref);
167 |
168 | /**
169 | * Resolve a symbolic reference
170 | *
171 | * Thie method iteratively peels a symbolic reference
172 | * until it resolves to a direct reference to an OID.
173 | *
174 | * If a direct reference is passed as an argument,
175 | * that reference is returned immediately
176 | *
177 | * @param resolved_ref Pointer to the peeled reference
178 | * @param ref The reference
179 | * @return 0 on success; error code otherwise
180 | */
181 | GIT_EXTERN(int) git_reference_resolve(git_reference **resolved_ref, git_reference *ref);
182 |
183 | /**
184 | * Get the repository where a reference resides
185 | *
186 | * @param ref The reference
187 | * @return a pointer to the repo
188 | */
189 | GIT_EXTERN(git_repository *) git_reference_owner(git_reference *ref);
190 |
191 | /**
192 | * Set the symbolic target of a reference.
193 | *
194 | * The reference must be a symbolic reference, otherwise
195 | * this method will fail.
196 | *
197 | * The reference will be automatically updated in
198 | * memory and on disk.
199 | *
200 | * @param ref The reference
201 | * @param target The new target for the reference
202 | * @return 0 on success; error code otherwise
203 | */
204 | GIT_EXTERN(int) git_reference_set_target(git_reference *ref, const char *target);
205 |
206 | /**
207 | * Set the OID target of a reference.
208 | *
209 | * The reference must be a direct reference, otherwise
210 | * this method will fail.
211 | *
212 | * The reference will be automatically updated in
213 | * memory and on disk.
214 | *
215 | * @param ref The reference
216 | * @param target The new target OID for the reference
217 | * @return 0 on success; error code otherwise
218 | */
219 | GIT_EXTERN(int) git_reference_set_oid(git_reference *ref, const git_oid *id);
220 |
221 | /**
222 | * Rename an existing reference
223 | *
224 | * This method works for both direct and symbolic references.
225 | * The new name will be checked for validity and may be
226 | * modified into a normalized form.
227 | *
228 | * The refernece will be immediately renamed in-memory
229 | * and on disk.
230 | *
231 | */
232 | GIT_EXTERN(int) git_reference_rename(git_reference *ref, const char *new_name);
233 |
234 | /**
235 | * Rename an existing reference, overwriting an existing one with the
236 | * same name, if it exists.
237 | *
238 | * This method works for both direct and symbolic references.
239 | * The new name will be checked for validity and may be
240 | * modified into a normalized form.
241 | *
242 | * The refernece will be immediately renamed in-memory
243 | * and on disk.
244 | *
245 | */
246 | GIT_EXTERN(int) git_reference_rename_f(git_reference *ref, const char *new_name);
247 |
248 | /**
249 | * Delete an existing reference
250 | *
251 | * This method works for both direct and symbolic references.
252 | *
253 | * The reference will be immediately removed on disk and from
254 | * memory. The given reference pointer will no longer be valid.
255 | *
256 | */
257 | GIT_EXTERN(int) git_reference_delete(git_reference *ref);
258 |
259 | /**
260 | * Pack all the loose references in the repository
261 | *
262 | * This method will load into the cache all the loose
263 | * references on the repository and update the
264 | * `packed-refs` file with them.
265 | *
266 | * Once the `packed-refs` file has been written properly,
267 | * the loose references will be removed from disk.
268 | *
269 | * WARNING: calling this method may invalidate any existing
270 | * references previously loaded on the cache.
271 | *
272 | * @param repo Repository where the loose refs will be packed
273 | * @return 0 on success; error code otherwise
274 | */
275 | GIT_EXTERN(int) git_reference_packall(git_repository *repo);
276 |
277 | /**
278 | * Fill a list with all the references that can be found
279 | * in a repository.
280 | *
281 | * The listed references may be filtered by type, or using
282 | * a bitwise OR of several types. Use the magic value
283 | * `GIT_REF_LISTALL` to obtain all references, including
284 | * packed ones.
285 | *
286 | * The string array will be filled with the names of all
287 | * references; these values are owned by the user and
288 | * should be free'd manually when no longer needed, using
289 | * `git_strarray_free`.
290 | *
291 | * @param array Pointer to a git_strarray structure where
292 | * the reference names will be stored
293 | * @param repo Repository where to find the refs
294 | * @param list_flags Filtering flags for the reference
295 | * listing.
296 | * @return 0 on success; error code otherwise
297 | */
298 | GIT_EXTERN(int) git_reference_listall(git_strarray *array, git_repository *repo, unsigned int list_flags);
299 |
300 |
301 | /**
302 | * List all the references in the repository, calling a custom
303 | * callback for each one.
304 | *
305 | * The listed references may be filtered by type, or using
306 | * a bitwise OR of several types. Use the magic value
307 | * `GIT_REF_LISTALL` to obtain all references, including
308 | * packed ones.
309 | *
310 | * The `callback` function will be called for each of the references
311 | * in the repository, and will receive the name of the reference and
312 | * the `payload` value passed to this method.
313 | *
314 | * @param repo Repository where to find the refs
315 | * @param list_flags Filtering flags for the reference
316 | * listing.
317 | * @param callback Function which will be called for every listed ref
318 | * @param payload Additional data to pass to the callback
319 | * @return 0 on success; error code otherwise
320 | */
321 | GIT_EXTERN(int) git_reference_listcb(git_repository *repo, unsigned int list_flags, int (*callback)(const char *, void *), void *payload);
322 |
323 | /** @} */
324 | GIT_END_DECL
325 | #endif
326 |
--------------------------------------------------------------------------------
/test/fixtures/git2/repository.h:
--------------------------------------------------------------------------------
1 | /*
2 | * This file is free software; you can redistribute it and/or modify
3 | * it under the terms of the GNU General Public License, version 2,
4 | * as published by the Free Software Foundation.
5 | *
6 | * In addition to the permissions in the GNU General Public License,
7 | * the authors give you unlimited permission to link the compiled
8 | * version of this file into combinations with other programs,
9 | * and to distribute those combinations without any restriction
10 | * coming from the use of this file. (The General Public License
11 | * restrictions do apply in other respects; for example, they cover
12 | * modification of the file, and distribution when not linked into
13 | * a combined executable.)
14 | *
15 | * This file is distributed in the hope that it will be useful, but
16 | * WITHOUT ANY WARRANTY; without even the implied warranty of
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 | * General Public License for more details.
19 | *
20 | * You should have received a copy of the GNU General Public License
21 | * along with this program; see the file COPYING. If not, write to
22 | * the Free Software Foundation, 51 Franklin Street, Fifth Floor,
23 | * Boston, MA 02110-1301, USA.
24 | */
25 | #ifndef INCLUDE_git_repository_h__
26 | #define INCLUDE_git_repository_h__
27 |
28 | #include "common.h"
29 | #include "types.h"
30 | #include "oid.h"
31 |
32 | /**
33 | * @file git2/repository.h
34 | * @brief Git repository management routines
35 | * @defgroup git_repository Git repository management routines
36 | * @ingroup Git
37 | * @{
38 | */
39 | GIT_BEGIN_DECL
40 |
41 | /**
42 | * Open a git repository.
43 | *
44 | * The 'path' argument must point to an existing git repository
45 | * folder, e.g.
46 | *
47 | * /path/to/my_repo/.git/ (normal repository)
48 | * objects/
49 | * index
50 | * HEAD
51 | *
52 | * /path/to/bare_repo/ (bare repository)
53 | * objects/
54 | * index
55 | * HEAD
56 | *
57 | * The method will automatically detect if 'path' is a normal
58 | * or bare repository or fail is 'path' is neither.
59 | *
60 | * @param repository pointer to the repo which will be opened
61 | * @param path the path to the repository
62 | * @return 0 on success; error code otherwise
63 | */
64 | GIT_EXTERN(int) git_repository_open(git_repository **repository, const char *path);
65 |
66 |
67 | /**
68 | * Open a git repository by manually specifying all its paths
69 | *
70 | * @param repository pointer to the repo which will be opened
71 | *
72 | * @param git_dir The full path to the repository folder
73 | * e.g. a '.git' folder for live repos, any folder for bare
74 | * Equivalent to $GIT_DIR.
75 | * Cannot be NULL.
76 | *
77 | * @param git_object_directory The full path to the ODB folder.
78 | * the folder where all the loose and packed objects are stored
79 | * Equivalent to $GIT_OBJECT_DIRECTORY.
80 | * If NULL, "$GIT_DIR/objects/" is assumed.
81 | *
82 | * @param git_index_file The full path to the index (dircache) file
83 | * Equivalent to $GIT_INDEX_FILE.
84 | * If NULL, "$GIT_DIR/index" is assumed.
85 | *
86 | * @param git_work_tree The full path to the working tree of the repository,
87 | * if the repository is not bare.
88 | * Equivalent to $GIT_WORK_TREE.
89 | * If NULL, the repository is assumed to be bare.
90 | *
91 | * @return 0 on success; error code otherwise
92 | */
93 | GIT_EXTERN(int) git_repository_open2(git_repository **repository,
94 | const char *git_dir,
95 | const char *git_object_directory,
96 | const char *git_index_file,
97 | const char *git_work_tree);
98 |
99 |
100 | /**
101 | * Open a git repository by manually specifying its paths and
102 | * the object database it will use.
103 | *
104 | * @param repository pointer to the repo which will be opened
105 | *
106 | * @param git_dir The full path to the repository folder
107 | * e.g. a '.git' folder for live repos, any folder for bare
108 | * Equivalent to $GIT_DIR.
109 | * Cannot be NULL.
110 | *
111 | * @param object_database A pointer to a git_odb created & initialized
112 | * by the user (e.g. with custom backends). This object database
113 | * will be owned by the repository and will be automatically free'd.
114 | * It should not be manually free'd by the user, or this
115 | * git_repository object will become invalid.
116 | *
117 | * @param git_index_file The full path to the index (dircache) file
118 | * Equivalent to $GIT_INDEX_FILE.
119 | * If NULL, "$GIT_DIR/index" is assumed.
120 | *
121 | * @param git_work_tree The full path to the working tree of the repository,
122 | * if the repository is not bare.
123 | * Equivalent to $GIT_WORK_TREE.
124 | * If NULL, the repository is assumed to be bare.
125 | *
126 | * @return 0 on success; error code otherwise
127 | */
128 |
129 | GIT_EXTERN(int) git_repository_open3(git_repository **repository,
130 | const char *git_dir,
131 | git_odb *object_database,
132 | const char *git_index_file,
133 | const char *git_work_tree);
134 |
135 | /**
136 | * Get the object database behind a Git repository
137 | *
138 | * @param repo a repository object
139 | * @return a pointer to the object db
140 | */
141 | GIT_EXTERN(git_odb *) git_repository_database(git_repository *repo);
142 |
143 | /**
144 | * Get the Index file of a Git repository
145 | *
146 | * This is a cheap operation; the index is only opened on the first call,
147 | * and subsequent calls only retrieve the previous pointer.
148 | *
149 | * @param index Pointer where to store the index
150 | * @param repo a repository object
151 | * @return 0 on success; error code if the index could not be opened
152 | */
153 | GIT_EXTERN(int) git_repository_index(git_index **index, git_repository *repo);
154 |
155 | /**
156 | * Free a previously allocated repository
157 | *
158 | * Note that after a repository is free'd, all the objects it has spawned
159 | * will still exist until they are manually closed by the user
160 | * with `git_object_close`, but accessing any of the attributes of
161 | * an object without a backing repository will result in undefined
162 | * behavior
163 | *
164 | * @param repo repository handle to close. If NULL nothing occurs.
165 | */
166 | GIT_EXTERN(void) git_repository_free(git_repository *repo);
167 |
168 | /**
169 | * Creates a new Git repository in the given folder.
170 | *
171 | * TODO:
172 | * - Reinit the repository
173 | * - Create config files
174 | *
175 | * @param repo_out pointer to the repo which will be created or reinitialized
176 | * @param path the path to the repository
177 | * @param is_bare if true, a Git repository without a working directory is created
178 | * at the pointed path. If false, provided path will be considered as the working
179 | * directory into which the .git directory will be created.
180 | *
181 | * @return 0 on success; error code otherwise
182 | */
183 | GIT_EXTERN(int) git_repository_init(git_repository **repo_out, const char *path, unsigned is_bare);
184 |
185 | /**
186 | * Check if a repository is empty
187 | *
188 | * An empty repository has just been initialized and contains
189 | * no commits.
190 | *
191 | * @param repo Repo to test
192 | * @return 1 if the repository is empty, 0 if it isn't, error code
193 | * if the repository is corrupted
194 | */
195 | GIT_EXTERN(int) git_repository_is_empty(git_repository *repo);
196 |
197 | /**
198 | * Get the normalized path to the git repository.
199 | *
200 | * @param repo a repository object
201 | * @return absolute path to the git directory
202 | */
203 | GIT_EXTERN(const char *) git_repository_path(git_repository *repo);
204 |
205 | /**
206 | * Get the normalized path to the working directory of the repository.
207 | *
208 | * If the repository is bare, there is no working directory and NULL we be returned.
209 | *
210 | * @param repo a repository object
211 | * @return NULL if the repository is bare; absolute path to the working directory otherwise.
212 | */
213 | GIT_EXTERN(const char *) git_repository_workdir(git_repository *repo);
214 |
215 | /**
216 | * Extended options structure for `git_repository_init_ext`.
217 | *
218 | * This contains extra options for `git_repository_init_ext` that enable
219 | * additional initialization features. The fields are:
220 | *
221 | * * flags - Combination of GIT_REPOSITORY_INIT flags above.
222 | * * mode - Set to one of the standard GIT_REPOSITORY_INIT_SHARED_...
223 | * constants above, or to a custom value that you would like.
224 | * * workdir_path - The path to the working dir or NULL for default (i.e.
225 | * repo_path parent on non-bare repos). IF THIS IS RELATIVE PATH,
226 | * IT WILL BE EVALUATED RELATIVE TO THE REPO_PATH. If this is not
227 | * the "natural" working directory, a .git gitlink file will be
228 | * created here linking to the repo_path.
229 | * * description - If set, this will be used to initialize the "description"
230 | * file in the repository, instead of using the template content.
231 | * * template_path - When GIT_REPOSITORY_INIT_EXTERNAL_TEMPLATE is set,
232 | * this contains the path to use for the template directory. If
233 | * this is NULL, the config or default directory options will be
234 | * used instead.
235 | * * initial_head - The name of the head to point HEAD at. If NULL, then
236 | * this will be treated as "master" and the HEAD ref will be set
237 | * to "refs/heads/master". If this begins with "refs/" it will be
238 | * used verbatim; otherwise "refs/heads/" will be prefixed.
239 | * * origin_url - If this is non-NULL, then after the rest of the
240 | * repository initialization is completed, an "origin" remote
241 | * will be added pointing to this URL.
242 | */
243 | typedef struct {
244 | unsigned int version;
245 | uint32_t flags;
246 | uint32_t mode;
247 | const char *workdir_path;
248 | const char *description;
249 | const char *template_path;
250 | const char *initial_head;
251 | const char *origin_url;
252 | } git_repository_init_options;
253 |
254 | /** @} */
255 | GIT_END_DECL
256 | #endif
257 |
--------------------------------------------------------------------------------
/test/fixtures/git2/revwalk.h:
--------------------------------------------------------------------------------
1 | /*
2 | * This file is free software; you can redistribute it and/or modify
3 | * it under the terms of the GNU General Public License, version 2,
4 | * as published by the Free Software Foundation.
5 | *
6 | * In addition to the permissions in the GNU General Public License,
7 | * the authors give you unlimited permission to link the compiled
8 | * version of this file into combinations with other programs,
9 | * and to distribute those combinations without any restriction
10 | * coming from the use of this file. (The General Public License
11 | * restrictions do apply in other respects; for example, they cover
12 | * modification of the file, and distribution when not linked into
13 | * a combined executable.)
14 | *
15 | * This file is distributed in the hope that it will be useful, but
16 | * WITHOUT ANY WARRANTY; without even the implied warranty of
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 | * General Public License for more details.
19 | *
20 | * You should have received a copy of the GNU General Public License
21 | * along with this program; see the file COPYING. If not, write to
22 | * the Free Software Foundation, 51 Franklin Street, Fifth Floor,
23 | * Boston, MA 02110-1301, USA.
24 | */
25 | #ifndef INCLUDE_git_revwalk_h__
26 | #define INCLUDE_git_revwalk_h__
27 |
28 | #include "common.h"
29 | #include "types.h"
30 | #include "oid.h"
31 |
32 | /**
33 | * @file git2/revwalk.h
34 | * @brief Git revision traversal routines
35 | * @defgroup git_revwalk Git revision traversal routines
36 | * @ingroup Git
37 | * @{
38 | */
39 | GIT_BEGIN_DECL
40 |
41 | /**
42 | * Sort the repository contents in no particular ordering;
43 | * this sorting is arbitrary, implementation-specific
44 | * and subject to change at any time.
45 | * This is the default sorting for new walkers.
46 | */
47 | #define GIT_SORT_NONE (0)
48 |
49 | /**
50 | * Sort the repository contents in topological order
51 | * (parents before children); this sorting mode
52 | * can be combined with time sorting.
53 | */
54 | #define GIT_SORT_TOPOLOGICAL (1 << 0)
55 |
56 | /**
57 | * Sort the repository contents by commit time;
58 | * this sorting mode can be combined with
59 | * topological sorting.
60 | */
61 | #define GIT_SORT_TIME (1 << 1)
62 |
63 | /**
64 | * Iterate through the repository contents in reverse
65 | * order; this sorting mode can be combined with
66 | * any of the above.
67 | */
68 | #define GIT_SORT_REVERSE (1 << 2)
69 |
70 | /**
71 | * Allocate a new revision walker to iterate through a repo.
72 | *
73 | * This revision walker uses a custom memory pool and an internal
74 | * commit cache, so it is relatively expensive to allocate.
75 | *
76 | * For maximum performance, this revision walker should be
77 | * reused for different walks.
78 | *
79 | * This revision walker is *not* thread safe: it may only be
80 | * used to walk a repository on a single thread; however,
81 | * it is possible to have several revision walkers in
82 | * several different threads walking the same repository.
83 | *
84 | * @param walker pointer to the new revision walker
85 | * @param repo the repo to walk through
86 | * @return 0 on success; error code otherwise
87 | */
88 | GIT_EXTERN(int) git_revwalk_new(git_revwalk **walker, git_repository *repo);
89 |
90 | /**
91 | * Reset the revision walker for reuse.
92 | *
93 | * This will clear all the pushed and hidden commits, and
94 | * leave the walker in a blank state (just like at
95 | * creation) ready to receive new commit pushes and
96 | * start a new walk.
97 | *
98 | * The revision walk is automatically reset when a walk
99 | * is over.
100 | *
101 | * @param walker handle to reset.
102 | */
103 | GIT_EXTERN(void) git_revwalk_reset(git_revwalk *walker);
104 |
105 | /**
106 | * Mark a commit to start traversal from.
107 | *
108 | * The given OID must belong to a commit on the walked
109 | * repository.
110 | *
111 | * The given commit will be used as one of the roots
112 | * when starting the revision walk. At least one commit
113 | * must be pushed the repository before a walk can
114 | * be started.
115 | *
116 | * @param walker the walker being used for the traversal.
117 | * @param oid the oid of the commit to start from.
118 | * @return 0 on success; error code otherwise
119 | */
120 | GIT_EXTERN(int) git_revwalk_push(git_revwalk *walk, const git_oid *oid);
121 |
122 |
123 | /**
124 | * Mark a commit (and its ancestors) uninteresting for the output.
125 | *
126 | * The given OID must belong to a commit on the walked
127 | * repository.
128 | *
129 | * The resolved commit and all its parents will be hidden from the
130 | * output on the revision walk.
131 | *
132 | * @param walker the walker being used for the traversal.
133 | * @param commit the commit that will be ignored during the traversal
134 | * @return 0 on success; error code otherwise
135 | */
136 | GIT_EXTERN(int) git_revwalk_hide(git_revwalk *walk, const git_oid *oid);
137 |
138 | /**
139 | * Get the next commit from the revision walk.
140 | *
141 | * The initial call to this method is *not* blocking when
142 | * iterating through a repo with a time-sorting mode.
143 | *
144 | * Iterating with Topological or inverted modes makes the initial
145 | * call blocking to preprocess the commit list, but this block should be
146 | * mostly unnoticeable on most repositories (topological preprocessing
147 | * times at 0.3s on the git.git repo).
148 | *
149 | * The revision walker is reset when the walk is over.
150 | *
151 | * @param oid Pointer where to store the oid of the next commit
152 | * @param walk the walker to pop the commit from.
153 | * @return GIT_SUCCESS if the next commit was found;
154 | * GIT_EREVWALKOVER if there are no commits left to iterate
155 | */
156 | GIT_EXTERN(int) git_revwalk_next(git_oid *oid, git_revwalk *walk);
157 |
158 | /**
159 | * Change the sorting mode when iterating through the
160 | * repository's contents.
161 | *
162 | * Changing the sorting mode resets the walker.
163 | *
164 | * @param walk the walker being used for the traversal.
165 | * @param sort_mode combination of GIT_SORT_XXX flags
166 | */
167 | GIT_EXTERN(void) git_revwalk_sorting(git_revwalk *walk, unsigned int sort_mode);
168 |
169 | /**
170 | * Free a revision walker previously allocated.
171 | *
172 | * @param walk traversal handle to close. If NULL nothing occurs.
173 | */
174 | GIT_EXTERN(void) git_revwalk_free(git_revwalk *walk);
175 |
176 | /**
177 | * Return the repository on which this walker
178 | * is operating.
179 | *
180 | * @param walk the revision walker
181 | * @return the repository being walked
182 | */
183 | GIT_EXTERN(git_repository *) git_revwalk_repository(git_revwalk *walk);
184 |
185 | /** @} */
186 | GIT_END_DECL
187 | #endif
188 |
--------------------------------------------------------------------------------
/test/fixtures/git2/signature.h:
--------------------------------------------------------------------------------
1 | /*
2 | * This file is free software; you can redistribute it and/or modify
3 | * it under the terms of the GNU General Public License, version 2,
4 | * as published by the Free Software Foundation.
5 | *
6 | * In addition to the permissions in the GNU General Public License,
7 | * the authors give you unlimited permission to link the compiled
8 | * version of this file into combinations with other programs,
9 | * and to distribute those combinations without any restriction
10 | * coming from the use of this file. (The General Public License
11 | * restrictions do apply in other respects; for example, they cover
12 | * modification of the file, and distribution when not linked into
13 | * a combined executable.)
14 | *
15 | * This file is distributed in the hope that it will be useful, but
16 | * WITHOUT ANY WARRANTY; without even the implied warranty of
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 | * General Public License for more details.
19 | *
20 | * You should have received a copy of the GNU General Public License
21 | * along with this program; see the file COPYING. If not, write to
22 | * the Free Software Foundation, 51 Franklin Street, Fifth Floor,
23 | * Boston, MA 02110-1301, USA.
24 | */
25 | #ifndef INCLUDE_git_signature_h__
26 | #define INCLUDE_git_signature_h__
27 |
28 | #include "common.h"
29 | #include "types.h"
30 |
31 | /**
32 | * @file git2/signature.h
33 | * @brief Git signature creation
34 | * @defgroup git_signature Git signature creation
35 | * @ingroup Git
36 | * @{
37 | */
38 | GIT_BEGIN_DECL
39 |
40 | /**
41 | * Create a new action signature. The signature must be freed
42 | * manually or using git_signature_free
43 | *
44 | * @param name name of the person
45 | * @param mail email of the person
46 | * @param time time when the action happened
47 | * @param offset timezone offset in minutes for the time
48 | * @return the new sig, NULL on out of memory
49 | */
50 | GIT_EXTERN(git_signature *) git_signature_new(const char *name, const char *email, git_time_t time, int offset);
51 |
52 | /**
53 | * Create a new action signature with a timestamp of 'now'. The
54 | * signature must be freed manually or using git_signature_free
55 | *
56 | * @param name name of the person
57 | * @param email email of the person
58 | * @return the new sig, NULL on out of memory
59 | */
60 | GIT_EXTERN(git_signature *) git_signature_now(const char *name, const char *email);
61 |
62 |
63 | /**
64 | * Create a copy of an existing signature.
65 | *
66 | * All internal strings are also duplicated.
67 | * @param sig signature to duplicated
68 | * @return a copy of sig, NULL on out of memory
69 | */
70 | GIT_EXTERN(git_signature *) git_signature_dup(const git_signature *sig);
71 |
72 | /**
73 | * Free an existing signature
74 | *
75 | * @param sig signature to free
76 | */
77 | GIT_EXTERN(void) git_signature_free(git_signature *sig);
78 |
79 | /** @} */
80 | GIT_END_DECL
81 | #endif
82 |
--------------------------------------------------------------------------------
/test/fixtures/git2/tag.h:
--------------------------------------------------------------------------------
1 | /*
2 | * This file is free software; you can redistribute it and/or modify
3 | * it under the terms of the GNU General Public License, version 2,
4 | * as published by the Free Software Foundation.
5 | *
6 | * In addition to the permissions in the GNU General Public License,
7 | * the authors give you unlimited permission to link the compiled
8 | * version of this file into combinations with other programs,
9 | * and to distribute those combinations without any restriction
10 | * coming from the use of this file. (The General Public License
11 | * restrictions do apply in other respects; for example, they cover
12 | * modification of the file, and distribution when not linked into
13 | * a combined executable.)
14 | *
15 | * This file is distributed in the hope that it will be useful, but
16 | * WITHOUT ANY WARRANTY; without even the implied warranty of
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 | * General Public License for more details.
19 | *
20 | * You should have received a copy of the GNU General Public License
21 | * along with this program; see the file COPYING. If not, write to
22 | * the Free Software Foundation, 51 Franklin Street, Fifth Floor,
23 | * Boston, MA 02110-1301, USA.
24 | */
25 | #ifndef INCLUDE_git_tag_h__
26 | #define INCLUDE_git_tag_h__
27 |
28 | #include "common.h"
29 | #include "types.h"
30 | #include "oid.h"
31 | #include "object.h"
32 |
33 | /**
34 | * @file git2/tag.h
35 | * @brief Git tag parsing routines
36 | * @defgroup git_tag Git tag management
37 | * @ingroup Git
38 | * @{
39 | */
40 | GIT_BEGIN_DECL
41 |
42 | /**
43 | * Lookup a tag object from the repository.
44 | *
45 | * @param tag pointer to the looked up tag
46 | * @param repo the repo to use when locating the tag.
47 | * @param id identity of the tag to locate.
48 | * @return 0 on success; error code otherwise
49 | */
50 | GIT_INLINE(int) git_tag_lookup(git_tag **tag, git_repository *repo, const git_oid *id)
51 | {
52 | return git_object_lookup((git_object **)tag, repo, id, (git_otype)GIT_OBJ_TAG);
53 | }
54 |
55 | /**
56 | * Close an open tag
57 | *
58 | * This is a wrapper around git_object_close()
59 | *
60 | * IMPORTANT:
61 | * It *is* necessary to call this method when you stop
62 | * using a tag. Failure to do so will cause a memory leak.
63 | *
64 | * @param tag the tag to close
65 | */
66 |
67 | GIT_INLINE(void) git_tag_close(git_tag *tag)
68 | {
69 | git_object_close((git_object *) tag);
70 | }
71 |
72 |
73 | /**
74 | * Get the id of a tag.
75 | *
76 | * @param tag a previously loaded tag.
77 | * @return object identity for the tag.
78 | */
79 | GIT_EXTERN(const git_oid *) git_tag_id(git_tag *tag);
80 |
81 | /**
82 | * Get the tagged object of a tag
83 | *
84 | * This method performs a repository lookup for the
85 | * given object and returns it
86 | *
87 | * @param target pointer where to store the target
88 | * @param tag a previously loaded tag.
89 | * @return 0 on success; error code otherwise
90 | */
91 | GIT_EXTERN(int) git_tag_target(git_object **target, git_tag *t);
92 |
93 | /**
94 | * Get the OID of the tagged object of a tag
95 | *
96 | * @param tag a previously loaded tag.
97 | * @return pointer to the OID
98 | */
99 | GIT_EXTERN(const git_oid *) git_tag_target_oid(git_tag *t);
100 |
101 | /**
102 | * Get the type of a tag's tagged object
103 | *
104 | * @param tag a previously loaded tag.
105 | * @return type of the tagged object
106 | */
107 | GIT_EXTERN(git_otype) git_tag_type(git_tag *t);
108 |
109 | /**
110 | * Get the name of a tag
111 | *
112 | * @param tag a previously loaded tag.
113 | * @return name of the tag
114 | */
115 | GIT_EXTERN(const char *) git_tag_name(git_tag *t);
116 |
117 | /**
118 | * Get the tagger (author) of a tag
119 | *
120 | * @param tag a previously loaded tag.
121 | * @return reference to the tag's author
122 | */
123 | GIT_EXTERN(const git_signature *) git_tag_tagger(git_tag *t);
124 |
125 | /**
126 | * Get the message of a tag
127 | *
128 | * @param tag a previously loaded tag.
129 | * @return message of the tag
130 | */
131 | GIT_EXTERN(const char *) git_tag_message(git_tag *t);
132 |
133 |
134 | /**
135 | * Create a new tag in the repository from an OID
136 | *
137 | * @param oid Pointer where to store the OID of the
138 | * newly created tag
139 | *
140 | * @param repo Repository where to store the tag
141 | *
142 | * @param tag_name Name for the tag; this name is validated
143 | * for consistency. It should also not conflict with an
144 | * already existing tag name
145 | *
146 | * @param target OID to which this tag points; note that no
147 | * validation is done on this OID. Use the _o version of this
148 | * method to assure a proper object is being tagged
149 | *
150 | * @param target_type Type of the tagged OID; note that no
151 | * validation is performed here either
152 | *
153 | * @param tagger Signature of the tagger for this tag, and
154 | * of the tagging time
155 | *
156 | * @param message Full message for this tag
157 | *
158 | * @return 0 on success; error code otherwise.
159 | * A tag object is written to the ODB, and a proper reference
160 | * is written in the /refs/tags folder, pointing to it
161 | */
162 | GIT_EXTERN(int) git_tag_create(
163 | git_oid *oid,
164 | git_repository *repo,
165 | const char *tag_name,
166 | const git_oid *target,
167 | git_otype target_type,
168 | const git_signature *tagger,
169 | const char *message);
170 |
171 |
172 | /**
173 | * Create a new tag in the repository from an existing
174 | * `git_object` instance
175 | *
176 | * This method replaces the `target` and `target_type`
177 | * paremeters of `git_tag_create` by a single instance
178 | * of a `const git_object *`, which is assured to be
179 | * a proper object in the ODB and hence will create
180 | * a valid tag
181 | *
182 | * @see git_tag_create
183 | */
184 | GIT_EXTERN(int) git_tag_create_o(
185 | git_oid *oid,
186 | git_repository *repo,
187 | const char *tag_name,
188 | const git_object *target,
189 | const git_signature *tagger,
190 | const char *message);
191 |
192 | /**
193 | * Create a new tag in the repository from a buffer
194 | *
195 | * @param oid Pointer where to store the OID of the newly created tag
196 | *
197 | * @param repo Repository where to store the tag
198 | *
199 | * @param buffer Raw tag data
200 | */
201 | GIT_EXTERN(int) git_tag_create_frombuffer(
202 | git_oid *oid,
203 | git_repository *repo,
204 | const char *buffer);
205 |
206 | /**
207 | * Create a new tag in the repository from an OID
208 | * and overwrite an already existing tag reference, if any.
209 | *
210 | * @param oid Pointer where to store the OID of the
211 | * newly created tag
212 | *
213 | * @param repo Repository where to store the tag
214 | *
215 | * @param tag_name Name for the tag; this name is validated
216 | * for consistency.
217 | *
218 | * @param target OID to which this tag points; note that no
219 | * validation is done on this OID. Use the _fo version of this
220 | * method to assure a proper object is being tagged
221 | *
222 | * @param target_type Type of the tagged OID; note that no
223 | * validation is performed here either
224 | *
225 | * @param tagger Signature of the tagger for this tag, and
226 | * of the tagging time
227 | *
228 | * @param message Full message for this tag
229 | *
230 | * @return 0 on success; error code otherwise.
231 | * A tag object is written to the ODB, and a proper reference
232 | * is written in the /refs/tags folder, pointing to it
233 | */
234 | GIT_EXTERN(int) git_tag_create_f(
235 | git_oid *oid,
236 | git_repository *repo,
237 | const char *tag_name,
238 | const git_oid *target,
239 | git_otype target_type,
240 | const git_signature *tagger,
241 | const char *message);
242 |
243 | /**
244 | * Create a new tag in the repository from an existing
245 | * `git_object` instance and overwrite an already existing
246 | * tag reference, if any.
247 | *
248 | * This method replaces the `target` and `target_type`
249 | * paremeters of `git_tag_create_f` by a single instance
250 | * of a `const git_object *`, which is assured to be
251 | * a proper object in the ODB and hence will create
252 | * a valid tag
253 | *
254 | * @see git_tag_create_f
255 | */
256 | GIT_EXTERN(int) git_tag_create_fo(
257 | git_oid *oid,
258 | git_repository *repo,
259 | const char *tag_name,
260 | const git_object *target,
261 | const git_signature *tagger,
262 | const char *message);
263 |
264 | /**
265 | * Delete an existing tag reference.
266 | *
267 | * @param repo Repository where lives the tag
268 | *
269 | * @param tag_name Name of the tag to be deleted;
270 | * this name is validated for consistency.
271 | *
272 | * @return 0 on success; error code otherwise.
273 | */
274 | GIT_EXTERN(int) git_tag_delete(
275 | git_repository *repo,
276 | const char *tag_name);
277 |
278 | /**
279 | * Fill a list with all the tags in the Repository
280 | *
281 | * The string array will be filled with the names of the
282 | * matching tags; these values are owned by the user and
283 | * should be free'd manually when no longer needed, using
284 | * `git_strarray_free`.
285 | *
286 | * @param array Pointer to a git_strarray structure where
287 | * the tag names will be stored
288 | * @param repo Repository where to find the tags
289 | * @return 0 on success; error code otherwise
290 | */
291 | GIT_EXTERN(int) git_tag_list(
292 | git_strarray *tag_names,
293 | git_repository *repo);
294 |
295 | /** @} */
296 | GIT_END_DECL
297 | #endif
298 |
--------------------------------------------------------------------------------
/test/fixtures/git2/thread-utils.h:
--------------------------------------------------------------------------------
1 | /*
2 | * This file is free software; you can redistribute it and/or modify
3 | * it under the terms of the GNU General Public License, version 2,
4 | * as published by the Free Software Foundation.
5 | *
6 | * In addition to the permissions in the GNU General Public License,
7 | * the authors give you unlimited permission to link the compiled
8 | * version of this file into combinations with other programs,
9 | * and to distribute those combinations without any restriction
10 | * coming from the use of this file. (The General Public License
11 | * restrictions do apply in other respects; for example, they cover
12 | * modification of the file, and distribution when not linked into
13 | * a combined executable.)
14 | *
15 | * This file is distributed in the hope that it will be useful, but
16 | * WITHOUT ANY WARRANTY; without even the implied warranty of
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 | * General Public License for more details.
19 | *
20 | * You should have received a copy of the GNU General Public License
21 | * along with this program; see the file COPYING. If not, write to
22 | * the Free Software Foundation, 51 Franklin Street, Fifth Floor,
23 | * Boston, MA 02110-1301, USA.
24 | */
25 | #ifndef INCLUDE_git_thread_utils_h__
26 | #define INCLUDE_git_thread_utils_h__
27 |
28 | /*
29 | * How TLS works is compiler+platform dependant
30 | * Sources: http://en.wikipedia.org/wiki/Thread-Specific_Storage
31 | * http://predef.sourceforge.net/precomp.html
32 | */
33 |
34 | #define GIT_HAS_TLS 1
35 |
36 | #if defined(__APPLE__) && defined(__MACH__)
37 | # undef GIT_TLS
38 | # define GIT_TLS
39 |
40 | #elif defined(__GNUC__) || \
41 | defined(__SUNPRO_C) || \
42 | defined(__SUNPRO_CC) || \
43 | defined(__xlc__) || \
44 | defined(__xlC__)
45 | # define GIT_TLS __thread
46 |
47 | #elif defined(__INTEL_COMPILER)
48 | # if defined(_WIN32) || defined(_WIN32_CE)
49 | # define GIT_TLS __declspec(thread)
50 | # else
51 | # define GIT_TLS __thread
52 | # endif
53 |
54 | #elif defined(_WIN32) || \
55 | defined(_WIN32_CE) || \
56 | defined(__BORLANDC__)
57 | # define GIT_TLS __declspec(thread)
58 |
59 | #else
60 | # undef GIT_HAS_TLS
61 | # define GIT_TLS /* nothing: tls vars are thread-global */
62 | #endif
63 |
64 | /* sparse and cygwin don't grok thread-local variables */
65 | #if defined(__CHECKER__) || defined(__CYGWIN__)
66 | # undef GIT_HAS_TLS
67 | # undef GIT_TLS
68 | # define GIT_TLS
69 | #endif
70 |
71 | #endif /* INCLUDE_git_thread_utils_h__ */
72 |
--------------------------------------------------------------------------------
/test/fixtures/git2/tree.h:
--------------------------------------------------------------------------------
1 | /*
2 | * This file is free software; you can redistribute it and/or modify
3 | * it under the terms of the GNU General Public License, version 2,
4 | * as published by the Free Software Foundation.
5 | *
6 | * In addition to the permissions in the GNU General Public License,
7 | * the authors give you unlimited permission to link the compiled
8 | * version of this file into combinations with other programs,
9 | * and to distribute those combinations without any restriction
10 | * coming from the use of this file. (The General Public License
11 | * restrictions do apply in other respects; for example, they cover
12 | * modification of the file, and distribution when not linked into
13 | * a combined executable.)
14 | *
15 | * This file is distributed in the hope that it will be useful, but
16 | * WITHOUT ANY WARRANTY; without even the implied warranty of
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 | * General Public License for more details.
19 | *
20 | * You should have received a copy of the GNU General Public License
21 | * along with this program; see the file COPYING. If not, write to
22 | * the Free Software Foundation, 51 Franklin Street, Fifth Floor,
23 | * Boston, MA 02110-1301, USA.
24 | */
25 | #ifndef INCLUDE_git_tree_h__
26 | #define INCLUDE_git_tree_h__
27 |
28 | #include "common.h"
29 | #include "types.h"
30 | #include "oid.h"
31 | #include "object.h"
32 |
33 | /**
34 | * @file git2/tree.h
35 | * @brief Git tree parsing, loading routines
36 | * @defgroup git_tree Git tree parsing, loading routines
37 | * @ingroup Git
38 | * @{
39 | */
40 | GIT_BEGIN_DECL
41 |
42 | /**
43 | * Lookup a tree object from the repository.
44 | *
45 | * @param tree pointer to the looked up tree
46 | * @param repo the repo to use when locating the tree.
47 | * @param id identity of the tree to locate.
48 | * @return 0 on success; error code otherwise
49 | */
50 | GIT_INLINE(int) git_tree_lookup(git_tree **tree, git_repository *repo, const git_oid *id)
51 | {
52 | return git_object_lookup((git_object **)tree, repo, id, GIT_OBJ_TREE);
53 | }
54 |
55 | /**
56 | * Close an open tree
57 | *
58 | * This is a wrapper around git_object_close()
59 | *
60 | * IMPORTANT:
61 | * It *is* necessary to call this method when you stop
62 | * using a tree. Failure to do so will cause a memory leak.
63 | *
64 | * @param tree the tree to close
65 | */
66 |
67 | GIT_INLINE(void) git_tree_close(git_tree *tree)
68 | {
69 | git_object_close((git_object *) tree);
70 | }
71 |
72 |
73 | /**
74 | * Get the id of a tree.
75 | *
76 | * @param tree a previously loaded tree.
77 | * @return object identity for the tree.
78 | */
79 | GIT_EXTERN(const git_oid *) git_tree_id(git_tree *tree);
80 |
81 | /**
82 | * Get the number of entries listed in a tree
83 | *
84 | * @param tree a previously loaded tree.
85 | * @return the number of entries in the tree
86 | */
87 | GIT_EXTERN(size_t) git_tree_entrycount(git_tree *tree);
88 |
89 | /**
90 | * Lookup a tree entry by its filename
91 | *
92 | * @param tree a previously loaded tree.
93 | * @param filename the filename of the desired entry
94 | * @return the tree entry; NULL if not found
95 | */
96 | GIT_EXTERN(const git_tree_entry *) git_tree_entry_byname(git_tree *tree, const char *filename);
97 |
98 | /**
99 | * Lookup a tree entry by its position in the tree
100 | *
101 | * @param tree a previously loaded tree.
102 | * @param idx the position in the entry list
103 | * @return the tree entry; NULL if not found
104 | */
105 | GIT_EXTERN(const git_tree_entry *) git_tree_entry_byindex(git_tree *tree, int idx);
106 |
107 | /**
108 | * Get the UNIX file attributes of a tree entry
109 | *
110 | * @param entry a tree entry
111 | * @return attributes as an integer
112 | */
113 | GIT_EXTERN(unsigned int) git_tree_entry_attributes(const git_tree_entry *entry);
114 |
115 | /**
116 | * Get the filename of a tree entry
117 | *
118 | * @param entry a tree entry
119 | * @return the name of the file
120 | */
121 | GIT_EXTERN(const char *) git_tree_entry_name(const git_tree_entry *entry);
122 |
123 | /**
124 | * Get the id of the object pointed by the entry
125 | *
126 | * @param entry a tree entry
127 | * @return the oid of the object
128 | */
129 | GIT_EXTERN(const git_oid *) git_tree_entry_id(const git_tree_entry *entry);
130 |
131 | /**
132 | * Convert a tree entry to the git_object it points too.
133 | *
134 | * @param object pointer to the converted object
135 | * @param repo repository where to lookup the pointed object
136 | * @param entry a tree entry
137 | * @return 0 on success; error code otherwise
138 | */
139 | GIT_EXTERN(int) git_tree_entry_2object(git_object **object_out, git_repository *repo, const git_tree_entry *entry);
140 |
141 | /**
142 | * Write a tree to the ODB from the index file
143 | *
144 | * This method will scan the index and write a representation
145 | * of its current state back to disk; it recursively creates
146 | * tree objects for each of the subtrees stored in the index,
147 | * but only returns the OID of the root tree. This is the OID
148 | * that can be used e.g. to create a commit.
149 | *
150 | * The index instance cannot be bare, and needs to be associated
151 | * to an existing repository.
152 | *
153 | * @param oid Pointer where to store the written tree
154 | * @param index Index to write
155 | * @return 0 on success; error code otherwise
156 | */
157 | GIT_EXTERN(int) git_tree_create_fromindex(git_oid *oid, git_index *index);
158 |
159 | /**
160 | * Create a new tree builder.
161 | *
162 | * The tree builder can be used to create or modify
163 | * trees in memory and write them as tree objects to the
164 | * database.
165 | *
166 | * If the `source` parameter is not NULL, the tree builder
167 | * will be initialized with the entries of the given tree.
168 | *
169 | * If the `source` parameter is NULL, the tree builder will
170 | * have no entries and will have to be filled manually.
171 | *
172 | * @param builder_p Pointer where to store the tree builder
173 | * @param source Source tree to initialize the builder (optional)
174 | * @return 0 on sucess; error code otherwise
175 | */
176 | GIT_EXTERN(int) git_treebuilder_create(git_treebuilder **builder_p, const git_tree *source);
177 |
178 | /**
179 | * Clear all the entires in the builder
180 | *
181 | * @param bld Builder to clear
182 | */
183 | GIT_EXTERN(void) git_treebuilder_clear(git_treebuilder *bld);
184 |
185 | /**
186 | * Free a tree builder
187 | *
188 | * This will clear all the entries and free to builder.
189 | * Failing to free the builder after you're done using it
190 | * will result in a memory leak
191 | *
192 | * @param bld Builder to free
193 | */
194 | GIT_EXTERN(void) git_treebuilder_free(git_treebuilder *bld);
195 |
196 | /**
197 | * Get an entry from the builder from its filename
198 | *
199 | * The returned entry is owned by the builder and should
200 | * not be freed manually.
201 | *
202 | * @param bld Tree builder
203 | * @param filename Name of the entry
204 | * @return pointer to the entry; NULL if not found
205 | */
206 | GIT_EXTERN(const git_tree_entry *) git_treebuilder_get(git_treebuilder *bld, const char *filename);
207 |
208 | /**
209 | * Add or update an entry to the builder
210 | *
211 | * Insert a new entry for `filename` in the builder with the
212 | * given attributes.
213 | *
214 | * if an entry named `filename` already exists, its attributes
215 | * will be updated with the given ones.
216 | *
217 | * The optional pointer `entry_out` can be used to retrieve a
218 | * pointer to the newly created/updated entry.
219 | *
220 | * @param entry_out Pointer to store the entry (optional)
221 | * @param bld Tree builder
222 | * @param filename Filename of the entry
223 | * @param id SHA1 oid of the entry
224 | * @param attributes Folder attributes of the entry
225 | * @return 0 on success; error code otherwise
226 | */
227 | GIT_EXTERN(int) git_treebuilder_insert(git_tree_entry **entry_out, git_treebuilder *bld, const char *filename, const git_oid *id, unsigned int attributes);
228 |
229 | /**
230 | * Remove an entry from the builder by its filename
231 | *
232 | * @param bld Tree builder
233 | * @param filename Filename of the entry to remove
234 | */
235 | GIT_EXTERN(int) git_treebuilder_remove(git_treebuilder *bld, const char *filename);
236 |
237 | /**
238 | * Filter the entries in the tree
239 | *
240 | * The `filter` callback will be called for each entry
241 | * in the tree with a pointer to the entry and the
242 | * provided `payload`: if the callback returns 1, the
243 | * entry will be filtered (removed from the builder).
244 | *
245 | * @param bld Tree builder
246 | * @param filter Callback to filter entries
247 | */
248 | GIT_EXTERN(void) git_treebuilder_filter(git_treebuilder *bld, int (*filter)(const git_tree_entry *, void *), void *payload);
249 |
250 | /**
251 | * Write the contents of the tree builder as a tree object
252 | *
253 | * The tree builder will be written to the given `repo`, and
254 | * it's identifying SHA1 hash will be stored in the `oid`
255 | * pointer.
256 | *
257 | * @param oid Pointer where to store the written OID
258 | * @param repo Repository where to store the object
259 | * @param bld Tree builder to write
260 | * @return 0 on success; error code otherwise
261 | */
262 | GIT_EXTERN(int) git_treebuilder_write(git_oid *oid, git_repository *repo, git_treebuilder *bld);
263 |
264 | /** @} */
265 | GIT_END_DECL
266 | #endif
267 |
--------------------------------------------------------------------------------
/test/fixtures/git2/types.h:
--------------------------------------------------------------------------------
1 | /*
2 | * This file is free software; you can redistribute it and/or modify
3 | * it under the terms of the GNU General Public License, version 2,
4 | * as published by the Free Software Foundation.
5 | *
6 | * In addition to the permissions in the GNU General Public License,
7 | * the authors give you unlimited permission to link the compiled
8 | * version of this file into combinations with other programs,
9 | * and to distribute those combinations without any restriction
10 | * coming from the use of this file. (The General Public License
11 | * restrictions do apply in other respects; for example, they cover
12 | * modification of the file, and distribution when not linked into
13 | * a combined executable.)
14 | *
15 | * This file is distributed in the hope that it will be useful, but
16 | * WITHOUT ANY WARRANTY; without even the implied warranty of
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 | * General Public License for more details.
19 | *
20 | * You should have received a copy of the GNU General Public License
21 | * along with this program; see the file COPYING. If not, write to
22 | * the Free Software Foundation, 51 Franklin Street, Fifth Floor,
23 | * Boston, MA 02110-1301, USA.
24 | */
25 | #ifndef INCLUDE_git_types_h__
26 | #define INCLUDE_git_types_h__
27 |
28 | #include "common.h"
29 |
30 | /**
31 | * @file git2/types.h
32 | * @brief libgit2 base & compatibility types
33 | * @ingroup Git
34 | * @{
35 | */
36 | GIT_BEGIN_DECL
37 |
38 | /**
39 | * Cross-platform compatibility types for off_t / time_t
40 | *
41 | * NOTE: This needs to be in a public header so that both the library
42 | * implementation and client applications both agree on the same types.
43 | * Otherwise we get undefined behavior.
44 | *
45 | * Use the "best" types that each platform provides. Currently we truncate
46 | * these intermediate representations for compatibility with the git ABI, but
47 | * if and when it changes to support 64 bit types, our code will naturally
48 | * adapt.
49 | * NOTE: These types should match those that are returned by our internal
50 | * stat() functions, for all platforms.
51 | */
52 | #include