include/tig/util.h

   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 #ifndef TIG_UTIL_H
  15 #define TIG_UTIL_H
  16
  17 #include "tig/tig.h"
  18 #include "tig/types.h"
  19
  20 /*
  21  * Error handling.
  22  */
  23
  24 #define STATUS_CODE_INFO(_) \
  25         _(CUSTOM_MESSAGE, NULL), \
  26         _(NO_OPTION_VALUE, "No option value"), \
  27         _(OUT_OF_MEMORY, "Out of memory"), \
  28         _(FILE_DOES_NOT_EXIST, "File does not exist"), \
  29         _(UNMATCHED_QUOTATION, "Unmatched quotation"), \
  30
  31 enum status_code {
  32         SUCCESS,
  33 #define STATUS_CODE_ENUM(name, msg) ERROR_ ## name
  34         STATUS_CODE_INFO(STATUS_CODE_ENUM)
  35 };
  36
  37 const char *get_status_message(enum status_code code);
  38 enum status_code error(const char *fmt, ...) PRINTF_LIKE(1, 2);
  39 enum status_code success(const char *fmt, ...) PRINTF_LIKE(1, 2);
  40
  41 typedef void (*die_fn)(void);
  42 extern die_fn die_callback;
  43 void TIG_NORETURN die(const char *err, ...) PRINTF_LIKE(1, 2);
  44 void warn(const char *msg, ...) PRINTF_LIKE(1, 2);
  45
  46 static inline int
  47 count_digits(unsigned long i)
  48 {
  49         int digits;
  50
  51         if (!i)
  52                 return 1;
  53
  54         for (digits = 0; i; digits++)
  55                 i /= 10;
  56         return digits;
  57 }
  58
  59 static inline int
  60 apply_step(double step, int value)
  61 {
  62         if (step >= 1)
  63                 return (int) step;
  64         value *= step + 0.01;
  65         return value ? value : 1;
  66 }
  67
  68 /*
  69  * Git data formatters.
  70  */
  71
  72 struct time {
  73         time_t sec;
  74         int tz;
  75 };
  76
  77 struct ident {
  78         const char *name;
  79         const char *email;
  80 };
  81
  82 extern const struct ident unknown_ident;
  83
  84 int timecmp(const struct time *t1, const struct time *t2);
  85 int ident_compare(const struct ident *i1, const struct ident *i2);
  86
  87 const char *mkdate(const struct time *time, enum date date);
  88 const char *mkfilesize(unsigned long size, enum file_size format);
  89 const char *mkauthor(const struct ident *ident, int cols, enum author author);
  90 const char *mkmode(mode_t mode);
  91 const char *mkstatus(const char status, enum status_label label);
  92
  93 #define author_trim(cols) (cols == 0 || cols > 10)
  94
  95 /*
  96  * Allocation helper.
  97  */
  98
  99 #define DEFINE_ALLOCATOR(name, type, chunk_size)                                \
 100 static type *                                                                   \
 101 name(type **mem, size_t size, size_t increase)                                  \
 102 {                                                                               \
 103         size_t num_chunks = (size + chunk_size - 1) / chunk_size;               \
 104         size_t num_chunks_new = (size + increase + chunk_size - 1) / chunk_size;\
 105         type *tmp = *mem;                                                       \
 106                                                                                 \
 107         if (mem == NULL || num_chunks != num_chunks_new) {                      \
 108                 size_t newsize = num_chunks_new * chunk_size * sizeof(type);    \
 109                                                                                 \
 110                 tmp = realloc(tmp, newsize);                                    \
 111                 if (tmp) {                                                      \
 112                         *mem = tmp;                                             \
 113                         if (num_chunks_new > num_chunks) {                      \
 114                                 size_t offset = num_chunks * chunk_size;        \
 115                                 size_t oldsize = offset * sizeof(type);         \
 116                                                                                 \
 117                                 memset(tmp + offset, 0, newsize - oldsize);     \
 118                         }                                                       \
 119                 }                                                               \
 120         }                                                                       \
 121                                                                                 \
 122         return tmp;                                                             \
 123 }
 124
 125 #endif
 126 /* vim: set ts=8 sw=8 noexpandtab: */