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

int main(void){  const char *filedir = "dirfile";  const char *format = "dirfile/format";  const char *data = "dirfile/data";  const char *zata = "dirfile/zata";  const char *format_data = "cata RAW UINT8 8/n/ALIAS data cata/n"    "eata RAW UINT8 8/n";  unsigned char data_data[256];  int fd, ret, error, unlink_data, unlink_zata, r = 0;  const char **fl;  char *field_list[4];  DIRFILE *D;  rmdirfile();  mkdir(filedir, 0777);  for (fd = 0; fd < 256; ++fd)    data_data[fd] = (unsigned char)fd;  fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);  write(fd, format_data, strlen(format_data));  close(fd);  fd = open(data, O_CREAT | O_EXCL | O_WRONLY | O_BINARY, 0666);  write(fd, data_data, 256);  close(fd);  D = gd_open(filedir, GD_RDWR | GD_VERBOSE);  ret = gd_rename(D, "data", "zata", GD_REN_DATA);  error = gd_error(D);  fl = gd_field_list(D);  field_list[0] = strdup(fl[0]);  field_list[1] = strdup(fl[1]);  field_list[2] = strdup(fl[2]);  field_list[3] = strdup(fl[3]);  gd_close(D);  unlink_data = unlink(data);  unlink_zata = unlink(zata);  unlink(format);  rmdir(filedir);  CHECKI(error, 0);  CHECKI(ret, 0);  CHECKS(field_list[0], "INDEX");  CHECKS(field_list[1], "cata");  CHECKS(field_list[2], "eata");  CHECKS(field_list[3], "zata");  CHECKI(unlink_data, 0);  CHECKI(unlink_zata, -1);  free(field_list[0]);  free(field_list[1]);  free(field_list[2]);  free(field_list[3]);  return r;}

int main(void){  const char *filedir = "dirfile";  const char *format = "dirfile/format";  const char *format_data =     "early RAW UINT8 c/n"    "late RAW UINT8 c/n"    "/ALIAS b c/n"    "e CONST UINT8 2/n"    "/ALIAS c e/n";  int fd, e1, e2, e3, e4, r = 0;  char *s1, *s2, *s3;  DIRFILE *D;  gd_entry_t E;  rmdirfile();  mkdir(filedir, 0777);  fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);  write(fd, format_data, strlen(format_data));  close(fd);  D = gd_open(filedir, GD_RDWR);  gd_validate(D, "early");  gd_rename(D, "c", "d", GD_REN_UPDB);  e1 = gd_error(D);  gd_spf(D, "early");  e2 = gd_error(D);  gd_spf(D, "late");  e3 = gd_error(D);  gd_entry(D, "early", &E);  s1 = E.scalar[0];  E.scalar[0] = NULL;  gd_free_entry_strings(&E);  gd_entry(D, "late", &E);  s2 = E.scalar[0];  E.scalar[0] = NULL;  gd_free_entry_strings(&E);  gd_entry(D, "b", &E);  e4 = gd_error(D);  s3 = strdup(gd_alias_target(D, "b"));  gd_discard(D);  unlink(format);  rmdir(filedir);  CHECKI(e1,0);  CHECKI(e2,0);  CHECKI(e3,0);  CHECKI(e4,0);  CHECKS(s1, "d");  CHECKS(s2, "d");  CHECKS(s3, "d");  return r;}

int main(void){  const char *filedir = "dirfile";  const char *format = "dirfile/format";  int error, ge_error, r = 0;  gd_entry_t e;  DIRFILE *D;  rmdirfile();  D = gd_open(filedir, GD_RDWR | GD_CREAT | GD_VERBOSE);  gd_add_phase(D, "new", "in", 3, 0);  gd_madd_linterp(D, "new", "meta", "in", "table");  error = gd_error(D);  /* check */  gd_entry(D, "new/meta", &e);  ge_error = gd_error(D);  CHECKI(ge_error, 0);  if (!r) {    CHECKI(e.field_type, GD_LINTERP_ENTRY);    CHECKS(e.in_fields[0], "in");    CHECKS(e.EN(linterp,table), "table");    CHECKI(e.fragment_index, 0);    gd_free_entry_strings(&e);  }  gd_close(D);  unlink(format);  rmdir(filedir);  CHECKI(error, GD_E_OK);   return r;}

/* Parse_Start. */ParseFilePtr Parse_Start(const char *fileroot,const char *filename,char *erstr) {	ParseFilePtr pfp;	char string[STRCHAR];	pfp=Parse_AllocFilePtr(fileroot,filename);	CHECKS(pfp,"Unable to allocate memory for reading configuration file");	pfp->fptr=fopen(pfp->fname,"r");	if(!pfp->fptr) {		sprintf(string,"File '%s' not found/n",pfp->fname);		Parse_FreeFilePtr(pfp);		CHECKS(0,"%s",string); }	return pfp; failure:	return NULL; }

static Bool VMArenaCheck(VMArena vmArena){  Arena arena;  VMChunk primary;  CHECKS(VMArena, vmArena);  arena = VMArena2Arena(vmArena);  CHECKD(Arena, arena);  /* spare pages are committed, so must be less spare than committed. */  CHECKL(vmArena->spareSize <= arena->committed);  CHECKL(vmArena->extendBy > 0);  CHECKL(vmArena->extendMin <= vmArena->extendBy);  if (arena->primary != NULL) {    primary = Chunk2VMChunk(arena->primary);    CHECKD(VMChunk, primary);    /* We could iterate over all chunks accumulating an accurate */    /* count of committed, but we don't have all day. */    CHECKL(VMMapped(primary->vm) <= arena->committed);  }    CHECKD_NOSIG(Ring, &vmArena->spareRing);  /* FIXME: Can't check VMParams */  return TRUE;}

Bool LockCheck(Lock lock){  CHECKS(Lock, lock);  /* While claims can't be very large, I don't dare to put a limit on it. */  /* There's no way to test the mutex, or check if it's held by somebody. */  return TRUE;}

Bool MutatorContextCheck(MutatorContext context){  CHECKS(MutatorContext, context);  CHECKL(NONNEGATIVE(context->var));  CHECKL(context->var < MutatorContextLIMIT);  return TRUE;}

Bool KeyCheck(Key key){  CHECKS(Key, key);  CHECKL(key->name != NULL);  CHECKL(FUNCHECK(key->check));  return TRUE;}

Bool SegBufCheck(SegBuf segbuf){  Buffer buffer;  CHECKS(SegBuf, segbuf);  buffer = MustBeA(Buffer, segbuf);  CHECKD(Buffer, buffer);  CHECKL(RankSetCheck(segbuf->rankSet));  if (buffer->mode & BufferModeTRANSITION) {    /* nothing to check */  } else if ((buffer->mode & BufferModeATTACHED) == 0) {    CHECKL(segbuf->seg == NULL);  } else {    /* The buffer is attached to a segment. */    CHECKL(segbuf->seg != NULL);    CHECKD(Seg, segbuf->seg);    /* To avoid recursive checking, leave it to SegCheck to make */    /* sure the buffer and segment fields tally. */       if (buffer->mode & BufferModeFLIPPED) {      /* Only buffers that allocate pointers get flipped. */      CHECKL(segbuf->rankSet != RankSetEMPTY);    }  }  return TRUE;}

ATTRIBUTE_UNUSEDstatic Bool AMSTCheck(AMST amst){  CHECKS(AMST, amst);  CHECKD_NOSIG(AMS, AMST2AMS(amst)); /* <design/check#.hidden-type> */  return TRUE;}

static Bool FormattedObjectsStepClosureCheck(FormattedObjectsStepClosure c){  CHECKS(FormattedObjectsStepClosure, c);  CHECKL(FUNCHECK(c->f));  /* p and s fields are arbitrary closures which cannot be checked */  return TRUE;}

int main(void){  const char *filedir = "dirfile";  const char *format = "dirfile/format";  const char *format_data = "/ALIAS alias target/n/ALIAS target next/n";  int fd, e, r = 0;  DIRFILE *D;  const char *t;  rmdirfile();  mkdir(filedir, 0777);  fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);  write(fd, format_data, strlen(format_data));  close(fd);  D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);  t = gd_alias_target(D, "alias");  CHECKS(t, "target");  e = gd_error(D);  CHECKI(e, GD_E_OK);  gd_close(D);  unlink(format);  rmdir(filedir);  return r;}

int main(void){  const char *filedir = "dirfile";  const char *format = "dirfile/format";  int error, r = 0;  gd_entry_t e;  DIRFILE *D;  rmdirfile();  D = gd_open(filedir, GD_RDWR | GD_CREAT | GD_VERBOSE);  gd_add_sbit(D, "new", "input", 1, 1, 0);  error = gd_error(D);  /* check */  gd_entry(D, "new", &e);  if (gd_error(D))    r = 1;  else {    CHECKI(e.field_type, GD_SBIT_ENTRY);    CHECKS(e.in_fields[0], "input");    CHECKI(e.fragment_index, 0);    CHECKI(e.EN(bit,bitnum), 1);    CHECKI(e.EN(bit,numbits), 1);    gd_free_entry_strings(&e);  }  gd_close(D);  unlink(format);  rmdir(filedir);  CHECKI(error, GD_E_OK);    return r;}

ATTRIBUTE_UNUSEDstatic Bool MVTCheck(MVT mvt){  CHECKS(MVT, mvt);  CHECKC(MVTPool, mvt);  CHECKD(Pool, MVTPool(mvt));  CHECKC(MVTPool, mvt);  CHECKD(CBS, &mvt->cbsStruct);  CHECKD(ABQ, &mvt->abqStruct);  CHECKD(Freelist, &mvt->flStruct);  CHECKD(Failover, &mvt->foStruct);  CHECKL(mvt->reuseSize >= 2 * mvt->fillSize);  CHECKL(mvt->fillSize >= mvt->maxSize);  CHECKL(mvt->maxSize >= mvt->meanSize);  CHECKL(mvt->meanSize >= mvt->minSize);  CHECKL(mvt->minSize > 0);  CHECKL(mvt->fragLimit <= 100);  CHECKL(mvt->availLimit == mvt->size * mvt->fragLimit / 100);  CHECKL(BoolCheck(mvt->abqOverflow));  CHECKL(BoolCheck(mvt->splinter));  if (mvt->splinter) {    CHECKL(AddrOffset(mvt->splinterBase, mvt->splinterLimit) >=           mvt->minSize);    CHECKL(mvt->splinterBase < mvt->splinterLimit);  }  CHECKL(mvt->size == mvt->allocated + mvt->available +         mvt->unavailable);  /* --- could check that sum of segment sizes == mvt->size */  /* --- check meters? */  return TRUE;}

int main(void){  const char *filedir = "dirfile";  const char *format = "dirfile/format";  int error, r = 0;  gd_entry_t e;  char val[1000];  DIRFILE *D;  rmdirfile();  D = gd_open(filedir, GD_RDWR | GD_CREAT | GD_VERBOSE);  gd_add_string(D, "data", "A string.", 0);  error = gd_error(D);  /* check */  gd_entry(D, "data", &e);  if (gd_error(D))    r = 1;  else {    CHECKI(e.field_type, GD_STRING_ENTRY);    CHECKI(e.fragment_index, 0);    gd_get_string(D, "data", 1000, val);    CHECKS(val, "A string.");    gd_free_entry_strings(&e);  }  gd_close(D);  unlink(format);  rmdir(filedir);  CHECKI(error, GD_E_OK);  return r;}

Bool ThreadCheck(Thread thread){    CHECKS(Thread, thread);    CHECKU(Arena, thread->arena);    CHECKL(thread->serial < thread->arena->threadSerial);    CHECKL(RingCheck(&thread->arenaRing));    return TRUE;}

Bool FreelistCheck(Freelist fl){  CHECKS(Freelist, fl);  /* See <design/freelist/#impl.grain.align> */  CHECKL(AlignIsAligned(fl->alignment, freelistMinimumAlignment));  CHECKL((fl->list == NULL) == (fl->listSize == 0));  return TRUE;}

ATTRIBUTE_UNUSEDstatic Bool AMSTSegCheck(AMSTSeg amstseg){  CHECKS(AMSTSeg, amstseg);  CHECKD_NOSIG(AMSSeg, &amstseg->amsSegStruct); /* <design/check#.hidden-type> */  /* don't bother to do other checks - this is a stress test */  return TRUE;}

Bool PoolClassCheck(PoolClass klass){  CHECKD(InstClass, &klass->protocol);  CHECKL(klass->size >= sizeof(PoolStruct));  CHECKL(AttrCheck(klass->attr));  CHECKL(!(klass->attr & AttrMOVINGGC) || (klass->attr & AttrGC));  CHECKL(FUNCHECK(klass->varargs));  CHECKL(FUNCHECK(klass->init));  CHECKL(FUNCHECK(klass->finish));  CHECKL(FUNCHECK(klass->alloc));  CHECKL(FUNCHECK(klass->free));  CHECKL(FUNCHECK(klass->bufferFill));  CHECKL(FUNCHECK(klass->bufferEmpty));  CHECKL(FUNCHECK(klass->access));  CHECKL(FUNCHECK(klass->whiten));  CHECKL(FUNCHECK(klass->grey));  CHECKL(FUNCHECK(klass->blacken));  CHECKL(FUNCHECK(klass->scan));  CHECKL(FUNCHECK(klass->fix));  CHECKL(FUNCHECK(klass->fixEmergency));  CHECKL(FUNCHECK(klass->reclaim));  CHECKL(FUNCHECK(klass->traceEnd));  CHECKL(FUNCHECK(klass->rampBegin));  CHECKL(FUNCHECK(klass->rampEnd));  CHECKL(FUNCHECK(klass->framePush));  CHECKL(FUNCHECK(klass->framePop));  CHECKL(FUNCHECK(klass->addrObject));  CHECKL(FUNCHECK(klass->walk));  CHECKL(FUNCHECK(klass->freewalk));  CHECKL(FUNCHECK(klass->bufferClass));  CHECKL(FUNCHECK(klass->describe));  CHECKL(FUNCHECK(klass->debugMixin));  CHECKL(FUNCHECK(klass->totalSize));  CHECKL(FUNCHECK(klass->freeSize));  /* Check that pool classes overide sets of related methods. */  CHECKL((klass->init == PoolAbsInit) == (klass->finish == PoolAbsFinish));  CHECKL((klass->bufferFill == PoolNoBufferFill) ==         (klass->bufferEmpty == PoolNoBufferEmpty));  CHECKL((klass->framePush == PoolNoFramePush) ==         (klass->framePop == PoolNoFramePop));  CHECKL((klass->rampBegin == PoolNoRampBegin) ==         (klass->rampEnd == PoolNoRampEnd));  /* Check that pool classes that set attributes also override the     methods they imply. */  /* .check.ams.walk: Can't enforce this one until job003738 is resolved. */  /* CHECKL(((klass->attr & AttrFMT) == 0) == (klass->walk == PoolNoWalk)); */  if (klass != &CLASS_STATIC(AbstractCollectPool)) {    CHECKL(((klass->attr & AttrGC) == 0) == (klass->fix == PoolNoFix));    CHECKL(((klass->attr & AttrGC) == 0) == (klass->fixEmergency == PoolNoFix));    CHECKL(((klass->attr & AttrGC) == 0) == (klass->reclaim == PoolNoReclaim));  }    CHECKS(PoolClass, klass);  return TRUE;}

int main(void){  const char *filedir = "dirfile";  const char *format = "dirfile/format";  const char *format1 = "dirfile/format1";  const char *format_data = "CdataD CONST UINT8 1/nINCLUDE format1 A Z/n";  const char *format1_data = "data RAW UINT8 11/n";  char *prefix;  char *suffix;  int fd, ret, e1, e2, r = 0;  DIRFILE *D;  rmdirfile();  mkdir(filedir, 0777);  fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);  write(fd, format_data, strlen(format_data));  close(fd);  fd = open(format1, O_CREAT | O_EXCL | O_WRONLY, 0666);  write(fd, format1_data, strlen(format1_data));  close(fd);  D = gd_open(filedir, GD_RDWR);  ret = gd_alter_affixes(D, 1, "C", "D");  e1 = gd_error(D);  gd_fragment_affixes(D, 1, &prefix, &suffix);  e2 = gd_error(D);  gd_close(D);  unlink(format1);  unlink(format);  rmdir(filedir);  CHECKS(prefix,"A");  CHECKS(suffix,"Z");  CHECKI(ret,-1);  CHECKI(e1,GD_E_DUPLICATE);  CHECKI(e2,0);  free(prefix);  free(suffix);  return r;}

int main(void){  const char *filedir = "dirfile";  const char *format = "dirfile/format";  int error, ge_error, r = 0;  gd_entry_t e;  const char *in_fields[2] = {"in1", "in2"};  const double m[2] = {1, 0.3};  const double b[2] = {0, 0.9};  DIRFILE *D;  rmdirfile();  D = gd_open(filedir, GD_RDWR | GD_CREAT | GD_VERBOSE);  gd_add_phase(D, "new", "in", 3, 0);  gd_madd_lincom(D, "new", "meta", 2, in_fields, m, b);  error = gd_error(D);  /* check */  gd_entry(D, "new/meta", &e);  ge_error = gd_error(D);  CHECKI(ge_error, 0);  if (!r) {    CHECKI(e.field_type, GD_LINCOM_ENTRY);    CHECKI(e.fragment_index, 0);    CHECKI(e.EN(lincom,n_fields), 2);    CHECKS(e.in_fields[0], "in1");    CHECKS(e.in_fields[1], "in2");    CHECKF(e.EN(lincom,m)[0], m[0]);    CHECKF(e.EN(lincom,m)[1], m[1]);    CHECKF(e.EN(lincom,b)[0], b[0]);    CHECKF(e.EN(lincom,b)[1], b[1]);    CHECKI(e.comp_scal, 0);    gd_free_entry_strings(&e);  }  gd_close(D);  unlink(format);  rmdir(filedir);  CHECKI(error, 0);  return r;}

Bool ThreadCheck(Thread thread){    CHECKS(Thread, thread);    CHECKU(Arena, thread->arena);    CHECKL(thread->serial < thread->arena->threadSerial);    CHECKD_NOSIG(Ring, &thread->arenaRing);    CHECKL(BoolCheck(thread->alive));    CHECKD(PThreadext, &thread->thrextStruct);    return TRUE;}

Bool MessageCheck(Message message){  CHECKS(Message, message);  CHECKU(Arena, message->arena);  CHECKL(MessageTypeCheck(message->type));  CHECKU(MessageClass, message->class);  CHECKL(RingCheck(&message->queueRing));  return TRUE;}

Bool VMCheck(VM vm){  CHECKS(VM, vm);  CHECKL(vm->base != 0);  CHECKL(vm->limit != 0);  CHECKL(vm->base < vm->limit);  CHECKL(vm->mapped <= vm->reserved);  CHECKL(AddrIsAligned(vm->base, vm->align));  CHECKL(AddrIsAligned(vm->limit, vm->align));  return TRUE;}

Bool ThreadCheck(Thread thread){  CHECKS(Thread, thread);  CHECKU(Arena, thread->arena);  CHECKL(thread->serial < thread->arena->threadSerial);  CHECKD_NOSIG(Ring, &thread->arenaRing);  CHECKL(BoolCheck(thread->alive));  CHECKL(BoolCheck(thread->forking));  CHECKL(MACH_PORT_VALID(thread->port));  return TRUE;}

Bool SplayTreeCheck(SplayTree splay){  UNUSED(splay);  CHECKS(SplayTree, splay);  CHECKL(FUNCHECK(splay->compare));  CHECKL(FUNCHECK(splay->nodeKey));  CHECKL(FUNCHECK(splay->updateNode));  /* Can't use CHECKD_NOSIG because TreeEMPTY is NULL. */  CHECKL(TreeCheck(splay->root));  return TRUE;}

Bool TraceMessageCheck(TraceMessage tMessage){  CHECKS(TraceMessage, tMessage);  CHECKD(Message, TraceMessageMessage(tMessage));  CHECKL(MessageGetType(TraceMessageMessage(tMessage)) ==         MessageTypeGC);  /* We can't check anything about the statistics.  In particular, */  /* liveSize may exceed condemnedSize because they are only estimates. */  return TRUE;}

static Bool rootsStepClosureCheck(rootsStepClosure rsc){  CHECKS(rootsStepClosure, rsc);  CHECKD(ScanState, &rsc->ssStruct);  CHECKL(FUNCHECK(rsc->f));  /* p and s fields are arbitrary closures which cannot be checked */  if (rsc->root != NULL) {    CHECKD_NOSIG(Root, rsc->root); /* <design/check/#.hidden-type> */  }  return TRUE;}

int main(void){  const char *filedir = "dirfile";  const char *format = "dirfile/format";  const char *format1 = "dirfile/format1";  const char *format_data = "INCLUDE format1 A Z/n";  const char *format1_data = "data RAW UINT8 11/n";  char *prefix;  char *suffix;  int fd, ret, error, r = 0;  DIRFILE *D;  rmdirfile();  mkdir(filedir, 0777);  fd = open(format, O_CREAT | O_EXCL | O_WRONLY, 0666);  write(fd, format_data, strlen(format_data));  close(fd);  fd = open(format1, O_CREAT | O_EXCL | O_WRONLY, 0666);  write(fd, format1_data, strlen(format1_data));  close(fd);  D = gd_open(filedir, GD_RDONLY | GD_VERBOSE);  ret = gd_fragment_affixes(D, 1, &prefix, &suffix);  error = gd_error(D);  gd_close(D);  unlink(format1);  unlink(format);  rmdir(filedir);  CHECKS(prefix,"A");  CHECKS(suffix,"Z");  CHECKI(ret,0);  CHECKI(error,0);  free(prefix);  free(suffix);  return r;}

static Bool ClientChunkCheck(ClientChunk clChunk){  Chunk chunk;  CHECKS(ClientChunk, clChunk);  chunk = ClientChunk2Chunk(clChunk);  CHECKL(ChunkCheck(chunk));  CHECKL(clChunk->freePages <= chunk->pages);  /* check they don't overlap (knowing the order) */  CHECKL((Addr)(chunk + 1) < (Addr)chunk->allocTable);  return TRUE;}