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

  /* Run when an AccessVariable is executed. Uses the details in exec   * to access instance variables of args.recv() */  Object* AccessVariable::access_execute(STATE, CallFrame* call_frame, Executable* exec, Module* mod,                                         Arguments& args) {    AccessVariable* access = as<AccessVariable>(exec);    Object* const self = args.recv();    /* The writer case. */    if(access->write()->true_p()) {      if(CBOOL(self->frozen_p(state)) && CBOOL(self->frozen_mod_disallowed(state))) {        Exception::frozen_error(state, call_frame, self);        return 0;      }      if(args.total() != 1) {        Exception::argument_error(state, 1, args.total());        return NULL;      }      if(kind_of<Class>(mod) && self->reference_p()) {        // Promote this to use a direct accessor        if(TypeInfo* ti = state->memory()->find_type_info(self)) {          TypeInfo::Slots::iterator it = ti->slots.find(access->name()->index());          if(it != ti->slots.end()) {            // Found one!            access->set_executor(ti->slot_accessors[it->second]);            ti->set_field(state, self, it->second, args.get_argument(0));            return args.get_argument(0);          }        }        /* Fall through, handle it as a normal ivar. */        access->set_executor(access_write_regular_ivar);      }      self->set_ivar(state, access->name(), args.get_argument(0));      return args.get_argument(0);    }    /* The read case. */    if(args.total() != 0) {      Exception::argument_error(state, 0, args.total());      return NULL;    }    if(kind_of<Class>(mod) && self->reference_p()) {      // Promote this to use a direct accessor      if(TypeInfo* ti = state->memory()->find_type_info(self)) {        TypeInfo::Slots::iterator it = ti->slots.find(access->name()->index());        if(it != ti->slots.end()) {          // Found one!          access->set_executor(ti->slot_accessors[it->second]);          return ti->get_field(state, self, it->second);        }      }      // Ok, its a table ivar, setup fast access for next time.      access->set_executor(access_read_regular_ivar);    }    return self->get_ivar(state, access->name());  }

  String* Time::strftime(STATE, String* format) {    struct tm64 tm = get_tm();    struct timespec64 ts;    ts.tv_sec = seconds_;    ts.tv_nsec = nanoseconds_;    int off = 0;    if(Fixnum* offset = try_as<Fixnum>(utc_offset(state))) {      off = offset->to_int();    }    if(format->byte_size() == 0) return String::create(state, NULL, 0);    char stack_str[STRFTIME_STACK_BUF];    size_t chars = ::strftime_extended(stack_str, STRFTIME_STACK_BUF,                       format->c_str(state), &tm, &ts, CBOOL(is_gmt_) ? 1 : 0,                       off);    size_t buf_size = format->byte_size();    String* result = 0;    if(chars == 0) {      buf_size *= 2;      char* malloc_str = (char*)malloc(buf_size);      if(!malloc_str) {        Exception::memory_error(state);        return NULL;      }      chars = ::strftime_extended(malloc_str, buf_size,                  format->c_str(state), &tm, &ts, CBOOL(is_gmt_) ? 1 : 0,                  off);      if(chars) {        result = String::create(state, malloc_str, chars);        result->encoding(state, format->encoding());      }      free(malloc_str);    } else {      result = String::create(state, stack_str, chars);      result->encoding(state, format->encoding());    }    return result;  }

 Object* Regexp::propagate_last_match(STATE, CallFrame* call_frame) {   Object* obj = call_frame->last_match(state);   if(CBOOL(obj)) {     Regexp::set_last_match(state, obj, call_frame);   }   return obj; }

  Array* Array::to_ary(STATE, Object* value, CallFrame* call_frame) {    if(Tuple* tup = try_as<Tuple>(value)) {      return Array::from_tuple(state, tup);    }    if(CBOOL(value->respond_to(state, G(sym_to_ary), cTrue))) {      Object* res = value->send(state, call_frame, G(sym_to_ary));      if(!res) return 0;      if(Array* ary = try_as<Array>(res)) {        return ary;      }      if(LANGUAGE_18_ENABLED || !res->nil_p()) {        Exception::type_error(state, "to_ary should return an Array", call_frame);        return 0;      }      // NOTE: On >= 1.9, if res is nil just fall through and return [value]    }    Array* ary = Array::create(state, 1);    ary->set(state, 0, value);    return ary;  }

  Time* Time::specific(STATE, Object* self, Integer* sec, Integer* nsec,                       Object* gmt, Object* offset)  {    Time* tm = state->new_object_dirty<Time>(as<Class>(self));    tm->seconds_ = sec->to_long_long();    tm->nanoseconds_ = nsec->to_native();    // Do a little overflow cleanup.    if(tm->nanoseconds_ >= 1000000000) {      tm->seconds_ += tm->nanoseconds_ / 1000000000;      tm->nanoseconds_ %= 1000000000;    }    if(tm->nanoseconds_ < 0) {      tm->seconds_ += NDIV(tm->nanoseconds_, 1000000000);      tm->nanoseconds_ = NMOD(tm->nanoseconds_, 1000000000);    }    tm->decomposed(state, nil<Array>());    tm->is_gmt(state, RBOOL(CBOOL(gmt)));    tm->offset(state, offset);    tm->zone(state, nil<String>());    return tm;  }

/* read-config_sch */	obj_t BGl_readzd2config_schzd2zzinit_libzd2dirzd2(obj_t BgL_fz00_8)	{		AN_OBJECT;		{	/* Init/lib_dir.scm 63 */			{	/* Init/lib_dir.scm 64 */				obj_t BgL_portz00_124;				{	/* Init/lib_dir.scm 64 */					BgL_portz00_124 =						BGl_openzd2inputzd2filez00zz__r4_ports_6_10_1z00(BgL_fz00_8, BTRUE);				}				{	/* Init/lib_dir.scm 65 */					obj_t BgL_val1508z00_125;					BgL_val1508z00_125 =						BGl_zc3exitza31528ze3z83zzinit_libzd2dirzd2(BgL_fz00_8,						BgL_portz00_124);					bgl_close_input_port(BgL_portz00_124);					if (CBOOL(BGl_valzd2fromzd2exitzf3zf3zz__bexitz00							(BgL_val1508z00_125)))						{	/* Init/lib_dir.scm 71 */							return								BGl_unwindzd2untilz12zc0zz__bexitz00(CAR(BgL_val1508z00_125),								CDR(BgL_val1508z00_125));						}					else						{	/* Init/lib_dir.scm 71 */							return BgL_val1508z00_125;						}				}			}		}	}

/* unix-filename */	BGL_EXPORTED_DEF obj_t BGl_unixzd2filenamezd2zzcc_execz00(obj_t BgL_argsz00_1)	{		AN_OBJECT;		{	/* Cc/exec.scm 33 */			{	/* Cc/exec.scm 34 */				obj_t BgL_sz00_91;				BgL_sz00_91 =					BGl_stringzd2appendzd2zz__r4_strings_6_7z00(BgL_argsz00_1);				{	/* Cc/exec.scm 35 */					bool_t BgL_testz00_139;					{	/* Cc/exec.scm 35 */						BgL_testz00_139 =							CBOOL(BGl_stringzd2indexzd2zz__r4_strings_6_7z00(BgL_sz00_91,								BCHAR(((unsigned char) ' ')), BINT(((long) 0))));					}					if (BgL_testz00_139)						{	/* Cc/exec.scm 35 */							return								string_append_3(BGl_string1528z00zzcc_execz00, BgL_sz00_91,								BGl_string1528z00zzcc_execz00);						}					else						{	/* Cc/exec.scm 35 */							return BgL_sz00_91;						}				}			}		}	}

/*----------------------------------------------------------------------------------- * Name: dlbe_PassThrough * * Description: * This function verifies the validity of a Unique Record Id and then retrieves the * information from it (RecordType) * * Parameters: * UniqueIdPtr (input) - A Unique Record Id Ptr * * RETURN: * The recordtype that the unique record id coresponds to if the Unique ID is valid, * otherwise returns DAL_OOB. * * ERROR CODES * CSSMERR_DL_INVALID_RECORD_UID *-----------------------------------------------------------------------------------*/CSSM_RETURN dlbe_PassThrough (	CSSM_DL_DB_HANDLE DLDBHandle,	uint32 PassThroughId,	const void * InputParams,	void ** OutputParams){	FFDL_WRITE_BACK_CACHE_STATUS CacheStatus;	if (PassThroughId == FFDL_PASSTHROUGH_SET_WRITE_BACK_CACHE)	{		if (port_IsBadReadPtr(InputParams, sizeof(FFDL_WRITE_BACK_CACHE_STATUS)))			return CSSMERR_DL_INVALID_POINTER;		if (DLDBHandle.DBHandle != 0)			return CSSMERR_DL_INVALID_DB_HANDLE;		CacheStatus = *((const FFDL_WRITE_BACK_CACHE_STATUS *)InputParams);		if (CacheStatus != FFDL_ENABLE_CACHE && CacheStatus != FFDL_DISABLE_CACHE)			return FFDL_CACHE_STATUS_INVALID;		ffport_nrSetCache(CBOOL(CacheStatus == FFDL_ENABLE_CACHE));	}	else		return CSSMERR_DL_INVALID_PASSTHROUGH_ID;	return CSSM_OK;}

  Object* Module::cvar_set(STATE, Symbol* name, Object* value) {    if(!name->is_cvar_p(state)->true_p()) return Primitives::failure();    if(CBOOL(frozen_p(state))) {      Exception::type_error(state, "unable to change frozen object");    }    Module* mod = this;    Module* mod_to_query;    while(!mod->nil_p()) {      mod_to_query = get_module_to_query(mod);      if(mod_to_query->table_ivar_defined(state, name)->true_p()) {        mod_to_query->set_table_ivar(state, name, value);        return value;      }      mod = mod->superclass();    }    mod = this;    mod_to_query = get_module_to_query(mod);    mod_to_query->set_ivar(state, name, value);    return value;  }

  Time* Time::specific(STATE, Object* self, Integer* sec, Integer* nsec,                       Object* gmt)  {    Time* tm = state->new_object<Time>(as<Class>(self));    if(sizeof(time_t) == sizeof(long long)) {      tm->seconds_ = sec->to_long_long();      tm->nanoseconds_ = nsec->to_long_long();    } else {      tm->seconds_ = sec->to_native();      tm->nanoseconds_ = nsec->to_native();    }    // Do a little overflow cleanup.    if(tm->nanoseconds_ >= 1000000000) {      tm->seconds_ += tm->nanoseconds_ / 1000000000;      tm->nanoseconds_ %= 1000000000;    }    if(tm->nanoseconds_ < 0) {      tm->seconds_ += NDIV(tm->nanoseconds_, 1000000000);      tm->nanoseconds_ = NMOD(tm->nanoseconds_, 1000000000);    }    if(LANGUAGE_18_ENABLED(state)) {      tm->nanoseconds_ -= (tm->nanoseconds_ % 1000);    }    tm->is_gmt(state, CBOOL(gmt) ? cTrue : cFalse);    return tm;  }

 inline bool goto_if_false(CallFrame* call_frame) {   Object* t1 = stack_pop();   if(!CBOOL(t1)) {     return true;   } else {     return false;   } }

  Object* AccessVariable::access_write_regular_ivar(STATE, CallFrame* call_frame, Executable* exec, Module* mod,                                         Arguments& args) {    AccessVariable* access = as<AccessVariable>(exec);    if(unlikely(args.total() != 1)) {      Exception::argument_error(state, 1, args.total());      return NULL;    }    Object* recv = args.recv();    if(CBOOL(recv->frozen_p(state)) && CBOOL(recv->frozen_mod_disallowed(state))) {      Exception::frozen_error(state, call_frame, recv);      return 0;    }    return recv->set_ivar(state, access->name(), args.get_argument(0));  }

 Object* Thread::set_critical(STATE, Object* obj) {   if(CBOOL(obj)) {     state->shared().set_critical(state);     return cTrue;   } else {     state->shared().clear_critical(state);     return cFalse;   } }

    /** @todo Remove redundancy between this and sends. --rue */    Tuple* locate_method_on(STATE, CallFrame* call_frame, Object* recv, Symbol* name, Object* priv) {      LookupData lookup(recv, recv->lookup_begin(state), CBOOL(priv) ? G(sym_private) : G(sym_protected));      Dispatch dis(name);      if(!GlobalCache::resolve(state, dis.name, dis, lookup)) {        return nil<Tuple>();      }      return Tuple::from(state, 2, dis.method, dis.module);    }

    inline bool set_ivar(STATE, CallFrame* call_frame, intptr_t literal) {      if(CBOOL(call_frame->self()->frozen_p(state))) {        Exception::frozen_error(state, call_frame->self());        return false;      }      Symbol* sym = reinterpret_cast<Symbol*>(literal);      call_frame->self()->set_ivar(state, sym, stack_top());      return true;    }

  Object* JIT::enable(STATE) {    if(!CBOOL(enabled())) return cFalse;    /* TODO: JIT    state->shared().llvm_state->enable(state);    */    enabled(state, cTrue);    return cTrue;  }

/* _exec */	obj_t BGl__execz00zzcc_execz00(obj_t BgL_envz00_123, obj_t BgL_cmdz00_124,		obj_t BgL_comezd2backzd2_125, obj_t BgL_namez00_126)	{		AN_OBJECT;		{	/* Cc/exec.scm 48 */			return				BGl_execz00zzcc_execz00(BgL_cmdz00_124,				CBOOL(BgL_comezd2backzd2_125), BgL_namez00_126);		}	}

  Object* JIT::start_method_update(STATE) {    if(!CBOOL(enabled())) return cFalse;    /* TODO: JIT    LLVMState* ls = state->shared().llvm_state;    ls->start_method_update();    */    return cTrue;  }

/* _effect-walk! */	obj_t BGl__effectzd2walkz12zc0zzeffect_walkz00(obj_t BgL_envz00_1416,		obj_t BgL_globalsz00_1417, obj_t BgL_feffectz00_1418)	{		AN_OBJECT;		{	/* Effect/walk.scm 33 */			return				BGl_effectzd2walkz12zc0zzeffect_walkz00(BgL_globalsz00_1417,				CBOOL(BgL_feffectz00_1418));		}	}

  Thread* Thread::wakeup(STATE) {    utilities::thread::SpinLock::LockGuard guard(init_lock_);    if(!CBOOL(alive()) || !vm()) {      return force_as<Thread>(Primitives::failure());    }    vm()->wakeup(state);    return this;  }

/* _make-tmp-main */	obj_t BGl__makezd2tmpzd2mainz00zzengine_linkz00(obj_t BgL_envz00_532,		obj_t BgL_filez00_533, obj_t BgL_mainz00_534, obj_t BgL_modulez00_535,		obj_t BgL_clausesz00_536, obj_t BgL_librariesz00_537)	{		AN_OBJECT;		{	/* Engine/link.scm 146 */			return				BGl_makezd2tmpzd2mainz00zzengine_linkz00(BgL_filez00_533,				CBOOL(BgL_mainz00_534), BgL_modulez00_535, BgL_clausesz00_536,				BgL_librariesz00_537);		}	}

  Object* JIT::compile_soon(STATE, CompiledCode* code,      Class* receiver_class, BlockEnvironment* block_env, bool is_block)  {    if(!CBOOL(enabled())) return cFalse;    /* TODO: JIT    LLVMState* ls = state->shared().llvm_state;    ls->compile_soon(state, code, receiver_class, block_env, is_block);    */    return cTrue;  }

  Object* JIT::compile_callframe(STATE, CompiledCode* code,      int primitive)  {    if(!CBOOL(enabled())) return cFalse;    /* TODO: JIT    LLVMState* ls = state->shared().llvm_state;    ls->compile_callframe(state, code, primitive);    */    return cTrue;  }

/* setup-default-values */	BGL_EXPORTED_DEF obj_t BGl_setupzd2defaultzd2valuesz00zzinit_setrcz00()	{		AN_OBJECT;		{	/* Init/setrc.scm 25 */			{	/* Init/setrc.scm 26 */				obj_t BgL_pathz00_87;				{	/* Init/setrc.scm 26 */					obj_t BgL_homez00_91;					BgL_homez00_91 =						BGl_getenvz00zz__osz00(BSTRING_TO_STRING						(BGl_string1523z00zzinit_setrcz00));					if (STRINGP(BgL_homez00_91))						{	/* Init/setrc.scm 27 */							BgL_pathz00_87 =								MAKE_PAIR(BgL_homez00_91,								BGl_za2libzd2dirza2zd2zzengine_paramz00);						}					else						{	/* Init/setrc.scm 27 */							BgL_pathz00_87 = BGl_za2libzd2dirza2zd2zzengine_paramz00;						}				}				{	/* Init/setrc.scm 26 */					obj_t BgL_fnamez00_88;					BgL_fnamez00_88 =						BGl_findzd2filezf2pathz20zz__osz00(BGl_string1524z00zzinit_setrcz00,						BgL_pathz00_87);					{	/* Init/setrc.scm 30 */						if (CBOOL(BgL_fnamez00_88))							{	/* Init/setrc.scm 32 */								obj_t BgL_envz00_90;								BgL_envz00_90 = BGl_defaultzd2environmentzd2zz__evalz00();								{	/* Init/setrc.scm 32 */									return										BGl_loadqz00zz__evalz00(BgL_fnamez00_88, BgL_envz00_90);								}							}						else							{	/* Init/setrc.scm 31 */								return BFALSE;							}					}				}			}		}	}

/* module-initialization */BGL_EXPORTED_DEF obj_t BGl_modulezd2initializa7ationz75zz__foreignz00(long BgL_checksumz00_688, char * BgL_fromz00_689){ AN_OBJECT;{ if(CBOOL(BGl_requirezd2initializa7ationz75zz__foreignz00)){ BGl_requirezd2initializa7ationz75zz__foreignz00 = BBOOL(((bool_t)0)); BGl_importedzd2moduleszd2initz00zz__foreignz00(); return BUNSPEC;}  else { return BUNSPEC;} } }

/* foreign-null? */BGL_EXPORTED_DEF bool_t BGl_foreignzd2nullzf3z21zz__foreignz00(obj_t BgL_objz00_4){ AN_OBJECT;{ /* Llib/foreign.scm 101 */if(FOREIGNP(BgL_objz00_4)){ /* Llib/foreign.scm 102 */return FOREIGN_NULLP(BgL_objz00_4);}  else { /* Llib/foreign.scm 102 */return CBOOL(BGl_errorz00zz__errorz00(BGl_string1397z00zz__foreignz00, BGl_string1398z00zz__foreignz00, BgL_objz00_4));} } }

/* unprof-src-name */	BGL_EXPORTED_DEF obj_t BGl_unprofzd2srczd2namez00zzengine_linkz00(obj_t		BgL_namez00_1)	{		AN_OBJECT;		{	/* Engine/link.scm 71 */			if (CBOOL(BGl_za2profilezd2modeza2zd2zzengine_paramz00))				{	/* Engine/link.scm 74 */					long BgL_lenz00_218;					BgL_lenz00_218 = STRING_LENGTH(BgL_namez00_1);					{	/* Engine/link.scm 75 */						bool_t BgL_testz00_614;						if ((BgL_lenz00_218 > ((long) 2)))							{	/* Engine/link.scm 75 */								if (									(STRING_REF(BgL_namez00_1,											(BgL_lenz00_218 - ((long) 1))) == ((unsigned char) 'p')))									{	/* Engine/link.scm 76 */										BgL_testz00_614 =											(STRING_REF(BgL_namez00_1,												(BgL_lenz00_218 - ((long) 2))) ==											((unsigned char) '_'));									}								else									{	/* Engine/link.scm 76 */										BgL_testz00_614 = ((bool_t) 0);									}							}						else							{	/* Engine/link.scm 75 */								BgL_testz00_614 = ((bool_t) 0);							}						if (BgL_testz00_614)							{	/* Engine/link.scm 75 */								return									c_substring(BgL_namez00_1, ((long) 0),									(BgL_lenz00_218 - ((long) 2)));							}						else							{	/* Engine/link.scm 75 */								return BgL_namez00_1;							}					}				}			else				{	/* Engine/link.scm 72 */					return BgL_namez00_1;				}		}	}