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

staticint _vlsctlc_pack_cmd_probe_service(struct vlsctlc* lsctlc, void* buf, int len){    struct probe_service_args* args = &lsctlc->args.probe_service_args;    void* len_addr = NULL;    int tsz = 0;    int bsz = 0;    vassert(lsctlc);    vassert(buf);    vassert(len > 0);    if (lsctlc->bound_cmd != VLSCTL_PROBE_SERVICE) {        return 0;    }    set_uint16(buf + tsz, lsctlc->bound_cmd);    tsz += sizeof(uint16_t);    set_uint16(len_addr = buf + tsz, 0);    tsz += sizeof(uint16_t);    memcpy(buf + tsz, &args->hash, sizeof(vsrvcHash));    bsz += sizeof(vsrvcHash);    tsz += sizeof(vsrvcHash);    set_uint16(len_addr, bsz);    return tsz;}

staticint _vlsctlc_unpack_cmd_probe_service_rsp(struct vlsctlc* lsctlc, void* buf, int len){    struct probe_service_rsp_args* args = &lsctlc->rsp_args.probe_service_rsp_args;    int tsz = 0;    int i = 0;    vassert(lsctlc);    vassert(buf);    vassert(len > 0);    if (lsctlc->bound_cmd != VLSCTL_PROBE_SERVICE) {        return 0;    }    memcpy(&args->hash, buf + tsz, sizeof(vsrvcHash));    tsz += sizeof(vsrvcHash);    args->proto = *(int32_t*)(buf + tsz);    tsz += sizeof(int32_t);    while(len - tsz > 0) {        tsz += _aux_vlsctlc_unpack_vaddr(buf + tsz, len - tsz, &args->addrs[i]);        i++;    }    args->num = i;    return tsz;}

staticint _vlsctlc_pack_cmd_unpost_service(struct vlsctlc* lsctlc, void* buf, int len){    struct unpost_service_args* args = &lsctlc->args.unpost_service_args;    void* len_addr = NULL;    int tsz = 0;    int bsz = 0;    int ret = 0;    int i = 0;    vassert(lsctlc);    vassert(buf);    vassert(len > 0);    if (lsctlc->bound_cmd != VLSCTL_UNPOST_SERVICE) {        return 0;    }    set_uint16(buf + tsz, lsctlc->bound_cmd);    tsz += sizeof(uint16_t);    set_uint16(len_addr = buf + tsz, 0);    tsz += sizeof(uint16_t);    memcpy(buf + tsz, &args->hash, sizeof(vsrvcHash));    bsz += sizeof(vsrvcHash);    tsz += sizeof(vsrvcHash);    for (i = 0;i < args->naddrs; i++) {        ret = _aux_vlsctlc_pack_addr(buf + tsz, len - tsz, &args->addrs[i]);        bsz += ret;        tsz += ret;    }    set_uint16(len_addr, bsz);    return tsz;}

staticint _vlsctlc_pack_cmd_bogus_query(struct vlsctlc* lsctlc, void* buf, int len){    struct bogus_query_args* args = &lsctlc->args.bogus_query_args;    void* len_addr = NULL;    int tsz = 0;    int bsz = 0;    int ret = 0;    vassert(lsctlc);    vassert(buf);    vassert(len > 0);    if (lsctlc->bound_cmd != VLSCTL_BOGUS_QUERY) {        return 0;    }    set_uint16(buf + tsz, lsctlc->bound_cmd);    tsz += sizeof(uint16_t);    set_uint16(len_addr = buf + tsz, 0);    tsz += sizeof(uint16_t);    set_int32(buf + tsz, args->queryId);    bsz += sizeof(int32_t);    tsz += sizeof(int32_t);    ret = _aux_vlsctlc_pack_addr(buf + tsz, len - tsz, &args->addr);    bsz += ret;    tsz += ret;    set_uint16(len_addr, bsz);    return tsz;}

staticint _vlsctlc_pack_cmd_join_node(struct vlsctlc* lsctlc, void* buf, int len){    struct join_node_args* args = &lsctlc->args.join_node_args;    void* len_addr = NULL;    int tsz = 0;    int bsz = 0;    vassert(lsctlc);    vassert(buf);    vassert(len > 0);    if (lsctlc->bound_cmd != VLSCTL_JOIN_NODE) {        return 0;    }    set_uint16(buf + tsz, lsctlc->bound_cmd);    tsz += sizeof(uint16_t);    set_uint16(len_addr = buf + tsz, 0);    tsz += sizeof(uint16_t);    bsz = _aux_vlsctlc_pack_addr(buf + tsz, len - tsz, &args->addr);    tsz += bsz;    set_uint16(len_addr, bsz);    return tsz;}

staticint _vlsctlc_pack_cmd(struct vlsctlc* lsctlc, void* buf, int len){    struct vlsctlc_pack_cmd_desc* desc = lsctlc_pack_cmd_desc;    void* len_addr = NULL;    int ret = 0;    int tsz = 0;    int bsz = 0;    vassert(lsctlc);    vassert(buf);    vassert(len > 0);    set_uint8(buf + tsz, VLSCTL_VERSION);    tsz += sizeof(uint8_t);    set_uint8(buf + tsz, (uint8_t)lsctlc->type);    tsz += sizeof(uint8_t);    set_uint16(len_addr = buf + tsz, 0);    tsz += sizeof(uint16_t);    set_uint32(buf + tsz, VLSCTL_MAGIC);    tsz += sizeof(uint32_t);    for (; desc->cmd; desc++) {        ret = desc->cmd(lsctlc, buf + tsz, len - tsz);        if (ret < 0) {            return -1;        }        bsz += ret;        tsz += ret;    }    *(uint16_t*)len_addr = (uint16_t)bsz;    return tsz;}

char *strcasestr(const char *str1,const char *str2) {	char *res = NULL;	char *sub;	vassert(str1 != NULL,"str1 == NULL");	vassert(str2 != NULL,"str2 == NULL");	/* handle special case to prevent looping the string */	if(!*str2)		return (char*)str1;	while(*str1) {		/* matching char? */		if(tolower(*str1++) == tolower(*str2)) {			res = (char*)--str1;			sub = (char*)str2;			/* continue until the strings don't match anymore */			while(*sub && tolower(*str1) == tolower(*sub)) {				str1++;				sub++;			}			/* complete substring matched? */			if(!*sub)				return res;		}	}	return NULL;}

staticint _vlsctlc_bind_cmd_post_service(struct vlsctlc* lsctlc, vsrvcHash* hash, struct vsockaddr_in* addrs, int num, int proto){    struct post_service_args* args = &lsctlc->args.post_service_args;    int i = 0;    vassert(lsctlc);    vassert(hash);    vassert(addrs);    vassert(num > 0);    if (lsctlc->bound_cmd > 0) {        return -1;    }    lsctlc->bound_cmd = VLSCTL_POST_SERVICE;    lsctlc->type = vlsctl_cmd;    args->proto  = proto;    args->naddrs = num;    memcpy(&args->hash, hash, sizeof(vsrvcHash));    for (i = 0; i < num; i++) {        memcpy(&args->addrs[i], &addrs[i], sizeof(struct vsockaddr_in));    }    return 0;}

staticint _vlsctlc_unbind_cmd_probe_service(struct vlsctlc* lsctlc, vsrvcHash* hash, struct vsockaddr_in* addrs, int* num, int* proto){    struct probe_service_rsp_args* args = &lsctlc->rsp_args.probe_service_rsp_args;    vassert(lsctlc);    vassert(hash);    vassert(addrs);    vassert(num);    vassert(proto);    int i = 0;    if (lsctlc->bound_cmd != VLSCTL_PROBE_SERVICE) {        return -1;    }    if (lsctlc->type == vlsctl_rsp_err) {        //todo with errno.        return -1;    }    memcpy(hash, &args->hash, sizeof(vsrvcHash));    *proto = args->proto;    *num   = args->num;    for (i = 0; i < args->num; i++) {        memcpy(&addrs[i], &args->addrs[i], sizeof(struct vsockaddr_in));    }    return 0;}

/* Search forward from some given point in the incoming instruction   sequence.  Point is to select a virtual register to spill, by   finding the vreg which is mentioned as far ahead as possible, in   the hope that this will minimise the number of consequent reloads.   Only do the search for vregs which are Bound in the running state,   and for which the .is_spill_cand field is set.  This allows the   caller to arbitrarily restrict the set of spill candidates to be   considered.   Returns an index into the state array indicating the (v,r) pair to   spill, or -1 if none was found.  */staticInt findMostDistantlyMentionedVReg (   void (*getRegUsage) (HRegUsage*, HInstr*),   HInstrArray* instrs_in,   Int          search_from_instr,   RRegState*   state,   Int          n_state){   Int k, m;   Int furthest_k = -1;   Int furthest   = -1;   vassert(search_from_instr >= 0);   for (k = 0; k < n_state; k++) {      if (!state[k].is_spill_cand)         continue;      vassert(state[k].disp == Bound);      for (m = search_from_instr; m < instrs_in->arr_used; m++) {         if (instrMentionsReg(getRegUsage,                              instrs_in->arr[m], state[k].vreg))            break;      }      if (m > furthest) {         furthest   = m;         furthest_k = k;      }   }   return furthest_k;}

void vexSetAllocMode ( VexAllocMode m ){   vexAllocSanityCheck();   /* Save away the current allocation point .. */   if (mode == VexAllocModeTEMP){      temporary_curr = private_LibVEX_alloc_curr;   }    else   if (mode == VexAllocModePERM) {      permanent_curr = private_LibVEX_alloc_curr;   }   else       vassert(0);   /* Did that screw anything up? */   vexAllocSanityCheck();   if (m == VexAllocModeTEMP){      private_LibVEX_alloc_first = temporary_first;      private_LibVEX_alloc_curr  = temporary_curr;      private_LibVEX_alloc_last  = temporary_last;   }    else   if (m == VexAllocModePERM) {      private_LibVEX_alloc_first = permanent_first;      private_LibVEX_alloc_curr  = permanent_curr;      private_LibVEX_alloc_last  = permanent_last;   }   else       vassert(0);   mode = m;}

/* * the routine to find best suitable service from service routing table * so that local app can meet its needs with that service. * * @route: * @svc_hash: service hash id. * @addr : [out] address of service */staticint _vroute_find_service(struct vroute* route, vsrvcHash* hash, vsrvcInfo_number_addr_t ncb, vsrvcInfo_iterate_addr_t icb, void* cookie){    struct vroute_srvc_space* srvc_space = &route->srvc_space;    vsrvcInfo_relax srvci;    int ret = 0;    int i = 0;    vassert(route);    vassert(hash);    vassert(ncb);    vassert(icb);    memset(&srvci, 0, sizeof(srvci));    srvci.capc = VSRVCINFO_MAX_ADDRS;    vlock_enter(&route->lock);    ret = srvc_space->ops->get_service(srvc_space, hash, (vsrvcInfo*)&srvci);    vlock_leave(&route->lock);    retE((ret < 0));    if (!ret) {        ncb(&srvci.hash, 0, VPROTO_UNKNOWN, cookie);        return 0;    }    ncb(&srvci.hash, srvci.naddrs, VPROTO_UDP, cookie);    for (i = 0; i < srvci.naddrs; i++) {        icb(&srvci.hash, &srvci.addrs[i], ((i+1) == srvci.naddrs), cookie);    }    return 0;}

/* * the routine to get service info from service routing table space if local host * require some kind of system service. * * @space: service routing table space; * @srvcHash: * @svci : service infos */staticint _vroute_srvc_space_get_service(struct vroute_srvc_space* space, vsrvcHash* hash, vsrvcInfo* srvci){    struct vservice*  to = NULL;    int min_nice = 100;    int found = 0;    int i = 0;    vassert(space);    vassert(hash);    vassert(srvci);    for (i = 0; i < NBUCKETS; i++) {        void* argv[] = {            &to,            hash,            &min_nice        };        varray_iterate(&space->bucket[i].srvcs, _aux_srvc_get_service_cb, argv);        if (to) {            vsrvcInfo_copy(&srvci, to->srvci);            found = 1;        }    }    return found;}

void ufDestroy(ufOgNode * element){  HWord hashkey;   ufOgHashNode * delHashNode;   vassert(element != NULL);   vassert(element != NULL);   //  VG_(printf)("XXX ufDestroy %u %u /n", element->tmpName, element->bbExecNum);   hashkey = locToHashKey(element->tmpName, element->bbExecNum, TmpLoc);  // delete x from H   delHashNode = VG_(HT_remove)(ufOgHash, hashkey);   if (delHashNode)  {    VG_(free)(delHashNode);   }  // delete x from LiveTempVarNodes  //  delHashNode = VG_(HT_remove)(ufOgLiveTempVarNodes, hashkey);   // if (delHashNode)  //{  //  VG_(free)(delHashNode);   //}  // free x itself  VG_(free)(element); }

staticint _vlsctlc_unpack_cmd(struct vlsctlc* lsctlc, void* buf, int len){    struct vlsctlc_unpack_cmd_desc* desc = lsctlc_unpack_cmd_desc;    uint32_t magic = 0;    int tsz = 0;    int bsz = 0;    int csz = 0;    int ret = 0;    vassert(lsctlc);    vassert(buf);    vassert(len > 0);    tsz += sizeof(uint8_t); // skip version;    lsctlc->type = get_uint8(buf + tsz);    tsz += sizeof(uint8_t);    bsz  = (int)get_uint16(buf + tsz);    tsz += sizeof(uint16_t);    magic = get_uint32(buf + tsz);    tsz += sizeof(uint32_t);//    _aux_vhexbuf_dump(buf, bsz);    if (magic != VLSCTL_MAGIC) {        return -1;    }    while(bsz - csz > 0) {        uint16_t cmd_id = 0;        int cmd_len = 0;        int i = 0;        cmd_id = get_uint16(buf + tsz);        tsz += sizeof(uint16_t);        csz += sizeof(uint16_t);        cmd_len = get_uint16(buf + tsz);        tsz += sizeof(uint16_t);        csz += sizeof(uint16_t);        lsctlc->bound_cmd = cmd_id;        while(cmd_len > 0) {            for (i = 0; desc[i].cmd; i++) {                ret = desc[i].cmd(lsctlc, buf + tsz, cmd_len);                if (ret < 0) {                    return -1;                } else if (ret > 0) {                    tsz += ret;                    csz += ret;                    cmd_len -= ret;                    break;                }else {                    //do nothing;                }            }        }    }    return 0;}

int kmytid_test() {    reset();    kmytid(t1);    vassert(t1->state == READY);    vassert(task_get_return_value(t1) == 1);    return 0;}

projectile_data *get_projectile_data(	const short projectile_index){	struct projectile_data *projectile =  GetMemberWithBounds(projectiles,projectile_index,MAXIMUM_PROJECTILES_PER_MAP);		vassert(projectile, csprintf(temporary, "projectile index #%d is out of range", projectile_index));	vassert(SLOT_IS_USED(projectile), csprintf(temporary, "projectile index #%d (%p) is unused", projectile_index, projectile));		return projectile;}

staticint vservice_init(struct vservice* item, vsrvcInfo* srvci, time_t ts){    vassert(item);    vassert(srvci);    vsrvcInfo_copy(&item->srvci, srvci);    item->rcv_ts = ts;    return 0;}

void _vroute_set_inspect_cb(struct vroute* route, vroute_inspect_t cb, void* cookie){    vassert(route);    vassert(cb);    vlock_enter(&route->lock);    route->insp_cb = cb;    route->insp_cookie = cookie;    vlock_leave(&route->lock);    return ;}

void _vroute_inspect(struct vroute* route, vtoken* token, uint32_t insp_id){    vassert(route);    vassert(token);    vlock_enter(&route->lock);    if (route->insp_cb) {        route->insp_cb(route, route->insp_cookie, token, insp_id);    }    vlock_leave(&route->lock);    return ;}

int kmy_parent_tid_test() {    reset();    kmy_parent_tid(t1);    kmy_parent_tid(t2);    vassert(t1->state == READY);    vassert(task_get_return_value(t1) == 0);    vassert(t2->state == READY);    vassert(task_get_return_value(t2) == 1);    return 0;}

int kcreate_test() {    reset();    kcreate(t2, MEDIUM, 0, 0);    vassert(t2->state == READY);    vassert(task_get_return_value(t2) > t2->tid);    Task *child = task_get(task_get_return_value(t2));    vassert(child != 0);    vassert(child->state == READY);    return 0;}

int _vroute_probe_connectivity(struct vroute* route, struct sockaddr_in* laddr){    struct vroute_node_space* node_space = &route->node_space;    int ret = 0;    vassert(route);    vassert(laddr);    vlock_enter(&route->lock);    ret = node_space->ops->probe_connectivity(node_space, laddr);    vlock_leave(&route->lock);    retE((ret < 0));    return 0;}

int vroute_srvc_space_init(struct vroute_srvc_space* space, struct vconfig* cfg){    int i = 0;    vassert(space);    vassert(cfg);    for (i = 0; i < NBUCKETS; i++) {        varray_init(&space->bucket[i].srvcs, 8);    }    space->bucket_sz = cfg->ext_ops->get_route_bucket_sz(cfg);    space->ops = &route_srvc_space_ops;    return 0;}

staticint _vroute_reflex_addr(struct vroute* route, struct sockaddr_in* addr){    struct vroute_node_space* node_space = &route->node_space;    int ret = 0;    vassert(route);    vassert(addr);    vlock_enter(&route->lock);    ret = node_space->ops->reflex_addr(node_space, addr);    vlock_leave(&route->lock);    retE((ret < 0));    return 0;}

staticint _vroute_air_service(struct vroute* route, vsrvcInfo* srvci){    struct vroute_node_space* node_space = &route->node_space;    int ret = 0;    vassert(route);    vassert(srvci);    vlock_enter(&route->lock);    ret = node_space->ops->air_service(node_space, srvci);    vlock_leave(&route->lock);    retE((ret < 0));    return 0;}

size_t strnzcpy(char *to,const char *from,size_t size) {	char *res = to;	vassert(from != NULL,"from == NULL");	vassert(to != NULL,"to == NULL");	/* copy source string */	while(*from && size > 1) {		*to++ = *from++;		size--;	}	/* terminate */	*to = '/0';	return to - res;}

/* Add a register to a usage table.  Combines incoming read uses with   existing write uses into a modify use, and vice versa.  Does not   create duplicate entries -- each reg is only mentioned once.  */void addHRegUse ( HRegUsage* tab, HRegMode mode, HReg reg ){   /* Because real and virtual registers are represented differently,      they have completely different paths here. */   if (LIKELY(hregIsVirtual(reg))) {      /* Virtual register */      UInt i;      /* Find it ... */      for (i = 0; i < tab->n_vRegs; i++)         if (sameHReg(tab->vRegs[i], reg))            break;      if (i == tab->n_vRegs) {         /* Not found, add new entry. */         vassert(tab->n_vRegs < N_HREGUSAGE_VREGS);         tab->vRegs[tab->n_vRegs] = reg;         tab->vMode[tab->n_vRegs] = mode;         tab->n_vRegs++;      } else {         /* Found: combine or ignore. */         /* This is a greatest-lower-bound operation in the poset:               R   W                / /                 M            Need to do: tab->mode[i] = GLB(tab->mode, mode).  In this            case very simple -- if tab->mode[i] != mode then result must            be M.         */         if (tab->vMode[i] == mode) {            /* duplicate, ignore */         } else {            tab->vMode[i] = HRmModify;         }      }   } else {      /* Real register */      UInt ix = hregIndex(reg);      vassert(ix < N_RREGUNIVERSE_REGS);      ULong mask = 1ULL << ix;      switch (mode) {         case HRmRead:   tab->rRead |= mask; break;         case HRmWrite:  tab->rWritten |= mask; break;         case HRmModify: tab->rRead |= mask; tab->rWritten |= mask; break;         default: vassert(0);      }   }}

int setTypeOf(HWord varname, IntType type){  OgTypeOfHashNode * node;   node = VG_(HT_lookup)(ogTypeOf,varname);  if (!node)    {       /* Allocate and add node for varname, since we are setting TypeOf()*/       node = (OgTypeOfHashNode *)VG_(malloc)("HashNode", sizeof(OgTypeOfHashNode));      node->varname = varname;       VG_(HT_add_node)(ogTypeOf,node);    }   vassert(node->varname == varname);   node->type = type;  /* Debugging only for now: */ /*  switch (type)    {    case (Bot) : VG_(printf)("XXX Varname var.%u set to Bot. /n",varname); break;    case (Top) : VG_(printf)("XXX Varname var.%u set to Top. /n",varname); break;    case (SignedTy) : VG_(printf)("XXX Varname var.%u set to SIGNED. /n",varname);       break;    case (UnsignedTy) : VG_(printf)("XXX Varname var.%u set to UNSIGNED. /n",varname);       break;    case (BogusTy) : vpanic("Set variable to bogus type!/n");    }*/  return 0; }

bool ParameterManager::handleMessage(const message::SetParameter &param) {    // sent by controller    switch (param.getParameterType()) {    case Parameter::Integer:        setIntParameter(param.getName(), param.getInteger(), &param);        break;    case Parameter::Float:        setFloatParameter(param.getName(), param.getFloat(), &param);        break;    case Parameter::Vector:        setVectorParameter(param.getName(), param.getVector(), &param);        break;    case Parameter::IntVector:        setIntVectorParameter(param.getName(), param.getIntVector(), &param);        break;    case Parameter::String:        setStringParameter(param.getName(), param.getString(), &param);        break;    default:        std::cerr << "Module::handleMessage: unknown parameter type " << param.getParameterType() << std::endl;        vassert("unknown parameter type" == 0);        break;    }    return true;}