src/parse.c

   1 /* Copyright (c) 2006-2014 Jonas Fonseca <jonas.fonseca@gmail.com>
   2  *
   3  * This program is free software; you can redistribute it and/or
   4  * modify it under the terms of the GNU General Public License as
   5  * published by the Free Software Foundation; either version 2 of
   6  * the License, or (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU General Public License for more details.
  12  */
  13
  14 #include "tig/tig.h"
  15 #include "tig/parse.h"
  16
  17 size_t
  18 parse_size(const char *text)
  19 {
  20         size_t size = 0;
  21
  22         while (*text == ' ')
  23                 text++;
  24
  25         while (isdigit(*text))
  26                 size = (size * 10) + (*text++ - '0');
  27
  28         return size;
  29 }
  30
  31 /*
  32  * Parsing of ident lines.
  33  */
  34
  35 static void
  36 parse_timesec(struct time *time, const char *sec)
  37 {
  38         time->sec = (time_t) atol(sec);
  39 }
  40
  41 static void
  42 parse_timezone(struct time *time, const char *zone)
  43 {
  44         long tz;
  45
  46         tz  = ('0' - zone[1]) * 60 * 60 * 10;
  47         tz += ('0' - zone[2]) * 60 * 60;
  48         tz += ('0' - zone[3]) * 60 * 10;
  49         tz += ('0' - zone[4]) * 60;
  50
  51         if (zone[0] == '-')
  52                 tz = -tz;
  53
  54         time->tz = tz;
  55         time->sec -= tz;
  56 }
  57
  58 void
  59 parse_author_line(char *ident, const struct ident **author, struct time *time)
  60 {
  61         char *nameend = strchr(ident, '<');
  62         char *emailend = strchr(ident, '>');
  63         const char *name, *email = "";
  64
  65         if (nameend && emailend)
  66                 *nameend = *emailend = 0;
  67         name = chomp_string(ident);
  68         if (nameend)
  69                 email = chomp_string(nameend + 1);
  70         if (!*name)
  71                 name = *email ? email : unknown_ident.name;
  72         if (!*email)
  73                 email = *name ? name : unknown_ident.email;
  74
  75         *author = get_author(name, email);
  76
  77         /* Parse epoch and timezone */
  78         if (time && emailend && emailend[1] == ' ') {
  79                 char *secs = emailend + 2;
  80                 char *zone = strchr(secs, ' ');
  81
  82                 parse_timesec(time, secs);
  83
  84                 if (zone && strlen(zone) == STRING_SIZE(" +0700"))
  85                         parse_timezone(time, zone + 1);
  86         }
  87 }
  88
  89 /*
  90  * Blame.
  91  */
  92
  93 static bool
  94 parse_number(const char **posref, size_t *number, size_t min, size_t max)
  95 {
  96         const char *pos = *posref;
  97
  98         *posref = NULL;
  99         pos = strchr(pos + 1, ' ');
 100         if (!pos || !isdigit(pos[1]))
 101                 return FALSE;
 102         *number = atoi(pos + 1);
 103         if (*number < min || *number > max)
 104                 return FALSE;
 105
 106         *posref = pos;
 107         return TRUE;
 108 }
 109
 110 bool
 111 parse_blame_header(struct blame_header *header, const char *text, size_t max_lineno)
 112 {
 113         const char *pos = text + SIZEOF_REV - 2;
 114
 115         if (strlen(text) <= SIZEOF_REV || pos[1] != ' ')
 116                 return FALSE;
 117
 118         string_ncopy(header->id, text, SIZEOF_REV);
 119
 120         if (!parse_number(&pos, &header->orig_lineno, 1, 9999999) ||
 121             !parse_number(&pos, &header->lineno, 1, max_lineno) ||
 122             !parse_number(&pos, &header->group, 1, max_lineno - header->lineno + 1))
 123                 return FALSE;
 124
 125         return TRUE;
 126 }
 127
 128 static bool
 129 match_blame_header(const char *name, char **line)
 130 {
 131         size_t namelen = strlen(name);
 132         bool matched = !strncmp(name, *line, namelen);
 133
 134         if (matched)
 135                 *line += namelen;
 136
 137         return matched;
 138 }
 139
 140 bool
 141 parse_blame_info(struct blame_commit *commit, char author[SIZEOF_STR], char *line)
 142 {
 143         if (match_blame_header("author ", &line)) {
 144                 string_ncopy_do(author, SIZEOF_STR, line, strlen(line));
 145
 146         } else if (match_blame_header("author-mail ", &line)) {
 147                 char *end = strchr(line, '>');
 148
 149                 if (end)
 150                         *end = 0;
 151                 if (*line == '<')
 152                         line++;
 153                 commit->author = get_author(author, line);
 154                 author[0] = 0;
 155
 156         } else if (match_blame_header("author-time ", &line)) {
 157                 parse_timesec(&commit->time, line);
 158
 159         } else if (match_blame_header("author-tz ", &line)) {
 160                 parse_timezone(&commit->time, line);
 161
 162         } else if (match_blame_header("summary ", &line)) {
 163                 string_ncopy(commit->title, line, strlen(line));
 164
 165         } else if (match_blame_header("previous ", &line)) {
 166                 if (strlen(line) <= SIZEOF_REV)
 167                         return FALSE;
 168                 string_copy_rev(commit->parent_id, line);
 169                 line += SIZEOF_REV;
 170                 commit->parent_filename = get_path(line);
 171                 if (!commit->parent_filename)
 172                         return TRUE;
 173
 174         } else if (match_blame_header("filename ", &line)) {
 175                 commit->filename = get_path(line);
 176                 return TRUE;
 177         }
 178
 179         return FALSE;
 180 }
 181
 182 /*
 183  * Diff.
 184  */
 185
 186 static bool
 187 parse_ulong(const char **pos_ptr, unsigned long *value, const char *skip)
 188 {
 189         const char *start = *pos_ptr;
 190         char *end;
 191
 192         if (!isdigit(*start))
 193                 return 0;
 194
 195         *value = strtoul(start, &end, 10);
 196         if (end == start)
 197                 return FALSE;
 198
 199         start = end;
 200         while (skip && *start && strchr(skip, *start))
 201                 start++;
 202         *pos_ptr = start;
 203         return TRUE;
 204 }
 205
 206 bool
 207 parse_chunk_header(struct chunk_header *header, const char *line)
 208 {
 209         memset(header, 0, sizeof(*header));
 210
 211         if (!prefixcmp(line, "@@ -"))
 212                 line += STRING_SIZE("@@ -");
 213         else if (!prefixcmp(line, "@@@ -") &&
 214                  (line = strchr(line + STRING_SIZE("@@@ -"), '-')))
 215                 line += 1;
 216         else
 217                 return FALSE;
 218
 219
 220         return  parse_ulong(&line, &header->old.position, ",") &&
 221                 parse_ulong(&line, &header->old.lines, " +") &&
 222                 parse_ulong(&line, &header->new.position, ",") &&
 223                 parse_ulong(&line, &header->new.lines, NULL);
 224 }
 225
 226 bool
 227 parse_chunk_lineno(unsigned long *lineno, const char *chunk, int marker)
 228 {
 229         struct chunk_header chunk_header;
 230
 231         *lineno = 0;
 232
 233         if (!parse_chunk_header(&chunk_header, chunk))
 234                 return FALSE;
 235
 236         *lineno = marker == '-' ? chunk_header.old.position : chunk_header.new.position;
 237         return TRUE;
 238 }
 239
 240 /*
 241  * Caches.
 242  */
 243
 244 DEFINE_ALLOCATOR(realloc_paths, const char *, 256)
 245
 246 /* Small cache to reduce memory consumption. It uses binary search to
 247  * lookup or find place to position new entries. No entries are ever
 248  * freed. */
 249 const char *
 250 get_path(const char *path)
 251 {
 252         static const char **paths;
 253         static size_t paths_size;
 254         int from = 0, to = paths_size - 1;
 255         char *entry;
 256
 257         while (from <= to) {
 258                 size_t pos = (to + from) / 2;
 259                 int cmp = strcmp(path, paths[pos]);
 260
 261                 if (!cmp)
 262                         return paths[pos];
 263
 264                 if (cmp < 0)
 265                         to = pos - 1;
 266                 else
 267                         from = pos + 1;
 268         }
 269
 270         if (!realloc_paths(&paths, paths_size, 1))
 271                 return NULL;
 272         entry = strdup(path);
 273         if (!entry)
 274                 return NULL;
 275
 276         memmove(paths + from + 1, paths + from, (paths_size - from) * sizeof(*paths));
 277         paths[from] = entry;
 278         paths_size++;
 279
 280         return entry;
 281 }
 282
 283 DEFINE_ALLOCATOR(realloc_authors, struct ident *, 256)
 284
 285 /* Small author cache to reduce memory consumption. It uses binary
 286  * search to lookup or find place to position new entries. No entries
 287  * are ever freed. */
 288 struct ident *
 289 get_author(const char *name, const char *email)
 290 {
 291         static struct ident **authors;
 292         static size_t authors_size;
 293         int from = 0, to = authors_size - 1;
 294         struct ident *ident;
 295
 296         while (from <= to) {
 297                 size_t pos = (to + from) / 2;
 298                 int cmp = strcmp(email, authors[pos]->email);
 299
 300                 if (!cmp)
 301                         return authors[pos];
 302
 303                 if (cmp < 0)
 304                         to = pos - 1;
 305                 else
 306                         from = pos + 1;
 307         }
 308
 309         if (!realloc_authors(&authors, authors_size, 1))
 310                 return NULL;
 311         ident = calloc(1, sizeof(*ident));
 312         if (!ident)
 313                 return NULL;
 314         ident->name = strdup(name);
 315         ident->email = strdup(email);
 316         if (!ident->name || !ident->email) {
 317                 free((void *) ident->name);
 318                 free(ident);
 319                 return NULL;
 320         }
 321
 322         memmove(authors + from + 1, authors + from, (authors_size - from) * sizeof(*authors));
 323         authors[from] = ident;
 324         authors_size++;
 325
 326         return ident;
 327 }
 328
 329 /* vim: set ts=8 sw=8 noexpandtab: */