ext/gitdll/gitdll.c

   1 // gitdll.cpp : Defines the exported functions for the DLL application.
   2 //
   3
   4 #include "stdafx.h"
   5 #include "git-compat-util.h"
   6 #include "msvc.h"
   7 #include "gitdll.h"
   8 #include "cache.h"
   9 #include "commit.h"
  10 #include "diff.h"
  11 #include "revision.h"
  12 #include "diffcore.h"
  13 const char git_version_string[] = GIT_VERSION;
  14
  15
  16 #if 0
  17
  18 // This is an example of an exported variable
  19 GITDLL_API int ngitdll=0;
  20
  21 // This is an example of an exported function.
  22 GITDLL_API int fngitdll(void)
  23 {
  24         return 42;
  25 }
  26
  27 // This is the constructor of a class that has been exported.
  28 // see gitdll.h for the class definition
  29 Cgitdll::Cgitdll()
  30 {
  31         return;
  32 }
  33 #endif
  34
  35 #define MAX_ERROR_STR_SIZE 512
  36 char g_last_error[MAX_ERROR_STR_SIZE]={0};
  37 void * g_prefix;
  38
  39 char * get_git_last_error()
  40 {
  41         return g_last_error;
  42 }
  43
  44 static void die_dll(const char *err, va_list params)
  45 {
  46         memset(g_last_error,0,MAX_ERROR_STR_SIZE);
  47         vsnprintf(g_last_error, MAX_ERROR_STR_SIZE-1, err, params);
  48 }
  49
  50 void dll_entry()
  51 {
  52         set_die_routine(die_dll);
  53 }
  54
  55 int git_get_sha1(const char *name, GIT_HASH sha1)
  56 {
  57         return get_sha1(name,sha1);
  58 }
  59
  60 static int convert_slash(char * path)
  61 {
  62         while(*path)
  63         {
  64                 if(*path == '\\' )
  65                         *path = '/';
  66                 path++;
  67         }
  68 }
  69
  70 int git_init()
  71 {
  72         char *home;
  73         char path[MAX_PATH+1];
  74         char *prefix;
  75         size_t homesize,size,httpsize;
  76
  77         _fmode = _O_BINARY;
  78         _setmode(_fileno(stdin), _O_BINARY);
  79         _setmode(_fileno(stdout), _O_BINARY);
  80         _setmode(_fileno(stderr), _O_BINARY);
  81
  82         // set HOME if not set already
  83         getenv_s(&homesize, NULL, 0, "HOME");
  84         if (!homesize)
  85         {
  86                 _dupenv_s(&home,&size,"USERPROFILE");
  87                 _putenv_s("HOME",home);
  88                 free(home);
  89         }
  90         GetModuleFileName(NULL, path, MAX_PATH);
  91         convert_slash(path);
  92
  93         git_extract_argv0_path(path);
  94         g_prefix = prefix = setup_git_directory();
  95         return git_config(git_default_config, NULL);
  96 }
  97
  98 static int git_parse_commit_author(struct GIT_COMMIT_AUTHOR *author, char *pbuff)
  99 {
 100         char *end;
 101
 102         author->Name=pbuff;
 103         end=strchr(pbuff,'<');
 104         if( end == 0)
 105         {
 106                 return -1;
 107         }
 108         author->NameSize = end - pbuff - 1;
 109
 110         pbuff = end +1;
 111         end = strchr(pbuff, '>');
 112         if( end == 0)
 113                 return -1;
 114
 115         author->Email = pbuff ;
 116         author->EmailSize = end - pbuff;
 117
 118         pbuff = end + 2;
 119
 120         author->Date = atol(pbuff);
 121         end =  strchr(pbuff, ' ');
 122         if( end == 0 )
 123                 return -1;
 124
 125         pbuff=end;
 126         author->TimeZone = atol(pbuff);
 127
 128         return 0;
 129 }
 130
 131 int git_parse_commit(GIT_COMMIT *commit)
 132 {
 133         int ret = 0;
 134         char *pbuf;
 135         char *end;
 136         struct commit *p;
 137
 138         p= (struct commit *)commit->m_pGitCommit;
 139
 140         memcpy(commit->m_hash,p->object.sha1,GIT_HASH_SIZE);
 141
 142         commit->m_Encode = NULL;
 143         commit->m_EncodeSize = 0;
 144
 145         if(p->buffer == NULL)
 146                 return -1;
 147
 148         pbuf = p->buffer;
 149         while(pbuf)
 150         {
 151                 if( strncmp(pbuf,"author",6) == 0)
 152                 {
 153                         ret = git_parse_commit_author(&commit->m_Author,pbuf + 7);
 154                         if(ret)
 155                                 return ret;
 156                 }
 157                 if( strncmp(pbuf, "committer",9) == 0)
 158                 {
 159                         ret =  git_parse_commit_author(&commit->m_Committer,pbuf + 10);
 160                         if(ret)
 161                                 return ret;
 162
 163                         pbuf = strchr(pbuf,'\n');
 164                         if(pbuf == NULL)
 165                                 return -1;
 166
 167                         while((*pbuf) && (*pbuf == '\n'))
 168                                 pbuf ++;
 169
 170                         if( strncmp(pbuf, "encoding",8) == 0 )
 171                         {
 172                                 pbuf += 9;
 173                                 commit->m_Encode=pbuf;
 174                                 end = strchr(pbuf,'\n');
 175                                 commit->m_EncodeSize=end -pbuf;
 176
 177                                 pbuf = end +1;
 178                                 while((*pbuf) && (*pbuf == '\n'))
 179                                         pbuf ++;
 180                         }
 181                         commit->m_Subject=pbuf;
 182                         end = strchr(pbuf,'\n');
 183                         if( end == 0)
 184                                 commit->m_SubjectSize = strlen(pbuf);
 185                         else
 186                         {
 187                                 commit->m_SubjectSize = end - pbuf;
 188                                 pbuf = end +1;
 189                                 commit->m_Body = pbuf;
 190                                 commit->m_BodySize = strlen(pbuf);
 191                                 return 0;
 192                         }
 193
 194                 }
 195
 196                 pbuf = strchr(pbuf,'\n');
 197                 if(pbuf)
 198                         pbuf ++;
 199         }
 200
 201 }
 202
 203 int git_get_commit_from_hash(GIT_COMMIT *commit, GIT_HASH hash)
 204 {
 205         int ret = 0;
 206
 207         struct commit *p;
 208
 209         memset(commit,0,sizeof(GIT_COMMIT));
 210
 211         commit->m_pGitCommit = p = lookup_commit(hash);
 212
 213         if(commit == NULL)
 214                 return -1;
 215
 216         if(p == NULL)
 217                 return -1;
 218
 219         ret = parse_commit(p);
 220         if( ret )
 221                 return ret;
 222
 223         return git_parse_commit(commit);
 224 }
 225
 226 int git_get_commit_first_parent(GIT_COMMIT *commit,GIT_COMMIT_LIST *list)
 227 {
 228         struct commit *p = commit->m_pGitCommit;
 229
 230         if(list == NULL)
 231                 return -1;
 232
 233         *list = (GIT_COMMIT_LIST*)p->parents;
 234         return 0;
 235 }
 236 int git_get_commit_next_parent(GIT_COMMIT_LIST *list, GIT_HASH hash)
 237 {
 238         struct commit_list *l = *(struct commit_list **)list;
 239         if(list == NULL || l==NULL)
 240                 return -1;
 241
 242         if(hash)
 243                 memcpy(hash, l->item->object.sha1, GIT_HASH_SIZE);
 244
 245         *list = (GIT_COMMIT_LIST *)l->next;
 246         return 0;
 247
 248 }
 249
 250
 251 int git_free_commit(GIT_COMMIT *commit)
 252 {
 253         struct commit *p = commit->m_pGitCommit;
 254
 255         if( p->parents)
 256                 free_commit_list(p->parents);
 257
 258         if( p->buffer )
 259         {
 260                 free(p->buffer);
 261                 p->buffer=NULL;
 262                 p->object.parsed=0;
 263                 p->parents=0;
 264                 p->tree=0;
 265         }
 266         memset(commit,0,sizeof(GIT_COMMIT));
 267         return 0;
 268 }
 269
 270 char **strtoargv(char *arg, int *size)
 271 {
 272         int count=0;
 273         char *p=arg;
 274         char **argv;
 275
 276         int i=0;
 277         while(*p)
 278         {
 279                 if(*p == '\\')
 280                         *p='/';
 281                 p++;
 282         }
 283         p=arg;
 284
 285         while(*p)
 286         {
 287                 if(*p == ' ')
 288                         count ++;
 289                 p++;
 290         }
 291
 292         argv=malloc(strlen(arg)+1 + (count +2)*sizeof(void*));
 293         p=(char*)(argv+count+2);
 294
 295         while(*arg)
 296         {
 297                 if(*arg == '"')
 298                 {
 299                         argv[i] = p;
 300                         arg++;
 301                         *p=*arg;
 302                         while(*arg && *arg!= '"')
 303                                 *p++=*arg++;
 304                         *p++=0;
 305                         arg++;
 306                         i++;
 307                         if(*arg == 0)
 308                                 break;
 309                 }
 310                 if(*arg != ' ')
 311                 {
 312                         argv[i]=p;
 313                         while(*arg && *arg !=' ')
 314                                 *p++ = *arg++;
 315                         i++;
 316                         *p++=0;
 317                 }
 318                 arg++;
 319         }
 320         argv[i]=NULL;
 321         *size = i;
 322         return argv;
 323 }
 324 int git_open_log(GIT_LOG * handle, char * arg)
 325 {
 326         struct rev_info *p_Rev;
 327         int size;
 328         char ** argv=0;
 329         int argc=0;
 330         int i=0;
 331
 332         /* clear flags */
 333         unsigned int obj_size = get_max_object_index();
 334         for(i =0; i<obj_size; i++)
 335         {
 336                 struct object *ob= get_indexed_object(i);
 337                 if(ob)
 338                         ob->flags=0;
 339         }
 340
 341         if(arg != NULL)
 342                 argv = strtoargv(arg,&argc);
 343
 344         p_Rev = malloc(sizeof(struct rev_info));
 345         memset(p_Rev,0,sizeof(struct rev_info));
 346
 347         if(p_Rev == NULL)
 348                 return -1;
 349
 350         init_revisions(p_Rev, g_prefix);
 351         p_Rev->diff = 1;
 352
 353         cmd_log_init(argc, argv, g_prefix,p_Rev);
 354
 355         p_Rev->pPrivate = argv;
 356         *handle = p_Rev;
 357         return 0;
 358
 359 }
 360 int git_get_log_firstcommit(GIT_LOG handle)
 361 {
 362         return prepare_revision_walk(handle);
 363 }
 364
 365 int git_get_log_estimate_commit_count(GIT_LOG handle)
 366 {
 367         struct rev_info *p_Rev;
 368         p_Rev=(struct rev_info *)handle;
 369
 370         return estimate_commit_count(p_Rev, p_Rev->commits);
 371 }
 372
 373 int git_get_log_nextcommit(GIT_LOG handle, GIT_COMMIT *commit)
 374 {
 375         int ret =0;
 376
 377         commit->m_pGitCommit = get_revision(handle);
 378         if( commit->m_pGitCommit == NULL)
 379                 return -2;
 380
 381         ret=git_parse_commit(commit);
 382         if(ret)
 383                 return ret;
 384
 385         return 0;
 386 }
 387
 388 int git_close_log(GIT_LOG handle)
 389 {
 390         if(handle)
 391         {
 392                 struct rev_info *p_Rev;
 393                 p_Rev=(struct rev_info *)handle;
 394                 if(p_Rev->pPrivate)
 395                         free(p_Rev->pPrivate);
 396                 free(handle);
 397         }
 398
 399         return 0;
 400 }
 401
 402 int git_open_diff(GIT_DIFF *diff, char * arg)
 403 {
 404         struct rev_info *p_Rev;
 405         int size;
 406         char ** argv=0;
 407         int argc=0;
 408
 409         if(arg != NULL)
 410                 argv = strtoargv(arg,&argc);
 411
 412         p_Rev = malloc(sizeof(struct rev_info));
 413         memset(p_Rev,0,sizeof(struct rev_info));
 414
 415         p_Rev->pPrivate = argv;
 416         *diff = (GIT_DIFF)p_Rev;
 417
 418         init_revisions(p_Rev, g_prefix);
 419         git_config(git_diff_basic_config, NULL); /* no "diff" UI options */
 420         p_Rev->abbrev = 0;
 421         p_Rev->diff = 1;
 422         argc = setup_revisions(argc, argv, p_Rev, NULL);
 423
 424         return 0;
 425 }
 426 int git_close_diff(GIT_DIFF handle)
 427 {
 428         git_diff_flush(handle);
 429         if(handle)
 430         {
 431                 struct rev_info *p_Rev;
 432                 p_Rev=(struct rev_info *)handle;
 433                 if(p_Rev->pPrivate)
 434                         free(p_Rev->pPrivate);
 435                 free(handle);
 436         }
 437         return 0;
 438 }
 439 int git_diff_flush(GIT_DIFF diff)
 440 {
 441         struct diff_queue_struct *q = &diff_queued_diff;
 442         struct rev_info *p_Rev;
 443         int i;
 444         p_Rev = (struct rev_info *)diff;
 445
 446         if(q->nr == 0)
 447                 return 0;
 448
 449         for (i = 0; i < q->nr; i++)
 450                 diff_free_filepair(q->queue[i]);
 451
 452         if(q->queue)
 453         {
 454                 free(q->queue);
 455                 q->queue = NULL;
 456                 q->nr = q->alloc = 0;
 457         }
 458
 459         if (p_Rev->diffopt.close_file)
 460                 fclose(p_Rev->diffopt.close_file);
 461
 462         free_diffstat_info(&p_Rev->diffstat);
 463 }
 464
 465 int git_root_diff(GIT_DIFF diff, GIT_HASH hash,GIT_FILE *file, int *count)
 466 {
 467         int ret;
 468         struct rev_info *p_Rev;
 469         int i;
 470         struct diff_queue_struct *q = &diff_queued_diff;
 471
 472         p_Rev = (struct rev_info *)diff;
 473
 474         ret=diff_root_tree_sha1(hash, "", &p_Rev->diffopt);
 475
 476         if(ret)
 477                 return ret;
 478
 479         diffcore_std(&p_Rev->diffopt);
 480
 481         memset(&p_Rev->diffstat, 0, sizeof(struct diffstat_t));
 482         for (i = 0; i < q->nr; i++) {
 483                 struct diff_filepair *p = q->queue[i];
 484                 //if (check_pair_status(p))
 485                 diff_flush_stat(p, &p_Rev->diffopt, &p_Rev->diffstat);
 486         }
 487
 488         if(file)
 489                 *file = q;
 490         if(count)
 491                 *count = q->nr;
 492
 493         return 0;
 494 }
 495
 496 int git_diff(GIT_DIFF diff, GIT_HASH hash1, GIT_HASH hash2, GIT_FILE * file, int *count)
 497 {
 498         struct rev_info *p_Rev;
 499         int ret;
 500         int i;
 501         struct diff_queue_struct *q = &diff_queued_diff;
 502
 503         p_Rev = (struct rev_info *)diff;
 504
 505         ret = diff_tree_sha1(hash1,hash2,"",&p_Rev->diffopt);
 506         if( ret )
 507                 return ret;
 508
 509         diffcore_std(&p_Rev->diffopt);
 510
 511         memset(&p_Rev->diffstat, 0, sizeof(struct diffstat_t));
 512         for (i = 0; i < q->nr; i++) {
 513                 struct diff_filepair *p = q->queue[i];
 514                 //if (check_pair_status(p))
 515                 diff_flush_stat(p, &p_Rev->diffopt, &p_Rev->diffstat);
 516         }
 517
 518         if(file)
 519                 *file = q;
 520         if(count)
 521                 *count = q->nr;
 522         return 0;
 523 }
 524
 525 int git_get_diff_file(GIT_DIFF diff,GIT_FILE file,int i, char **newname, char ** oldname,  int *status, int *IsBin, int *inc, int *dec)
 526 {
 527         struct diff_queue_struct *q = &diff_queued_diff;
 528         struct rev_info *p_Rev;
 529         p_Rev = (struct rev_info *)diff;
 530
 531         q = (struct diff_queue_struct *)file;
 532         if(file == 0)
 533                 return -1;
 534         if(i>=q->nr)
 535                 return -1;
 536
 537         if(newname)
 538                 *newname = q->queue[i]->two->path;
 539
 540         if(oldname)
 541                 *oldname = q->queue[i]->one->path;
 542
 543         if(status)
 544                 *status = q->queue[i]->status;
 545
 546         if(p_Rev->diffstat.files)
 547         {
 548                 int j;
 549                 for(j=0;j<p_Rev->diffstat.nr;j++)
 550                 {
 551                         if(strcmp(*newname,p_Rev->diffstat.files[j]->name)==0)
 552                                 break;
 553                 }
 554                 if( j== p_Rev->diffstat.nr)
 555                 {
 556                         *IsBin=1;
 557                         *inc=0;
 558                         *dec=0;
 559                         return 0;
 560                 }
 561                 if(IsBin)
 562                         *IsBin = p_Rev->diffstat.files[j]->is_binary;
 563                 if(inc)
 564                         *inc = p_Rev->diffstat.files[j]->added;
 565                 if(dec)
 566                         *dec = p_Rev->diffstat.files[j]->deleted;
 567         }else
 568         {
 569                 *IsBin=1;
 570                 *inc=0;
 571                 *dec=0;
 572         }
 573
 574         return 0;
 575 }