igit.c

   1 // igit.c
   2 //
   3
   4 #include <windows.h>
   5 #include "igit.h"
   6 #include "exec_cmd.h"
   7 #include "git-compat-util.h"
   8 #include "builtin.h"
   9 #include "diff.h"
  10 #include "revision.h"
  11 #include <fcntl.h>
  12 #include <stdlib.h>
  13
  14
  15 #define IGIT_VERSION "0.1.0"
  16
  17
  18 #define SAFE_FREE(_x) if (_x) { free(_x); _x = NULL; }
  19
  20 #define ASSERT(_x) //assert(_x)
  21
  22
  23 static char l_sGitBinPath[2048];
  24
  25
  26 /////////////////////////////////////////////////////////////////////
  27 // Git utils
  28
  29 // GitCommandInit flags (mirrored from git.c)
  30 #define RUN_SETUP               (1<<0)
  31 #define USE_PAGER               (1<<1)
  32 #define NEED_WORK_TREE  (1<<2)
  33
  34
  35 // GitCommandInit - does the basic init of run_command in git.c (returns path relative to project root)
  36 static const char* GitCommandInit(int flags)
  37 {
  38         // simple init in main of git.c to set up git sys path
  39
  40         git_extract_argv0_path(l_sGitBinPath);
  41
  42         setup_path();
  43
  44         // init from run_command
  45
  46         const char *prefix = NULL;
  47
  48         if (flags & RUN_SETUP)
  49                 prefix = setup_git_directory();
  50
  51         if (flags & NEED_WORK_TREE)
  52                 setup_work_tree();
  53
  54         return prefix;
  55 }
  56
  57
  58 void fputsha1(LPBYTE sha1, FILE *fp)
  59 {
  60         int i;
  61         for (i=0; i<20; i++)
  62         {
  63                 fprintf(fp, "%02x", (UINT)*sha1++);
  64         }
  65 }
  66
  67 /////////////////////////////////////////////////////////////////////
  68 // igInitPath
  69
  70 static LPSTR nextpath(LPCSTR src, LPSTR dst, UINT maxlen)
  71 {
  72         LPCSTR orgsrc;
  73
  74         while (*src == ';')
  75                 src++;
  76
  77         orgsrc = src;
  78
  79         if (!--maxlen)
  80                 goto nullterm;
  81
  82         while (*src && *src != ';')
  83         {
  84                 if (*src != '"')
  85                 {
  86                         *dst++ = *src++;
  87                         if (!--maxlen)
  88                         {
  89                                 orgsrc = src;
  90                                 goto nullterm;
  91                         }
  92                 }
  93                 else
  94                 {
  95                         src++;
  96                         while (*src && *src != '"')
  97                         {
  98                                 *dst++ = *src++;
  99                                 if (!--maxlen)
 100                                 {
 101                                         orgsrc = src;
 102                                         goto nullterm;
 103                                 }
 104                         }
 105
 106                         if (*src)
 107                                 src++;
 108                 }
 109         }
 110
 111         while (*src == ';')
 112                 src++;
 113
 114 nullterm:
 115
 116         *dst = 0;
 117
 118         return (orgsrc != src) ? (LPSTR)src : NULL;
 119 }
 120
 121 static inline BOOL FileExists(LPCSTR lpszFileName)
 122 {
 123         struct stat st;
 124         return lstat(lpszFileName, &st) == 0;
 125 }
 126
 127 static BOOL FindGitPath()
 128 {
 129         char *env;
 130
 131         if ( !(env = getenv("PATH")) )
 132         {
 133                 return FALSE;
 134         }
 135
 136         char buf[_MAX_PATH];
 137
 138         const LPCSTR filename = "git.exe";
 139         const int filelen = strlen(filename);
 140
 141         // search in all paths defined in PATH
 142         while ((env = nextpath(env, buf, _MAX_PATH-1)) && *buf)
 143         {
 144                 char *pfin = buf + strlen(buf)-1;
 145
 146                 // ensure trailing slash
 147                 if (*pfin != '/' && *pfin != '\\')
 148                         strcpy(pfin+1, "\\");
 149
 150                 const int len = strlen(buf);
 151
 152                 if ((len + filelen) < _MAX_PATH)
 153                         strcpy(buf+len, filename);
 154                 else
 155                         break;
 156
 157                 if ( FileExists(buf) )
 158                 {
 159                         // dir found
 160                         memcpy(l_sGitBinPath, buf, len);
 161                         l_sGitBinPath[len] = 0;
 162                         return TRUE;
 163                 }
 164         }
 165
 166         return FALSE;
 167 }
 168
 169
 170 BOOL igInitPath(void)
 171 {
 172         if ( !FindGitPath() )
 173         {
 174                 // fallback and use path of libiconv2.dll which wingit is linked to and normally is located in the git dir
 175                 if ( !GetModuleFileName(GetModuleHandle("libiconv2.dll"), l_sGitBinPath, sizeof(l_sGitBinPath)) )
 176                 {
 177                         OutputDebugString("[IGIT] Failed to locate Git/bin path\r\n");
 178                         return FALSE;
 179                 }
 180         }
 181
 182         // slashify path to avoid mixing back and forward slashes (git uses forward)
 183         char *p = l_sGitBinPath;
 184         while (*p)
 185         {
 186                 if (*p == '\\') *p = '/';
 187                 p++;
 188         }
 189
 190         return TRUE;
 191 }
 192
 193
 194 /////////////////////////////////////////////////////////////////////
 195 // igEnumFiles - based on builtin-ls-files
 196
 197 extern BOOL ig_enum_files(const char *pszProjectPath, const char *pszSubPath, const char *prefix, unsigned int nFlags);
 198
 199
 200 int igEnumFiles(const char *pszProjectPath, const char *pszSubPath, unsigned int nFlags)
 201 {
 202         // clean up subpath
 203         if (pszSubPath)
 204         {
 205                 int len = strlen(pszSubPath);
 206
 207                 //char *s = alloca(len+1);
 208                 //strcpy(s, pszSubPath);
 209                 char *s = strdup(pszSubPath);
 210
 211                 // slashify
 212                 char *p = s;
 213                 while (*p)
 214                 {
 215                         if (*p == '\\') *p = '/';
 216                         p++;
 217                 }
 218
 219                 // remove trailing slashes
 220                 char *c = &s[len-1];
 221                 while (*c == '/' && c > s) *c-- = 0;
 222                 // remove initial slashes
 223                 while (*s == '/') s++;
 224
 225                 pszSubPath = *s ? s : NULL;
 226         }
 227
 228         const char *prefix = GitCommandInit(RUN_SETUP);
 229
 230         if ( !ig_enum_files(pszProjectPath, pszSubPath, prefix, nFlags) )
 231         {
 232                 return -1;
 233         }
 234
 235         return 0;
 236 }
 237
 238
 239 /////////////////////////////////////////////////////////////////////
 240 // igGetRevisionID
 241
 242 int igGetRevisionID(const char *pszName)
 243 {
 244         BYTE sha1[20];
 245
 246         GitCommandInit(0);
 247
 248         git_config(git_default_config, NULL);
 249
 250         if ( !get_sha1(pszName, sha1) )
 251         {
 252                 fputsha1(sha1, stdout);
 253                 fputc(0, stdout);
 254
 255                 return 0;
 256         }
 257
 258         return -1;
 259 }
 260
 261
 262 /////////////////////////////////////////////////////////////////////
 263 // main
 264
 265 int main(int argc, const char **argv)
 266 {
 267         if (argc < 3)
 268         {
 269                 if (argc == 2 && !strcasecmp(argv[1], "version"))
 270                 {
 271                         fputs(IGIT_VERSION, stdout);
 272                         fputc(0, stdout);
 273                         return 0;
 274                 }
 275
 276                 fputs("igit v"IGIT_VERSION" - backend interface to git intended for use by frontends\n\n", stderr);
 277                 fputs("usage: igit <project path> <command> [params]*\n", stderr);
 278                 fputs("       igit version\n\n", stderr);
 279                 fputs("commands:\n", stderr);
 280                 fputs("    revision [name]           SHA1 for specified commit or HEAD if none\n", stderr);
 281                 fputs("    status [flags [sub path]] list working copy files with status\n", stderr);
 282                 fputs("                              flags: dDefrs-\n", stderr);
 283                 return -1;
 284         }
 285
 286         if ( !igInitPath() )
 287         {
 288                 return -1;
 289         }
 290
 291         //if (argv[0] && *argv[0])
 292         //      git_extract_argv0_path(argv[0]);
 293         git_extract_argv0_path(l_sGitBinPath);
 294
 295         argv++;
 296         argc--;
 297
 298         // get project path
 299
 300         const char *projpath = argv[0];
 301
 302         if ( chdir(projpath) )
 303                 return -1;
 304
 305         argv++;
 306         argc--;
 307
 308         // get command
 309
 310         const char *cmd = argv[0];
 311
 312         argv++;
 313         argc--;
 314
 315         // process command
 316
 317         int res = 0;
 318
 319         if ( !strcasecmp(cmd, "revision") )
 320         {
 321                 const char *name = argc ? argv[0] : "HEAD";
 322
 323                 res = igGetRevisionID(name);
 324         }
 325         else if ( !strcasecmp(cmd, "status") )
 326         {
 327                 UINT nFlags = 0;
 328                 LPCSTR pszSubPath = NULL;
 329
 330                 if (argc)
 331                 {
 332                         LPCSTR q = argv[0];
 333                         while (*q)
 334                         {
 335                                 switch (*q++)
 336                                 {
 337                                 case 'd': nFlags |= WGEFF_DirStatusDelta; break;
 338                                 case 'D': nFlags |= WGEFF_DirStatusAll; break;
 339                                 case 'e': nFlags |= WGEFF_EmptyAsNormal; break;
 340                                 case 'f': nFlags |= WGEFF_FullPath; break;
 341                                 case 'r': nFlags |= WGEFF_NoRecurse; break;
 342                                 case 's': nFlags |= WGEFF_SingleFile; break;
 343                                 }
 344                         }
 345
 346                         if (argc > 1)
 347                                 pszSubPath = argv[1];
 348                 }
 349
 350                 res = igEnumFiles(projpath, pszSubPath, nFlags);
 351         }
 352
 353         return res;
 354 }