This is probably a naive question, but: there are quite a lot of static
variables in the git code where it's really unnecessary.  Is that just a
historical artifact, or is there some reason to prefer them?  I'm working
on a patch that will introduce threading, so naturally I'm on the lookout
for static variables.  In general, can I get rid of static variables where
it seems straightforward to do so?

As an example, here's an excerpt from symlnks.c.  In addition to being
static, if I'm reading this right, it appears that the 'removal' variable
is used before it's initialized:

static struct removal_def {
  char path[PATH_MAX];
  int len;
} removal;

static void do_remove_scheduled_dirs(int new_len)
  while (removal.len > new_len) {
    removal.path[removal.len] = '\0';
    if (rmdir(removal.path))
    do {
    } while (removal.len > new_len &&
       removal.path[removal.len] != '/');
  removal.len = new_len;

void schedule_dir_for_removal(const char *name, int len)
  int match_len, last_slash, i, previous_slash;

  match_len = last_slash = i =
    longest_path_match(name, len, removal.path, removal.len,
  /* Find last slash inside 'name' */
  while (i < len) {
    if (name[i] == '/')
      last_slash = i;

   * If we are about to go down the directory tree, we check if
   * we must first go upwards the tree, such that we then can
   * remove possible empty directories as we go upwards.
  if (match_len < last_slash && match_len < removal.len)
   * If we go deeper down the directory tree, we only need to
   * save the new path components as we go down.
  if (match_len < last_slash) {
    memcpy(&removal.path[match_len], &name[match_len],
           last_slash - match_len);
    removal.len = last_slash;

void remove_scheduled_dirs(void)



To unsubscribe from this list: send the line "unsubscribe git" in
the body of a message to
More majordomo info at

Reply via email to