int main(int argc, char *argv[]) {
git_libgit2_init();
git_repository *repo = NULL;
git_diff *diff = NULL;
const char *repo_path = "/home/nghia/.git_packages/cache/version-checker/.git";
fprintf(stdout, "Current working dir: %s\n", repo_path);
int error = git_repository_open(&repo, repo_path);
fprintf(stdout, "error: %d\n", error);
error = git_diff_index_to_workdir(&diff, repo, NULL, NULL);
fprintf(stdout, "error: %d\n", error);
git_diff_print(diff, GIT_DIFF_FORMAT_PATCH, color_printer, NULL);
git_diff_free(diff);
git_libgit2_shutdown();
return 0;
// error = git_diff_index_to_workdir(&diff, repo, NULL, NULL);
// struct opts o = {
// GIT_DIFF_OPTIONS_INIT, GIT_DIFF_FIND_OPTIONS_INIT,
// -1, 0, 0, GIT_DIFF_FORMAT_PATCH, NULL, NULL, "."
// };
// git_libgit2_init();
}
void initGit()
{
static bool haveInitialized = false;
if (!haveInitialized) {
git_libgit2_init();
}
}
CTortoiseMergeApp::CTortoiseMergeApp()
: m_nAppLook(0)
{
EnableHtmlHelp();
m_bHiColorIcons = TRUE;
git_libgit2_init();
}
int main(int argc, char *argv[])
#endif
{
int res;
#if defined(GIT_MSVC_CRTDBG)
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_DEBUG | _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
#endif
clar_test_init(argc, argv);
git_libgit2_init();
cl_global_trace_register();
cl_sandbox_set_search_path_defaults();
/* Run the test suite */
res = clar_test_run();
clar_test_shutdown();
cl_global_trace_disable();
git_libgit2_shutdown();
return res;
}
GitRepository::GitRepository(const QString &localDirPath)
: m_local_dir_path(localDirPath),
m_repo(NULL),
m_signature(NULL)
{
git_libgit2_init();
}
void RTXIWizard::Panel::initParameters(void)
{
#if LIBGIT2_SOVERSION >= 22
git_libgit2_init();
#else
git_threads_init();
#endif
// syntax here only works in c++11
exclude_list = std::vector<QString> ({
QString("rtxi"),
QString("rtxi.github.io"),
QString("genicam-camera"),
QString("rtxi-crawler"),
QString("matlab-tools"),
QString("tutorials"),
QString("autapse"),
QString("camera-control"),
QString("gen-net"),
QString("dynamo-examples"),
QString("plot-lib"),
QString("python-plugin"),
QString("poster"),
QString("user-manual"),
QString("logos"),
QString("live-image"),
QString("conference-2015")
});
button_mode = DOWNLOAD;
}
int main(int argc, char *argv[])
#endif
{
int res;
char *at_exit_cmd;
clar_test_init(argc, argv);
res = git_libgit2_init();
if (res < 0) {
fprintf(stderr, "failed to init libgit2");
return res;
}
cl_global_trace_register();
cl_sandbox_set_search_path_defaults();
/* Run the test suite */
res = clar_test_run();
clar_test_shutdown();
cl_global_trace_disable();
git_libgit2_shutdown();
at_exit_cmd = getenv("CLAR_AT_EXIT");
if (at_exit_cmd != NULL) {
int at_exit = system(at_exit_cmd);
return res || at_exit;
}
return res;
}
void CacheGitDirectory::updateRef() {
currentGitRef_ = "";
git_repository *repo = NULL;
git_reference *head = NULL;
git_libgit2_init();
int r = git_repository_open(&repo, gitRepository_.c_str());
if (r != 0) {
LOG(INFO) << "Cannot open git repository " << gitRepository_;
goto cleanup;
}
if (git_repository_head_detached(repo)) {
LOG(INFO) << "We are in detached state";
goto cleanup;
}
r = git_repository_head(&head, repo);
if (r != 0) {
LOG(INFO) << "Cannot get current ref head";
goto cleanup;
}
currentGitRef_ = git_reference_name(head);
LOG(INFO) << "found ref: " << currentGitRef_;
cleanup:
git_repository_free(repo);
git_libgit2_shutdown();
}
int main()
{
git_libgit2_init();
git_repository* rep = nullptr;
git_remote* remote = nullptr;
git_push_options opts = GIT_PUSH_OPTIONS_INIT;
int error = 0;
// git open
git_repository_open(&rep, path);
// take remote
git_remote_lookup(&remote, rep, "origin");
const char *refs[] = {"refs/heads/master:refs/heads/master"};
git_strarray strarr = {(char**)refs, 1};
opts.callbacks.credentials = cred_acquire_cb;
error = git_remote_push(remote, &strarr, &opts);
if (error < 0)
{
const git_error *e = giterr_last();
std::cout << "Error: " << error << " / " << e->klass << " : " << e->message << std::endl;
goto SHUTDOWN;
}
SHUTDOWN:
git_repository_free(rep);
git_libgit2_shutdown();
}
bool CacheGitDirectory::checkIsGitRepository() const {
git_libgit2_init();
git_repository *repo = NULL;
bool found = !git_repository_open(&repo, gitRepository_.c_str());
git_repository_free(repo);
git_libgit2_shutdown();
return found;
}
int main(int argc, char **argv)
{
int i;
bool no_filenames = true;
init_qt(&argc, &argv);
QStringList files;
QStringList importedFiles;
QStringList arguments = QCoreApplication::arguments();
bool dedicated_console = arguments.length() > 1 &&
(arguments.at(1) == QString("--win32console"));
subsurface_console_init(dedicated_console);
for (i = 1; i < arguments.length(); i++) {
QString a = arguments.at(i);
if (a.at(0) == '-') {
parse_argument(a.toLocal8Bit().data());
continue;
}
if (imported) {
importedFiles.push_back(a);
} else {
no_filenames = false;
files.push_back(a);
}
}
#if !LIBGIT2_VER_MAJOR && LIBGIT2_VER_MINOR < 22
git_threads_init();
#else
git_libgit2_init();
#endif
setup_system_prefs();
prefs = default_prefs;
fill_profile_color();
parse_xml_init();
taglist_init_global();
init_ui();
if (no_filenames) {
QString defaultFile(prefs.default_filename);
if (!defaultFile.isEmpty())
files.push_back(QString(prefs.default_filename));
}
MainWindow *m = MainWindow::instance();
m->setLoadedWithFiles(!files.isEmpty() || !importedFiles.isEmpty());
m->loadFiles(files);
m->importFiles(importedFiles);
if (!quit)
run_ui();
exit_ui();
taglist_free(g_tag_list);
parse_xml_exit();
subsurface_console_exit();
free_prefs();
return 0;
}
int main(int argc, char **argv)
{
struct stat st;
struct timeval start, end;
char filepath[1024], repodir[64];
char *dirpath, *filename, *ref = NULL;
if (argc != 3) {
fprintf(stderr, "Usage: ./log dirpath filename\n");
exit(-1);
}
dirpath = argv[1];
filename = argv[2];
strcpy(repodir, dirpath);
strcat(repodir, "/.git");
strcpy(filepath, dirpath);
strcat(filepath, "/");
strcat(filepath, filename);
if (stat(filepath, &st) < 0) {
fprintf(stderr, "Not valid file path: \"%s\"!\n", filepath);
exit(-2);
}
memset(&s, 0, sizeof(s));
s.sorting = GIT_SORT_TIME;
s.hide = 0;
s.repodir = strlen(repodir) > 0 ? repodir : "/tmp/git/.git";
s.ref = ref ? ref : "refs/heads/master";
/* Init libgit2 library */
git_libgit2_init();
/* Open repo. */
check_lg2(git_repository_open_ext(&s.repo, s.repodir, 0, NULL),
"Could not open repository", s.repodir);
/* Create revwalker. */
check_lg2(git_revwalk_new(&s.walker, s.repo),
"Could not create revision walker", NULL);
git_revwalk_sorting(s.walker, s.sorting);
/* Show file's latest commit. */
printf("filename: %s\n", filename);
gettimeofday(&start, NULL);
git_show_last_commit(filename);
gettimeofday(&end, NULL);
printf("time span: %ld(ms)\n", (end.tv_sec - start.tv_sec) * 1000 + \
(end.tv_usec - start.tv_usec) / 1000);
git_revwalk_free(s.walker);
git_repository_free(s.repo);
git_libgit2_shutdown();
return 0;
}
int configctl_git_open()
{
int error;
git_libgit2_init();
error = git_repository_open(&repo, repo_path);
check_error(error, "opening repository");
return error;
}
int _tmain(int argc, _TCHAR* argv[])
{
git_libgit2_init();
// Since Google Mock depends on Google Test, InitGoogleMock() is
// also responsible for initializing Google Test. Therefore there's
// no need for calling testing::InitGoogleTest() separately.
testing::InitGoogleMock(&argc, argv);
int result = RUN_ALL_TESTS();
git_libgit2_shutdown();
return result;
}
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
ui(new Ui::MainWindow)
{
ui->setupUi(this);
git_libgit2_init();
hasDir = false;
git_repository* repo = NULL;
ui->pushButtonInit->setDisabled(true); //don't allow init on start
}
void test_threads_basic__multiple_init(void)
{
git_repository *nested_repo;
git_libgit2_init();
cl_git_pass(git_repository_open(&nested_repo, cl_fixture("testrepo.git")));
git_repository_free(nested_repo);
git_libgit2_shutdown();
cl_git_pass(git_repository_open(&nested_repo, cl_fixture("testrepo.git")));
git_repository_free(nested_repo);
}
int main(int argc, char **argv)
{
int i;
int return_code = 1;
int error;
git_repository *repo;
struct args_info args = ARGS_INFO_INIT;
const char *git_dir = NULL;
if (argc < 2) {
fprintf(stderr, "usage: %s <cmd> [repo]\n", argv[0]);
exit(EXIT_FAILURE);
}
git_libgit2_init();
for (args.pos = 1; args.pos < args.argc; ++args.pos) {
char *a = args.argv[args.pos];
if (a[0] != '-') {
/* non-arg */
break;
} else if (optional_str_arg(&git_dir, &args, "--git-dir", ".git")) {
continue;
} else if (!strcmp(a, "--")) {
/* arg separator */
break;
}
}
/* Before running the actual command, create an instance of the local
* repository and pass it to the function. */
error = git_repository_open(&repo, git_dir);
if (error < 0)
repo = NULL;
for (i = 0; commands[i].name != NULL; ++i) {
if (!strcmp(args.argv[args.pos], commands[i].name)) {
return_code = run_command(commands[i].fn, repo, args);
goto shutdown;
}
}
fprintf(stderr, "Command not found: %s\n", argv[1]);
shutdown:
git_repository_free(repo);
git_libgit2_shutdown();
return return_code;
}
int main(void)
{
git_libgit2_init();
git_repository *repo;
const char *path = "/home/pcarphin/Documents/GitHub/tests/C_tests/libgit2/.git";
git_repository_init(&repo, path, 0);
nftw(path, unlink_callback, 64, FTW_DEPTH | FTW_PHYS);
return 0;
}
CTortoiseGitBlameApp::CTortoiseGitBlameApp()
{
SetDllDirectory(L"");
SetTaskIDPerUUID();
#if ENABLE_CRASHHANLDER
CCrashReportTGit crasher(L"TortoiseGitBlame " _T(APP_X64_STRING), TGIT_VERMAJOR, TGIT_VERMINOR, TGIT_VERMICRO, TGIT_VERBUILD, TGIT_VERDATE);
CCrashReport::Instance().AddUserInfoToReport(L"CommandLine", GetCommandLine());
#endif
EnableHtmlHelp();
git_libgit2_init();
m_gdiplusToken = NULL;
m_bHiColorIcons = TRUE;
}
//-----------------------------------------------------------------------------------------//
int AdVersion::gitInit(QString gitDirectory)
{
int ierr;
git_repository *repository;
QByteArray tempData = gitDirectory.toLatin1();
const char *cgitDirectory = tempData.data();
git_libgit2_init();
ierr = git_repository_init(&repository,cgitDirectory,0);
git_repository_free(repository);
git_libgit2_shutdown();
return ERROR_NOERROR;
}
int configctl_git_create_config_dir(char *path)
{
int rc = 0;
git_repository *repo = NULL;
git_libgit2_init();
git_repository_init(&repo, path, 0);
rc = create_initial_commit(repo);
git_repository_free(repo);
git_libgit2_shutdown();
return rc;
}
static void AutomationMain()
{
// initialize the COM library
HRESULT hr = ::CoInitialize(nullptr);
if (FAILED(hr))
return;
git_libgit2_init();
RunOutprocServer();
git_libgit2_shutdown();
::CoUninitialize();
}
STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppvOut)
{
if (ppvOut == 0)
return E_POINTER;
*ppvOut = NULL;
FileState state = FileStateInvalid;
if (IsEqualIID(rclsid, CLSID_Tortoisegit_UPTODATE))
state = FileStateVersioned;
else if (IsEqualIID(rclsid, CLSID_Tortoisegit_MODIFIED))
state = FileStateModified;
else if (IsEqualIID(rclsid, CLSID_Tortoisegit_CONFLICTING))
state = FileStateConflict;
else if (IsEqualIID(rclsid, CLSID_Tortoisegit_UNCONTROLLED))
state = FileStateUncontrolled;
else if (IsEqualIID(rclsid, CLSID_Tortoisegit_DROPHANDLER))
state = FileStateDropHandler;
else if (IsEqualIID(rclsid, CLSID_Tortoisegit_DELETED))
state = FileStateDeleted;
else if (IsEqualIID(rclsid, CLSID_Tortoisegit_READONLY))
state = FileStateReadOnly;
else if (IsEqualIID(rclsid, CLSID_Tortoisegit_LOCKED))
state = FileStateLockedOverlay;
else if (IsEqualIID(rclsid, CLSID_Tortoisegit_ADDED))
state = FileStateAddedOverlay;
else if (IsEqualIID(rclsid, CLSID_Tortoisegit_IGNORED))
state = FileStateIgnoredOverlay;
else if (IsEqualIID(rclsid, CLSID_Tortoisegit_UNVERSIONED))
state = FileStateUnversionedOverlay;
if (state != FileStateInvalid)
{
CShellExtClassFactory *pcf = new (std::nothrow) CShellExtClassFactory(state);
if (pcf == NULL)
return E_OUTOFMEMORY;
// refcount currently set to 0
git_libgit2_init();
const HRESULT hr = pcf->QueryInterface(riid, ppvOut);
if(FAILED(hr))
delete pcf;
return hr;
}
return CLASS_E_CLASSNOTAVAILABLE;
}
SyncState::SyncState(StateStack& stack, Context& context)
: State(stack, context)
, m_thread(&SyncState::sync, this)
{
m_textStatus.setCharacterSize(14);
m_textStatus.setFillColor(cpp3ds::Color::White);
m_textStatus.setOutlineColor(cpp3ds::Color(0, 0, 0, 70));
m_textStatus.setOutlineThickness(2.f);
m_textStatus.setPosition(160.f, 155.f);
TweenEngine::Tween::to(m_textStatus, util3ds::TweenText::OUTLINE_COLOR_ALPHA, 0.15f)
.target(90)
.repeatYoyo(-1, 0)
.start(m_tweenManager);
git_libgit2_init();
m_thread.launch();
}
int QGit::createLocalRepository(const QDir &path)
{
git_repository *repo = nullptr;
int err = 0;
git_libgit2_init();
err = git_repository_init(&repo, path.absolutePath().toUtf8().constData(), 0);
if (repo)
{
git_repository_free(repo);
repo = nullptr;
}
git_libgit2_shutdown();
return err;
}
QString QGit::getBranchNameFromPath(const QString &path)
{
git_repository *repo = nullptr;
git_reference *ref = nullptr;
int result = 0;
const char *branch = nullptr;
QString ret;
git_libgit2_init();
result = git_repository_open(&repo, path.toUtf8().constData());
if (result)
{
goto cleanup;
}
result = git_repository_head(&ref, repo);
if (result)
{
goto cleanup;
}
git_branch_name(&branch, ref);
ret = branch;
cleanup:
if (ref)
{
git_reference_free(ref);
ref = nullptr;
}
if (repo)
{
git_repository_free(repo);
repo = nullptr;
}
git_libgit2_shutdown();
return ret;
}
int main(int argc, char **argv) {
if (argc < 2) {
printf("Usage: %s <repo url>\n", argv[0]);
return 1;
}
git_libgit2_init();
git_repository *repo = NULL;
git_clone_options opts = GIT_CLONE_OPTIONS_INIT;
opts.repository_cb = repository_create_memory_cb;
const char *url = argv[1];
const char *path = "repo";
int error = git_clone(&repo, url, path, &opts);
if (error) {
fprintf(stderr, "%s\n", giterr_last()->message);
}
git_libgit2_shutdown();
return 0;
}
int main(int argc, char **argv)
{
git_repository *repo;
describe_options opts;
git_libgit2_init();
check_lg2(git_repository_open_ext(&repo, ".", 0, NULL),
"Could not open repository", NULL);
describe_options_init(&opts);
parse_options(&opts, argc, argv);
do_describe(repo, &opts);
git_repository_free(repo);
git_libgit2_shutdown();
return 0;
}
int
main (int argc,
char **argv)
{
GError *local_error = NULL;
GError **error = &local_error;
struct EvTag self = { NULL, };
/* avoid gvfs (http://bugzilla.gnome.org/show_bug.cgi?id=526454) */
g_setenv ("GIO_USE_VFS", "local", TRUE);
#ifdef HAVE_GIT_LIBGIT2_INIT
git_libgit2_init ();
#else
git_threads_init ();
#endif
if (!submain (&self, argc, argv, error))
goto out;
out:
if (self.top_repo)
git_repository_free (self.top_repo);
if (self.checksum)
g_checksum_free (self.checksum);
if (local_error)
{
int is_tty = isatty (1);
const char *prefix = "";
const char *suffix = "";
if (is_tty)
{
prefix = "\x1b[31m\x1b[1m"; /* red, bold */
suffix = "\x1b[22m\x1b[0m"; /* bold off, color reset */
}
g_printerr ("%serror: %s%s\n", prefix, suffix, local_error->message);
g_error_free (local_error);
return 1;
}
return 0;
}
Status
syncInit(const char *szCaCertPath)
{
AutoSyncLock lock(gSyncMutex);
if (gbInitialized)
return ABC_ERROR(ABC_CC_Reinitialization,
"ABC_Sync has already been initalized");
ABC_CHECK_GIT(git_libgit2_init());
gbInitialized = true;
if (szCaCertPath)
ABC_CHECK_GIT(git_libgit2_opts(GIT_OPT_SET_SSL_CERT_LOCATIONS, szCaCertPath,
nullptr));
// Choose a random server to start with:
syncServerIndex = time(nullptr);
return Status();
}