void AutoGL_SetUp (int argc, char *argv[])
{
AutoGL_SetViewRedrawCallback (BIND(autogl_redraw));
AutoGL_SetIdleEventCallback (BIND(autogl_idle));
BIND(autogl_setup) ();
}
COMA_USING_NS
ResourceManager::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");
}
// Helper to insert argument slots into the stack.
// arg_slots must be a multiple of stack_move_unit() and <= 0
void MethodHandles::insert_arg_slots(MacroAssembler* _masm,
RegisterOrConstant arg_slots,
int arg_mask,
Register rax_argslot,
Register rbx_temp, Register rdx_temp, Register temp3_reg) {
assert(temp3_reg == noreg, "temp3 not required");
assert_different_registers(rax_argslot, rbx_temp, rdx_temp,
(!arg_slots.is_register() ? rsp : arg_slots.as_register()));
#ifdef ASSERT
verify_argslot(_masm, rax_argslot, "insertion point must fall within current frame");
if (arg_slots.is_register()) {
Label L_ok, L_bad;
__ cmpptr(arg_slots.as_register(), (int32_t) NULL_WORD);
__ jccb(Assembler::greater, L_bad);
__ testl(arg_slots.as_register(), -stack_move_unit() - 1);
__ jccb(Assembler::zero, L_ok);
__ bind(L_bad);
__ stop("assert arg_slots <= 0 and clear low bits");
__ bind(L_ok);
} else {
assert(arg_slots.as_constant() <= 0, "");
assert(arg_slots.as_constant() % -stack_move_unit() == 0, "");
}
#endif //ASSERT
#ifdef _LP64
if (arg_slots.is_register()) {
// clean high bits of stack motion register (was loaded as an int)
__ movslq(arg_slots.as_register(), arg_slots.as_register());
}
#endif
// Make space on the stack for the inserted argument(s).
// Then pull down everything shallower than rax_argslot.
// The stacked return address gets pulled down with everything else.
// That is, copy [rsp, argslot) downward by -size words. In pseudo-code:
// rsp -= size;
// for (rdx = rsp + size; rdx < argslot; rdx++)
// rdx[-size] = rdx[0]
// argslot -= size;
BLOCK_COMMENT("insert_arg_slots {");
__ mov(rdx_temp, rsp); // source pointer for copy
__ lea(rsp, Address(rsp, arg_slots, Address::times_ptr));
{
Label loop;
__ BIND(loop);
// pull one word down each time through the loop
__ movptr(rbx_temp, Address(rdx_temp, 0));
__ movptr(Address(rdx_temp, arg_slots, Address::times_ptr), rbx_temp);
__ addptr(rdx_temp, wordSize);
__ cmpptr(rdx_temp, rax_argslot);
__ jccb(Assembler::less, loop);
}
// Now move the argslot down, to point to the opened-up space.
__ lea(rax_argslot, Address(rax_argslot, arg_slots, Address::times_ptr));
BLOCK_COMMENT("} insert_arg_slots");
}
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;
}
