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

Merge pull request #270 from alliedmodders/modernize-vm-style

Browse Source 
Modernize sourcepawn/jit style.
This commit is contained in:
David Anderson 2015-02-23 14:38:28 -08:00
commit 7d64ade621
8 changed files with 1382 additions and 1497 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

80
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 et:
//
// 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 <stdlib.h>
#include <string.h>
@ -18,27 +29,27 @@ SourcePawnEngine2::SourcePawnEngine2()
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;
uint8_t *base;
int z_result;
int error;
size_t ignore;
BaseRuntime *pRuntime;
FILE *fp = fopen(file, "rb");
if (!fp)
{
if (!fp) {
error = SP_ERROR_NOT_FOUND;
goto return_error;
}
/* Rewind for safety */
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;
goto return_error;
}
@ -56,8 +67,8 @@ IPluginRuntime *SourcePawnEngine2::LoadPlugin(ICompilation *co, const char *file
void *uncompdata = malloc(uncompsize);
void *sectheader = malloc(sectsize);
fread(sectheader, sectsize, 1, fp);
fread(tempbuf, compsize, 1, fp);
ignore = fread(sectheader, sectsize, 1, fp);
ignore = fread(tempbuf, compsize, 1, fp);
z_result = uncompress((Bytef *)uncompdata, &destlen, (Bytef *)tempbuf, compsize);
free(tempbuf);
@ -81,7 +92,7 @@ IPluginRuntime *SourcePawnEngine2::LoadPlugin(ICompilation *co, const char *file
{
base = (uint8_t *)malloc(hdr.imagesize);
rewind(fp);
fread(base, hdr.imagesize, 1, fp);
ignore = fread(base, hdr.imagesize, 1, fp);
break;
}
default:
@ -92,8 +103,7 @@ IPluginRuntime *SourcePawnEngine2::LoadPlugin(ICompilation *co, const char *file
}
pRuntime = new BaseRuntime();
if ((error = pRuntime->CreateFromMemory(&hdr, base)) != SP_ERROR_NONE)
{
if ((error = pRuntime->CreateFromMemory(&hdr, base)) != SP_ERROR_NONE) {
delete pRuntime;
goto return_error;
}
@ -114,10 +124,10 @@ IPluginRuntime *SourcePawnEngine2::LoadPlugin(ICompilation *co, const char *file
}
}
(void)ignore;
if (!pRuntime->plugin()->name)
{
pRuntime->SetName(file);
}
pRuntime->ApplyCompilationOptions(co);
@ -135,65 +145,74 @@ return_error:
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);
}
void SourcePawnEngine2::DestroyFakeNative(SPVM_NATIVE_FUNC func)
void
SourcePawnEngine2::DestroyFakeNative(SPVM_NATIVE_FUNC func)
{
g_Jit.DestroyFakeNative(func);
}
const char *SourcePawnEngine2::GetEngineName()
const char *
SourcePawnEngine2::GetEngineName()
{
return "SourcePawn 1.7, jit-x86";
}
const char *SourcePawnEngine2::GetVersionString()
const char *
SourcePawnEngine2::GetVersionString()
{
return SOURCEMOD_VERSION;
}
IDebugListener *SourcePawnEngine2::SetDebugListener(IDebugListener *listener)
IDebugListener *
SourcePawnEngine2::SetDebugListener(IDebugListener *listener)
{
return g_engine1.SetDebugListener(listener);
}
unsigned int SourcePawnEngine2::GetAPIVersion()
unsigned int
SourcePawnEngine2::GetAPIVersion()
{
return SOURCEPAWN_ENGINE2_API_VERSION;
}
ICompilation *SourcePawnEngine2::StartCompilation()
ICompilation *
SourcePawnEngine2::StartCompilation()
{
return g_Jit.StartCompilation();
}
const char *SourcePawnEngine2::GetErrorString(int err)
const char *
SourcePawnEngine2::GetErrorString(int err)
{
return g_engine1.GetErrorString(err);
}
bool SourcePawnEngine2::Initialize()
bool
SourcePawnEngine2::Initialize()
{
return g_Jit.InitializeJIT();
}
void SourcePawnEngine2::Shutdown()
void
SourcePawnEngine2::Shutdown()
{
g_WatchdogTimer.Shutdown();
g_Jit.ShutdownJIT();
}
IPluginRuntime *SourcePawnEngine2::CreateEmptyRuntime(const char *name, uint32_t memory)
IPluginRuntime *
SourcePawnEngine2::CreateEmptyRuntime(const char *name, uint32_t memory)
{
int err;
BaseRuntime *rt;
rt = new BaseRuntime();
if ((err = rt->CreateBlank(memory)) != SP_ERROR_NONE)
{
BaseRuntime *rt = new BaseRuntime();
if ((err = rt->CreateBlank(memory)) != SP_ERROR_NONE) {
delete rt;
return NULL;
}
@ -205,7 +224,8 @@ IPluginRuntime *SourcePawnEngine2::CreateEmptyRuntime(const char *name, uint32_t
return rt;
}
bool SourcePawnEngine2::InstallWatchdogTimer(size_t timeout_ms)
bool
SourcePawnEngine2::InstallWatchdogTimer(size_t timeout_ms)
{
return g_WatchdogTimer.Initialize(timeout_ms);
}

32
sourcepawn/jit/engine2.h
View File

@ -1,18 +1,30 @@
// vim: set ts=4 sw=4 tw=99 noet:
// vim: set sts=2 ts=8 sw=2 tw=99 et:
//
// 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_
#define _INCLUDE_SOURCEPAWN_ENGINE_2_H_
#include <sp_vm_api.h>
namespace SourcePawn
{
/**
namespace SourcePawn {
/**
* @brief Outlines the interface a Virtual Machine (JIT) must expose
*/
class SourcePawnEngine2 : public ISourcePawnEngine2
{
class SourcePawnEngine2 : public ISourcePawnEngine2
{
public:
SourcePawnEngine2();
public:
unsigned int GetAPIVersion();
const char *GetEngineName();
@ -58,18 +70,20 @@ namespace SourcePawn
IProfilingTool *GetProfiler() {
return profiler_;
}
private:
IProfilingTool *profiler_;
bool jit_enabled_;
bool profiling_enabled_;
};
}
};
} // namespace SourcePawn
extern SourcePawn::SourcePawnEngine2 g_engine2;
class EnterProfileScope
{
public:
public:
EnterProfileScope(const char *group, const char *name)
{
if (g_engine2.IsProfilingEnabled())

366
sourcepawn/jit/sp_vm_basecontext.cpp
View File

@ -1,34 +1,15 @@
/**
* vim: set ts=4 sw=4 tw=99 noet:
* =============================================================================
* SourcePawn
* Copyright (C) 2004-2008 AlliedModders LLC. All rights reserved.
* =============================================================================
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License, version 3.0, as published by the
* Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, AlliedModders LLC gives you permission to link the
* code of this program (as well as its derivative works) to "Half-Life 2," the
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
* by the Valve Corporation. You must obey the GNU General Public License in
* all respects for all other code used. Additionally, AlliedModders LLC grants
* this exception to all derivative works. AlliedModders LLC defines further
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
* or <http://www.sourcemod.net/license.php>.
*
* Version: $Id$
*/
// vim: set sts=2 ts=8 sw=2 tw=99 et:
//
// 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 <string.h>
#include <stdarg.h>
#include <assert.h>
@ -55,25 +36,19 @@ BaseContext::BaseContext(BaseRuntime *pRuntime)
/* Initialize the null references */
uint32_t index;
if (FindPubvarByName("NULL_VECTOR", &index) == SP_ERROR_NONE)
{
if (FindPubvarByName("NULL_VECTOR", &index) == SP_ERROR_NONE) {
sp_pubvar_t *pubvar;
GetPubvarByIndex(index, &pubvar);
m_pNullVec = pubvar->offs;
}
else
{
} else {
m_pNullVec = NULL;
}
if (FindPubvarByName("NULL_STRING", &index) == SP_ERROR_NONE)
{
if (FindPubvarByName("NULL_STRING", &index) == SP_ERROR_NONE) {
sp_pubvar_t *pubvar;
GetPubvarByIndex(index, &pubvar);
m_pNullString = pubvar->offs;
}
else
{
} else {
m_pNullString = NULL;
}
@ -92,49 +67,58 @@ BaseContext::~BaseContext()
g_Jit.FreeContextVars(&m_ctx);
}
IVirtualMachine *BaseContext::GetVirtualMachine()
IVirtualMachine *
BaseContext::GetVirtualMachine()
{
return NULL;
}
sp_context_t *BaseContext::GetContext()
sp_context_t *
BaseContext::GetContext()
{
return reinterpret_cast<sp_context_t *>((IPluginContext * )this);
}
sp_context_t *BaseContext::GetCtx()
sp_context_t *
BaseContext::GetCtx()
{
return &m_ctx;
}
bool BaseContext::IsDebugging()
bool
BaseContext::IsDebugging()
{
return true;
}
int BaseContext::SetDebugBreak(void *newpfn, void *oldpfn)
int
BaseContext::SetDebugBreak(void *newpfn, void *oldpfn)
{
return SP_ERROR_ABORTED;
}
IPluginDebugInfo *BaseContext::GetDebugInfo()
IPluginDebugInfo *
BaseContext::GetDebugInfo()
{
return NULL;
}
int BaseContext::Execute(uint32_t code_addr, cell_t *result)
int
BaseContext::Execute(uint32_t code_addr, cell_t *result)
{
return SP_ERROR_ABORTED;
}
void BaseContext::SetErrorMessage(const char *msg, va_list ap)
void
BaseContext::SetErrorMessage(const char *msg, va_list ap)
{
m_CustomMsg = true;
vsnprintf(m_MsgCache, sizeof(m_MsgCache), msg, ap);
}
void BaseContext::_SetErrorMessage(const char *msg, ...)
void
BaseContext::_SetErrorMessage(const char *msg, ...)
{
va_list ap;
va_start(ap, msg);
@ -142,17 +126,15 @@ void BaseContext::_SetErrorMessage(const char *msg, ...)
va_end(ap);
}
cell_t BaseContext::ThrowNativeErrorEx(int error, const char *msg, ...)
cell_t
BaseContext::ThrowNativeErrorEx(int error, const char *msg, ...)
{
if (!m_InExec)
{
return 0;
}
m_ctx.n_err = error;
if (msg)
{
if (msg) {
va_list ap;
va_start(ap, msg);
SetErrorMessage(msg, ap);
@ -162,17 +144,15 @@ cell_t BaseContext::ThrowNativeErrorEx(int error, const char *msg, ...)
return 0;
}
cell_t BaseContext::ThrowNativeError(const char *msg, ...)
cell_t
BaseContext::ThrowNativeError(const char *msg, ...)
{
if (!m_InExec)
{
return 0;
}
m_ctx.n_err = SP_ERROR_NATIVE;
if (msg)
{
if (msg) {
va_list ap;
va_start(ap, msg);
SetErrorMessage(msg, ap);
@ -182,7 +162,8 @@ cell_t BaseContext::ThrowNativeError(const char *msg, ...)
return 0;
}
int BaseContext::HeapAlloc(unsigned int cells, cell_t *local_addr, cell_t **phys_addr)
int
BaseContext::HeapAlloc(unsigned int cells, cell_t *local_addr, cell_t **phys_addr)
{
cell_t *addr;
ucell_t realmem;
@ -202,9 +183,7 @@ int BaseContext::HeapAlloc(unsigned int cells, cell_t *local_addr, cell_t **phys
* Check if the space between the heap and stack is sufficient.
*/
if ((cell_t)(m_ctx.sp - m_ctx.hp - realmem) < STACKMARGIN)
{
return SP_ERROR_HEAPLOW;
}
addr = (cell_t *)(m_pRuntime->plugin()->memory + m_ctx.hp);
/* store size of allocation in cells */
@ -215,16 +194,15 @@ int BaseContext::HeapAlloc(unsigned int cells, cell_t *local_addr, cell_t **phys
*local_addr = m_ctx.hp;
if (phys_addr)
{
*phys_addr = addr;
}
m_ctx.hp += realmem;
return SP_ERROR_NONE;
}
int BaseContext::HeapPop(cell_t local_addr)
int
BaseContext::HeapPop(cell_t local_addr)
{
cell_t cellcount;
cell_t *addr;
@ -232,17 +210,13 @@ int BaseContext::HeapPop(cell_t local_addr)
/* check the bounds of this address */
local_addr -= sizeof(cell_t);
if (local_addr < (cell_t)m_pRuntime->plugin()->data_size || local_addr >= m_ctx.sp)
{
return SP_ERROR_INVALID_ADDRESS;
}
addr = (cell_t *)(m_pRuntime->plugin()->memory + local_addr);
cellcount = (*addr) * sizeof(cell_t);
/* check if this memory count looks valid */
if ((signed)(m_ctx.hp - cellcount - sizeof(cell_t)) != local_addr)
{
return SP_ERROR_INVALID_ADDRESS;
}
m_ctx.hp = local_addr;
@ -250,124 +224,139 @@ int BaseContext::HeapPop(cell_t local_addr)
}
int BaseContext::HeapRelease(cell_t local_addr)
int
BaseContext::HeapRelease(cell_t local_addr)
{
if (local_addr < (cell_t)m_pRuntime->plugin()->data_size)
{
return SP_ERROR_INVALID_ADDRESS;
}
m_ctx.hp = local_addr - sizeof(cell_t);
return SP_ERROR_NONE;
}
int BaseContext::FindNativeByName(const char *name, uint32_t *index)
int
BaseContext::FindNativeByName(const char *name, uint32_t *index)
{
return m_pRuntime->FindNativeByName(name, index);
}
int BaseContext::GetNativeByIndex(uint32_t index, sp_native_t **native)
int
BaseContext::GetNativeByIndex(uint32_t index, sp_native_t **native)
{
return m_pRuntime->GetNativeByIndex(index, native);
}
uint32_t BaseContext::GetNativesNum()
uint32_t
BaseContext::GetNativesNum()
{
return m_pRuntime->GetNativesNum();
}
int BaseContext::FindPublicByName(const char *name, uint32_t *index)
int
BaseContext::FindPublicByName(const char *name, uint32_t *index)
{
return m_pRuntime->FindPublicByName(name, index);
}
int BaseContext::GetPublicByIndex(uint32_t index, sp_public_t **pblic)
int
BaseContext::GetPublicByIndex(uint32_t index, sp_public_t **pblic)
{
return m_pRuntime->GetPublicByIndex(index, pblic);
}
uint32_t BaseContext::GetPublicsNum()
uint32_t
BaseContext::GetPublicsNum()
{
return m_pRuntime->GetPublicsNum();
}
int BaseContext::GetPubvarByIndex(uint32_t index, sp_pubvar_t **pubvar)
int
BaseContext::GetPubvarByIndex(uint32_t index, sp_pubvar_t **pubvar)
{
return m_pRuntime->GetPubvarByIndex(index, pubvar);
}
int BaseContext::FindPubvarByName(const char *name, uint32_t *index)
int
BaseContext::FindPubvarByName(const char *name, uint32_t *index)
{
return m_pRuntime->FindPubvarByName(name, index);
}
int BaseContext::GetPubvarAddrs(uint32_t index, cell_t *local_addr, cell_t **phys_addr)
int
BaseContext::GetPubvarAddrs(uint32_t index, cell_t *local_addr, cell_t **phys_addr)
{
return m_pRuntime->GetPubvarAddrs(index, local_addr, phys_addr);
}
uint32_t BaseContext::GetPubVarsNum()
uint32_t
BaseContext::GetPubVarsNum()
{
return m_pRuntime->GetPubVarsNum();
}
int BaseContext::BindNatives(const sp_nativeinfo_t *natives, unsigned int num, int overwrite)
int
BaseContext::BindNatives(const sp_nativeinfo_t *natives, unsigned int num, int overwrite)
{
return SP_ERROR_ABORTED;
}
int BaseContext::BindNative(const sp_nativeinfo_t *native)
int
BaseContext::BindNative(const sp_nativeinfo_t *native)
{
return SP_ERROR_ABORTED;
}
int BaseContext::BindNativeToIndex(uint32_t index, SPVM_NATIVE_FUNC func)
int
BaseContext::BindNativeToIndex(uint32_t index, SPVM_NATIVE_FUNC func)
{
return SP_ERROR_ABORTED;
}
int BaseContext::BindNativeToAny(SPVM_NATIVE_FUNC native)
int
BaseContext::BindNativeToAny(SPVM_NATIVE_FUNC native)
{
return SP_ERROR_ABORTED;
}
int BaseContext::LocalToPhysAddr(cell_t local_addr, cell_t **phys_addr)
int
BaseContext::LocalToPhysAddr(cell_t local_addr, cell_t **phys_addr)
{
if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp))
|| (local_addr < 0) || ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size))
if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp)) ||
(local_addr < 0) || ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size))
{
return SP_ERROR_INVALID_ADDRESS;
}
if (phys_addr)
{
*phys_addr = (cell_t *)(m_pRuntime->plugin()->memory + local_addr);
}
return SP_ERROR_NONE;
}
int BaseContext::PushCell(cell_t value)
int
BaseContext::PushCell(cell_t value)
{
return SP_ERROR_ABORTED;
}
int BaseContext::PushCellsFromArray(cell_t array[], unsigned int numcells)
int
BaseContext::PushCellsFromArray(cell_t array[], unsigned int numcells)
{
return SP_ERROR_ABORTED;
}
int BaseContext::PushCellArray(cell_t *local_addr, cell_t **phys_addr, cell_t array[], unsigned int numcells)
int
BaseContext::PushCellArray(cell_t *local_addr, cell_t **phys_addr, cell_t array[], unsigned int numcells)
{
return SP_ERROR_ABORTED;
}
int BaseContext::LocalToString(cell_t local_addr, char **addr)
int
BaseContext::LocalToString(cell_t local_addr, char **addr)
{
if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp))
|| (local_addr < 0) || ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size))
if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp)) ||
(local_addr < 0) || ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size))
{
return SP_ERROR_INVALID_ADDRESS;
}
@ -376,34 +365,32 @@ int BaseContext::LocalToString(cell_t local_addr, char **addr)
return SP_ERROR_NONE;
}
int BaseContext::PushString(cell_t *local_addr, char **phys_addr, const char *string)
int
BaseContext::PushString(cell_t *local_addr, char **phys_addr, const char *string)
{
return SP_ERROR_ABORTED;
}
int BaseContext::StringToLocal(cell_t local_addr, size_t bytes, const char *source)
int
BaseContext::StringToLocal(cell_t local_addr, size_t bytes, const char *source)
{
char *dest;
size_t len;
if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp))
|| (local_addr < 0) || ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size))
if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp)) ||
(local_addr < 0) || ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size))
{
return SP_ERROR_INVALID_ADDRESS;
}
if (bytes == 0)
{
return SP_ERROR_NONE;
}
len = strlen(source);
dest = (char *)(m_pRuntime->plugin()->memory + local_addr);
if (len >= bytes)
{
len = bytes - 1;
}
memmove(dest, source, len);
dest[len] = '\0';
@ -411,15 +398,14 @@ int BaseContext::StringToLocal(cell_t local_addr, size_t bytes, const char *sour
return SP_ERROR_NONE;
}
inline int __CheckValidChar(char *c)
static inline int
__CheckValidChar(char *c)
{
int count;
int bytecount = 0;
for (count=1; (*c & 0xC0) == 0x80; count++)
{
c--;
}
switch (*c & 0xF0)
{
@ -442,109 +428,99 @@ inline int __CheckValidChar(char *c)
}
if (bytecount != count)
{
return count;
}
return 0;
}
int BaseContext::StringToLocalUTF8(cell_t local_addr, size_t maxbytes, const char *source, size_t *wrtnbytes)
int
BaseContext::StringToLocalUTF8(cell_t local_addr, size_t maxbytes, const char *source, size_t *wrtnbytes)
{
char *dest;
size_t len;
bool needtocheck = false;
if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp))
|| (local_addr < 0)
|| ((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size))
if (((local_addr >= m_ctx.hp) && (local_addr < m_ctx.sp)) ||
(local_addr < 0) ||
((ucell_t)local_addr >= m_pRuntime->plugin()->mem_size))
{
return SP_ERROR_INVALID_ADDRESS;
}
if (maxbytes == 0)
{
return SP_ERROR_NONE;
}
len = strlen(source);
dest = (char *)(m_pRuntime->plugin()->memory + local_addr);
if ((size_t)len >= maxbytes)
{
if ((size_t)len >= maxbytes) {
len = maxbytes - 1;
needtocheck = true;
}
memmove(dest, source, len);
if ((dest[len-1] & 1<<7) && needtocheck)
{
len -= __CheckValidChar(dest+len-1);
}
dest[len] = '\0';
if (wrtnbytes)
{
*wrtnbytes = len;
}
return SP_ERROR_NONE;
}
IPluginFunction *BaseContext::GetFunctionById(funcid_t func_id)
IPluginFunction *
BaseContext::GetFunctionById(funcid_t func_id)
{
return m_pRuntime->GetFunctionById(func_id);
}
IPluginFunction *BaseContext::GetFunctionByName(const char *public_name)
IPluginFunction *
BaseContext::GetFunctionByName(const char *public_name)
{
return m_pRuntime->GetFunctionByName(public_name);
}
int BaseContext::LocalToStringNULL(cell_t local_addr, char **addr)
int
BaseContext::LocalToStringNULL(cell_t local_addr, char **addr)
{
int err;
if ((err = LocalToString(local_addr, addr)) != SP_ERROR_NONE)
{
return err;
}
if ((cell_t *)*addr == m_pNullString)
{
*addr = NULL;
}
return SP_ERROR_NONE;
}
SourceMod::IdentityToken_t *BaseContext::GetIdentity()
SourceMod::IdentityToken_t *
BaseContext::GetIdentity()
{
SourceMod::IdentityToken_t *tok;
if (GetKey(1, (void **)&tok))
{
return tok;
}
return NULL;
}
cell_t *BaseContext::GetNullRef(SP_NULL_TYPE type)
cell_t *
BaseContext::GetNullRef(SP_NULL_TYPE type)
{
if (type == SP_NULL_VECTOR)
{
return m_pNullVec;
}
return NULL;
}
bool BaseContext::IsInExec()
bool
BaseContext::IsInExec()
{
return m_InExec;
}
int BaseContext::Execute2(IPluginFunction *function, const cell_t *params, unsigned int num_params, cell_t *result)
int
BaseContext::Execute2(IPluginFunction *function, const cell_t *params, unsigned int num_params, cell_t *result)
{
int ir;
int serial;
@ -579,20 +555,16 @@ int BaseContext::Execute2(IPluginFunction *function, const cell_t *params, unsig
EnterProfileScope scriptScope("SourcePawn", cfun->FullName());
/* See if we have to compile the callee. */
if (g_engine2.IsJitEnabled() && (fn = m_pRuntime->m_PubJitFuncs[public_id]) == NULL)
if (g_engine2.IsJitEnabled() &&
(fn = m_pRuntime->m_PubJitFuncs[public_id]) == NULL)
{
/* We might not have to - check pcode offset. */
fn = m_pRuntime->GetJittedFunctionByOffset(cfun->Public()->code_offs);
if (fn)
{
if (fn) {
m_pRuntime->m_PubJitFuncs[public_id] = fn;
}
else
{
} else {
if ((fn = g_Jit.CompileFunction(m_pRuntime, cfun->Public()->code_offs, &ir)) == NULL)
{
return ir;
}
m_pRuntime->m_PubJitFuncs[public_id] = fn;
}
}
@ -617,9 +589,7 @@ int BaseContext::Execute2(IPluginFunction *function, const cell_t *params, unsig
sp[0] = num_params;
for (unsigned int i = 0; i < num_params; i++)
{
sp[i + 1] = params[i];
}
/* Clear internal state */
m_ctx.n_err = SP_ERROR_NONE;
@ -639,25 +609,21 @@ int BaseContext::Execute2(IPluginFunction *function, const cell_t *params, unsig
m_InExec = save_exec;
if (ir == SP_ERROR_NONE)
{
if (ir == SP_ERROR_NONE) {
m_ctx.n_err = SP_ERROR_NONE;
if (m_ctx.sp != save_sp)
{
if (m_ctx.sp != save_sp) {
ir = SP_ERROR_STACKLEAK;
_SetErrorMessage("Stack leak detected: sp:%d should be %d!",
m_ctx.sp,
save_sp);
}
if (m_ctx.hp != save_hp)
{
if (m_ctx.hp != save_hp) {
ir = SP_ERROR_HEAPLEAK;
_SetErrorMessage("Heap leak detected: hp:%d should be %d!",
m_ctx.hp,
save_hp);
}
if (m_ctx.rp != save_rp)
{
if (m_ctx.rp != save_rp) {
ir = SP_ERROR_STACKLEAK;
_SetErrorMessage("Return stack leak detected: rp:%d should be %d!",
m_ctx.rp,
@ -669,9 +635,7 @@ int BaseContext::Execute2(IPluginFunction *function, const cell_t *params, unsig
g_WatchdogTimer.NotifyTimeoutReceived();
if (ir != SP_ERROR_NONE)
{
g_engine1.ReportError(m_pRuntime, ir, m_MsgCache, save_rp);
}
m_ctx.sp = save_sp;
m_ctx.hp = save_hp;
@ -686,7 +650,8 @@ int BaseContext::Execute2(IPluginFunction *function, const cell_t *params, unsig
return ir;
}
IPluginRuntime *BaseContext::GetRuntime()
IPluginRuntime *
BaseContext::GetRuntime()
{
return m_pRuntime;
}
@ -697,57 +662,50 @@ DebugInfo::DebugInfo(sp_plugin_t *plugin) : m_pPlugin(plugin)
#define USHR(x) ((unsigned int)(x)>>1)
int DebugInfo::LookupFile(ucell_t addr, const char **filename)
int
DebugInfo::LookupFile(ucell_t addr, const char **filename)
{
int high, low, mid;
high = m_pPlugin->debug.files_num;
low = -1;
while (high - low > 1)
{
while (high - low > 1) {
mid = USHR(low + high);
if (m_pPlugin->debug.files[mid].addr <= addr)
{
low = mid;
} else {
else
high = mid;
}
}
if (low == -1)
{
return SP_ERROR_NOT_FOUND;
}
*filename = m_pPlugin->debug.stringbase + m_pPlugin->debug.files[low].name;
return SP_ERROR_NONE;
}
int DebugInfo::LookupFunction(ucell_t addr, const char **name)
int
DebugInfo::LookupFunction(ucell_t addr, const char **name)
{
if (!m_pPlugin->debug.unpacked)
{
if (!m_pPlugin->debug.unpacked) {
uint32_t max, iter;
sp_fdbg_symbol_t *sym;
uint8_t *cursor = (uint8_t *)(m_pPlugin->debug.symbols);
max = m_pPlugin->debug.syms_num;
for (iter = 0; iter < max; iter++)
{
for (iter = 0; iter < max; iter++) {
sym = (sp_fdbg_symbol_t *)cursor;
if (sym->ident == sp::IDENT_FUNCTION
&& sym->codestart <= addr
&& sym->codeend > addr)
if (sym->ident == sp::IDENT_FUNCTION &&
sym->codestart <= addr &&
sym->codeend > addr)
{
*name = m_pPlugin->debug.stringbase + sym->name;
return SP_ERROR_NONE;
}
if (sym->dimcount > 0)
{
if (sym->dimcount > 0) {
cursor += sizeof(sp_fdbg_symbol_t);
cursor += sizeof(sp_fdbg_arraydim_t) * sym->dimcount;
continue;
@ -757,28 +715,24 @@ int DebugInfo::LookupFunction(ucell_t addr, const char **name)
}
return SP_ERROR_NOT_FOUND;
}
else
{
} else {
uint32_t max, iter;
sp_u_fdbg_symbol_t *sym;
uint8_t *cursor = (uint8_t *)(m_pPlugin->debug.symbols);
max = m_pPlugin->debug.syms_num;
for (iter = 0; iter < max; iter++)
{
for (iter = 0; iter < max; iter++) {
sym = (sp_u_fdbg_symbol_t *)cursor;
if (sym->ident == sp::IDENT_FUNCTION
&& sym->codestart <= addr
&& sym->codeend > addr)
if (sym->ident == sp::IDENT_FUNCTION &&
sym->codestart <= addr &&
sym->codeend > addr)
{
*name = m_pPlugin->debug.stringbase + sym->name;
return SP_ERROR_NONE;
}
if (sym->dimcount > 0)
{
if (sym->dimcount > 0) {
cursor += sizeof(sp_u_fdbg_symbol_t);
cursor += sizeof(sp_u_fdbg_arraydim_t) * sym->dimcount;
continue;
@ -791,28 +745,24 @@ int DebugInfo::LookupFunction(ucell_t addr, const char **name)
}
}
int DebugInfo::LookupLine(ucell_t addr, uint32_t *line)
int
DebugInfo::LookupLine(ucell_t addr, uint32_t *line)
{
int high, low, mid;
high = m_pPlugin->debug.lines_num;
low = -1;
while (high - low > 1)
{
while (high - low > 1) {
mid = USHR(low + high);
if (m_pPlugin->debug.lines[mid].addr <= addr)
{
low = mid;
} else {
else
high = mid;
}
}
if (low == -1)
{
return SP_ERROR_NOT_FOUND;
}
/* Since the CIP occurs BEFORE the line, we have to add one */
*line = m_pPlugin->debug.lines[low].line + 1;
@ -822,40 +772,40 @@ int DebugInfo::LookupLine(ucell_t addr, uint32_t *line)
#undef USHR
int BaseContext::GetLastNativeError()
int
BaseContext::GetLastNativeError()
{
return m_ctx.n_err;
}
cell_t *BaseContext::GetLocalParams()
cell_t *
BaseContext::GetLocalParams()
{
return (cell_t *)(m_pRuntime->plugin()->memory + m_ctx.frm + (2 * sizeof(cell_t)));
}
void BaseContext::SetKey(int k, void *value)
void
BaseContext::SetKey(int k, void *value)
{
if (k < 1 || k > 4)
{
return;
}
m_keys[k - 1] = value;
m_keys_set[k - 1] = true;
}
bool BaseContext::GetKey(int k, void **value)
bool
BaseContext::GetKey(int k, void **value)
{
if (k < 1 || k > 4 || m_keys_set[k - 1] == false)
{
return false;
}
*value = m_keys[k - 1];
return true;
}
void BaseContext::ClearLastNativeError()
void
BaseContext::ClearLastNativeError()
{
m_ctx.n_err = SP_ERROR_NONE;
}

57
sourcepawn/jit/sp_vm_basecontext.h
View File

@ -1,34 +1,15 @@
/**
* vim: set ts=4 :
* =============================================================================
* SourcePawn
* Copyright (C) 2004-2008 AlliedModders LLC. All rights reserved.
* =============================================================================
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License, version 3.0, as published by the
* Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, AlliedModders LLC gives you permission to link the
* code of this program (as well as its derivative works) to "Half-Life 2," the
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
* by the Valve Corporation. You must obey the GNU General Public License in
* all respects for all other code used. Additionally, AlliedModders LLC grants
* this exception to all derivative works. AlliedModders LLC defines further
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
* or <http://www.sourcemod.net/license.php>.
*
* Version: $Id$
*/
// vim: set sts=2 ts=8 sw=2 tw=99 et:
//
// 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_BASECONTEXT_H_
#define _INCLUDE_SOURCEPAWN_BASECONTEXT_H_
@ -43,10 +24,11 @@
class BaseContext : public IPluginContext
{
public:
public:
BaseContext(BaseRuntime *pRuntime);
~BaseContext();
public: //IPluginContext
public: //IPluginContext
IVirtualMachine *GetVirtualMachine();
sp_context_t *GetContext();
sp_context_t *GetCtx();
@ -94,12 +76,15 @@ public: //IPluginContext
bool GetKey(int k, void **value);
void Refresh();
void ClearLastNativeError();
public:
public:
bool IsInExec();
private:
private:
void SetErrorMessage(const char *msg, va_list ap);
void _SetErrorMessage(const char *msg, ...);
private:
private:
cell_t *m_pNullVec;
cell_t *m_pNullString;
char m_MsgCache[1024];

167
sourcepawn/jit/sp_vm_engine.cpp
View File

@ -1,34 +1,15 @@
/**
* vim: set ts=4 sw=4 tw=99 et:
* =============================================================================
* SourcePawn
* Copyright (C) 2004-2008 AlliedModders LLC. All rights reserved.
* =============================================================================
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License, version 3.0, as published by the
* Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, AlliedModders LLC gives you permission to link the
* code of this program (as well as its derivative works) to "Half-Life 2," the
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
* by the Valve Corporation. You must obey the GNU General Public License in
* all respects for all other code used. Additionally, AlliedModders LLC grants
* this exception to all derivative works. AlliedModders LLC defines further
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
* or <http://www.sourcemod.net/license.php>.
*
* Version: $Id$
*/
// vim: set sts=2 ts=8 sw=2 tw=99 et:
//
// 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 <stdlib.h>
#include <string.h>
#include <assert.h>
@ -93,13 +74,11 @@ static const char *g_ErrorMsgTable[] =
"Script execution timed out"
};
const char *SourcePawnEngine::GetErrorString(int error)
const char *
SourcePawnEngine::GetErrorString(int error)
{
if (error < 1 || error > ERROR_MESSAGE_MAX)
{
return NULL;
}
return g_ErrorMsgTable[error];
}
@ -112,7 +91,8 @@ SourcePawnEngine::~SourcePawnEngine()
{
}
void *SourcePawnEngine::ExecAlloc(size_t size)
void *
SourcePawnEngine::ExecAlloc(size_t size)
{
#if defined WIN32
return VirtualAlloc(NULL, size, MEM_COMMIT, PAGE_EXECUTE_READWRITE);
@ -122,8 +102,7 @@ void *SourcePawnEngine::ExecAlloc(size_t size)
# else
void *base = memalign(sysconf(_SC_PAGESIZE), size);
# endif
if (mprotect(base, size, PROT_READ|PROT_WRITE|PROT_EXEC) != 0)
{
if (mprotect(base, size, PROT_READ|PROT_WRITE|PROT_EXEC) != 0) {
free(base);
return NULL;
}
@ -131,27 +110,32 @@ void *SourcePawnEngine::ExecAlloc(size_t size)
#endif
}
void *SourcePawnEngine::AllocatePageMemory(size_t size)
void *
SourcePawnEngine::AllocatePageMemory(size_t size)
{
return g_Jit.AllocCode(size);
}
void SourcePawnEngine::SetReadExecute(void *ptr)
void
SourcePawnEngine::SetReadExecute(void *ptr)
{
/* already re */
}
void SourcePawnEngine::SetReadWrite(void *ptr)
void
SourcePawnEngine::SetReadWrite(void *ptr)
{
/* already rw */
}
void SourcePawnEngine::FreePageMemory(void *ptr)
void
SourcePawnEngine::FreePageMemory(void *ptr)
{
g_Jit.FreeCode(ptr);
}
void SourcePawnEngine::ExecFree(void *address)
void
SourcePawnEngine::ExecFree(void *address)
{
#if defined WIN32
VirtualFree(address, 0, MEM_RELEASE);
@ -160,48 +144,51 @@ void SourcePawnEngine::ExecFree(void *address)
#endif
}
void SourcePawnEngine::SetReadWriteExecute(void *ptr)
void
SourcePawnEngine::SetReadWriteExecute(void *ptr)
{
//:TODO: g_ExeMemory.SetRWE(ptr);
SetReadExecute(ptr);
}
void *SourcePawnEngine::BaseAlloc(size_t size)
void *
SourcePawnEngine::BaseAlloc(size_t size)
{
return malloc(size);
}
void SourcePawnEngine::BaseFree(void *memory)
void
SourcePawnEngine::BaseFree(void *memory)
{
free(memory);
}
sp_plugin_t *SourcePawnEngine::LoadFromFilePointer(FILE *fp, int *err)
sp_plugin_t *
SourcePawnEngine::LoadFromFilePointer(FILE *fp, int *err)
{
if (err != NULL)
{
*err = SP_ERROR_ABORTED;
}
return NULL;
}
sp_plugin_t *SourcePawnEngine::LoadFromMemory(void *base, sp_plugin_t *plugin, int *err)
sp_plugin_t *
SourcePawnEngine::LoadFromMemory(void *base, sp_plugin_t *plugin, int *err)
{
if (err != NULL)
{
*err = SP_ERROR_ABORTED;
}
return NULL;
}
int SourcePawnEngine::FreeFromMemory(sp_plugin_t *plugin)
int
SourcePawnEngine::FreeFromMemory(sp_plugin_t *plugin)
{
return SP_ERROR_ABORTED;
}
IDebugListener *SourcePawnEngine::SetDebugListener(IDebugListener *pListener)
IDebugListener *
SourcePawnEngine::SetDebugListener(IDebugListener *pListener)
{
IDebugListener *old = m_pDebugHook;
@ -210,22 +197,23 @@ IDebugListener *SourcePawnEngine::SetDebugListener(IDebugListener *pListener)
return old;
}
unsigned int SourcePawnEngine::GetEngineAPIVersion()
unsigned int
SourcePawnEngine::GetEngineAPIVersion()
{
return SOURCEPAWN_ENGINE_API_VERSION;
}
unsigned int SourcePawnEngine::GetContextCallCount()
unsigned int
SourcePawnEngine::GetContextCallCount()
{
return 0;
}
void SourcePawnEngine::ReportError(BaseRuntime *runtime, int err, const char *errstr, cell_t rp_start)
void
SourcePawnEngine::ReportError(BaseRuntime *runtime, int err, const char *errstr, cell_t rp_start)
{
if (m_pDebugHook == NULL)
{
return;
}
CContextTrace trace(runtime, err, errstr, rp_start);
@ -233,54 +221,56 @@ void SourcePawnEngine::ReportError(BaseRuntime *runtime, int err, const char *er
}
CContextTrace::CContextTrace(BaseRuntime *pRuntime, int err, const char *errstr, cell_t start_rp)
: m_pRuntime(pRuntime), m_Error(err), m_pMsg(errstr), m_StartRp(start_rp), m_Level(0)
: m_pRuntime(pRuntime),
m_Error(err),
m_pMsg(errstr),
m_StartRp(start_rp),
m_Level(0)
{
m_ctx = pRuntime->m_pCtx->GetCtx();
m_pDebug = m_pRuntime->GetDebugInfo();
}
bool CContextTrace::DebugInfoAvailable()
bool
CContextTrace::DebugInfoAvailable()
{
return (m_pDebug != NULL);
}
const char *CContextTrace::GetCustomErrorString()
const char *
CContextTrace::GetCustomErrorString()
{
return m_pMsg;
}
int CContextTrace::GetErrorCode()
int
CContextTrace::GetErrorCode()
{
return m_Error;
}
const char *CContextTrace::GetErrorString()
const char *
CContextTrace::GetErrorString()
{
if (m_Error > ERROR_MESSAGE_MAX || m_Error < 1)
{
return "Invalid error code";
}
else
{
return g_ErrorMsgTable[m_Error];
}
}
void CContextTrace::ResetTrace()
void
CContextTrace::ResetTrace()
{
m_Level = 0;
}
bool CContextTrace::GetTraceInfo(CallStackInfo *trace)
bool
CContextTrace::GetTraceInfo(CallStackInfo *trace)
{
cell_t cip;
if (m_Level == 0)
{
if (m_Level == 0) {
cip = m_ctx->cip;
}
else if (m_ctx->rp > 0)
{
} else if (m_ctx->rp > 0) {
/* Entries go from ctx.rp - 1 to m_StartRp */
cell_t offs, start, end;
@ -294,60 +284,47 @@ bool CContextTrace::GetTraceInfo(CallStackInfo *trace)
}
cip = m_ctx->rstk_cips[start - offs];
}
else
{
} else {
return false;
}
if (trace == NULL)
{
if (trace == NULL) {
m_Level++;
return true;
}
if (m_pDebug->LookupFile(cip, &(trace->filename)) != SP_ERROR_NONE)
{
trace->filename = NULL;
}
if (m_pDebug->LookupFunction(cip, &(trace->function)) != SP_ERROR_NONE)
{
trace->function = NULL;
}
if (m_pDebug->LookupLine(cip, &(trace->line)) != SP_ERROR_NONE)
{
trace->line = 0;
}
m_Level++;
return true;
}
const char *CContextTrace::GetLastNative(uint32_t *index)
const char *
CContextTrace::GetLastNative(uint32_t *index)
{
if (m_ctx->n_err == SP_ERROR_NONE)
{
return NULL;
}
sp_native_t *native;
if (m_pRuntime->GetNativeByIndex(m_ctx->n_idx, &native) != SP_ERROR_NONE)
{
return NULL;
}
if (index)
{
*index = m_ctx->n_idx;
}
return native->name;
}
IDebugListener *SourcePawnEngine::GetDebugHook()
IDebugListener *
SourcePawnEngine::GetDebugHook()
{
return m_pDebugHook;
}

62
sourcepawn/jit/sp_vm_engine.h
View File

@ -1,34 +1,15 @@
/**
* vim: set ts=4 :
* =============================================================================
* SourcePawn
* Copyright (C) 2004-2008 AlliedModders LLC. All rights reserved.
* =============================================================================
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License, version 3.0, as published by the
* Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, AlliedModders LLC gives you permission to link the
* code of this program (as well as its derivative works) to "Half-Life 2," the
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
* by the Valve Corporation. You must obey the GNU General Public License in
* all respects for all other code used. Additionally, AlliedModders LLC grants
* this exception to all derivative works. AlliedModders LLC defines further
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
* or <http://www.sourcemod.net/license.php>.
*
* Version: $Id$
*/
// vim: set sts=2 ts=8 sw=2 tw=99 et:
//
// 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_VM_ENGINE_H_
#define _INCLUDE_SOURCEPAWN_VM_ENGINE_H_
@ -39,9 +20,10 @@ class BaseContext;
class CContextTrace : public IContextTrace
{
public:
public:
CContextTrace(BaseRuntime *pRuntime, int err, const char *errstr, cell_t start_rp);
public:
public:
int GetErrorCode();
const char *GetErrorString();
bool DebugInfoAvailable();
@ -49,7 +31,8 @@ public:
bool GetTraceInfo(CallStackInfo *trace);
void ResetTrace();
const char *GetLastNative(uint32_t *index);
private:
private:
BaseRuntime *m_pRuntime;
sp_context_t *m_ctx;
int m_Error;
@ -61,10 +44,11 @@ private:
class SourcePawnEngine : public ISourcePawnEngine
{
public:
public:
SourcePawnEngine();
~SourcePawnEngine();
public: //ISourcePawnEngine
public: //ISourcePawnEngine
sp_plugin_t *LoadFromFilePointer(FILE *fp, int *err);
sp_plugin_t *LoadFromMemory(void *base, sp_plugin_t *plugin, int *err);
int FreeFromMemory(sp_plugin_t *plugin);
@ -82,11 +66,13 @@ public: //ISourcePawnEngine
void FreePageMemory(void *ptr);
const char *GetErrorString(int err);
void ReportError(BaseRuntime *runtime, int err, const char *errstr, cell_t rp_start);
public: //Plugin function stuff
public: //Plugin function stuff
CFunction *GetFunctionFromPool(funcid_t f, IPluginContext *plugin);
void ReleaseFunctionToPool(CFunction *func);
IDebugListener *GetDebugHook();
private:
private:
IDebugListener *m_pDebugHook;
};

164
sourcepawn/jit/sp_vm_function.cpp
View File

@ -1,31 +1,15 @@
/**
* vim: set ts=4 sw=4 tw=99 noet :
* =============================================================================
* SourcePawn
* Copyright (C) 2004-2009 AlliedModders LLC. All rights reserved.
* =============================================================================
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License, version 3.0, as published by the
* Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, AlliedModders LLC gives you permission to link the
* code of this program (as well as its derivative works) to "Half-Life 2," the
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
* by the Valve Corporation. You must obey the GNU General Public License in
* all respects for all other code used. Additionally, AlliedModders LLC grants
* this exception to all derivative works. AlliedModders LLC defines further
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
* or <http://www.sourcemod.net/license.php>.
*/
// vim: set sts=2 ts=8 sw=2 tw=99 et:
//
// 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 <string.h>
@ -41,28 +25,34 @@ CFunction::~CFunction()
delete [] full_name_;
}
bool CFunction::IsRunnable()
bool
CFunction::IsRunnable()
{
return !m_pRuntime->IsPaused();
}
int CFunction::CallFunction(const cell_t *params, unsigned int num_params, cell_t *result)
int
CFunction::CallFunction(const cell_t *params, unsigned int num_params, cell_t *result)
{
return CallFunction2(m_pRuntime->GetDefaultContext(), params, num_params, result);
}
int CFunction::CallFunction2(IPluginContext *pContext, const cell_t *params, unsigned int num_params, cell_t *result)
int
CFunction::CallFunction2(IPluginContext *pContext, const cell_t *params, unsigned int num_params, cell_t *result)
{
return pContext->Execute2(this, params, num_params, result);
}
IPluginContext *CFunction::GetParentContext()
IPluginContext *
CFunction::GetParentContext()
{
return m_pRuntime->GetDefaultContext();
}
CFunction::CFunction(BaseRuntime *runtime, funcid_t id, uint32_t pub_id) :
m_curparam(0), m_errorstate(SP_ERROR_NONE), m_FnId(id)
CFunction::CFunction(BaseRuntime *runtime, funcid_t id, uint32_t pub_id)
: m_curparam(0),
m_errorstate(SP_ERROR_NONE),
m_FnId(id)
{
m_pRuntime = runtime;
@ -80,9 +70,7 @@ CFunction::CFunction(BaseRuntime *runtime, funcid_t id, uint32_t pub_id) :
int CFunction::PushCell(cell_t cell)
{
if (m_curparam >= SP_MAX_EXEC_PARAMS)
{
return SetError(SP_ERROR_PARAMS_MAX);
}
m_info[m_curparam].marked = false;
m_params[m_curparam] = cell;
@ -91,24 +79,28 @@ int CFunction::PushCell(cell_t cell)
return SP_ERROR_NONE;
}
int CFunction::PushCellByRef(cell_t *cell, int flags)
int
CFunction::PushCellByRef(cell_t *cell, int flags)
{
return PushArray(cell, 1, flags);
}
int CFunction::PushFloat(float number)
int
CFunction::PushFloat(float number)
{
cell_t val = *(cell_t *)&number;
return PushCell(val);
}
int CFunction::PushFloatByRef(float *number, int flags)
int
CFunction::PushFloatByRef(float *number, int flags)
{
return PushCellByRef((cell_t *)number, flags);
}
int CFunction::PushArray(cell_t *inarray, unsigned int cells, int copyback)
int
CFunction::PushArray(cell_t *inarray, unsigned int cells, int copyback)
{
if (m_curparam >= SP_MAX_EXEC_PARAMS)
{
@ -128,22 +120,23 @@ int CFunction::PushArray(cell_t *inarray, unsigned int cells, int copyback)
return SP_ERROR_NONE;
}
int CFunction::PushString(const char *string)
int
CFunction::PushString(const char *string)
{
return _PushString(string, SM_PARAM_STRING_COPY, 0, strlen(string)+1);
}
int CFunction::PushStringEx(char *buffer, size_t length, int sz_flags, int cp_flags)
int
CFunction::PushStringEx(char *buffer, size_t length, int sz_flags, int cp_flags)
{
return _PushString(buffer, sz_flags, cp_flags, length);
}
int CFunction::_PushString(const char *string, int sz_flags, int cp_flags, size_t len)
int
CFunction::_PushString(const char *string, int sz_flags, int cp_flags, size_t len)
{
if (m_curparam >= SP_MAX_EXEC_PARAMS)
{
return SetError(SP_ERROR_PARAMS_MAX);
}
ParamInfo *info = &m_info[m_curparam];
@ -159,33 +152,31 @@ int CFunction::_PushString(const char *string, int sz_flags, int cp_flags, size_
return SP_ERROR_NONE;
}
void CFunction::Cancel()
void
CFunction::Cancel()
{
if (!m_curparam)
{
return;
}
m_errorstate = SP_ERROR_NONE;
m_curparam = 0;
}
int CFunction::Execute(cell_t *result)
int
CFunction::Execute(cell_t *result)
{
return Execute2(m_pRuntime->GetDefaultContext(), result);
}
int CFunction::Execute2(IPluginContext *ctx, cell_t *result)
int
CFunction::Execute2(IPluginContext *ctx, cell_t *result)
{
int err = SP_ERROR_NONE;
if (!IsRunnable())
{
m_errorstate = SP_ERROR_NOT_RUNNABLE;
}
if (m_errorstate != SP_ERROR_NONE)
{
if (m_errorstate != SP_ERROR_NONE) {
err = m_errorstate;
Cancel();
return err;
@ -206,13 +197,10 @@ int CFunction::Execute2(IPluginContext *ctx, cell_t *result)
m_curparam = 0;
/* Browse the parameters and build arrays */
for (i=0; i<numparams; i++)
{
for (i=0; i<numparams; i++) {
/* Is this marked as an array? */
if (temp_info[i].marked)
{
if (!temp_info[i].str.is_sz)
{
if (temp_info[i].marked) {
if (!temp_info[i].str.is_sz) {
/* Allocate a normal/generic array */
if ((err=ctx->HeapAlloc(temp_info[i].size,
&(temp_info[i].local_addr),
@ -225,9 +213,7 @@ int CFunction::Execute2(IPluginContext *ctx, cell_t *result)
{
memcpy(temp_info[i].phys_addr, temp_info[i].orig_addr, sizeof(cell_t) * temp_info[i].size);
}
}
else
{
} else {
/* Calculate cells required for the string */
size_t cells = (temp_info[i].size + sizeof(cell_t) - 1) / sizeof(cell_t);
@ -243,8 +229,7 @@ int CFunction::Execute2(IPluginContext *ctx, cell_t *result)
if ((temp_info[i].str.sz_flags & SM_PARAM_STRING_COPY) && (temp_info[i].orig_addr != NULL))
{
/* Cut off UTF-8 properly */
if (temp_info[i].str.sz_flags & SM_PARAM_STRING_UTF8)
{
if (temp_info[i].str.sz_flags & SM_PARAM_STRING_UTF8) {
if ((err=ctx->StringToLocalUTF8(temp_info[i].local_addr,
temp_info[i].size,
(const char *)temp_info[i].orig_addr,
@ -274,52 +259,34 @@ int CFunction::Execute2(IPluginContext *ctx, cell_t *result)
} /* End array/string calculation */
/* Update the pushed parameter with the byref local address */
temp_params[i] = temp_info[i].local_addr;
}
else
{
} else {
/* Just copy the value normally */
temp_params[i] = m_params[i];
}
}
/* Make the call if we can */
if (err == SP_ERROR_NONE)
{
if (err == SP_ERROR_NONE) {
if ((err = CallFunction2(ctx, temp_params, numparams, result)) != SP_ERROR_NONE)
{
docopies = false;
}
}
else
{
} else {
docopies = false;
}
/* i should be equal to the last valid parameter + 1 */
while (i--)
{
while (i--) {
if (!temp_info[i].marked)
{
continue;
}
if (docopies && (temp_info[i].flags & SM_PARAM_COPYBACK))
{
if (temp_info[i].orig_addr)
{
if (temp_info[i].str.is_sz)
{
if (docopies && (temp_info[i].flags & SM_PARAM_COPYBACK)) {
if (temp_info[i].orig_addr) {
if (temp_info[i].str.is_sz) {
memcpy(temp_info[i].orig_addr, temp_info[i].phys_addr, temp_info[i].size);
}
else
{
if (temp_info[i].size == 1)
{
} else {
if (temp_info[i].size == 1) {
*temp_info[i].orig_addr = *(temp_info[i].phys_addr);
}
else
{
} else {
memcpy(temp_info[i].orig_addr,
temp_info[i].phys_addr,
temp_info[i].size * sizeof(cell_t));
@ -329,25 +296,26 @@ int CFunction::Execute2(IPluginContext *ctx, cell_t *result)
}
if ((err=ctx->HeapPop(temp_info[i].local_addr)) != SP_ERROR_NONE)
{
return err;
}
}
return err;
}
IPluginRuntime *CFunction::GetParentRuntime()
IPluginRuntime *
CFunction::GetParentRuntime()
{
return m_pRuntime;
}
funcid_t CFunction::GetFunctionID()
funcid_t
CFunction::GetFunctionID()
{
return m_FnId;
}
int CFunction::SetError(int err)
int
CFunction::SetError(int err)
{
m_errorstate = err;

63
sourcepawn/jit/sp_vm_function.h
View File

@ -1,32 +1,15 @@
/**
* vim: set ts=4 sw=4 tw=99 noet :
* =============================================================================
* SourcePawn
* Copyright (C) 2004-2009 AlliedModders LLC. All rights reserved.
* =============================================================================
*
* This program is free software; you can redistribute it and/or modify it under
* the terms of the GNU General Public License, version 3.0, as published by the
* Free Software Foundation.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*
* As a special exception, AlliedModders LLC gives you permission to link the
* code of this program (as well as its derivative works) to "Half-Life 2," the
* "Source Engine," the "SourcePawn JIT," and any Game MODs that run on software
* by the Valve Corporation. You must obey the GNU General Public License in
* all respects for all other code used. Additionally, AlliedModders LLC grants
* this exception to all derivative works. AlliedModders LLC defines further
* exceptions, found in LICENSE.txt (as of this writing, version JULY-31-2007),
* or <http://www.sourcemod.net/license.php>.
*/
// vim: set sts=2 ts=8 sw=2 tw=99 et:
//
// 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_SOURCEMOD_BASEFUNCTION_H_
#define _INCLUDE_SOURCEMOD_BASEFUNCTION_H_
@ -44,8 +27,7 @@ struct ParamInfo
cell_t *phys_addr; /* Physical address of our copy */
cell_t *orig_addr; /* Original address to copy back to */
ucell_t size; /* Size of array in bytes */
struct
{
struct {
bool is_sz; /* is a string */
int sz_flags; /* has sz flags */
} str;
@ -57,12 +39,12 @@ class JitFunction;
class CFunction : public IPluginFunction
{
friend class SourcePawnEngine;
public:
CFunction(BaseRuntime *pRuntime,
funcid_t fnid,
uint32_t pub_id);
public:
CFunction(BaseRuntime *pRuntime, funcid_t fnid, uint32_t pub_id);
~CFunction();
public:
public:
virtual int PushCell(cell_t cell);
virtual int PushCellByRef(cell_t *cell, int flags);
virtual int PushFloat(float number);
@ -82,17 +64,20 @@ public:
unsigned int num_params,
cell_t *result);
IPluginRuntime *GetParentRuntime();
public:
public:
const char *FullName() const {
return full_name_;
}
sp_public_t *Public() const {
return public_;
}
private:
private:
int _PushString(const char *string, int sz_flags, int cp_flags, size_t len);
int SetError(int err);
private:
private:
BaseRuntime *m_pRuntime;
cell_t m_params[SP_MAX_EXEC_PARAMS];
ParamInfo m_info[SP_MAX_EXEC_PARAMS];