// CONSTRUCTOR //------------------------------------------------------------------------------ /*explicit*/ CachePlugin::CachePlugin( const AString & dllName ) : #if defined( __WINDOWS__ ) m_DLL( nullptr ), #endif m_InitFunc( nullptr ), m_ShutdownFunc( nullptr ), m_PublishFunc( nullptr ), m_RetrieveFunc( nullptr ), m_FreeMemoryFunc( nullptr ) { #if defined( __WINDOWS__ ) m_DLL = ::LoadLibrary( dllName.Get() ); if ( !m_DLL ) { FLOG_WARN( "Cache plugin '%s' load failed (0x%x).", dllName.Get(), ::GetLastError() ); return; } m_InitFunc = (CacheInitFunc) GetFunction( "CacheInit", "?CacheInit@@YA_NPEBD@Z" ); m_ShutdownFunc = (CacheShutdownFunc) GetFunction( "CacheShutdown", "?CacheShutdown@@YAXXZ" ); m_PublishFunc = (CachePublishFunc) GetFunction( "CachePublish", "?CachePublish@@YA_NPEBDPEBX_K@Z" ); m_RetrieveFunc = (CacheRetrieveFunc) GetFunction( "CacheRetrieve", "?CacheRetrieve@@YA_NPEBDAEAPEAXAEA_K@Z" ); m_FreeMemoryFunc= (CacheFreeMemoryFunc) GetFunction( "CacheFreeMemory", "?CacheFreeMemory@@YAXPEAX_K@Z" ); #elif defined( __APPLE__ ) ASSERT( false ); // TODO:MAC Implement CachePlugin #elif defined( __LINUX__ ) ASSERT( false ); // TODO:LINUX Implement CachePlugin #else #error Unknown platform #endif }
void Statement::WriteToFile(FILE* fp, int indent)const { #if _DEBUG int num = GetFunctionNum(); Function* func1 = GetFunction(0); Function* func2 = GetFunction(1); if (num == 2 && NULL != func1 && NULL != func2 && func1->GetCall().GetParamClass() == Call::PARAM_CLASS_TERNARY_OPERATOR && func2->GetCall().GetParamClass() == Call::PARAM_CLASS_TERNARY_OPERATOR){ ISyntaxComponent* pcomp0 = func1->GetCall().GetParam(0); ISyntaxComponent* pcomp1 = func1->GetStatement(0); ISyntaxComponent* pcomp2 = func2->GetStatement(0); if (NULL!=pcomp0 && NULL != pcomp1 && NULL != pcomp2){ WriteComponent(fp, *pcomp0, indent); fwrite(" ? ", 3, 1, fp); WriteComponent(fp, *pcomp1, 0); fwrite(" : ", 3, 1, fp); WriteComponent(fp, *pcomp2, 0); } } else { for (int ix = 0; ix < num; ++ix){ ISyntaxComponent& component = *GetFunction(ix); WriteComponent(fp, component, indent); if (ix < num - 1){ fwrite("\n", 1, 1, fp); } } } #endif }
void ScriptFile::AddEventHandler(Object* sender, StringHash eventType, const String& handlerName) { if (!compiled_) return; if (!sender) { LOGERROR("Null event sender for event " + String(eventType) + ", handler " + handlerName); return; } String declaration = "void " + handlerName + "(StringHash, VariantMap&)"; asIScriptFunction* function = GetFunction(declaration); if (!function) { declaration = "void " + handlerName + "()"; function = GetFunction(declaration); if (!function) { LOGERROR("Event handler function " + handlerName + " not found in " + GetName()); return; } } SubscribeToEvent(sender, eventType, HANDLER_USERDATA(ScriptFile, HandleScriptEvent, (void*)function)); }
wxString wxStringFormatter::DoFunction(wxString func, wxString block) { wxLogDebug("DoFunction: " + block); if(GetFunction(func)) { return GetFunction(func)->Parse(ReplaceSymbols(block)); } return func + block; }
DiagNativeStackFrame::DiagNativeStackFrame( ScriptFunction* function, int byteCodeOffset, void* stackAddr, void *codeAddr, int frameIndex) : DiagStackFrame(frameIndex), m_function(function), m_byteCodeOffset(byteCodeOffset), m_stackAddr(stackAddr), m_localVarSlotsOffset(InvalidOffset), m_localVarChangedOffset(InvalidOffset) { Assert(m_stackAddr != NULL); AssertMsg(m_function && m_function->GetScriptContext() && m_function->GetScriptContext()->IsInDebugMode(), "This only supports functions in debug mode."); FunctionEntryPointInfo * entryPointInfo = GetFunction()->GetEntryPointFromNativeAddress((DWORD_PTR)codeAddr); if (entryPointInfo) { m_localVarSlotsOffset = entryPointInfo->localVarSlotsOffset; m_localVarChangedOffset = entryPointInfo->localVarChangedOffset; } else { AssertMsg(FALSE, "Failed to get entry point for native address. Most likely the frame is old/gone."); } OUTPUT_TRACE(Js::DebuggerPhase, L"DiagNativeStackFrame::DiagNativeStackFrame: e.p(addr %p)=%p varOff=%d changedOff=%d\n", codeAddr, entryPointInfo, m_localVarSlotsOffset, m_localVarChangedOffset); }
void CreateTimer(ScriptValue &s, ScriptValue *args) { if (args[1].intVal < 1 || args[1].intVal > (1<<30)) { return; } ObjectValue *obj; int function = GetFunction(&args[0], &args[3], obj); if (function < 0) return; int index = FindTimerSpace(); if (index == -1) { if (obj) obj->Release(); return; } if (!(timers[index].slowTimer = (Timer*) malloc(sizeof(Timer)))) { if (obj) obj->Release(); timers[index].type = KILLED_TIMER; return; } timers[index].obj = obj; timers[index].type = SLOW_TIMER; timers[index].function = function; timers[index].slowTimer->Init(SlowTimerProc, (void*)(size_t)index, args[1].intVal, RUN_ALWAYS, 0, SAVE_NONE); if (timers[index].slowTimer->timerMode != RUN_ALWAYS) { timers[index].Kill(); } else { CreateIntValue(s, index+1); if (args[2].intVal == 0) { timers[index].slowTimer->lastRun = time64i(); timers[index].slowTimer->ChangeDelay(timers[index].slowTimer->delay); } } }
void CreateFastTimer(ScriptValue &s, ScriptValue *args) { if (args[1].intVal < 10 || args[1].intVal > 3600000) { return; } ObjectValue *obj; int function = GetFunction(&args[0], &args[3], obj); if (function < 0) return; int index = FindTimerSpace(); if (index == -1) { if (obj) obj->Release(); return; } timers[index].type = FAST_TIMER; timers[index].obj = obj; timers[index].function = function; timers[index].fastTimer.active = 0; timers[index].fastTimer.id = index+10; timers[index].fastTimer.delay = args[1].i32; if (!timers[index].Start(1)) { timers[index].Kill(); } else { CreateIntValue(s, index+1); if (args[2].intVal) RunTimerFunction(timers[index].function, timers[index].obj, index+1); } }
extern "C" void NSMain(const v8::FunctionCallbackInfo<v8::Value>& args) { auto isolate = args.GetIsolate(); auto len = args.Length(); if (len != 5) { auto errMsg = v8::String::NewFromUtf8(isolate, "Wrong number of arguments (expected 5)"); auto err = v8::Exception::Error(errMsg); isolate->ThrowException(err); return; } auto exports = args[1].As<v8::Object>(); auto ft = v8::FunctionTemplate::New(isolate, AddFuncCallback); auto ctx = isolate->GetCurrentContext(); auto maybeFunc = ft->GetFunction(ctx); if (maybeFunc.IsEmpty()) { auto errMsg = v8::String::NewFromUtf8(isolate, "Cannot create 'add' function"); auto err = v8::Exception::Error(errMsg); isolate->ThrowException(err); return; } auto func = maybeFunc.ToLocalChecked(); auto propName = v8::String::NewFromUtf8(isolate, "add"); auto result = exports->Set(ctx, propName, func); }
static VALUE pkcs11_C_GetMechanismList(VALUE self, VALUE slot_id) { CK_RV rv; CK_C_GetMechanismList func; CK_MECHANISM_TYPE_PTR types; CK_ULONG count; VALUE ary; CK_ULONG i; ary = rb_ary_new(); GetFunction(self, C_GetMechanismList, func); CallFunction(C_GetMechanismList, func, rv, NUM2HANDLE(slot_id), NULL_PTR, &count); if (rv != CKR_OK) pkcs11_raise(self,rv); if (count == 0) return ary; types = (CK_MECHANISM_TYPE_PTR)malloc(sizeof(CK_MECHANISM_TYPE)*count); if (!types) rb_sys_fail(0); CallFunction(C_GetMechanismList, func, rv, NUM2HANDLE(slot_id), types, &count); if (rv != CKR_OK){ free(types); pkcs11_raise(self,rv); } for (i = 0; i < count; i++) rb_ary_push(ary, HANDLE2NUM(*(types+i))); free(types); return ary; }
/* ============ idScriptObject::SetSyncCallback ============ */ void idScriptObject::SetSyncCallback( const char *name, const char* functionName ) { const sdProgram::sdFunction* function = GetFunction( functionName ); if ( !function ) { gameLocal.Warning( "idScriptObject::SetSyncCallback Unknown Function '%s'", functionName ); return; } if ( typeObject == NULL ) { gameLocal.Warning( "idScriptObject::SetSyncCallback No Script Object" ); return; } byte* data = NULL; typeObject->GetVariable( name, &data ); if ( data == NULL ) { gameLocal.Warning( "idScriptObject::SetSyncCallback Unknown Field '%s'", name ); } for ( int k = 0; k < NSM_NUM_MODES; k++ ) { for ( int j = 0; j < networkFields[ k ].fields.Num(); j++ ) { if ( networkFields[ k ].fields[ j ].data == data ) { networkFields[ k ].fields[ j ].callback = function; return; } } } gameLocal.Warning( "idScriptObject::SetSyncCallback No Synced Field Named '%s' Found", name ); }
/* ============ idScriptObject::GetConstructor ============ */ const function_t *idScriptObject::GetConstructor( void ) const { const function_t *func; func = GetFunction( "init" ); return func; }
/* ============ idScriptObject::GetDestructor ============ */ const function_t *idScriptObject::GetDestructor( void ) const { const function_t *func; func = GetFunction( "destroy" ); return func; }
void ScrollComponent::OnAdd(Entity *pEnt) { EntityComponent::OnAdd(pEnt); //shared with the rest of the entity m_vecDisplacement = m_vecChildPos = CL_Vec2f(0,0); m_pPos2d = &GetParent()->GetVar("pos2d")->GetVector2(); m_pSize2d = &GetParent()->GetVar("size2d")->GetVector2(); //vars in our component namespace m_pBoundsRect = &GetVarWithDefault("boundsRect", CL_Rectf(0, 0, 0,0))->GetRect(); m_pScrollStyle = &GetVarWithDefault("scrollStyle", uint32(STYLE_MOMENTUM))->GetUINT32(); //only used for "momentum style" m_pFriction = &GetVarWithDefault("friction", 0.1f)->GetFloat(); m_pMaxScrollSpeed = &GetVarWithDefault("maxScrollSpeed", float(7))->GetFloat(); m_pPowerMod = &GetVarWithDefault("powerMod", float(0.15))->GetFloat(); m_progressVar = GetVar("progress2d"); m_pEnforceFingerTracking = &GetVarWithDefault("fingerTracking", uint32(0))->GetUINT32(); m_pSwipeDetectDistance = &GetVarWithDefault("swipeDetectDistance", 25.0f)->GetFloat(); m_pDontScrollUntilSwipeDetected = &GetVarWithDefault("dontScrollUntilSwipeDetected", uint32(0))->GetUINT32(); m_pEatAllInput = &GetVarWithDefault("eatAllInput", uint32(0))->GetUINT32(); GetParent()->GetFunction("OnOverStart")->sig_function.connect(1, boost::bind(&ScrollComponent::OnOverStart, this, _1)); GetParent()->GetFunction("OnOverEnd")->sig_function.connect(1, boost::bind(&ScrollComponent::OnOverEnd, this, _1)); GetParent()->GetFunction("OnOverMove")->sig_function.connect(1, boost::bind(&ScrollComponent::OnOverMove, this, _1)); GetParent()->GetFunction("OnUpdate")->sig_function.connect(1, boost::bind(&ScrollComponent::OnUpdate, this, _1)); GetFunction("SetProgress")->sig_function.connect(1, boost::bind(&ScrollComponent::SetProgress, this, _1)); }
static VALUE pkcs11_C_GetSlotList(VALUE self, VALUE presented) { CK_ULONG ulSlotCount; CK_SLOT_ID_PTR pSlotList; CK_RV rv; CK_C_GetSlotList func; CK_ULONG i; VALUE ary = rb_ary_new(); GetFunction(self, C_GetSlotList, func); CallFunction(C_GetSlotList, func, rv, CK_FALSE, NULL_PTR, &ulSlotCount); if (rv != CKR_OK) pkcs11_raise(self,rv); pSlotList = (CK_SLOT_ID_PTR)malloc(ulSlotCount*sizeof(CK_SLOT_ID)); CallFunction(C_GetSlotList, func, rv, RTEST(presented) ? CK_TRUE : CK_FALSE, pSlotList, &ulSlotCount); if (rv != CKR_OK) { free(pSlotList); pkcs11_raise(self,rv); } for (i = 0; i < ulSlotCount; i++) rb_ary_push(ary, HANDLE2NUM(pSlotList[i])); free(pSlotList); return ary; }
void TestFunctionEquality ( const JCharacter* fileName ) { std::ifstream input(fileName); TestVarList theVarList(input); JFunction* f1 = NULL; JFunction* f2 = NULL; while (1) { if (!GetFunction(input, &theVarList, &f1)) { break; } else if (f1 == NULL) { continue; } if (!GetFunction(input, &theVarList, &f2)) { jdelete f1; break; } else if (f2 == NULL) { jdelete f1; continue; } if (*f1 == *f2) { (JGetUserNotification())->DisplayMessage("These functions are the same"); } else { (JGetUserNotification())->DisplayMessage("These functions are not the same"); } jdelete f1; jdelete f2; } }
Module * ModuleFactory::createModule(const char * path) const { Info << "Loading " << path; void *hDLL; //do not add extension. It is handled by LoadSharedLibrary. hDLL = LoadSharedLibrary(path); if (hDLL == 0) return NULL; Instance instanciate = (Instance)GetFunction(hDLL, "create"); Destroy destroy = (Destroy)GetFunction(hDLL, "destroy"); if (instanciate == 0 || destroy == 0) return NULL; Module * module = instanciate(); module->setCleanLibraryCallback(new CleanLibraryCallBack(hDLL, destroy)); return module; }
void Dollar::InitInstance(Isolate* iso, v8::Handle<v8::Object> & target) { auto tmpl = Local<FunctionTemplate>::New(iso, _Template); // create an instance of dollar object and make a property auto dollar = tmpl->GetFunction()->NewInstance(); // target->SetAccessor(String::NewFromUtf8(iso, "$"), jsGetter, 0, dollar); target->Set(String::NewFromUtf8(iso, "$"), dollar); }
////////////////////////////////////////////////////////////////////// // // ClParser::internVarCell // // o Returns %rd of VARDEF instruction. // o Returns %rd of UPVAR instruction in pFun for pVar-> // Register* ClParser::internVarCell(Variable* pVar) { Register* pCell = ir_find_variable(GetFunction(), pVar); if (NULL == pCell) { pCell = new Register(); Function* pUser = GetFunction(); ir_insert_insn( new UpVarDefInsn(pCell, pVar), pUser->GetEntryInsn()->GetNext() ); } // if return pCell; } // ClParser::internVarCell
Var * DiagNativeStackFrame::GetSlotOffsetLocation(RegSlot slotId, bool allowTemp) { Assert(GetFunction() != NULL); int32 slotOffset; if (GetFunction()->GetSlotOffset(slotId, &slotOffset, allowTemp)) { Assert(m_localVarSlotsOffset != InvalidOffset); slotOffset = m_localVarSlotsOffset + slotOffset; // We will have the var offset only (which is always the Var size. With TypeSpecialization, below will change to accommodate double offset. return (Js::Var *)(((char *)m_stackAddr) + slotOffset); } Assert(false); return NULL; }
static void body (LexState *ls, expdesc *e, int needself, int line) { /* body -> `(' parlist `)' chunk END */ #ifdef LUA_UTILITIES_NET char szFuncName1[256]; char szFuncName2[256]; #endif FuncState new_fs; open_func(ls, &new_fs); new_fs.f->linedefined = line; #ifdef LUA_UTILITIES_NET szFuncName1[0] = 0; szFuncName2[0] = 0; TryGetFunctionName(ls->t.seminfo.ts, szFuncName1, 256); #endif checknext(ls, '('); if (needself) { new_localvarliteral(ls, "self", 0); adjustlocalvars(ls, 1); } parlist(ls); checknext(ls, ')'); chunk(ls); #ifdef LUA_UTILITIES_NET if (szFuncName1[0] == 0) TryGetFunctionName(ls->t.seminfo.ts, szFuncName2, 256); #endif new_fs.f->lastlinedefined = ls->linenumber; check_match(ls, TK_END, TK_FUNCTION, line); close_func(ls); #ifdef LUA_UTILITIES_NET // Use the correct function name based on values obtained if (szFuncName1[0] == 0) GetFunction(szFuncName2, ls, new_fs.f); else GetFunction(szFuncName1, ls, new_fs.f); #endif pushclosure(ls, &new_fs, e); }
void n32016_build_matrix() { uint32_t Index; for (Index = 0; Index < 256; Index++) { FunctionLookup[Index] = GetFunction(Index); } }
/* ============ idScriptObject::CallEvent ============ */ void idScriptObject::CallEvent( const char* name ) { const sdProgram::sdFunction* function = GetFunction( name ); if ( function == NULL ) { return; } sdScriptHelper h1; CallNonBlockingScriptEvent( function, h1 ); }
gmThread::State gmThread::Sys_PopStackFrame(const gmuint8 * &a_ip, const gmuint8 * &a_cp) { if(m_frame == NULL) { m_machine->GetLog().LogEntry("stack underflow"); return SYS_EXCEPTION; } // Write barrier old local objects { gmGarbageCollector* gc = m_machine->GetGC(); if( !gc->IsOff() ) { for(int index = m_base-2; index < m_top; ++index) { if(m_stack[index].IsReference()) { gmObject * object = GM_MOBJECT(m_machine, m_stack[index].m_value.m_ref); gc->WriteBarrier(object); } } } } gmStackFrame * frame = m_frame->m_prev; if( frame == NULL ) // Final frame, we will exit now { return KILLED; // Don't clean up stack, let the machine reset it as state changes to killed (so Exit callback can examine valid thread contents) } a_ip = m_frame->m_returnAddress; // Copy old tos to new tos m_stack[m_base - 2] = m_stack[m_top - 1]; m_top = m_base - 1; m_base = m_frame->m_returnBase; m_machine->Sys_FreeStackFrame(m_frame); m_frame = frame; // Update instruction and code pointers GM_ASSERT(GetFunction()->m_type == GM_FUNCTION); gmFunctionObject * fn = (gmFunctionObject *) GM_MOBJECT(m_machine, GetFunction()->m_value.m_ref); a_cp = (const gmuint8 *) fn->GetByteCode(); return RUNNING; }
Engine::Engine(void* moduleHandle) { m_End = false; m_GuiLib = LoadLib(".\\bin\\Debug\\Sentiment_SFMLGui"); if(m_GuiLib != nullptr) { GUI_CONSTRUCTOR GuiConstructor = (GUI_CONSTRUCTOR) GetFunction(m_GuiLib, "CreateGui"); if(GuiConstructor != nullptr) GuiConstructor(m_GuiManager); else throw std::runtime_error("Could not find token 'CreateGui' in Sentiment_SFMLGui.dll"); } else throw std::runtime_error("Could not open Sentiment_SFMLGui.dll"); m_RenderLib = LoadLib(".\\bin\\Debug\\Sentiment_OGL4-3Renderer"); if(m_RenderLib != nullptr) { RENDERER_CONSTRUCTOR renderConstructor = (RENDERER_CONSTRUCTOR) GetFunction(m_RenderLib, "CreateRendererAndUtility"); if(renderConstructor != nullptr) renderConstructor(m_Renderer, m_RenderUtility); else throw std::runtime_error("Could not find token 'CreateRendererAndUtility' in Sentiment_OGL4-3Renderer.dll"); } else throw std::runtime_error("could not open Sentiment_OGL4-3Renderer"); m_GameLib = LoadLib(".\\bin\\Debug\\game"); if(m_GameLib != nullptr) { GAME_CONSTRUCTOR gameConstructor = (GAME_CONSTRUCTOR) GetFunction(m_GameLib, "CreateGame"); if(gameConstructor != nullptr) gameConstructor(m_Game, this); else throw std::runtime_error("Could not find token 'CreateGame' in game.dll"); } else throw std::runtime_error("Could not open game.dll"); m_Game->Initialize(); m_Game->Activate(); }
void Plugin::Draw() { if(m_library) { if(!m_DrawFunc) m_DrawFunc = GetFunction("Render"); if(m_DrawFunc) m_DrawFunc(); } }
void Plugin::Update() { if(m_library) { if(!m_UpdateFunc) m_UpdateFunc = GetFunction("UpdatePlugin"); if(m_UpdateFunc) m_UpdateFunc(); } }
CLuaCFunction* CLuaCFunctions::AddFunction ( const char* szName, lua_CFunction f, bool bRestricted ) { ms_pFunctionPtrLow = Min < void* > ( ms_pFunctionPtrLow, (void*)f ); ms_pFunctionPtrHigh = Max < void* > ( ms_pFunctionPtrHigh, (void*)f ); // Already have a function by this name? CLuaCFunction* pFunction = GetFunction ( szName ); if ( pFunction ) return pFunction; // Already have a function by this address? pFunction = GetFunction ( f ); if ( !pFunction ) { pFunction = new CLuaCFunction ( szName, f, bRestricted ); ms_Functions [ f ] = pFunction; } ms_FunctionsByName [ szName ] = pFunction; return pFunction; }
bool ScriptFile::Execute(const String& declaration, const VariantVector& parameters, bool unprepare) { asIScriptFunction* function = GetFunction(declaration); if (!function) { LOGERROR("Function " + declaration + " not found in " + GetName()); return false; } return Execute(function, parameters, unprepare); }
USERFCN2 Problem::GetUserFunction2() { // load in the library function and cast appropriately before returning DOMElement* subroutineXML = GetSubroutineXML(); string fEval = XMLString::transcode(subroutineXML->getAttribute(XMLString::transcode("FEval"))); string libName = XMLString::transcode(subroutineXML->getAttribute(XMLString::transcode("LibName"))); void* function = GetFunction(libName, fEval); return (USERFCN2) function; }
INITFCN Problem::GetInitFunction() { // load in the library function and cast appropriately before returning DOMElement* subroutineXML = GetSubroutineXML(); string init = XMLString::transcode(subroutineXML->getAttribute(XMLString::transcode("Init"))); string libName = XMLString::transcode(subroutineXML->getAttribute(XMLString::transcode("LibName"))); void* function = GetFunction(libName, init); return (INITFCN) function; }