C++ UNUSED函数代码示例

void timer_callback(registers_t* regs) {
	UNUSED(regs);

	current_tick++;
}

/**
 * \fn void HMI_SetContrast(UINT8 contrast)
 * \brief Sets the contrast of the display
 * \param contrast contrast a value between 0 and 63
 */
void HMI_SetContrast(UINT8 contrast)
{
  UNUSED(LCD_SetContrast(contrast));
}

Bool ArgCheckCount(Arg arg) {
  UNUSED(arg); /* TODO: Add and call CountCheck */
  return TRUE;
}

ATF_TC_BODY(symtab_grow, tc) {
	isc_result_t result;
	isc_symtab_t *st = NULL;
	isc_symvalue_t value;
	isc_symexists_t policy = isc_symexists_reject;
	int i;

	UNUSED(tc);

	result = isc_test_begin(NULL, ISC_TRUE);
	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);

	result = isc_symtab_create(mctx, 3, undefine, NULL, ISC_FALSE, &st);
	ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
	ATF_REQUIRE(st != NULL);

	/* Nothing should be in the table yet */

	/*
	 * Put 1024 entries in the table (this should necessate
	 * regrowing the hash table several times
	 */
	for (i = 0; i < 1024; i++) {
		char str[16], *key;

		snprintf(str, sizeof(str), "%04x", i);
		key = isc_mem_strdup(mctx, str);
		ATF_REQUIRE(key != NULL);
		value.as_pointer = isc_mem_strdup(mctx, str);
		ATF_REQUIRE(value.as_pointer != NULL);
		result = isc_symtab_define(st, key, 1, value, policy);
		ATF_CHECK_EQ(result, ISC_R_SUCCESS);
		if (result != ISC_R_SUCCESS)
			undefine(key, 1, value, NULL);
	}

	/*
	 * Try to put them in again; this should fail
	 */
	for (i = 0; i < 1024; i++) {
		char str[16], *key;

		snprintf(str, sizeof(str), "%04x", i);
		key = isc_mem_strdup(mctx, str);
		ATF_REQUIRE(key != NULL);
		value.as_pointer = isc_mem_strdup(mctx, str);
		ATF_REQUIRE(value.as_pointer != NULL);
		result = isc_symtab_define(st, key, 1, value, policy);
		ATF_CHECK_EQ(result, ISC_R_EXISTS);
		undefine(key, 1, value, NULL);
	}

	/*
	 * Retrieve them; this should succeed
	 */
	for (i = 0; i < 1024; i++) {
		char str[16];

		snprintf(str, sizeof(str), "%04x", i);
		result = isc_symtab_lookup(st, str, 0, &value);
		ATF_CHECK_EQ(result, ISC_R_SUCCESS);
		ATF_CHECK_STREQ(str, (char *)value.as_pointer);
	}

	/*
	 * Undefine them
	 */
	for (i = 0; i < 1024; i++) {
		char str[16];

		snprintf(str, sizeof(str), "%04x", i);
		result = isc_symtab_undefine(st, str, 1);
		ATF_CHECK_EQ(result, ISC_R_SUCCESS);
	}

	/*
	 * Retrieve them again; this should fail
	 */
	for (i = 0; i < 1024; i++) {
		char str[16];

		snprintf(str, sizeof(str), "%04x", i);
		result = isc_symtab_lookup(st, str, 0, &value);
		ATF_CHECK_EQ(result, ISC_R_NOTFOUND);
	}

	isc_symtab_destroy(&st);
	isc_test_end();
}

/*! \brief This routine is required by IAR DLIB library since EWAVR V6.10
 * the implementation is empty to be compatible with old IAR version.
 */
long __lseek(int handle, long val, int val2)
{
	UNUSED(handle);
	UNUSED(val2);
	return val;
}

static isc_result_t
flush(dns_zone_t *zone, void *uap) {
	UNUSED(uap);
	return (dns_zone_flush(zone));
}

/*! \brief This routine is required by IAR DLIB library since EWAVR V6.10
 * the implementation is empty to be compatible with old IAR version.
 */
int __close(int handle)
{
	UNUSED(handle);
	return 0;
}

/*! \brief This routine is required by IAR DLIB library since EWAVR V6.10
 * the implementation is empty to be compatible with old IAR version.
 */
int remove(const char* val)
{
	UNUSED(val);
	return 0;
}

int main(int argc, char **argv) {
	UNUSED(argv);

//	dox_hooks_install();

	struct rlimit memlim;

	memlim.rlim_cur = 4 * GB;
	memlim.rlim_max = memlim.rlim_cur;
	setrlimit(RLIMIT_AS, &memlim);

	ppk_print_init();

	dox_texts_init(&texts);

	dox_store_t *store = dox_store_new("/home/dirk/tmp/dox");
	assert (store != NULL);

	dox_store_scan(store, iter_callback, NULL);

	if (texts.count == 0)
		goto unstore;

//	dox_mindex_t *mindex = dox_mindex_new_flags(DOX_MINDEX_DELTA);
	dox_mindex_t *mindex = dox_mindex_new_flags(DOX_MINDEX_ABSOLUTE);
//	dox_mindex_t *mindex = dox_mindex_new_flags(DOX_MINDEX_ABSOLUTE | DOX_MINDEX_DELTA);
//	dox_mindex_t *mindex = dox_mindex_new_flags(0);
	assert (mindex != NULL);

	uint32_t total_bit_widths = 0;

	int64_t time0 = ppk_time_get_ns();

	for (int i = 0; i < texts.count; i++) {
		const dox_text_t *text = texts.items + i;

		total_bit_widths += dox_text_bit_width(text);

		int ret = dox_mindex_add(mindex, text);

		if (ret != 0) {
			printf("Mindex now full\n\n");
			break;
		}
	}

	int64_t time1 = ppk_time_get_ns();

	printf("Indexed %lu MiB in %ld ms (%ld us per text)\n\n",
		(total_size * sizeof(dox_word_t)) / PPK_MiB,
		(long) ((time1 - time0) / PPK_MILLION),
		(long) ((time1 - time0) / (PPK_THOUSAND * texts.count)));

	printf("Average of %d bits per word\n",
		(int) (total_bit_widths / texts.count));


	dox_mindex_make_skip(mindex);

	dox_mindex_print_memory(mindex);



	dox_copies_t copies;
	dox_copies_init(&copies);
	unsigned long total_copies = 0;

	time0 = ppk_time_get_ns();

	for (int i = 0; i < texts.count; i++) {
		copies.count = 0;
		dox_mindex_get(mindex, &copies, texts.items + i, DOX_INDEX_SMART);

		total_copies += copies.count;
		if (total_copies < (unsigned long) copies.count)
			printf("\nCopy count wrapped after text %d\n", i);

		uint32_t done = i + 1;
		if ((texts.count - done) % 100 == 0) {
			time1 = ppk_time_get_ns();
			int64_t timed = time1 - time0;
			int64_t pertext = timed / (done * PPK_MILLION);

			printf("\r%d/%d (%d%%), %lu ms per text",
					done, texts.count, ppk_percent(done, texts.count),
					(unsigned long) pertext);
			fflush(stdout);
		}
	}

	printf("\n");

	time1 = ppk_time_get_ns();

	printf("\nSearched %d texts in %lu ms, %lu copies\n",
			texts.count,
			(unsigned long) ((time1 - time0) / PPK_MILLION),
			total_copies);

	printf(" (%lu ms per text, %lu us per word, %lu us per copy)\n",
//.........这里部分代码省略.........

int
mock_chdir( char *path ) {
  UNUSED( path );
  return ( int ) mock();
}

void
mock_warn( const char *format, ... ) {
  UNUSED( format );
}

Bool ArgCheckSize(Arg arg) {
  UNUSED(arg); /* TODO: Add and call SizeCheck */
  return TRUE;
}

static void dothecall (lua_State *L, void *ud) {
  UNUSED(ud);
  luaD_callnoyield(L, L->top - 2, 0);
}

Bool ArgCheckAddr(Arg arg) {
  UNUSED(arg); /* TODO: Add and call AddrCheck */
  return TRUE;
}

static void error_pipe_cb(liEventBase *watcher, int events) {
    liErrorPipe *epipe = LI_CONTAINER_OF(li_event_io_from(watcher), liErrorPipe, fd_watcher);
    UNUSED(events);

    read_pipe(epipe->srv, epipe, FALSE);
}