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

void AutoGL_SetUp (int argc, char *argv[]){  AutoGL_SetViewRedrawCallback (BIND(autogl_redraw));  AutoGL_SetIdleEventCallback (BIND(autogl_idle));  BIND(autogl_setup) ();}

COMA_USING_NSResourceManager::ResourceManager() : loading_(false){	SetEventListener(ResourceManagerEvent::LOAD_COMPLETE, BIND(ResourceManager::CompleteListener));	SetEventListener(ResourceManagerEvent::UNLOAD_COMPLETE, BIND(ResourceManager::CompleteListener));}

Weapon::Weapon(const WeaponConfig * pConfig) {    m_pConfig = pConfig;    m_bullet_level = BULLET_LEVEL_1;        BIND(BUND_ID_WEAPON_FIRE, this, Weapon::OnCmdFire);    BIND(BUND_ID_BULLET_LEVEL_UP, this, Weapon::OnCmdBulletUp);}

 vexcl_steppers::vexcl_steppers(tensor_factory& f, cse& cw, lambda_manager& lm, translator_data& p, language_printer& prn)   : ::macro_packages::replacement_rule_package(f, cw, lm, p, prn)   {     EMPLACE(pre_package, BIND(replace_backg_stepper, "MAKE_BACKG_STEPPER"));     EMPLACE(pre_package, BIND(replace_pert_stepper, "MAKE_PERT_STEPPER"));     EMPLACE(pre_package, BIND(stepper_name, "BACKG_STEPPER"));     EMPLACE(pre_package, BIND(stepper_name, "PERT_STEPPER"));   }

void clGLVertexArray::AfterConstruction(){	iVertexArray::AfterConstruction();	GetAPI( Env );	Env->Connect( L_EVENT_SURFACE_ATTACHED, BIND( &clGLVertexArray::Event_SURFACE_ATTACHED ) );	Env->Connect( L_EVENT_SURFACE_DETACHED, BIND( &clGLVertexArray::Event_SURFACE_DETACHED ) );}

void clConsole::AfterConstruction(){	RegisterCommand( "Quit",             Utils::Bind( &clConsole::QuitC,          this ) );	RegisterCommand( "Exit",             Utils::Bind( &clConsole::QuitC,          this ) );	RegisterCommand( "Exec",             Utils::Bind( &clConsole::ExecC,          this ) );	RegisterCommand( "Bind",             Utils::Bind( &clConsole::BindC,          this ) );	RegisterCommand( "Alias",            Utils::Bind( &clConsole::AliasC,         this ) );	RegisterCommand( "ToggleConsole",    Utils::Bind( &clConsole::ToggleConsoleC, this ) );	RegisterCommand( "Mount",            Utils::Bind( &clConsole::MountC,         this ) );	RegisterCommand( "Clear",            Utils::Bind( &clConsole::ClearC,         this ) );	RegisterCommand( "Version",          Utils::Bind( &clConsole::VersionC,       this ) );	RegisterCommand( "Help",             Utils::Bind( &clConsole::HelpC,          this ) );	RegisterCommand( "CmdList",          Utils::Bind( &clConsole::HelpC,          this ) );	RegisterCommand( "TogglePause",      Utils::Bind( &clConsole::TogglePauseC,   this ) );	RegisterCommand( "Toggle",           Utils::Bind( &clConsole::ToggleC,        this ) );	RegisterCommand( "Set",              Utils::Bind( &clConsole::SetC,           this ) );	RegisterCommand( "SetProperty",      Utils::Bind( &clConsole::SetPropertyC,   this ) );	RegisterCommand( "Show",             Utils::Bind( &clConsole::ShowC,          this ) );	RegisterCommand( "Menu",             Utils::Bind( &clConsole::MenuC,          this ) );	RegisterCommand( "SaveVars",         Utils::Bind( &clConsole::SaveVarsC,      this ) );	RegisterCommand( "RefreshScreen",    Utils::Bind( &clConsole::RefreshScreenC, this ) );	RegisterCommand( "Sleep",            Utils::Bind( &clConsole::SleepC,         this ) );	RegisterCommand( "SetLogLevel",      Utils::Bind( &clConsole::SetLogLevelC,   this ) );	RegisterCommand( "PrintLogLevel",    Utils::Bind( &clConsole::PrintLogLevelC, this ) );	RegisterCommand( "AddDirWatch",      Utils::Bind( &clFileSystem::AddDirWatchC,     Env->FileSystem ) );	RegisterCommand( "AddFileWatch",     Utils::Bind( &clFileSystem::AddFileWatchC,    Env->FileSystem ) );	RegisterCommand( "RemoveDirWatch",   Utils::Bind( &clFileSystem::RemoveDirWatchC,  Env->FileSystem ) );	RegisterCommand( "RemoveFileWatch",  Utils::Bind( &clFileSystem::RemoveFileWatchC, Env->FileSystem ) );	Env->Logger->Connect( L_EVENT_ERROR,       BIND( &clConsole::Event_ERROR ) );	Env->Connect( L_EVENT_TIMER,       BIND( &clConsole::Event_TIMER ) );	Env->ConnectWithPriority( L_EVENT_KEY,         BIND( &clConsole::Event_KEY         ),  -1 );	FConsoleHUDFileName = GetVar( "GUI.ConsoleHUD" );	FConsoleHUDFileName->SetString( "Interface/Console.gui" );	FShouldSaveHistory = GetVar ( "Console.SaveHistory" );	FShouldSaveHistory->SetBool( true );	GetVarDefault( "Core.EngineVersion", ENGINE_VERSION );	if ( Env->FileSystem->FileExists( HistoryFileName ) )	{		iIStream* Input = Env->FileSystem->CreateFileReader( HistoryFileName );		FCommandsHistory->LoadFromStream( Input );		delete( Input );	}	// instantiate script compiler	// its initialization is delayed until some script is actually compiled	FScriptCompiler = Env->Linker->Instantiate( "clScriptCompiler" );}

bool InputBinder::try_bind_scene_entity_to_input(    const Scene&                    scene,    const SymbolTable&              scene_symbols,    const char*                     entity_type,    const char*                     entity_name,    const char*                     param_value,    InputArray::iterator&           input){    if (input.format() == InputFormatEntity)    {        #define BIND(symbol, collection)                        /            case symbol:                                        /              input.bind(collection.get_by_name(param_value));  /              return true        switch (scene_symbols.lookup(param_value))        {          BIND(SymbolTable::SymbolColor, scene.colors());          BIND(SymbolTable::SymbolTexture, scene.textures());          BIND(SymbolTable::SymbolTextureInstance, scene.texture_instances());          BIND(SymbolTable::SymbolEnvironmentEDF, scene.environment_edfs());          BIND(SymbolTable::SymbolEnvironmentShader, scene.environment_shaders());        }        #undef BIND    }    else    {        switch (scene_symbols.lookup(param_value))        {          case SymbolTable::SymbolColor:            bind_color_to_input(                scene.colors(),                param_value,                input);            return true;          case SymbolTable::SymbolTextureInstance:            bind_texture_instance_to_input(                scene.texture_instances(),                ~0,                 // the parent is the scene, not an assembly                entity_type,                entity_name,                param_value,                input);            return true;        }    }    return false;}

int main(){    typedef void(*Callfp)();    Callfp u;    BIND( u, Base::f );    u();    Callfp v;    BIND( v, Base::g );    v();    Callfp w;    BIND( w, Base::h );    w();}

void Battle::onEnter() {    PublicUI::onEnter();    CCASSERT(s_mission_name != ""             && NULL != (m_pConfig = g_pGameConfig->getMissionConfig(s_mission_name)),             "set mission first");        schedule(schedule_selector(Battle::collidtion), 1/60.0f);        m_pBoss = NULL;        mask();    ArmatureDataManager::getInstance()->addArmatureFileInfo("Animation/UI/readygo.ExportJson");    m_pReadygo = Armature::create("readygo");    m_pReadygo->setAnchorPoint(Vec2(.5f, .5f));    this->addChild(m_pReadygo, GRADE_UI);    m_pReadygo->setPosition(g_pGameConfig->screenCenterPoint);    m_pReadygo->getAnimation()->play("readygo");    m_pReadygo->setScale(g_pGameConfig->scaleEleMin * 1.5f);    m_pReadygo->getAnimation()->setMovementEventCallFunc(this, movementEvent_selector(Battle::playActionOver));        s_enemy_count = 0;    s_itor = m_pConfig->events.begin();    if (s_itor != m_pConfig->events.end()) {        CTimer * timer = CTimer::create(&(*s_itor), BUND_ID_BATTLE_EVENT, 0, 0, s_itor->delay);        addChild(timer);    }        BIND(BUND_ID_BULLET_FIRED, this, Battle::bulletFired);    BIND(BUND_ID_BULLET_DISAPPEARED, this, Battle::bulletDisappear);    BIND(BUND_ID_BATTLE_EVENT, this, Battle::event_exec);    BIND(BUND_ID_ENEMY_EVENT, this, Battle::enemy_event);    BIND(BUND_ID_ENEMY_DISAPPEAR, this, Battle::enemydisappear);    BIND(BUND_ID_PLANE_DISAPPEAR, this, Battle::planedisappear);    BIND(BUND_ID_PLANE_INJURED, this, Battle::planeinjured);    BIND(BUND_ID_GLOBAL_TOUCH_BEGAN, this, Battle::globalTouchBegan);    BIND(BUND_ID_BOSS_DISAPPEAR, this, Battle::bossdisappear);        SEquip equip;    g_pEquipManager->getGrooveEquip(EQUIP_TYPE_PLANE, equip);    m_pPlane = Plane::create(equip);    m_pPlane->setScale(g_pGameConfig->scaleEleMin * .75f);    g_pEquipManager->getGrooveEquip(EQUIP_TYPE_WEAPON, equip);    m_pPlane->addWeapon(equip);    g_pEquipManager->getGrooveEquip(EQUIP_TYPE_WINGMAN, equip);    m_pPlane->addWingman(equip);        g_pEquipManager->getGrooveEquip(EQUIP_TYPE_ARMOR, equip);    m_pPlane->addArmor(equip);        m_pPlane->setPosition(Vec2(g_pGameConfig->screenCenterPoint.x, 0));    addChild(m_pPlane, GRADE_PLAYER);    ActionInterval * action = EaseExponentialOut::create(MoveBy::create(2, Vec2(0, 500 * g_pGameConfig->scaleEleY)));    m_pPlane->runAction(action);}

	int AlphaBeta  (const uint64_t P, const uint64_t O, uint64_t& NodeCounter, int alpha, int beta)	{		const uint64_t empties = Empties(P, O);		if (empties == 4)			return AlphaBeta_4(P, O, NodeCounter, alpha, beta);		uint64_t flipped;		uint64_t BitBoardPossible = PossibleMoves(P, O);		unsigned long Move;		int score = -64;		NodeCounter++;		if (!BitBoardPossible){			if (HasMoves(O, P))				return -AlphaBeta(O, P, NodeCounter, -beta, -alpha);			else //Game is over				return BIND(EvalGameOver(P, empties), alpha, beta);		}		while (BitBoardPossible)		{			Move = BitScanLSB(BitBoardPossible);			RemoveLSB(BitBoardPossible);			flipped = flip(P, O, Move);			score = -AlphaBeta(O ^ flipped, P ^ (1ULL << Move) ^ flipped, NodeCounter, -beta, -alpha);			if (score >= beta) return beta;			if (score > alpha) alpha = score;		}		return alpha;	}

void MethodHandles::jump_from_method_handle(MacroAssembler* _masm, Register method, Register temp,                                            bool for_compiler_entry) {  assert(method == rmethod, "interpreter calling convention");  Label L_no_such_method;  __ cbz(rmethod, L_no_such_method);  __ verify_method_ptr(method);  if (!for_compiler_entry && JvmtiExport::can_post_interpreter_events()) {    Label run_compiled_code;    // JVMTI events, such as single-stepping, are implemented partly by avoiding running    // compiled code in threads for which the event is enabled.  Check here for    // interp_only_mode if these events CAN be enabled.    __ ldrb(rscratch1, Address(rthread, JavaThread::interp_only_mode_offset()));    __ cbnz(rscratch1, run_compiled_code);    __ ldr(rscratch1, Address(method, Method::interpreter_entry_offset()));    __ br(rscratch1);    __ BIND(run_compiled_code);  }  const ByteSize entry_offset = for_compiler_entry ? Method::from_compiled_offset() :                                                     Method::from_interpreted_offset();  __ ldr(rscratch1,Address(method, entry_offset));  __ br(rscratch1);  __ bind(L_no_such_method);  __ far_jump(RuntimeAddress(StubRoutines::throw_AbstractMethodError_entry()));}

void MethodHandles::verify_klass(MacroAssembler* _masm,                                 Register obj, SystemDictionary::WKID klass_id,                                 const char* error_message) {  Klass** klass_addr = SystemDictionary::well_known_klass_addr(klass_id);  KlassHandle klass = SystemDictionary::well_known_klass(klass_id);  Register temp = rdi;  Register temp2 = noreg;  LP64_ONLY(temp2 = rscratch1);  // used by MacroAssembler::cmpptr  Label L_ok, L_bad;  BLOCK_COMMENT("verify_klass {");  __ verify_oop(obj);  __ testptr(obj, obj);  __ jcc(Assembler::zero, L_bad);  __ push(temp); if (temp2 != noreg)  __ push(temp2);#define UNPUSH { if (temp2 != noreg)  __ pop(temp2);  __ pop(temp); }  __ load_klass(temp, obj);  __ cmpptr(temp, ExternalAddress((address) klass_addr));  __ jcc(Assembler::equal, L_ok);  intptr_t super_check_offset = klass->super_check_offset();  __ movptr(temp, Address(temp, super_check_offset));  __ cmpptr(temp, ExternalAddress((address) klass_addr));  __ jcc(Assembler::equal, L_ok);  UNPUSH;  __ bind(L_bad);  __ STOP(error_message);  __ BIND(L_ok);  UNPUSH;  BLOCK_COMMENT("} verify_klass");}

int main(int argc,char *argv[]){	int sock,newsock;	int portNum,pid;	socklen_t clientLen;	struct sockaddr_in server_addr;	struct sockaddr_in client_addr;	char buffer[1000];	if(argc != 2){		printf("ERROR, wrong number of arguments!/n");		printf("./ftps portNumber");		exit(0);	}	sock = SOCKET(AF_INET,SOCK_STREAM,0);	if(sock < 0){		printf("ERROR OPENING SOCKET!");		exit(0);	}	/*Sets up connection for the server */	//portNum = atoi(argv[1]);	server_addr.sin_family = AF_INET;	server_addr.sin_addr.s_addr = 0;	server_addr.sin_port = htons(SERVERPORT);		if(BIND(sock,(struct sockaddr *)&server_addr,sizeof(server_addr)) < 0){		perror("ERROR binding to socket!");		exit(0);	}		receiveFile(sock);			return 0;	}

void MethodHandles::jump_from_method_handle(MacroAssembler* _masm, Register method, Register temp,                                            bool for_compiler_entry) {  assert(method == rbx, "interpreter calling convention");  __ verify_method_ptr(method);  if (!for_compiler_entry && JvmtiExport::can_post_interpreter_events()) {    Label run_compiled_code;    // JVMTI events, such as single-stepping, are implemented partly by avoiding running    // compiled code in threads for which the event is enabled.  Check here for    // interp_only_mode if these events CAN be enabled.#ifdef _LP64    Register rthread = r15_thread;#else    Register rthread = temp;    __ get_thread(rthread);#endif    // interp_only is an int, on little endian it is sufficient to test the byte only    // Is a cmpl faster?    __ cmpb(Address(rthread, JavaThread::interp_only_mode_offset()), 0);    __ jccb(Assembler::zero, run_compiled_code);    __ jmp(Address(method, Method::interpreter_entry_offset()));    __ BIND(run_compiled_code);  }  const ByteSize entry_offset = for_compiler_entry ? Method::from_compiled_offset() :                                                     Method::from_interpreted_offset();  __ jmp(Address(method, entry_offset));}

bool TcpServer::init(int port_num){  int rc;  bool rtn;  const int reuse_addr = 1;  //int err;  SOCKLEN_T addrSize = 0;  rc = SOCKET(AF_INET, SOCK_STREAM, 0);  if (this->SOCKET_FAIL != rc)  {    this->setSrvrHandle(rc);    LOG_DEBUG("Socket created, rc: %d", rc);    LOG_DEBUG("Socket handle: %d", this->getSrvrHandle());        SET_REUSE_ADDR(this->getSrvrHandle(), reuse_addr);    // Initialize address data structure    memset(&this->sockaddr_, 0, sizeof(this->sockaddr_));    this->sockaddr_.sin_family = AF_INET;    this->sockaddr_.sin_addr.s_addr = INADDR_ANY;    this->sockaddr_.sin_port = HTONS(port_num);    addrSize = sizeof(this->sockaddr_);    rc = BIND(this->getSrvrHandle(), (sockaddr *)&(this->sockaddr_), addrSize);    if (this->SOCKET_FAIL != rc)    {      LOG_INFO("Server socket successfully initialized");      rc = LISTEN(this->getSrvrHandle(), 1);      if (this->SOCKET_FAIL != rc)      {        LOG_INFO("Socket in listen mode");        rtn = true;      }      else      {        LOG_ERROR("Failed to set socket to listen");        rtn = false;      }    }    else    {      LOG_ERROR("Failed to bind socket, rc: %d", rc);      CLOSE(this->getSrvrHandle());      rtn = false;    }  }  else  {    LOG_ERROR("Failed to create socket, rc: %d", rc);    rtn = false;  }  return rtn;}

void MethodHandles::verify_klass(MacroAssembler* _masm,                                 Register obj, SystemDictionary::WKID klass_id,                                 const char* error_message) {  InstanceKlass** klass_addr = SystemDictionary::well_known_klass_addr(klass_id);  KlassHandle klass = SystemDictionary::well_known_klass(klass_id);  Register temp = rscratch2;  Register temp2 = rscratch1; // used by MacroAssembler::cmpptr  Label L_ok, L_bad;  BLOCK_COMMENT("verify_klass {");  __ verify_oop(obj);  __ cbz(obj, L_bad);  __ push(RegSet::of(temp, temp2), sp);  __ load_klass(temp, obj);  __ cmpptr(temp, ExternalAddress((address) klass_addr));  __ br(Assembler::EQ, L_ok);  intptr_t super_check_offset = klass->super_check_offset();  __ ldr(temp, Address(temp, super_check_offset));  __ cmpptr(temp, ExternalAddress((address) klass_addr));  __ br(Assembler::EQ, L_ok);  __ pop(RegSet::of(temp, temp2), sp);  __ bind(L_bad);  __ stop(error_message);  __ BIND(L_ok);  __ pop(RegSet::of(temp, temp2), sp);  BLOCK_COMMENT("} verify_klass");}

address AbstractInterpreterGenerator::generate_result_handler_for(BasicType type) {  //  // Registers alive  //   R3_RET  //   LR  //  // Registers updated  //   R3_RET  //  Label done;  address entry = __ pc();  switch (type) {  case T_BOOLEAN:    // convert !=0 to 1    __ neg(R0, R3_RET);    __ orr(R0, R3_RET, R0);    __ srwi(R3_RET, R0, 31);    break;  case T_BYTE:     // sign extend 8 bits     __ extsb(R3_RET, R3_RET);     break;  case T_CHAR:     // zero extend 16 bits     __ clrldi(R3_RET, R3_RET, 48);     break;  case T_SHORT:     // sign extend 16 bits     __ extsh(R3_RET, R3_RET);     break;  case T_INT:     // sign extend 32 bits     __ extsw(R3_RET, R3_RET);     break;  case T_LONG:     break;  case T_OBJECT:    // unbox result if not null    __ cmpdi(CCR0, R3_RET, 0);    __ beq(CCR0, done);    __ ld(R3_RET, 0, R3_RET);    __ verify_oop(R3_RET);    break;  case T_FLOAT:     break;  case T_DOUBLE:     break;  case T_VOID:     break;  default: ShouldNotReachHere();  }  __ BIND(done);  __ blr();  return entry;}

void clLocalizer::AfterConstruction(){	iObject::AfterConstruction();	FLocalePath = "Localizer";	Env->Connect( L_EVENT_LOCALE_CHANGED, BIND( &clLocalizer::Event_LOCALE_CHANGED ) );}

int main(int argc, char *argv[]) {    int sockfd;    struct addrinfo hints, *servinfo;    int status;        if (argc != 2) {        printf("Usage: %s <port>/n", argv[0]);        return 1;    }    printf("ftps: Starting server on port %s.../n", argv[1]);        // Create output folder    if (mkdir(OUTPUT_DIR, S_IRWXU) == -1) {        int err = errno;        if (err != EEXIST) {            fprintf(stderr, "ftps: Error creating output directory: %s/n",                    strerror(err));            exit(1);        }    }        // Setup structures    memset(&hints, 0, sizeof hints);    hints.ai_family = AF_INET;    hints.ai_socktype = SOCK_STREAM;    hints.ai_flags = AI_PASSIVE;    if ((status = getaddrinfo(NULL, argv[1], &hints, &servinfo)) != 0) {        fprintf(stderr, "ftps: getaddrinfo: %s/n", gai_strerror(status));        return 1;    }        // Get socket    if ((sockfd = SOCKET(servinfo->ai_family, servinfo->ai_socktype,                         servinfo->ai_protocol)) == -1) {        perror("ftps: socket");        exit(1);    }    // Bind    if (BIND(sockfd, servinfo->ai_addr, servinfo->ai_addrlen) == -1) {        perror("ftps: bind");        CLOSE(sockfd);        exit(1);    }        // Accept - Block until connection    while (ACCEPT(sockfd, servinfo->ai_addr, &(servinfo->ai_addrlen)) != 0);        // Clean up    freeaddrinfo(servinfo);        // Wait for file then exit    receiveFile(sockfd);    CLOSE(sockfd);    exit(0);        return 0;}

void BIND(autogl_set_idle_event_callback) (int *flag){  if (*flag) {    AutoGL_SetIdleEventCallback (BIND(autogl_idle));  } else {    AutoGL_SetIdleEventCallback (NULL);  }}

void Battle::playActionOver(cocostudio::Armature *armature, cocostudio::MovementEventType type, const char *name) {    if (armature == m_pReadygo) {        if (type == COMPLETE) {            removeChild(armature);            m_pReadygo = NULL;            unmask();            BIND(BUND_ID_GLOBAL_TOUCH_MOVED, this, Battle::globalTouchMoved);            g_pEventEngine->BundlerCall(BUND_ID_PLANE_FIRE, this, sizeof(this));        }    }        if (armature == m_pBossIn) {        if (type == COMPLETE) {            removeChild(armature);            m_pBossIn = NULL;            unmask();            const BossConfig * pconfig = g_pGameConfig->getBossConfig(m_pConfig->boss);            m_pBoss = Boss::create(pconfig);            addChild(m_pBoss, GRADE_ENEMY);            if (m_pConfig->boss != "chisezhilang") {                m_pBoss->setScale(g_pGameConfig->scaleEleMin);            } else {                m_pBoss->setScale(g_pGameConfig->scaleEleMin * 1.5);            }            m_pBoss->setPosition(Vec2(pconfig->pos.x * g_pGameConfig->scaleEleX, pconfig->pos.y * g_pGameConfig->scaleEleY));            m_pBoss->setRotation(pconfig->rotate);            ActionInterval * action = MoveBy::create(2, Vec2(0, -500 * g_pGameConfig->scaleEleY));            m_pBoss->runAction(Sequence::create(action, CallFuncN::create(this, callfuncN_selector(Battle::playbossAi)), NULL));        }    }        if (armature == m_pMissionVictory) {        if (type == COMPLETE) {            Node * icon = g_pGameConfig->getIcon(m_equip.model, m_equip.type);            icon->setPosition(Vec2(-200, -275));            icon->setScale(g_pGameConfig->scaleEleMin * 5);            m_pMissionVictory->addChild(icon, GRADE_UI);            icon->setOpacity(0);            ActionInterval * scale = ScaleTo::create(.5f, g_pGameConfig->scaleEleMin * 1.5);            ActionInterval * fadein = FadeIn::create(.5f);            icon->runAction(Spawn::create(scale, fadein, NULL));                        UNBIND(BUND_ID_GLOBAL_TOUCH_MOVED, this, Battle::globalTouchMoved);                        scheduleOnce(schedule_selector(Battle::returnMission), 2.0f);        }    }        if (armature == m_pMissionFaild) {        if (type == COMPLETE) {            UNBIND(BUND_ID_GLOBAL_TOUCH_MOVED, this, Battle::globalTouchMoved);                        scheduleOnce(schedule_selector(Battle::returnMission), 2.0f);        }    }}

void clViewport::AfterConstruction(){#ifdef OS_WINDOWS    DWORD dwVersion = 0;    DWORD dwMajorVersion = 0;    dwVersion = GetVersion();    // Get the Windows version.    dwMajorVersion = ( DWORD )( LOBYTE( LOWORD( dwVersion ) ) );    if ( dwMajorVersion > 5 )    {        /// Anything below WinXP without SP3 does not support High DPI, so we do not enable it on WinXP at all.        SetHighDPIAware();    }    StoreAndDisableStickyKeys();    if ( FTakeoverContext )    {        ResizeViewport( 0, 0 );    }    else#endif    {#ifdef OS_WINDOWS        if ( FRegisterWindowClass )        {            RegisterWindowClass();        }        if ( FExternalWindowHandle )        {            RECT Rect;            GetWindowRect( FExternalWindowHandle, &Rect );            FWidth  = Rect.right  - Rect.left;            FHeight = Rect.bottom - Rect.top;        }#endif        RecreateViewport();    }    ReinitializeViewport();    FMouseX = Env->Console->GetVar( "Viewport.MouseX" );    FMouseY = Env->Console->GetVar( "Viewport.MouseY" );    Env->Connect( L_EVENT_SURFACE_CHANGED, BIND( &clViewport::Event_SURFACE_CHANGED ) );}

void clAudioSubSystem_OpenAL::AfterConstruction(){#if L_AUDIO_USE_OPENAL	iAudioSubSystem::AfterConstruction();	// start thread	FAudioThread = new clAudioThread();	FAudioThread->Start( Env, iThread::Priority_Low );	Env->Connect( L_EVENT_ACTIVATE, BIND( &clAudioSubSystem_OpenAL::Event_ACTIVATE ) );#endif}

clAudioSubSystem_OpenAL::~clAudioSubSystem_OpenAL(){	Env->Disconnect( L_EVENT_ACTIVATE, BIND( &clAudioSubSystem_OpenAL::Event_ACTIVATE ) );	StopAllC( "" );	Utils::DeallocateAll( FAnnouncers );	FModule = NULL;	FAudioThread->Exit( true );	delete( FAudioThread );}

Parser *parser__new( Interpreter *itp ){    Parser *p;    Environment *e;    if ( DEBUG__SAFE && !itp )        abort();    if ( instance_exists )    {        ERROR( "parser__new: concurrent parser instances are not allowed" );        return 0;    }    p = NEW( Parser );    if ( !p )        return 0;    p->interpreter = itp;    e = interpreter__environment( itp );#define BIND(x)    p->TYPEOBJ( x ) = environment__resolve_type( e, NAMEOF( x ), FALSE )    if ( !(        ( BIND( APPLY ) )     && ( BIND( ARRAY ) )     && ( BIND( CHARACTER ) )     && ( BIND( DOUBLE ) )     && ( BIND( INTEGER ) )     && ( BIND( NAME ) )     && ( BIND( STRING ) )     && ( BIND( TERM ) ) ) )    {        free( p );        return 0;    }#undef BIND    p->manager = environment__manager( e );    p->locked = FALSE;    p->exit_early = FALSE;    instance_exists = TRUE;    return p;}

CBox::CBox() {    BIND(BUND_ID_CBOX_UNSELECTED, this, CBox::OnCmdUnSelected);        m_pIcon = NULL;    m_isSelected = false;        //装备背景    m_pPanel = Sprite::create("UI/Public/Panel/equipInfoPanel.png");    m_pPanel->setAnchorPoint(Vec2(0, 0));    addChild(m_pPanel);    setContentSize(m_pPanel->getContentSize());        //装备LV标签    Label * labelLv = Label::create("LV.", "WRYH.ttf", 35);    labelLv->setVerticalAlignment(TextVAlignment::BOTTOM);    labelLv->setAnchorPoint(Vec2(0, 0));    labelLv->setPosition(Vec2(800, 130));    m_pPanel->addChild(labelLv);            m_pLv = Label::create("", "WRYH.ttf", 40);    m_pLv->setVerticalAlignment(TextVAlignment::BOTTOM);    m_pLv->setAnchorPoint(Vec2(0, 0));    m_pLv->setPosition(Vec2(850, 130));    m_pPanel->addChild(m_pLv);        m_pLabelName = Label::create("", "WRYH.ttf", 45);    m_pLabelName->setVerticalAlignment(TextVAlignment::BOTTOM);    m_pLabelName->setAnchorPoint(Vec2(0, 0));    m_pLabelName->setPosition(Vec2(250, 125));    m_pPanel->addChild(m_pLabelName);        m_pLabel1 = Label::create("", "WRYH.ttf", 45);    m_pLabel1->setVerticalAlignment(TextVAlignment::BOTTOM);    m_pLabel1->setAnchorPoint(Vec2(0, 0));    m_pLabel1->setPosition(Vec2(250, 40));    m_pPanel->addChild(m_pLabel1);        m_pLabel2 = Label::create("", "WRYH.ttf", 45);    m_pLabel2->setVerticalAlignment(TextVAlignment::BOTTOM);    m_pLabel2->setAnchorPoint(Vec2(0, 0));    m_pLabel2->setPosition(Point(670, 40));    m_pPanel->addChild(m_pLabel2);        m_pSelectIcon = Sprite::create("UI/Public/Button/selected.png");    m_pSelectIcon->setAnchorPoint(Vec2(0, 0));    m_pSelectIcon->setVisible(m_isSelected);    m_pSelectIcon->setPosition(Point(1180, 70));    m_pPanel->addChild(m_pSelectIcon);}

bool UdpServer::init(int port_num){  int rc = this->SOCKET_FAIL;  bool rtn;  SOCKLEN_T addrSize = 0;  /* Create a socket using:   * AF_INET - IPv4 internet protocol   * SOCK_DGRAM - UDP type   * protocol (0) - System chooses   */  rc = SOCKET(AF_INET, SOCK_DGRAM, 0);  if (this->SOCKET_FAIL != rc)  {    this->setSockHandle(rc);    LOG_DEBUG("Socket created, rc: %d", rc);    LOG_DEBUG("Socket handle: %d", this->getSockHandle());    // Initialize address data structure    memset(&this->sockaddr_, 0, sizeof(this->sockaddr_));    this->sockaddr_.sin_family = AF_INET;    this->sockaddr_.sin_addr.s_addr = INADDR_ANY;    this->sockaddr_.sin_port = HTONS(port_num);    // This set the socket to be non-blocking (NOT SURE I WANT THIS) - sme    //fcntl(sock_handle, F_SETFL, O_NONBLOCK);    addrSize = sizeof(this->sockaddr_);    rc = BIND(this->getSockHandle(), (sockaddr *)&(this->sockaddr_), addrSize);    if (this->SOCKET_FAIL != rc)    {      rtn = true;      LOG_INFO("Server socket successfully initialized");    }    else    {      LOG_ERROR("Failed to bind socket, rc: %d", rc);      CLOSE(this->getSockHandle());      rtn = false;    }  }  else  {    LOG_ERROR("Failed to create socket, rc: %d", rc);    rtn = false;  }  return rtn;}

void MethodHandles::verify_klass(MacroAssembler* _masm,                                 Register obj_reg, SystemDictionary::WKID klass_id,                                 Register temp_reg, Register temp2_reg,                                 const char* error_message) {  Klass** klass_addr = SystemDictionary::well_known_klass_addr(klass_id);  KlassHandle klass = SystemDictionary::well_known_klass(klass_id);  Label L_ok, L_bad;  BLOCK_COMMENT("verify_klass {");  __ verify_oop(obj_reg);  __ cmpdi(CCR0, obj_reg, 0);  __ beq(CCR0, L_bad);  __ load_klass(temp_reg, obj_reg);  __ load_const_optimized(temp2_reg, (address) klass_addr);  __ ld(temp2_reg, 0, temp2_reg);  __ cmpd(CCR0, temp_reg, temp2_reg);  __ beq(CCR0, L_ok);  __ ld(temp_reg, klass->super_check_offset(), temp_reg);  __ cmpd(CCR0, temp_reg, temp2_reg);  __ beq(CCR0, L_ok);  __ BIND(L_bad);  __ stop(error_message);  __ BIND(L_ok);  BLOCK_COMMENT("} verify_klass");}

int main(int ac,char*av[]) {  char    sin[73],sout[100000];  int    dit = 100;  if (1 < ac) {    if (strlen(av[1]) != strspn(av[1],"0123456789"))      return 0*fprintf(stderr,"use: %s [duration]   dit in ms, default %d/n",*av,dit);    dit = BIND(atoi(av[1]),1,1000);  }  sprintf(dah," -n -f 440 -l %d -D %d",3*dit,dit);  sprintf(dih," -n -f 440 -l %d -D %d",dit,dit);  sprintf(medium," -n -D %d",(3-1)*dit);  sprintf(word," -n -D %d",(7-(3-1)-1)*dit);  while (NULL != fgets(sin,72,stdin))    puts(translate(sin,sout));  return 0;}