1. 28 Nov, 2018 4 commits
    • khash: move khash include into implementation files · f2f5ec84
      The current map implementations directly include the "khash.h" headers
      into their own headers to make available a set of static functions,
      defines et cetera. Besides leaking the complete khash namespace into
      files wherever khashes are used, this also triggers Clang's
      -Wunused-function warnings when some of the static functions are not
      being used at all.
      
      Fix the issue by moving the includes into the respective map
      implementation files. Add forward declares for all the map types to make
      them known.
      Patrick Steinhardt committed
    • khash: remove intricate knowledge of khash types · 852bc9f4
      Instead of using the `khiter_t`, `git_strmap_iter` and `khint_t` types,
      simply use `size_t` instead. This decouples code from the khash stuff
      and makes it possible to move the khash includes into the implementation
      files.
      Patrick Steinhardt committed
    • khash: implement map-specific foreach macros · 5bfb3b58
      The current foreach map macros simply redirect to the type-indifferent
      `kh_foreach` macro. As this type-indifferent macro directly accesses the
      structures, the current implementation makes it impossible to make the
      stuctures private to the implementation only. And making them private is
      required to move out the khash include into the implementations to
      decrease the namespace leak.
      Patrick Steinhardt committed
    • khash: implement begin/end via functions instead of macros · 382b668b
      Right now, the `git_*map_begin()` and `git_*map_end()` helpers are
      implemented via macros which simply redirect to `kh_begin` and `kh_end`.
      As these macros refer to members of the map structures, they make it
      impossible to move the khash include into the implementation files.
      
      Implement these helpers as real functions instead to further decouple
      the headers from implementations.
      Patrick Steinhardt committed
  2. 20 Mar, 2017 1 commit
    • map: remove `*map_free` macros · 94af9155
      The `map_free` functions were not implemented as functions but instead
      as macros which also set the map to NULL. While this is most certainly
      sensible in most cases, we should prefer the more obvious behavior,
      namingly leaving the map pointer intact.
      
      Furthermore, this macro has been refactored incorrectly during the
      map-refactorings: the two statements are not actually grouped together
      by a `do { ... } while (0)` block, as it is required for macros to
      match the behavior of functions more closely. This has led to at least
      one subtle nesting error in `pack-objects.c`. The following code block
      
      ```
          if (pb->object_ix)
              git_oidmap_free(pb->object_ix);
      ```
      
      would be expanded to
      
      ```
          if (pb->object_ix)
              git_oidmap__free(pb->object_ix); pb->object_ix = NULL;
      ```
      
      which is not what one woudl expect. While it is not a bug here as it
      would simply become a no-op, the wrong implementation could lead to bugs
      in other occasions.
      
      Fix this by simply removing the macro altogether and replacing it with
      real function calls. This leaves the burden of setting the pointer to
      NULL afterwards to the caller, but this is actually expected and behaves
      like other `free` functions.
      Patrick Steinhardt committed
  3. 17 Feb, 2017 6 commits
  4. 15 Feb, 2015 1 commit
  5. 13 Feb, 2015 1 commit
  6. 17 Apr, 2014 1 commit
  7. 12 Aug, 2013 1 commit
  8. 08 Aug, 2013 1 commit
  9. 08 Jan, 2013 1 commit
  10. 12 Jul, 2012 1 commit
  11. 04 May, 2012 1 commit
  12. 25 Apr, 2012 1 commit