UNLOZE/sourcemod
10
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Modernize engine2.* style.

Browse Source
This commit is contained in:
dvander@alliedmods.net 2015-02-23 12:49:26 -08:00
parent 0100ebadb9
commit 10d778e344
2 changed files with 234 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

291
sourcepawn/jit/engine2.cpp
View File

@ -1,4 +1,15 @@
// vim: set ts=4 sw=4 tw=99 noet: // vim: set sts=2 ts=8 sw=2 tw=99 noet:
//
// Copyright (C) 2006-2015 AlliedModders LLC
//
// This file is part of SourcePawn. SourcePawn is free software: you can
// redistribute it and/or modify it under the terms of the GNU General Public
// License as published by the Free Software Foundation, either version 3 of
// the License, or (at your option) any later version.
//
// You should have received a copy of the GNU General Public License along with
// SourcePawn. If not, see http://www.gnu.org/licenses/.
//
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
@ -14,202 +25,208 @@ using namespace SourcePawn;
SourcePawnEngine2::SourcePawnEngine2() SourcePawnEngine2::SourcePawnEngine2()
{ {
profiler_ = NULL; profiler_ = NULL;
jit_enabled_ = true; jit_enabled_ = true;
} }
IPluginRuntime *SourcePawnEngine2::LoadPlugin(ICompilation *co, const char *file, int *err) IPluginRuntime *
SourcePawnEngine2::LoadPlugin(ICompilation *co, const char *file, int *err)
{ {
sp_file_hdr_t hdr; sp_file_hdr_t hdr;
uint8_t *base; uint8_t *base;
int z_result; int z_result;
int error; int error;
size_t ignore; size_t ignore;
BaseRuntime *pRuntime; BaseRuntime *pRuntime;
FILE *fp = fopen(file, "rb"); FILE *fp = fopen(file, "rb");
if (!fp) if (!fp) {
{ error = SP_ERROR_NOT_FOUND;
error = SP_ERROR_NOT_FOUND; goto return_error;
goto return_error; }
}
/* Rewind for safety */ /* Rewind for safety */
ignore = fread(&hdr, sizeof(sp_file_hdr_t), 1, fp); ignore = fread(&hdr, sizeof(sp_file_hdr_t), 1, fp);
if (hdr.magic != SmxConsts::FILE_MAGIC) if (hdr.magic != SmxConsts::FILE_MAGIC) {
{ error = SP_ERROR_FILE_FORMAT;
error = SP_ERROR_FILE_FORMAT; goto return_error;
goto return_error; }
}
switch (hdr.compression) switch (hdr.compression)
{ {
case SmxConsts::FILE_COMPRESSION_GZ: case SmxConsts::FILE_COMPRESSION_GZ:
{ {
uint32_t uncompsize = hdr.imagesize - hdr.dataoffs; uint32_t uncompsize = hdr.imagesize - hdr.dataoffs;
uint32_t compsize = hdr.disksize - hdr.dataoffs; uint32_t compsize = hdr.disksize - hdr.dataoffs;
uint32_t sectsize = hdr.dataoffs - sizeof(sp_file_hdr_t); uint32_t sectsize = hdr.dataoffs - sizeof(sp_file_hdr_t);
uLongf destlen = uncompsize; uLongf destlen = uncompsize;
char *tempbuf = (char *)malloc(compsize); char *tempbuf = (char *)malloc(compsize);
void *uncompdata = malloc(uncompsize); void *uncompdata = malloc(uncompsize);
void *sectheader = malloc(sectsize); void *sectheader = malloc(sectsize);
ignore = fread(sectheader, sectsize, 1, fp); ignore = fread(sectheader, sectsize, 1, fp);
ignore = fread(tempbuf, compsize, 1, fp); ignore = fread(tempbuf, compsize, 1, fp);
z_result = uncompress((Bytef *)uncompdata, &destlen, (Bytef *)tempbuf, compsize); z_result = uncompress((Bytef *)uncompdata, &destlen, (Bytef *)tempbuf, compsize);
free(tempbuf); free(tempbuf);
if (z_result != Z_OK) if (z_result != Z_OK)
{ {
free(sectheader); free(sectheader);
free(uncompdata); free(uncompdata);
error = SP_ERROR_DECOMPRESSOR; error = SP_ERROR_DECOMPRESSOR;
goto return_error; goto return_error;
} }
base = (uint8_t *)malloc(hdr.imagesize); base = (uint8_t *)malloc(hdr.imagesize);
memcpy(base, &hdr, sizeof(sp_file_hdr_t)); memcpy(base, &hdr, sizeof(sp_file_hdr_t));
memcpy(base + sizeof(sp_file_hdr_t), sectheader, sectsize); memcpy(base + sizeof(sp_file_hdr_t), sectheader, sectsize);
free(sectheader); free(sectheader);
memcpy(base + hdr.dataoffs, uncompdata, uncompsize); memcpy(base + hdr.dataoffs, uncompdata, uncompsize);
free(uncompdata); free(uncompdata);
break; break;
} }
case SmxConsts::FILE_COMPRESSION_NONE: case SmxConsts::FILE_COMPRESSION_NONE:
{ {
base = (uint8_t *)malloc(hdr.imagesize); base = (uint8_t *)malloc(hdr.imagesize);
rewind(fp); rewind(fp);
ignore = fread(base, hdr.imagesize, 1, fp); ignore = fread(base, hdr.imagesize, 1, fp);
break; break;
} }
default: default:
{ {
error = SP_ERROR_DECOMPRESSOR; error = SP_ERROR_DECOMPRESSOR;
goto return_error; goto return_error;
} }
} }
pRuntime = new BaseRuntime(); pRuntime = new BaseRuntime();
if ((error = pRuntime->CreateFromMemory(&hdr, base)) != SP_ERROR_NONE) if ((error = pRuntime->CreateFromMemory(&hdr, base)) != SP_ERROR_NONE) {
{ delete pRuntime;
delete pRuntime; goto return_error;
goto return_error; }
}
size_t len; size_t len;
len = strlen(file); len = strlen(file);
for (size_t i = len - 1; i < len; i--) for (size_t i = len - 1; i < len; i--)
{ {
if (file[i] == '/' if (file[i] == '/'
#if defined WIN32 #if defined WIN32
|| file[i] == '\\' || file[i] == '\\'
#endif #endif
) )
{ {
pRuntime->SetName(&file[i+1]); pRuntime->SetName(&file[i+1]);
break; break;
} }
} }
(void)ignore; (void)ignore;
if (!pRuntime->plugin()->name) if (!pRuntime->plugin()->name)
{ pRuntime->SetName(file);
pRuntime->SetName(file);
}
pRuntime->ApplyCompilationOptions(co); pRuntime->ApplyCompilationOptions(co);
fclose(fp); fclose(fp);
return pRuntime; return pRuntime;
return_error: return_error:
*err = error; *err = error;
if (fp != NULL) if (fp != NULL)
{ {
fclose(fp); fclose(fp);
} }
return NULL; return NULL;
} }
SPVM_NATIVE_FUNC SourcePawnEngine2::CreateFakeNative(SPVM_FAKENATIVE_FUNC callback, void *pData) SPVM_NATIVE_FUNC
SourcePawnEngine2::CreateFakeNative(SPVM_FAKENATIVE_FUNC callback, void *pData)
{ {
return g_Jit.CreateFakeNative(callback, pData); return g_Jit.CreateFakeNative(callback, pData);
} }
void SourcePawnEngine2::DestroyFakeNative(SPVM_NATIVE_FUNC func) void
SourcePawnEngine2::DestroyFakeNative(SPVM_NATIVE_FUNC func)
{ {
g_Jit.DestroyFakeNative(func); g_Jit.DestroyFakeNative(func);
} }
const char *SourcePawnEngine2::GetEngineName() const char *
SourcePawnEngine2::GetEngineName()
{ {
return "SourcePawn 1.7, jit-x86"; return "SourcePawn 1.7, jit-x86";
} }
const char *SourcePawnEngine2::GetVersionString() const char *
SourcePawnEngine2::GetVersionString()
{ {
return SOURCEMOD_VERSION; return SOURCEMOD_VERSION;
} }
IDebugListener *SourcePawnEngine2::SetDebugListener(IDebugListener *listener) IDebugListener *
SourcePawnEngine2::SetDebugListener(IDebugListener *listener)
{ {
return g_engine1.SetDebugListener(listener); return g_engine1.SetDebugListener(listener);
} }
unsigned int SourcePawnEngine2::GetAPIVersion() unsigned int
SourcePawnEngine2::GetAPIVersion()
{ {
return SOURCEPAWN_ENGINE2_API_VERSION; return SOURCEPAWN_ENGINE2_API_VERSION;
} }
ICompilation *SourcePawnEngine2::StartCompilation() ICompilation *
SourcePawnEngine2::StartCompilation()
{ {
return g_Jit.StartCompilation(); return g_Jit.StartCompilation();
} }
const char *SourcePawnEngine2::GetErrorString(int err) const char *
SourcePawnEngine2::GetErrorString(int err)
{ {
return g_engine1.GetErrorString(err); return g_engine1.GetErrorString(err);
} }
bool SourcePawnEngine2::Initialize() bool
SourcePawnEngine2::Initialize()
{ {
return g_Jit.InitializeJIT(); return g_Jit.InitializeJIT();
} }
void SourcePawnEngine2::Shutdown() void
SourcePawnEngine2::Shutdown()
{ {
g_WatchdogTimer.Shutdown(); g_WatchdogTimer.Shutdown();
g_Jit.ShutdownJIT(); g_Jit.ShutdownJIT();
} }
IPluginRuntime *SourcePawnEngine2::CreateEmptyRuntime(const char *name, uint32_t memory) IPluginRuntime *
SourcePawnEngine2::CreateEmptyRuntime(const char *name, uint32_t memory)
{ {
int err; int err;
BaseRuntime *rt;
rt = new BaseRuntime(); BaseRuntime *rt = new BaseRuntime();
if ((err = rt->CreateBlank(memory)) != SP_ERROR_NONE) if ((err = rt->CreateBlank(memory)) != SP_ERROR_NONE) {
{ delete rt;
delete rt; return NULL;
return NULL; }
}
rt->SetName(name != NULL ? name : "<anonymous>"); rt->SetName(name != NULL ? name : "<anonymous>");
rt->ApplyCompilationOptions(NULL); rt->ApplyCompilationOptions(NULL);
return rt; return rt;
} }
bool SourcePawnEngine2::InstallWatchdogTimer(size_t timeout_ms) bool
SourcePawnEngine2::InstallWatchdogTimer(size_t timeout_ms)
{ {
return g_WatchdogTimer.Initialize(timeout_ms); return g_WatchdogTimer.Initialize(timeout_ms);
} }

146
sourcepawn/jit/engine2.h
View File

@ -1,86 +1,100 @@
// vim: set ts=4 sw=4 tw=99 noet: // vim: set sts=2 ts=8 sw=2 tw=99 noet:
//
// Copyright (C) 2006-2015 AlliedModders LLC
//
// This file is part of SourcePawn. SourcePawn is free software: you can
// redistribute it and/or modify it under the terms of the GNU General Public
// License as published by the Free Software Foundation, either version 3 of
// the License, or (at your option) any later version.
//
// You should have received a copy of the GNU General Public License along with
// SourcePawn. If not, see http://www.gnu.org/licenses/.
//
#ifndef _INCLUDE_SOURCEPAWN_ENGINE_2_H_ #ifndef _INCLUDE_SOURCEPAWN_ENGINE_2_H_
#define _INCLUDE_SOURCEPAWN_ENGINE_2_H_ #define _INCLUDE_SOURCEPAWN_ENGINE_2_H_
#include <sp_vm_api.h> #include <sp_vm_api.h>
namespace SourcePawn namespace SourcePawn {
/**
* @brief Outlines the interface a Virtual Machine (JIT) must expose
*/
class SourcePawnEngine2 : public ISourcePawnEngine2
{ {
/** public:
* @brief Outlines the interface a Virtual Machine (JIT) must expose SourcePawnEngine2();
*/
class SourcePawnEngine2 : public ISourcePawnEngine2
{
public:
SourcePawnEngine2();
public:
unsigned int GetAPIVersion();
const char *GetEngineName();
const char *GetVersionString();
IPluginRuntime *LoadPlugin(ICompilation *co, const char *file, int *err);
SPVM_NATIVE_FUNC CreateFakeNative(SPVM_FAKENATIVE_FUNC callback, void *pData);
void DestroyFakeNative(SPVM_NATIVE_FUNC func);
IDebugListener *SetDebugListener(IDebugListener *listener);
ICompilation *StartCompilation();
const char *GetErrorString(int err);
bool Initialize();
void Shutdown();
IPluginRuntime *CreateEmptyRuntime(const char *name, uint32_t memory);
bool InstallWatchdogTimer(size_t timeout_ms);
bool SetJitEnabled(bool enabled) { public:
jit_enabled_ = enabled; unsigned int GetAPIVersion();
return true; const char *GetEngineName();
} const char *GetVersionString();
IPluginRuntime *LoadPlugin(ICompilation *co, const char *file, int *err);
SPVM_NATIVE_FUNC CreateFakeNative(SPVM_FAKENATIVE_FUNC callback, void *pData);
void DestroyFakeNative(SPVM_NATIVE_FUNC func);
IDebugListener *SetDebugListener(IDebugListener *listener);
ICompilation *StartCompilation();
const char *GetErrorString(int err);
bool Initialize();
void Shutdown();
IPluginRuntime *CreateEmptyRuntime(const char *name, uint32_t memory);
bool InstallWatchdogTimer(size_t timeout_ms);
bool IsJitEnabled() { bool SetJitEnabled(bool enabled) {
return jit_enabled_; jit_enabled_ = enabled;
} return true;
}
void SetProfiler(IProfiler *profiler) { bool IsJitEnabled() {
// Deprecated. return jit_enabled_;
} }
void EnableProfiling() { void SetProfiler(IProfiler *profiler) {
profiling_enabled_ = !!profiler_; // Deprecated.
} }
void DisableProfiling() {
profiling_enabled_ = false;
}
bool IsProfilingEnabled() {
return profiling_enabled_;
}
void SetProfilingTool(IProfilingTool *tool) {
profiler_ = tool;
}
public: void EnableProfiling() {
IProfilingTool *GetProfiler() { profiling_enabled_ = !!profiler_;
return profiler_; }
} void DisableProfiling() {
private: profiling_enabled_ = false;
IProfilingTool *profiler_; }
bool jit_enabled_; bool IsProfilingEnabled() {
bool profiling_enabled_; return profiling_enabled_;
}; }
} void SetProfilingTool(IProfilingTool *tool) {
profiler_ = tool;
}
public:
IProfilingTool *GetProfiler() {
return profiler_;
}
private:
IProfilingTool *profiler_;
bool jit_enabled_;
bool profiling_enabled_;
};
} // namespace SourcePawn
extern SourcePawn::SourcePawnEngine2 g_engine2; extern SourcePawn::SourcePawnEngine2 g_engine2;
class EnterProfileScope class EnterProfileScope
{ {
public: public:
EnterProfileScope(const char *group, const char *name) EnterProfileScope(const char *group, const char *name)
{ {
if (g_engine2.IsProfilingEnabled()) if (g_engine2.IsProfilingEnabled())
g_engine2.GetProfiler()->EnterScope(group, name); g_engine2.GetProfiler()->EnterScope(group, name);
} }
~EnterProfileScope() ~EnterProfileScope()
{ {
if (g_engine2.IsProfilingEnabled()) if (g_engine2.IsProfilingEnabled())
g_engine2.GetProfiler()->LeaveScope(); g_engine2.GetProfiler()->LeaveScope();
} }
}; };
#endif //_INCLUDE_SOURCEPAWN_ENGINE_2_H_ #endif //_INCLUDE_SOURCEPAWN_ENGINE_2_H_