C++ UNUSEDPARAM函数代码示例

int cli_vm_execute_jit(const struct cli_all_bc *bcs, struct cli_bc_ctx *ctx, const struct cli_bc_func *func)
{
    UNUSEDPARAM(bcs);
    UNUSEDPARAM(ctx);
    UNUSEDPARAM(func);
    return CL_EBYTECODE;
}

static cl_error_t post(int fd, int result, const char *virname, void *context)
{
    struct clamscan_cb_data *d = context;
    struct metachain *c;
    char str[128];

    UNUSEDPARAM(fd);
    UNUSEDPARAM(result);

    if (d != NULL)
        c = d->chain;

    if (c && c->nchains) {
        print_chain(c, str, sizeof(str));

        if (c->level == c->lastadd && !virname)
            free(c->chains[--c->nchains]);

        if (virname && !c->lastvir)
            c->lastvir = c->level;
    }

    if (c)
        c->level--;

    return CL_CLEAN;
}

///-------------------------------------------------------------------------
// @brief 
///-------------------------------------------------------------------------
void RotatingBlades::update( RenderInstanceTree& renderInstances, float elapsedTime, const Input& input )
{
    m_angle += 25.0f*elapsedTime;

    if (m_active)
    {
        //m_rotatingblades1.update( renderInstances, elapsedTime, m_world );
//#ifdef _DEBUG
//        renderInstances.back()->m_name = L"Rotating blades 1";
//#endif
        //m_rotatingblades2.update(renderInstances, elapsedTime, m_world, "Rotating blades 2");

        //glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 1.0f);
        //glDepthMask(false);
        //TextureManager& tm = TextureManager::getInstance();

        //.glActiveTexture(GL_TEXTURE0);
        //glEnable(GL_TEXTURE_2D);
        //glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        //tm.activateTexture(SpaceSim::getInstance().getstd::stringSetting("blades"));

        //.glActiveTexture(GL_TEXTURE1);
        //glEnable(GL_TEXTURE_2D);
        //glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        //tm.activateTexture(SpaceSim::getInstance().getstd::stringSetting("bladesalpha"));

        //glDisable(GL_CULL_FACE);
        //glEnable(GL_BLEND);
        //glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
        //glEnable(GL_TEXTURE_2D);

        //glPushMatrix();
        //glTranslatef(m_position.x(), m_position.y(), m_position.z());
        //glRotatef(m_angle, 0.0f, 0.1f, 0.0f);
        //m_rotatingblades1.draw();
        //m_rotatingblades2.draw();
        //glPopMatrix();
        //glEnable(GL_CULL_FACE);
        //glDisable(GL_BLEND);
        //.glClientActiveTexture(GL_TEXTURE1);
        //glDisable(GL_TEXTURE_2D);
        //.glClientActiveTexture(GL_TEXTURE0);
        //glDisable(GL_TEXTURE_2D);
        //glDepthMask(true);
        //glLightModelf(GL_LIGHT_MODEL_TWO_SIDE, 0.0f);
    }

    //Minimap
    //glPointSize(4.0f);
    //glColor4fv(Color::cyan().rgba());
    //glBegin(GL_POintS);
    //(m_position.x(), m_position.y(), m_position.z() + 25.0f);
    //glEnd();

    UNUSEDPARAM(input);
    UNUSEDPARAM(renderInstances);
    UNUSEDPARAM(elapsedTime);
}

int cli_pcre_build(struct cli_matcher *root, long long unsigned match_limit, long long unsigned recmatch_limit, const struct cli_dconf *dconf)
{
    UNUSEDPARAM(root);
    UNUSEDPARAM(match_limit);
    UNUSEDPARAM(recmatch_limit);
    UNUSEDPARAM(dconf);

    cli_errmsg("cli_pcre_build: Cannot build PCRE expression without PCRE support\n");
    return CL_SUCCESS;
}

int cli_pcre_recaloff(struct cli_matcher *root, struct cli_pcre_off *data, struct cli_target_info *info, cli_ctx *ctx)
{
    UNUSEDPARAM(root);
    UNUSEDPARAM(info);
    UNUSEDPARAM(ctx);
    if (data) {
        data->offset = NULL;
        data->shift = NULL;
    }
    return CL_SUCCESS;
}

void hash_callback(int fd, unsigned long long size, const unsigned char *md5, const char *virname, void *ctx)
{
    struct cb_context *c = ctx;
    UNUSEDPARAM(fd);
    UNUSEDPARAM(virname);

    if (!c)
	return;
    c->virsize = size;
    strncpy(c->virhash, (const char *)md5, 32);
    c->virhash[32] = '\0';
}

static void pppSendCommMessageInd(PppControlS * pppControl, MessageBufS * ptr)
{
	U_CHAR *buf = pppControl->OutMessageContainer.Buf;
	U_CHAR *inbuf = (U_CHAR *) ptr->Buf;
	U_INT inLen = ptr->Length;
	U_INT index = 0;
	U_SHORT fcs = PPP_INITFCS;

	PPP_LOG_ENTRY(MDB_pppSendCommMessageInd);
	UNUSEDPARAM(fcs);

	if (!pppControl->lcpXmitParams.isAcfcEnabled) {
		PPP_LOG();
		PPP_APPEND(buf, index, PPP_ALLSTATIONS, fcs);
		PPP_APPEND(buf, index, PPP_UI, fcs);
	}

	PPP_APPEND(buf, index, PPP_IP, fcs);
	PPP_MEMCPY(&buf[index], inbuf, inLen);
	index += inLen;

	pppControl->OutMessageContainer.Length = index;

	PppCreateMessageFrameIp();

	PppSendToCallback(pppControl, pppControl->OutFrameContainer.Buf, pppControl->OutFrameContainer.Length);

	PPP_LOG_EXIT();

}

void
fileblobPartialSet(fileblob *fb, const char *fullname, const char *arg)
{
    UNUSEDPARAM(arg);

    if(fb->b.name)
        return;

    assert(fullname != NULL);

    cli_dbgmsg("fileblobPartialSet: saving to %s\n", fullname);

    fb->fd = open(fullname, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY|O_EXCL, 0600);
    if(fb->fd < 0) {
        cli_errmsg("fileblobPartialSet: unable to create file: %s\n",fullname);
        return;
    }
    fb->fp = fdopen(fb->fd, "wb");

    if(fb->fp == NULL) {
        cli_errmsg("fileblobSetFilename: fdopen failed\n");
        close(fb->fd);
        return;
    }
    blobSetFilename(&fb->b, fb->ctx ? fb->ctx->engine->tmpdir : NULL, fullname);
    if(fb->b.data)
        if(fileblobAddData(fb, fb->b.data, fb->b.len) == 0) {
            free(fb->b.data);
            fb->b.data = NULL;
            fb->b.len = fb->b.size = 0;
            fb->isNotEmpty = 1;
        }
    fb->fullname = cli_strdup(fullname);
}

static int hash_match(const struct regex_matcher *rlist, const char *host, size_t hlen, const char *path, size_t plen, int *prefix_matched)
{
	const char *virname;
#if 0
	char s[1024];
	strncpy(s, host, hlen);
	strncpy(s+hlen, path, plen);
	s[hlen+plen] = '\0';
	cli_dbgmsg("hash lookup for: %s\n",s);
#endif
    UNUSEDPARAM(prefix_matched);

	if(rlist->sha256_hashes.bm_patterns) {
	    const char hexchars[] = "0123456789ABCDEF";
	    unsigned char h[65];
	    unsigned char sha256_dig[32];
	    unsigned i;
        void *sha256;

        sha256 = cl_hash_init("sha256");
        if (!(sha256))
            return CL_EMEM;

        cl_update_hash(sha256, (void *)host, hlen);
        cl_update_hash(sha256, (void *)path, plen);
        cl_finish_hash(sha256, sha256_dig);

	    for(i=0;i<32;i++) {
		h[2*i] = hexchars[sha256_dig[i]>>4];
		h[2*i+1] = hexchars[sha256_dig[i]&0xf];
	    }
	    h[64]='\0';
	    cli_dbgmsg("Looking up hash %s for %s(%u)%s(%u)\n", h, host, (unsigned)hlen, path, (unsigned)plen);
#if 0
	    if (prefix_matched) {
		if (cli_bm_scanbuff(sha256_dig, 4, &virname, NULL, &rlist->hostkey_prefix,0,NULL,NULL,NULL) == CL_VIRUS) {
		    cli_dbgmsg("prefix matched\n");
		    *prefix_matched = 1;
		} else
		    return CL_SUCCESS;
	    }
#endif
	    if (cli_bm_scanbuff(sha256_dig, 32, &virname, NULL, &rlist->sha256_hashes,0,NULL,NULL,NULL) == CL_VIRUS) {
		cli_dbgmsg("This hash matched: %s\n", h);
		switch(*virname) {
		    case 'W':
			cli_dbgmsg("Hash is whitelisted, skipping\n");
			break;
		    case '1':
			return CL_PHISH_HASH1;
		    case '2':
			return CL_PHISH_HASH2;
		    default:
			return CL_PHISH_HASH0;
		}
	    }
	}
	return CL_SUCCESS;
}

void game::draw( void )
{
    const view_data& vp = mCamPtr->view_params();

    UNUSEDPARAM( vp );


    application< game >::draw();
}

static void gpt_printSectors(cli_ctx *ctx, size_t sectorsize)
{
#ifdef DEBUG_GPT_PARSE
    struct gpt_header phdr, shdr;
    off_t ppos = 0, spos = 0;
    size_t pptable_len, sptable_len, maplen;
    uint64_t ptableLastLBA, stableLastLBA;

    /* sector size calculation */
    sectorsize = GPT_DEFAULT_SECTOR_SIZE;

    maplen = (*ctx->fmap)->real_len;

    ppos = 1 * sectorsize; /* sector 1 (second sector) is the primary gpt header */
    spos = maplen - sectorsize; /* last sector is the secondary gpt header */

    /* read in the primary and secondary gpt headers */
    if (fmap_readn(*ctx->fmap, &phdr, ppos, sizeof(phdr)) != sizeof(phdr)) {
        cli_dbgmsg("cli_scangpt: Invalid primary GPT header\n");
        return;
    }
    if (fmap_readn(*ctx->fmap, &shdr, spos, sizeof(shdr)) != sizeof(shdr)) {
        cli_dbgmsg("cli_scangpt: Invalid secondary GPT header\n");
        return;
    }

    pptable_len = phdr.tableNumEntries * phdr.tableEntrySize;
    sptable_len = shdr.tableNumEntries * shdr.tableEntrySize;
    ptableLastLBA = (phdr.tableStartLBA + (pptable_len / sectorsize)) - 1;
    stableLastLBA = (shdr.tableStartLBA + (sptable_len / sectorsize)) - 1;

    gpt_parsemsg("0: MBR\n");
    gpt_parsemsg("%llu: Primary GPT Header\n", phdr.currentLBA);
    gpt_parsemsg("%llu-%llu: Primary GPT Partition Table\n", phdr.tableStartLBA, ptableLastLBA);
    gpt_parsemsg("%llu-%llu: Usable LBAs\n", phdr.firstUsableLBA, phdr.lastUsableLBA);
    gpt_parsemsg("%llu-%llu: Secondary GPT Partition Table\n", shdr.tableStartLBA, stableLastLBA);
    gpt_parsemsg("%llu: Secondary GPT Header\n", phdr.backupLBA);
#else
    UNUSEDPARAM(ctx);
    UNUSEDPARAM(sectorsize);
    return;
#endif
}

static cl_error_t pre(int fd, const char *type, void *context)
{
    struct metachain *c;
    struct clamscan_cb_data *d;

    UNUSEDPARAM(fd);
    UNUSEDPARAM(type);

    if (!(context))
        return CL_CLEAN;
    d = (struct clamscan_cb_data *)context;
    c = d->chain;
    if (c == NULL)
        return CL_CLEAN;

    c->level++;

    return CL_CLEAN;
}

///-----------------------------------------------------------------------------
///! @brief   TODO enter a description
///! @remark
///-----------------------------------------------------------------------------
void MouseController::internalActionSetup(InputActions::ActionType inputAction, const tinyxml2::XMLAttribute* input)
{
    UNUSEDPARAM(inputAction);

    InputDefines::MouseControlDefinitions mouseDefinitions;
    unsigned int inputHash = hashString(input->Value());
    InputDefines::MouseControlDefinitions::MouseInput mouseInput = mouseDefinitions.FindControllerInputIdForHashId(inputHash);

    m_physicalKeyToAction.insert(PhysicalInputPair(mouseInput, inputAction));
}

void *SzAlloc(void *p, size_t size)
{
    UNUSEDPARAM(p);
  if (size == 0)
    return 0;
  #ifdef _SZ_ALLOC_DEBUG
  fprintf(stderr, "\nAlloc %10d bytes; count = %10d", size, g_allocCount);
  g_allocCount++;
  #endif
  return malloc(size);
}

void *__lzma_wrap_alloc(void *unused, size_t size) { 
    UNUSEDPARAM(unused);
    if(!size || size > CLI_MAX_ALLOCATION)
	return NULL;
    if(!size || size > CLI_MAX_ALLOCATION) {
	cli_dbgmsg("lzma_wrap_alloc(): Attempt to allocate %lu bytes.\n", (unsigned long int) size);
	return NULL;
    }

    return cli_calloc(1, size);
}