自学教程：C++ unused_parameter函数代码示例

static void cmd_shutdown(struct watchman_client *client, json_t *args) {  json_t *resp = make_response();  unused_parameter(args);  w_log(W_LOG_ERR, "shutdown-server was requested, exiting!/n");  w_request_shutdown();  set_prop(resp, "shutdown-server", json_true());  send_and_dispose_response(client, resp);}

/* watch-list * Returns a list of watched roots */static void cmd_watch_list(struct watchman_client *client, json_t *args){  json_t *resp;  json_t *root_paths;  unused_parameter(args);  resp = make_response();  root_paths = w_root_watch_list_to_json();  set_prop(resp, "roots", root_paths);  send_and_dispose_response(client, resp);}

static bool kqueue_root_consume_notify(watchman_global_watcher_t watcher,    w_root_t *root, struct watchman_pending_collection *coll){  struct kqueue_root_state *state = root->watch;  int n;  int i;  struct timespec ts = { 0, 0 };  struct timeval now;  unused_parameter(watcher);  errno = 0;  w_log(W_LOG_DBG, "kqueue(%s)/n", root->root_path->buf);  n = kevent(state->kq_fd, NULL, 0,      state->keventbuf, sizeof(state->keventbuf) / sizeof(state->keventbuf[0]),      &ts);  w_log(W_LOG_DBG, "consume_kqueue: %s n=%d err=%s/n",      root->root_path->buf, n, strerror(errno));  if (root->cancelled) {    return 0;  }  gettimeofday(&now, NULL);  for (i = 0; n > 0 && i < n; i++) {    uint32_t fflags = state->keventbuf[i].fflags;    if (IS_DIR_BIT_SET(state->keventbuf[i].udata)) {      struct watchman_dir *dir = DECODE_DIR(state->keventbuf[i].udata);      w_log(W_LOG_DBG, " KQ dir %s [0x%x]/n", dir->path->buf, fflags);      if ((fflags & (NOTE_DELETE|NOTE_RENAME|NOTE_REVOKE)) &&          w_string_equal(dir->path, root->root_path)) {        w_log(W_LOG_ERR,            "root dir %s has been (re)moved [code 0x%x], canceling watch/n",            root->root_path->buf, fflags);        w_root_cancel(root);        return 0;      }      w_pending_coll_add(coll, dir->path, false, now, false);    } else {      // NetBSD defines udata as intptr type, so the cast is necessary      struct watchman_file *file = (void *)state->keventbuf[i].udata;      w_string_t *path;      path = w_string_path_cat(file->parent->path, file->name);      w_pending_coll_add(coll, path, true, now, true);      w_log(W_LOG_DBG, " KQ file %.*s [0x%x]/n", path->len, path->buf, fflags);      w_string_delref(path);    }  }  return n > 0;}

w_query_expr *w_expr_imatch_parser(w_query *query, json_t *term){#ifdef NO_CASELESS_FNMATCH  unused_parameter(term);  asprintf(&query->errmsg,      "imatch: Your system doesn't support FNM_CASEFOLD");  return NULL;#else  return match_parser(query, term, true);#endif}

/* version */void cmd_version(struct watchman_client *client, json_t *args){  json_t *resp = make_response();  unused_parameter(args);#ifdef WATCHMAN_BUILD_INFO  set_prop(resp, "buildinfo", json_string(WATCHMAN_BUILD_INFO));#endif  send_and_dispose_response(client, resp);}

static bool kqueue_root_start_watch_file(watchman_global_watcher_t watcher,      w_root_t *root, struct watchman_file *file) {  struct kqueue_root_state *state = root->watch;  struct kevent k;  w_ht_val_t fdval;  int fd;  w_string_t *full_name;  unused_parameter(watcher);  full_name = w_string_path_cat(file->parent->path, file->name);  pthread_mutex_lock(&state->lock);  if (w_ht_lookup(state->name_to_fd, w_ht_ptr_val(full_name), &fdval, false)) {    // Already watching it    pthread_mutex_unlock(&state->lock);    return true;  }  pthread_mutex_unlock(&state->lock);  w_log(W_LOG_DBG, "watch_file(%s)/n", full_name->buf);  fd = open(full_name->buf, O_EVTONLY|O_CLOEXEC);  if (fd == -1) {    w_log(W_LOG_ERR, "failed to open %s O_EVTONLY: %s/n",        full_name->buf, strerror(errno));    w_string_delref(full_name);    return false;  }  memset(&k, 0, sizeof(k));  EV_SET(&k, fd, EVFILT_VNODE, EV_ADD|EV_CLEAR,      NOTE_WRITE|NOTE_DELETE|NOTE_EXTEND|NOTE_RENAME|NOTE_ATTRIB,      0, full_name);  pthread_mutex_lock(&state->lock);  w_ht_replace(state->name_to_fd, w_ht_ptr_val(full_name), fd);  w_ht_replace(state->fd_to_name, fd, w_ht_ptr_val(full_name));  pthread_mutex_unlock(&state->lock);  if (kevent(state->kq_fd, &k, 1, NULL, 0, 0)) {    w_log(W_LOG_DBG, "kevent EV_ADD file %s failed: %s",        full_name->buf, strerror(errno));    close(fd);    pthread_mutex_lock(&state->lock);    w_ht_del(state->name_to_fd, w_ht_ptr_val(full_name));    w_ht_del(state->fd_to_name, fd);    pthread_mutex_unlock(&state->lock);  } else {    w_log(W_LOG_DBG, "kevent file %s -> %d/n", full_name->buf, fd);  }  w_string_delref(full_name);  return true;}

static void portfs_root_stop_watch_file(watchman_global_watcher_t watcher,      w_root_t *root, struct watchman_file *file) {  struct portfs_root_state *state = root->watch;  unused_parameter(watcher);  port_dissociate(state->port_fd, PORT_SOURCE_FILE,      (uintptr_t)&file->port_file);  if (file->port_file.fo_name) {    free(file->port_file.fo_name);    file->port_file.fo_name = NULL;  }}

static bool eval_size(struct w_query_ctx *ctx, struct watchman_file *file,    void *data){  struct w_query_int_compare *comp = data;  unused_parameter(ctx);  // Removed files never evaluate true  if (!file->exists) {    return false;  }  return eval_int_compare(file->stat.size, comp);}

void kqueue_root_dtor(watchman_global_watcher_t watcher, w_root_t *root) {  struct kqueue_root_state *state = root->watch;  unused_parameter(watcher);  if (!state) {    return;  }  close(state->kq_fd);  state->kq_fd = -1;  free(state);  root->watch = NULL;}

static DIR *winwatch_root_start_watch_dir(watchman_global_watcher_t watcher,    w_root_t *root, struct watchman_dir *dir, struct timeval now,    const char *path) {  DIR *osdir;  unused_parameter(watcher);  osdir = opendir(path);  if (!osdir) {    handle_open_errno(root, dir, now, "opendir", errno, strerror(errno));    return NULL;  }  return osdir;}

static bool kqueue_root_wait_notify(watchman_global_watcher_t watcher,    w_root_t *root, int timeoutms) {  struct kqueue_root_state *state = root->watch;  int n;  struct pollfd pfd;  unused_parameter(watcher);  pfd.fd = state->kq_fd;  pfd.events = POLLIN;  n = poll(&pfd, 1, timeoutms);  return n == 1;}

static void crash_handler(int signo, siginfo_t *si, void *ucontext) {  const char *reason = "";  unused_parameter(ucontext);  if (si) {    switch (si->si_signo) {      case SIGILL:        switch (si->si_code) {          case ILL_ILLOPC: reason = "illegal opcode"; break;          case ILL_ILLOPN: reason = "illegal operand"; break;          case ILL_ILLADR: reason = "illegal addressing mode"; break;          case ILL_ILLTRP: reason = "illegal trap"; break;          case ILL_PRVOPC: reason = "privileged opcode"; break;          case ILL_PRVREG: reason = "privileged register"; break;          case ILL_COPROC: reason = "co-processor error"; break;          case ILL_BADSTK: reason = "internal stack error"; break;        }        break;      case SIGFPE:        switch (si->si_code) {          case FPE_INTDIV: reason = "integer divide by zero"; break;          case FPE_INTOVF: reason = "integer overflow"; break;          case FPE_FLTDIV: reason = "floating point divide by zero"; break;          case FPE_FLTOVF: reason = "floating point overflow"; break;          case FPE_FLTUND: reason = "floating point underflow"; break;          case FPE_FLTRES: reason = "floating point inexact result"; break;          case FPE_FLTINV: reason = "invalid floating point operation"; break;          case FPE_FLTSUB: reason = "subscript out of range"; break;        }        break;      case SIGSEGV:        switch (si->si_code) {          case SEGV_MAPERR: reason = "address not mapped to object"; break;          case SEGV_ACCERR: reason = "invalid permissions for mapped object";                            break;        }        break;#ifdef SIGBUS      case SIGBUS:        switch (si->si_code) {          case BUS_ADRALN: reason = "invalid address alignment"; break;          case BUS_ADRERR: reason = "non-existent physical address"; break;        }        break;#endif    }  }  w_log(W_LOG_FATAL, "Terminating due to signal %d %s. %s (%p)/n",      signo, strsignal(signo), reason, si ? si->si_value.sival_ptr : NULL);}

static void cmd_shutdown(    struct watchman_client *client,    json_t *args){  json_t *resp = make_response();  unused_parameter(args);  w_log(W_LOG_ERR, "shutdown-server was requested, exiting!/n");  stopping = true;  // Knock listener thread out of poll/accept  pthread_kill(listener_thread, SIGUSR1);  set_prop(resp, "shutdown-server", json_true());  send_and_dispose_response(client, resp);}

static void kqueue_root_stop_watch_file(watchman_global_watcher_t watcher,      w_root_t *root, struct watchman_file *file) {  struct kqueue_root_state *state = root->watch;  struct kevent k;  unused_parameter(watcher);  if (file->kq_fd == -1) {    return;  }  memset(&k, 0, sizeof(k));  EV_SET(&k, file->kq_fd, EVFILT_VNODE, EV_DELETE, 0, 0, file);  kevent(state->kq_fd, &k, 1, NULL, 0, 0);  close(file->kq_fd);  file->kq_fd = -1;}

void kqueue_root_dtor(watchman_global_watcher_t watcher, w_root_t *root) {  struct kqueue_root_state *state = root->watch;  unused_parameter(watcher);  if (!state) {    return;  }  pthread_mutex_destroy(&state->lock);  close(state->kq_fd);  state->kq_fd = -1;  w_ht_free(state->name_to_fd);  w_ht_free(state->fd_to_name);  free(state);  root->watch = NULL;}

static void *child_reaper(void *arg){  sigset_t sigset;  unused_parameter(arg);  // Unblock SIGCHLD only in this thread  sigemptyset(&sigset);  sigaddset(&sigset, SIGCHLD);  pthread_sigmask(SIG_UNBLOCK, &sigset, NULL);  while (!stopping) {    usleep(200000);    w_reap_children(true);  }  return 0;}

static bool default_generators(    w_query *query,    w_root_t *root,    struct w_query_ctx *ctx,    void *gendata){  bool generated = false;  unused_parameter(gendata);  // Time based query  if (ctx->since.is_timestamp || !ctx->since.clock.is_fresh_instance) {    if (!time_generator(query, root, ctx)) {      return false;    }    generated = true;  }  // Suffix  if (query->suffixes) {    if (!suffix_generator(query, root, ctx)) {      return false;    }    generated = true;  }  if (query->npaths) {    if (!path_generator(query, root, ctx)) {      return false;    }    generated = true;  }  // And finally, if there were no other generators, we walk all known  // files  if (!generated) {    if (!all_files_generator(query, root, ctx)) {      return false;    }  }  return true;}

static struct watchman_dir_handle *inot_root_start_watch_dir(    watchman_global_watcher_t watcher,    w_root_t *root, struct watchman_dir *dir, struct timeval now,    const char *path) {  struct inot_root_state *state = root->watch;  struct watchman_dir_handle *osdir = NULL;  int newwd, err;  unused_parameter(watcher);  // Carry out our very strict opendir first to ensure that we're not  // traversing symlinks in the context of this root  osdir = w_dir_open(path);  if (!osdir) {    handle_open_errno(root, dir, now, "opendir", errno, NULL);    return NULL;  }  // The directory might be different since the last time we looked at it, so  // call inotify_add_watch unconditionally.  newwd = inotify_add_watch(state->infd, path, WATCHMAN_INOTIFY_MASK);  if (newwd == -1) {    err = errno;    if (errno == ENOSPC || errno == ENOMEM) {      // Limits exceeded, no recovery from our perspective      set_poison_state(root, dir->path, now, "inotify-add-watch", errno,          inot_strerror(errno));    } else {      handle_open_errno(root, dir, now, "inotify_add_watch", errno,          inot_strerror(errno));    }    w_dir_close(osdir);    errno = err;    return NULL;  }  // record mapping  pthread_mutex_lock(&state->lock);  w_ht_replace(state->wd_to_name, newwd, w_ht_ptr_val(dir->path));  pthread_mutex_unlock(&state->lock);  w_log(W_LOG_DBG, "adding %d -> %s mapping/n", newwd, path);  return osdir;}

void winwatch_root_dtor(watchman_global_watcher_t watcher, w_root_t *root) {  struct winwatch_root_state *state = root->watch;  unused_parameter(watcher);  if (!state) {    return;  }  // wait for readchanges_thread to quit before we tear down state  if (!pthread_equal(state->thread, pthread_self())) {    void *ignore;    pthread_join(state->thread, &ignore);  }  CloseHandle(state->ping);  CloseHandle(state->olap);  CloseHandle(state->dir_handle);  free(state);  root->watch = NULL;}

static bool eval_dirname(struct w_query_ctx *ctx,                         struct watchman_file *file, void *ptr) {    struct dirname_data *data = ptr;    w_string_t *str = w_query_ctx_get_wholename(ctx);    json_int_t depth = 0;    size_t i;    unused_parameter(file);    if (str->len <= data->dirname->len) {        // Either it doesn't prefix match, or file name is == dirname.        // That means that the best case is that the wholename matches.        // we only want to match if dirname(wholename) matches, so it        // is not possible for us to match unless the length of wholename        // is greater than the dirname operand        return false;    }    // Want to make sure that wholename is a child of dirname, so    // check for a dir separator.  Special case for dirname == '' (the root),    // which won't have a slash in position 0.    if (data->dirname->len > 0 && str->buf[data->dirname->len] != '/') {        // may have a common prefix with, but is not a child of dirname        return false;    }    if (!data->startswith(str, data->dirname)) {        return false;    }    // Now compute the depth of file from dirname.  We do this by    // counting dir separators, not including the one we saw above.    for (i = data->dirname->len + 1; i < str->len; i++) {        if (str->buf[i] == '/') {            depth++;        }    }    return eval_int_compare(depth, &data->depth);}

static DIR *portfs_root_start_watch_dir(watchman_global_watcher_t watcher,    w_root_t *root, struct watchman_dir *dir, struct timeval now,    const char *path) {  struct portfs_root_state *state = root->watch;  DIR *osdir;  struct stat st;  unused_parameter(watcher);  osdir = opendir_nofollow(path);  if (!osdir) {    handle_open_errno(root, dir, now, "opendir", errno, NULL);    return NULL;  }  if (fstat(dirfd(osdir), &st) == -1) {    // whaaa?    w_log(W_LOG_ERR, "fstat on opened dir %s failed: %s/n", path,        strerror(errno));    w_root_schedule_recrawl(root, "fstat failed");    closedir(osdir);    return NULL;  }  dir->port_file.fo_mtime = st.st_atim;  dir->port_file.fo_mtime = st.st_mtim;  dir->port_file.fo_ctime = st.st_ctim;  dir->port_file.fo_name = (char*)dir->path->buf;  errno = 0;  if (port_associate(state->port_fd, PORT_SOURCE_FILE,        (uintptr_t)&dir->port_file, WATCHMAN_PORT_EVENTS,        SET_DIR_BIT(dir))) {    w_log(W_LOG_ERR, "port_associate %s %s/n",        dir->port_file.fo_name, strerror(errno));  }  return osdir;}

static bool winwatch_root_wait_notify(watchman_global_watcher_t watcher,    w_root_t *root, int timeoutms) {  struct winwatch_root_state *state = root->watch;  struct timeval now, delta, target;  struct timespec ts;  unused_parameter(watcher);  if (timeoutms == 0 || state->head) {    return state->head ? true : false;  }  // Add timeout to current time, convert to absolute timespec  gettimeofday(&now, NULL);  delta.tv_sec = timeoutms / 1000;  delta.tv_usec = (timeoutms - (delta.tv_sec * 1000)) * 1000;  w_timeval_add(now, delta, &target);  w_timeval_to_timespec(target, &ts);  pthread_mutex_lock(&state->mtx);  pthread_cond_timedwait(&state->cond, &state->mtx, &ts);  pthread_mutex_unlock(&state->mtx);  return state->head ? true : false;}

bool kqueue_root_init(watchman_global_watcher_t watcher, w_root_t *root,    char **errmsg) {  struct kqueue_root_state *state;  unused_parameter(watcher);  state = calloc(1, sizeof(*state));  if (!state) {    *errmsg = strdup("out of memory");    return false;  }  root->watch = state;  state->kq_fd = kqueue();  if (state->kq_fd == -1) {    ignore_result(asprintf(errmsg, "watch(%.*s): kqueue() error: %s",        root->root_path->len, root->root_path->buf, strerror(errno)));    w_log(W_LOG_ERR, "%s/n", *errmsg);    return false;  }  w_set_cloexec(state->kq_fd);  return true;}

static void kqueue_root_stop_watch_dir(watchman_global_watcher_t watcher,    w_root_t *root, struct watchman_dir *dir) {  struct kqueue_root_state *state = root->watch;  struct kevent k;  unused_parameter(watcher);  if (dir->wd == -1) {    return;  }  memset(&k, 0, sizeof(k));  EV_SET(&k, dir->wd, EVFILT_VNODE, EV_DELETE,      0, 0, SET_DIR_BIT(dir));  if (kevent(state->kq_fd, &k, 1, NULL, 0, 0)) {    w_log(W_LOG_ERR, "rm_watch: %d %.*s %s/n",        dir->wd, dir->path->len, dir->path->buf,        strerror(errno));    w_root_schedule_recrawl(root, "rm_watch failed");  }  close(dir->wd);  dir->wd = -1;}

void inot_root_dtor(watchman_global_watcher_t watcher, w_root_t *root) {  struct inot_root_state *state = root->watch;  unused_parameter(watcher);  if (!state) {    return;  }  pthread_mutex_destroy(&state->lock);  close(state->infd);  state->infd = -1;  if (state->wd_to_name) {    w_ht_free(state->wd_to_name);    state->wd_to_name = NULL;  }  if (state->move_map) {    w_ht_free(state->move_map);    state->move_map = NULL;  }  free(state);  root->watch = NULL;}

static void *child_reaper(void *arg){#ifndef _WIN32  sigset_t sigset;  // By default, keep both SIGCHLD and SIGUSR1 blocked  sigemptyset(&sigset);  sigaddset(&sigset, SIGUSR1);  sigaddset(&sigset, SIGCHLD);  pthread_sigmask(SIG_BLOCK, &sigset, NULL);  // SIGCHLD is ordinarily blocked, so we listen for it only in  // sigsuspend, when we're also listening for the SIGUSR1 that tells  // us to exit.  pthread_sigmask(SIG_BLOCK, NULL, &sigset);  sigdelset(&sigset, SIGCHLD);  sigdelset(&sigset, SIGUSR1);#endif  unused_parameter(arg);  w_set_thread_name("child_reaper");#ifdef _WIN32  while (!stopping) {    usleep(200000);    w_reap_children(true);  }#else  while (!stopping) {    w_reap_children(false);    sigsuspend(&sigset);  }#endif  return 0;}

// This is just a placeholder.// This catches SIGUSR1 so we don't terminate.// We use this to interrupt blocking syscalls// on the worker threadsstatic void wakeme(int signo){  unused_parameter(signo);}

void kqueue_global_dtor(watchman_global_watcher_t watcher) {  unused_parameter(watcher);}

static void kqueue_file_free(watchman_global_watcher_t watcher,    struct watchman_file *file) {  unused_parameter(watcher);  unused_parameter(file);}

static void kqueue_root_signal_threads(watchman_global_watcher_t watcher,    w_root_t *root) {  unused_parameter(watcher);  unused_parameter(root);}