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

intmain(void){	int res = 0;#if !defined __uint128_t_defined	typedef struct {		uint64_t l;		uint64_t h;	} uint128_t;#define __uint128_t_defined#endif	/* !uint128_t */#define CHECK_SIZE(x, y)						/	if (sizeof(x) != sizeof(y)) {					/		fprintf(						/			stderr,						/			"sizeof(" #x ") -> %zu/t"			/			"sizeof(" #y ") -> %zu/n",			/			sizeof(x), sizeof(y));				/		res = 1;						/	}	CHECK_SIZE(struct dt_dt_s, uint128_t);	CHECK_SIZE(struct dt_d_s, uint64_t);	CHECK_SIZE(struct dt_t_s, uint64_t);	CHECK_SIZE(dt_ymdhms_t, uint64_t);	CHECK_SIZE(dt_sexy_t, uint64_t);	return res;}

static bool nodeset_expandtofit (nodeset_t *n, uint32_t r){    uint32_t size = NS_SIZE (n);    while (size <= r && CHECK_SIZE(size, size << 1))        size = size << 1;    while (size <= r && CHECK_SIZE(size, size + veb_minsize))        size += veb_minsize;    if (size <= r && CHECK_SIZE(size, r + 1))        size = r + 1;    if (size <= r)        return false;    return nodeset_resize (n, size);}

static intanoubisd_msg_authverify_size(const char *buf, int buflen){	DECLARE_SIZE();	struct anoubisd_msg_authverify		*verify;	CAST(verify, buf, buflen);	SHIFT_FIELD(verify, payload, buf, buflen);	CHECK_SIZE(verify->datalen);	CHECK_SIZE(verify->siglen);	SHIFT_CNT(verify->datalen, buf, buflen);	SHIFT_CNT(verify->siglen, buf, buflen);	RETURN_SIZE();}

static intanoubisd_msg_authchallenge_size(const char *buf, int buflen){	DECLARE_SIZE();	struct anoubisd_msg_authchallenge	*challenge;	CAST(challenge, buf, buflen);	SHIFT_FIELD(challenge, payload, buf, buflen);	CHECK_SIZE(challenge->challengelen);	CHECK_SIZE(challenge->idlen);	SHIFT_CNT(challenge->challengelen, buf, buflen);	SHIFT_CNT(challenge->idlen, buf, buflen);	RETURN_SIZE();}

static bool test_unref_reparent(void){	void *root, *p1, *p2, *c1;	printf("test: unref_reparent/n# UNREFERENCE AFTER PARENT FREED/n");	root = talloc_named_const(NULL, 0, "root");	p1 = talloc_named_const(root, 1, "orig parent");	p2 = talloc_named_const(root, 1, "parent by reference");	c1 = talloc_named_const(p1, 1, "child");	talloc_reference(p2, c1);	CHECK_PARENT("unref_reparent", c1, p1);	talloc_free(p1);	CHECK_PARENT("unref_reparent", c1, p2);	talloc_unlink(p2, c1);	CHECK_SIZE("unref_reparent", root, 1);	talloc_free(p2);	talloc_free(root);	printf("success: unref_reparent/n");	return true;}

// fall(linethickness)static Box *fall(ListBox *args){    CHECK_ATOMS(args);    CHECK_SIZE(args);    return new FallBox((*args)[0]->size(X));}

void str_buf_append( str_buf_t *buf, const char *str ){  int len = strlen( str );  CHECK_SIZE( buf, len );  memcpy( buf->data + buf->data_len, str, len );  buf->data_len += len;}

/*  test references */static bool test_ref3(void){	void *root, *p1, *p2, *ref, *r1;	printf("test: ref3 [/nPARENT REFERENCE FREE/n]/n");	root = talloc_named_const(NULL, 0, "root");	p1 = talloc_named_const(root, 1, "p1");	p2 = talloc_named_const(root, 1, "p2");	r1 = talloc_named_const(p1, 1, "r1");	ref = talloc_reference(p2, r1);	talloc_report_full(root, stderr);	CHECK_BLOCKS("ref3", p1, 2);	CHECK_BLOCKS("ref3", p2, 2);	CHECK_BLOCKS("ref3", r1, 1);	fprintf(stderr, "Freeing p1/n");	talloc_free(p1);	talloc_report_full(root, stderr);	CHECK_BLOCKS("ref3", p2, 2);	CHECK_BLOCKS("ref3", r1, 1);	fprintf(stderr, "Freeing p2/n");	talloc_free(p2);	talloc_report_full(root, stderr);	CHECK_SIZE("ref3", root, 0);	talloc_free(root);	printf("success: ref3/n");	return true;}

voidWRATHDefaultTextAttributePacker::attribute_names(std::vector<std::string> &out_names, int number_custom_data) const{  CHECK_SIZE(0);  CHECK_SIZE(1);  CHECK_SIZE(2);  CHECK_SIZE(3);  CHECK_SIZE(4);  CHECK_SIZE(5);  CHECK_SIZE(6);  unsigned int N, R;  N=number_custom_data/4;  R=number_custom_data%4;  if(R>0)     {      ++N;    }    out_names.resize(packer_attribute_names().size()+N);  std::copy(packer_attribute_names().begin(),            packer_attribute_names().end(),            out_names.begin());  for(unsigned int i=0, k=packer_attribute_names().size(); i<N; ++i, ++k)    {      std::ostringstream ostr;      ostr << "custom_data" << i;      out_names[k]=ostr.str();    }}

intmain(void){	int res = 0;#define CHECK_SIZE(x, y)						/	if (sizeof(x) != sizeof(y)) {					/		fprintf(stderr, "sizeof(" #x ") -> %zu/n", sizeof(x));	/		res = 1;						/	}	CHECK_SIZE(struct dt_d_s, uint64_t);	CHECK_SIZE(dt_ymd_t, uint32_t);	CHECK_SIZE(dt_ymcw_t, uint32_t);	CHECK_SIZE(dt_bizda_t, uint32_t);	CHECK_SIZE(dt_md_t, uint32_t);	CHECK_SIZE(dt_daisy_t, uint32_t);	return res;}

/*  test references */static bool test_ref1(void){	void *root, *p1, *p2, *ref, *r1;	printf("test: ref1/n# SINGLE REFERENCE FREE/n");	root = talloc_named_const(NULL, 0, "root");	p1 = talloc_named_const(root, 1, "p1");	p2 = talloc_named_const(p1, 1, "p2");	talloc_named_const(p1, 1, "x1");	talloc_named_const(p1, 2, "x2");	talloc_named_const(p1, 3, "x3");	r1 = talloc_named_const(root, 1, "r1");		ref = talloc_reference(r1, p2);	talloc_report_full(root, stderr);	CHECK_BLOCKS("ref1", p1, 5);	CHECK_BLOCKS("ref1", p2, 1);	CHECK_BLOCKS("ref1", ref, 1);	CHECK_BLOCKS("ref1", r1, 2);	fprintf(stderr, "Freeing p2/n");	talloc_unlink(r1, p2);	talloc_report_full(root, stderr);	CHECK_BLOCKS("ref1", p1, 5);	CHECK_BLOCKS("ref1", p2, 1);	CHECK_BLOCKS("ref1", r1, 1);	fprintf(stderr, "Freeing p1/n");	talloc_free(p1);	talloc_report_full(root, stderr);	CHECK_BLOCKS("ref1", r1, 1);	fprintf(stderr, "Freeing r1/n");	talloc_free(r1);	talloc_report_full(NULL, stderr);	fprintf(stderr, "Testing NULL/n");	if (talloc_reference(root, NULL)) {		return false;	}	CHECK_BLOCKS("ref1", root, 1);	CHECK_SIZE("ref1", root, 0);	talloc_free(root);	printf("success: ref1/n");	return true;}

intXvdiGetVideo(   ClientPtr client,   DrawablePtr pDraw,   XvPortPtr pPort,   GCPtr pGC,   INT16 vid_x, INT16 vid_y,    CARD16 vid_w, CARD16 vid_h,    INT16 drw_x, INT16 drw_y,   CARD16 drw_w, CARD16 drw_h){  DrawablePtr pOldDraw;  CHECK_SIZE(drw_w, drw_h, vid_w, vid_h);  /* UPDATE TIME VARIABLES FOR USE IN EVENTS */  UpdateCurrentTime();  /* CHECK FOR GRAB; IF THIS CLIENT DOESN'T HAVE THE PORT GRABBED THEN     INFORM CLIENT OF ITS FAILURE */  if (pPort->grab.client && (pPort->grab.client != client))    {      XvdiSendVideoNotify(pPort, pDraw, XvBusy);      return Success;    }  /* CHECK TO SEE IF PORT IS IN USE; IF SO THEN WE MUST DELIVER INTERRUPTED     EVENTS TO ANY CLIENTS WHO WANT THEM */  pOldDraw = pPort->pDraw;  if ((pOldDraw) && (pOldDraw != pDraw))    {      XvdiSendVideoNotify(pPort, pPort->pDraw, XvPreempted);    }  (void) (* pPort->pAdaptor->ddGetVideo)(client, pDraw, pPort, pGC,					   vid_x, vid_y, vid_w, vid_h, 					   drw_x, drw_y, drw_w, drw_h);  if ((pPort->pDraw) && (pOldDraw != pDraw))    {      pPort->client = client;      XvdiSendVideoNotify(pPort, pPort->pDraw, XvStarted);    }  pPort->time = currentTime;  return (Success);}

METHOD(array, Binary_encode, KeyPair){    CHECK_SIZE(args, 2);    CHECK_TYPE(args.ptr[0], MSGPACK_OBJECT_BIN);    CHECK_TYPE(args.ptr[1], MSGPACK_OBJECT_BIN);    msgpack_object_bin secret_key = args.ptr[0].via.bin;    msgpack_object_bin public_key = args.ptr[1].via.bin;    CHECK_SIZE(secret_key, 32);    CHECK_SIZE(public_key, 32);    SUCCESS {        uint8_t data[64];        memcpy(data, secret_key.ptr, 32);        memcpy(data + 32, public_key.ptr, 32);        msgpack_pack_bin(res, 64);        msgpack_pack_bin_body(res, data, 64);    }    return 0;}

/*  test references */static bool test_ref2(void){	void *root, *p1, *p2, *ref, *r1;	printf("test: ref2/n# DOUBLE REFERENCE FREE/n");	root = talloc_named_const(NULL, 0, "root");	p1 = talloc_named_const(root, 1, "p1");	talloc_named_const(p1, 1, "x1");	talloc_named_const(p1, 1, "x2");	talloc_named_const(p1, 1, "x3");	p2 = talloc_named_const(p1, 1, "p2");	r1 = talloc_named_const(root, 1, "r1");		ref = talloc_reference(r1, p2);	talloc_report_full(root, stderr);	CHECK_BLOCKS("ref2", p1, 5);	CHECK_BLOCKS("ref2", p2, 1);	CHECK_BLOCKS("ref2", r1, 2);	fprintf(stderr, "Freeing ref/n");	talloc_unlink(r1, ref);	talloc_report_full(root, stderr);	CHECK_BLOCKS("ref2", p1, 5);	CHECK_BLOCKS("ref2", p2, 1);	CHECK_BLOCKS("ref2", r1, 1);	fprintf(stderr, "Freeing p2/n");	talloc_free(p2);	talloc_report_full(root, stderr);	CHECK_BLOCKS("ref2", p1, 4);	CHECK_BLOCKS("ref2", r1, 1);	fprintf(stderr, "Freeing p1/n");	talloc_free(p1);	talloc_report_full(root, stderr);	CHECK_BLOCKS("ref2", r1, 1);	fprintf(stderr, "Freeing r1/n");	talloc_free(r1);	talloc_report_full(root, stderr);	CHECK_SIZE("ref2", root, 0);	talloc_free(root);	printf("success: ref2/n");	return true;}

/*  test steal*/static bool test_steal(void){	void *root, *p1, *p2;	printf("test: steal/n# STEAL/n");	root = talloc_new(NULL);	p1 = talloc_array(root, char, 10);	CHECK_SIZE("steal", p1, 10);	p2 = talloc_realloc(root, NULL, char, 20);	CHECK_SIZE("steal", p1, 10);	CHECK_SIZE("steal", root, 30);	torture_assert("steal", talloc_steal(p1, NULL) == NULL,		"failed: stealing NULL should give NULL/n");	torture_assert("steal", talloc_steal(p1, p1) == p1,		"failed: stealing to ourselves is a nop/n");	CHECK_BLOCKS("steal", root, 3);	CHECK_SIZE("steal", root, 30);	talloc_steal(NULL, p1);	talloc_steal(NULL, p2);	CHECK_BLOCKS("steal", root, 1);	CHECK_SIZE("steal", root, 0);	talloc_free(p1);	talloc_steal(root, p2);	CHECK_BLOCKS("steal", root, 2);	CHECK_SIZE("steal", root, 20);		talloc_free(p2);	CHECK_BLOCKS("steal", root, 1);	CHECK_SIZE("steal", root, 0);	talloc_free(root);	p1 = talloc_size(NULL, 3);	talloc_report_full(NULL, stderr);	CHECK_SIZE("steal", NULL, 3);	talloc_free(p1);	printf("success: steal/n");	return true;}

/*  test talloc_realloc_fn*/static bool test_realloc_fn(void){	void *root, *p1;	printf("test: realloc_fn/n# talloc_realloc_fn/n");	root = talloc_new(NULL);	p1 = talloc_realloc_fn(root, NULL, 10);	CHECK_BLOCKS("realloc_fn", root, 2);	CHECK_SIZE("realloc_fn", root, 10);	p1 = talloc_realloc_fn(root, p1, 20);	CHECK_BLOCKS("realloc_fn", root, 2);	CHECK_SIZE("realloc_fn", root, 20);	p1 = talloc_realloc_fn(root, p1, 0);	CHECK_BLOCKS("realloc_fn", root, 1);	CHECK_SIZE("realloc_fn", root, 0);	talloc_free(root);	printf("success: realloc_fn/n");	return true;}

static intanoubisd_msg_eventask_size(const char *buf, int buflen){	struct anoubisd_msg_eventask	*msg;	struct buf_offset		 offs[5];	int				 i, j, total = 0;	DECLARE_SIZE();	CAST(msg, buf, buflen);	/* Detect offset overlaps */	ADDOFFSET(0, csum);	ADDOFFSET(1, path);	ADDOFFSET(2, ctxcsum);	ADDOFFSET(3, ctxpath);	ADDOFFSET(4, ev);	for (i=0; i<5; ++i) {		int	s1, e1;		if (offs[i].len == 0)			continue;		s1 = offs[i].off;		e1 = s1 + offs[i].len;		if (e1 > total)			total = e1;		for (j=0; j<i; ++j) {			int	s2, e2;			if (offs[j].len == 0)				continue;			s2 = offs[j].off;			e2 = s2 + offs[j].len;			if (s2 < e1 && s1 < e2)				return -1;		}	}	SHIFT_FIELD(msg, payload, buf, buflen);	if (total > buflen)		return -1;	ADD_SIZE(total);	if (msg->pathlen)		CHECK_STRING(buf+msg->pathoff, msg->pathlen);	if (msg->ctxpathlen)		CHECK_STRING(buf+msg->ctxpathoff, msg->ctxpathlen);	if (msg->evlen) {		int	size = eventdev_hdr_size(buf+msg->evoff, msg->evlen);		CHECK_SIZE(size);	}	RETURN_SIZE();}

    status_t    BackupDataReader::skip_padding() {        ssize_t amt;        ssize_t paddingSize;        paddingSize = padding_extra(m_pos);        if (paddingSize > 0) {            uint32_t padding;            amt = read(m_fd, &padding, paddingSize);            CHECK_SIZE(amt, paddingSize);            m_pos += amt;        }        return NO_ERROR;    }

/* Copy to source to stream. */voidstream_put (struct stream *s, void *src, size_t size){  CHECK_SIZE(s, size);  if (src)    memcpy (s->data + s->putp, src, size);  else    memset (s->data + s->putp, 0, size);  s->putp += size;  if (s->putp > s->endp)    s->endp = s->putp;}