metin-server/m2dev-client-src
3
0
Fork 1
Code Issues 1 Pull Requests 1 Actions 1 Packages Projects Releases Wiki Activity

python 2.7 -> python 3.14

Browse Source
This commit is contained in:
d1str4ught
2026-02-09 01:07:43 +01:00
parent 0ca2a293c8
commit 85609303d8
664 changed files with 666292 additions and 9725 deletions
Download Patch File Download Diff File Expand all files Collapse all files

242
src/ScriptLib/PythonLauncher.cpp
View File

@@ -7,10 +7,15 @@
#include "PackLib/PackManager.h"
#include "PythonLauncher.h"
#include "PythonModules/frozen_modules.h"
#include <utf8.h>
CPythonLauncher::CPythonLauncher()
{
InitStandardPythonModules();
Py_FrozenFlag = 1;
Py_Initialize();
}
@@ -27,18 +32,50 @@ void CPythonLauncher::Clear()
std::string g_stTraceBuffer[512];
int g_nCurTraceN = 0;
namespace
{
const char* SafePyString(PyObject* obj, const char* fallback = "")
{
if (!obj)
return fallback;
const char* value = PyString_AsString(obj);
if (value)
return value;
PyErr_Clear();
return fallback;
}
bool ReadCompiledFileHeader(FILE* fp)
{
const long magic = PyMarshal_ReadLongFromFile(fp);
if (magic != PyImport_GetMagicNumber()) {
PyErr_SetString(PyExc_RuntimeError, "Bad magic number in .pyc file");
return false;
}
PyMarshal_ReadLongFromFile(fp); // flags
PyMarshal_ReadLongFromFile(fp); // hash / timestamp
PyMarshal_ReadLongFromFile(fp); // hash / source size
if (PyErr_Occurred())
return false;
return true;
}
}
void Traceback()
{
std::string str;
for (int i = 0; i < g_nCurTraceN; ++i)
{
for (int i = 0; i < g_nCurTraceN; ++i) {
str.append(g_stTraceBuffer[i]);
str.append("\n");
}
if (!PyErr_Occurred())
{
if (!PyErr_Occurred()) {
str.append("(No Python error set - failure occurred at C++ level)");
LogBoxf("Traceback:\n\n%s\n", str.c_str());
return;
@@ -53,23 +90,18 @@ void Traceback()
// Try using traceback.format_exception for full details
PyObject* tbMod = PyImport_ImportModule("traceback");
if (tbMod)
{
if (tbMod) {
PyObject* fmtFunc = PyObject_GetAttrString(tbMod, "format_exception");
if (fmtFunc)
{
if (fmtFunc) {
PyObject* result = PyObject_CallFunction(fmtFunc, (char*)"OOO",
exc ? exc : Py_None,
v ? v : Py_None,
tb ? tb : Py_None);
if (result && PyList_Check(result))
{
if (result && PyList_Check(result)) {
Py_ssize_t n = PyList_Size(result);
for (Py_ssize_t i = 0; i < n; ++i)
{
for (Py_ssize_t i = 0; i < n; ++i) {
PyObject* line = PyList_GetItem(result, i);
if (line && PyString_Check(line))
str.append(PyString_AS_STRING(line));
str.append(SafePyString(line));
}
Py_DECREF(result);
Py_DECREF(fmtFunc);
@@ -86,24 +118,19 @@ void Traceback()
Py_DECREF(tbMod);
}
// Fallback: manual extraction
if (exc)
{
if (exc) {
PyObject* excName = PyObject_GetAttrString(exc, "__name__");
if (excName && PyString_Check(excName))
{
str.append(PyString_AS_STRING(excName));
if (excName) {
str.append(SafePyString(excName));
str.append(": ");
}
Py_XDECREF(excName);
}
if (v)
{
if (v) {
PyObject* vStr = PyObject_Str(v);
if (vStr && PyString_Check(vStr))
{
const char* errStr = PyString_AS_STRING(vStr);
if (vStr) {
const char* errStr = SafePyString(vStr);
str.append(errStr);
Tracef("%s\n", errStr);
}
@@ -118,55 +145,58 @@ void Traceback()
int TraceFunc(PyObject * obj, PyFrameObject * f, int what, PyObject *arg)
{
const char * funcname;
char szTraceBuffer[128];
switch (what)
{
case PyTrace_CALL:
case PyTrace_CALL: {
if (g_nCurTraceN >= 512)
return 0;
if (Py_OptimizeFlag)
f->f_lineno = PyCode_Addr2Line(f->f_code, f->f_lasti);
PyCodeObject* code = PyFrame_GetCode(f);
const int lineNo = PyFrame_GetLineNumber(f);
funcname = PyString_AsString(f->f_code->co_name);
PyObject* fileNameObj = code ? PyObject_GetAttrString((PyObject*)code, "co_filename") : NULL;
PyObject* funcNameObj = code ? PyObject_GetAttrString((PyObject*)code, "co_name") : NULL;
_snprintf(szTraceBuffer, sizeof(szTraceBuffer), "Call: File \"%s\", line %d, in %s",
PyString_AsString(f->f_code->co_filename),
f->f_lineno,
funcname);
_snprintf(szTraceBuffer, sizeof(szTraceBuffer), "Call: File \"%s\", line %d, in %s",
SafePyString(fileNameObj, "<unknown>"),
lineNo,
SafePyString(funcNameObj, "<unknown>"));
g_stTraceBuffer[g_nCurTraceN++]=szTraceBuffer;
break;
g_stTraceBuffer[g_nCurTraceN++] = szTraceBuffer;
case PyTrace_RETURN:
Py_XDECREF(fileNameObj);
Py_XDECREF(funcNameObj);
Py_XDECREF((PyObject*)code);
} break;
case PyTrace_RETURN: {
if (g_nCurTraceN > 0)
--g_nCurTraceN;
break;
} break;
case PyTrace_EXCEPTION:
case PyTrace_EXCEPTION: {
if (g_nCurTraceN >= 512)
return 0;
PyObject * exc_type, * exc_value, * exc_traceback;
PyTuple_GetObject(arg, 0, &exc_type);
PyTuple_GetObject(arg, 1, &exc_value);
PyTuple_GetObject(arg, 2, &exc_traceback);
PyCodeObject* code = PyFrame_GetCode(f);
const int lineNo = PyFrame_GetLineNumber(f);
Py_ssize_t len;
const char * exc_str;
PyObject_AsCharBuffer(exc_type, &exc_str, &len);
_snprintf(szTraceBuffer, sizeof(szTraceBuffer), "Exception: File \"%s\", line %d, in %s",
PyString_AS_STRING(f->f_code->co_filename),
f->f_lineno,
PyString_AS_STRING(f->f_code->co_name));
PyObject* fileNameObj = code ? PyObject_GetAttrString((PyObject*)code, "co_filename") : NULL;
PyObject* funcNameObj = code ? PyObject_GetAttrString((PyObject*)code, "co_name") : NULL;
g_stTraceBuffer[g_nCurTraceN++]=szTraceBuffer;
break;
_snprintf(szTraceBuffer, sizeof(szTraceBuffer), "Exception: File \"%s\", line %d, in %s",
SafePyString(fileNameObj, "<unknown>"),
lineNo,
SafePyString(funcNameObj, "<unknown>"));
g_stTraceBuffer[g_nCurTraceN++] = szTraceBuffer;
Py_XDECREF(fileNameObj);
Py_XDECREF(funcNameObj);
Py_XDECREF((PyObject*)code);
} break;
}
return 0;
}
@@ -176,25 +206,25 @@ void CPythonLauncher::SetTraceFunc(int (*pFunc)(PyObject * obj, PyFrameObject *
PyEval_SetTrace(pFunc, NULL);
}
bool CPythonLauncher::Create(const char* c_szProgramName)
bool CPythonLauncher::Create()
{
NANOBEGIN
Py_SetProgramName((char*)c_szProgramName);
#ifdef _DEBUG
PyEval_SetTrace(TraceFunc, NULL);
#endif
m_poModule = PyImport_AddModule((char *) "__main__");
m_poModule = PyImport_AddModule("__main__");
if (!m_poModule)
return false;
m_poDic = PyModule_GetDict(m_poModule);
PyObject * builtins = PyImport_ImportModule("__builtin__");
PyModule_AddIntConstant(builtins, "TRUE", 1);
PyModule_AddIntConstant(builtins, "FALSE", 0);
PyDict_SetItemString(m_poDic, "__builtins__", builtins);
Py_DECREF(builtins);
PyObject* builtins = PyImport_ImportModule("builtins");
if (builtins) {
PyModule_AddIntConstant(builtins, "TRUE", 1);
PyModule_AddIntConstant(builtins, "FALSE", 0);
PyDict_SetItemString(m_poDic, "__builtins__", builtins);
Py_DECREF(builtins);
}
if (!RunLine("import __main__"))
return false;
@@ -202,62 +232,40 @@ bool CPythonLauncher::Create(const char* c_szProgramName)
if (!RunLine("import sys"))
return false;
NANOEND
return true;
}
bool CPythonLauncher::RunCompiledFile(const char* c_szFileName)
{
NANOBEGIN
// UTF-8 → UTF-16 conversion for Unicode path support
std::wstring wFileName = Utf8ToWide(c_szFileName);
FILE * fp = _wfopen(wFileName.c_str(), L"rb");
if (!fp)
return false;
if (!fp) return false;
PyCodeObject *co;
PyObject *v;
long magic;
long PyImport_GetMagicNumber(void);
magic = _PyMarshal_ReadLongFromFile(fp);
if (magic != PyImport_GetMagicNumber())
{
PyErr_SetString(PyExc_RuntimeError, "Bad magic number in .pyc file");
if (!ReadCompiledFileHeader(fp)) {
fclose(fp);
return false;
}
_PyMarshal_ReadLongFromFile(fp);
v = _PyMarshal_ReadLastObjectFromFile(fp);
PyObject* code = PyMarshal_ReadLastObjectFromFile(fp);
fclose(fp);
if (!v || !PyCode_Check(v))
{
Py_XDECREF(v);
if (!code || !PyCode_Check(code)) {
Py_XDECREF(code);
PyErr_SetString(PyExc_RuntimeError, "Bad code object in .pyc file");
return false;
}
co = (PyCodeObject *) v;
v = PyEval_EvalCode(co, m_poDic, m_poDic);
/* if (v && flags)
flags->cf_flags |= (co->co_flags & PyCF_MASK);*/
Py_DECREF(co);
if (!v)
{
PyObject* result = PyEval_EvalCode(code, m_poDic, m_poDic);
Py_DECREF(code);
if (!result) {
Traceback();
return false;
}
Py_DECREF(v);
if (Py_FlushLine())
PyErr_Clear();
Py_DECREF(result);
NANOEND
return true;
}
@@ -271,13 +279,9 @@ bool CPythonLauncher::RunMemoryTextFile(const char* c_szFileName, UINT uFileSize
stConvFileData.reserve(uFileSize);
stConvFileData+="exec(compile('''";
// ConvertPythonTextFormat
{
for (UINT i=0; i<uFileSize; ++i)
{
if (c_pcFileData[i]!=13)
stConvFileData+=c_pcFileData[i];
}
for (UINT i = 0; i < uFileSize; ++i) {
if (c_pcFileData[i] != 13)
stConvFileData += c_pcFileData[i];
}
stConvFileData+= "''', ";
@@ -299,35 +303,28 @@ bool CPythonLauncher::RunFile(const char* c_szFileName)
if (file.empty())
return false;
// Convert \r\n to \n and null-terminate
std::string source;
source.reserve(file.size());
for (size_t i = 0; i < file.size(); ++i)
{
for (size_t i = 0; i < file.size(); ++i) {
if (file[i] != '\r')
source += (char)file[i];
}
// Compile directly with the filename for proper error reporting
PyObject* code = Py_CompileString(source.c_str(), c_szFileName, Py_file_input);
if (!code)
{
if (!code) {
Traceback();
return false;
}
PyObject* result = PyEval_EvalCode((PyCodeObject*)code, m_poDic, m_poDic);
PyObject* result = PyEval_EvalCode(code, m_poDic, m_poDic);
Py_DECREF(code);
if (!result)
{
if (!result) {
Traceback();
return false;
}
Py_DECREF(result);
if (Py_FlushLine())
PyErr_Clear();
return true;
}
@@ -336,8 +333,7 @@ bool CPythonLauncher::RunLine(const char* c_szSrc)
{
PyObject * v = PyRun_String((char *) c_szSrc, Py_file_input, m_poDic, m_poDic);
if (!v)
{
if (!v) {
Traceback();
return false;
}
@@ -348,14 +344,26 @@ bool CPythonLauncher::RunLine(const char* c_szSrc)
const char* CPythonLauncher::GetError()
{
static std::string s_error;
s_error.clear();
PyObject* exc;
PyObject* v;
PyObject* tb;
PyErr_Fetch(&exc, &v, &tb);
if (PyString_Check(v))
return PyString_AS_STRING(v);
if (v) {
s_error = SafePyString(v);
Py_XDECREF(exc);
Py_XDECREF(v);
Py_XDECREF(tb);
return s_error.c_str();
}
Py_XDECREF(exc);
Py_XDECREF(v);
Py_XDECREF(tb);
return "";
}

2
src/ScriptLib/PythonLauncher.h
View File

@@ -14,7 +14,7 @@ class CPythonLauncher : public CSingleton<CPythonLauncher>
void Clear();
bool Create(const char* c_szProgramName="eter.python");
bool Create();
void SetTraceFunc(int (*pFunc)(PyObject * obj, PyFrameObject * f, int what, PyObject *arg));
bool RunLine(const char* c_szLine);
bool RunFile(const char* c_szFileName);

481
src/ScriptLib/PythonMarshal.cpp
View File

@@ -1,481 +0,0 @@
/* Write Python objects to files and read them back.
This is intended for writing and reading compiled Python code only;
a true persistent storage facility would be much harder, since
it would have to take circular links and sharing into account. */
#include "Stdafx.h"
#include <python/longintrepr.h>
#ifdef BYTE
#undef BYTE
#endif
/* High water mark to determine when the marshalled object is dangerously deep
* and risks coring the interpreter. When the object stack gets this deep,
* raise an exception instead of continuing.
*/
#define MAX_MARSHAL_STACK_DEPTH 5000
#define TYPE_NULL '0'
#define TYPE_NONE 'N'
#define TYPE_STOPITER 'S'
#define TYPE_ELLIPSIS '.'
#define TYPE_INT 'i'
#define TYPE_INT64 'I'
#define TYPE_FLOAT 'f'
#define TYPE_COMPLEX 'x'
#define TYPE_LONG 'l'
#define TYPE_STRING 's'
#define TYPE_TUPLE '('
#define TYPE_LIST '['
#define TYPE_DICT '{'
#define TYPE_CODE 'c'
#define TYPE_UNICODE 'u'
#define TYPE_UNKNOWN '?'
typedef struct
{
FILE * fp;
int error;
int depth;
PyObject * str;
char * ptr;
char * end;
} WFILE;
typedef WFILE RFILE; /* Same struct with different invariants */
#define rs_byte(p) (((p)->ptr != (p)->end) ? (unsigned char)*(p)->ptr++ : EOF)
#define r_byte(p) ((p)->fp ? getc((p)->fp) : rs_byte(p))
static int r_string(char *s, int n, RFILE *p)
{
if (p->fp != NULL)
return fread(s, 1, n, p->fp);
if (p->end - p->ptr < n)
n = p->end - p->ptr;
memcpy(s, p->ptr, n);
p->ptr += n;
return n;
}
static int r_short(RFILE *p)
{
short x;
x = (short) r_byte(p);
x |= (short) r_byte(p) << 8;
/* Sign-extension, in case short greater than 16 bits */
x |= -(x & 0x8000);
return x;
}
static long r_long(RFILE *p)
{
long x;
FILE *fp = p->fp;
if (fp) {
x = getc(fp);
x |= (long)getc(fp) << 8;
x |= (long)getc(fp) << 16;
x |= (long)getc(fp) << 24;
}
else {
x = rs_byte(p);
x |= (long)rs_byte(p) << 8;
x |= (long)rs_byte(p) << 16;
x |= (long)rs_byte(p) << 24;
}
#if SIZEOF_LONG > 4
/* Sign extension for 64-bit machines */
x |= -(x & 0x80000000L);
#endif
return x;
}
/* r_long64 deals with the TYPE_INT64 code. On a machine with
sizeof(long) > 4, it returns a Python int object, else a Python long
object. Note that w_long64 writes out TYPE_INT if 32 bits is enough,
so there's no inefficiency here in returning a PyLong on 32-bit boxes
for everything written via TYPE_INT64 (i.e., if an int is written via
TYPE_INT64, it *needs* more than 32 bits).
*/
static PyObject * r_long64(RFILE *p)
{
long lo4 = r_long(p);
long hi4 = r_long(p);
#if SIZEOF_LONG > 4
long x = (hi4 << 32) | (lo4 & 0xFFFFFFFFL);
return PyInt_FromLong(x);
#else
unsigned char buf[8];
int one = 1;
int is_little_endian = (int)*(char*)&one;
if (is_little_endian) {
memcpy(buf, &lo4, 4);
memcpy(buf+4, &hi4, 4);
}
else {
memcpy(buf, &hi4, 4);
memcpy(buf+4, &lo4, 4);
}
return _PyLong_FromByteArray(buf, 8, is_little_endian, 1);
#endif
}
static PyObject * r_object(RFILE *p)
{
PyObject *v, *v2;
long i, n;
int type = r_byte(p);
switch (type) {
case EOF:
PyErr_SetString(PyExc_EOFError,
"EOF read where object expected");
return NULL;
case TYPE_NULL:
return NULL;
case TYPE_NONE:
Py_INCREF(Py_None);
return Py_None;
case TYPE_STOPITER:
Py_INCREF(PyExc_StopIteration);
return PyExc_StopIteration;
case TYPE_ELLIPSIS:
Py_INCREF(Py_Ellipsis);
return Py_Ellipsis;
case TYPE_INT:
return PyInt_FromLong(r_long(p));
case TYPE_INT64:
return r_long64(p);
case TYPE_LONG:
{
int size;
PyLongObject* ob;
n = r_long(p);
size = n<0 ? -n : n;
ob = _PyLong_New(size);
if (ob == NULL)
return NULL;
ob->ob_size = n;
for (i = 0; i < size; i++)
ob->ob_digit[i] = (short) r_short(p);
return (PyObject *) ob;
}
case TYPE_FLOAT:
{
char buf[256];
double dx;
n = r_byte(p);
if (r_string(buf, (int)n, p) != n) {
PyErr_SetString(PyExc_EOFError,
"EOF read where object expected");
return NULL;
}
buf[n] = '\0';
PyFPE_START_PROTECT("atof", return 0)
dx = atof(buf);
PyFPE_END_PROTECT(dx)
return PyFloat_FromDouble(dx);
}
#ifndef WITHOUT_COMPLEX
case TYPE_COMPLEX:
{
char buf[256];
Py_complex c;
n = r_byte(p);
if (r_string(buf, (int)n, p) != n) {
PyErr_SetString(PyExc_EOFError,
"EOF read where object expected");
return NULL;
}
buf[n] = '\0';
PyFPE_START_PROTECT("atof", return 0)
c.real = atof(buf);
PyFPE_END_PROTECT(c)
n = r_byte(p);
if (r_string(buf, (int)n, p) != n) {
PyErr_SetString(PyExc_EOFError,
"EOF read where object expected");
return NULL;
}
buf[n] = '\0';
PyFPE_START_PROTECT("atof", return 0)
c.imag = atof(buf);
PyFPE_END_PROTECT(c)
return PyComplex_FromCComplex(c);
}
#endif
case TYPE_STRING:
n = r_long(p);
if (n < 0) {
PyErr_SetString(PyExc_ValueError, "bad marshal data");
return NULL;
}
v = PyString_FromStringAndSize((char *)NULL, n);
if (v != NULL) {
if (r_string(PyString_AS_STRING(v), (int)n, p) != n) {
Py_DECREF(v);
v = NULL;
PyErr_SetString(PyExc_EOFError,
"EOF read where object expected");
}
}
return v;
#ifdef Py_USING_UNICODE
case TYPE_UNICODE:
{
char *buffer;
n = r_long(p);
if (n < 0) {
PyErr_SetString(PyExc_ValueError, "bad marshal data");
return NULL;
}
buffer = PyMem_NEW(char, n);
if (buffer == NULL)
return PyErr_NoMemory();
if (r_string(buffer, (int)n, p) != n) {
PyMem_DEL(buffer);
PyErr_SetString(PyExc_EOFError,
"EOF read where object expected");
return NULL;
}
v = PyUnicode_DecodeUTF8(buffer, n, NULL);
PyMem_DEL(buffer);
return v;
}
#endif
case TYPE_TUPLE:
n = r_long(p);
if (n < 0) {
PyErr_SetString(PyExc_ValueError, "bad marshal data");
return NULL;
}
v = PyTuple_New((int)n);
if (v == NULL)
return v;
for (i = 0; i < n; i++) {
v2 = r_object(p);
if ( v2 == NULL ) {
Py_DECREF(v);
v = NULL;
break;
}
PyTuple_SET_ITEM(v, (int)i, v2);
}
return v;
case TYPE_LIST:
n = r_long(p);
if (n < 0) {
PyErr_SetString(PyExc_ValueError, "bad marshal data");
return NULL;
}
v = PyList_New((int)n);
if (v == NULL)
return v;
for (i = 0; i < n; i++) {
v2 = r_object(p);
if ( v2 == NULL ) {
Py_DECREF(v);
v = NULL;
break;
}
PyList_SetItem(v, (int)i, v2);
}
return v;
case TYPE_DICT:
v = PyDict_New();
if (v == NULL)
return NULL;
for (;;) {
PyObject *key, *val;
key = r_object(p);
if (key == NULL)
break; /* XXX Assume TYPE_NULL, not an error */
val = r_object(p);
if (val != NULL)
PyDict_SetItem(v, key, val);
Py_DECREF(key);
Py_XDECREF(val);
}
return v;
case TYPE_CODE:
if (PyEval_GetRestricted()) {
PyErr_SetString(PyExc_RuntimeError,
"cannot unmarshal code objects in "
"restricted execution mode");
return NULL;
}
else {
int argcount = r_short(p);
int nlocals = r_short(p);
int stacksize = r_short(p);
int flags = r_short(p);
PyObject *code = NULL;
PyObject *consts = NULL;
PyObject *names = NULL;
PyObject *varnames = NULL;
PyObject *freevars = NULL;
PyObject *cellvars = NULL;
PyObject *filename = NULL;
PyObject *name = NULL;
int firstlineno = 0;
PyObject *lnotab = NULL;
code = r_object(p);
if (code) consts = r_object(p);
if (consts) names = r_object(p);
if (names) varnames = r_object(p);
if (varnames) freevars = r_object(p);
if (freevars) cellvars = r_object(p);
if (cellvars) filename = r_object(p);
if (filename) name = r_object(p);
if (name) {
firstlineno = r_short(p);
lnotab = r_object(p);
}
if (!PyErr_Occurred()) {
v = (PyObject *) PyCode_New(
argcount, nlocals, stacksize, flags,
code, consts, names, varnames,
freevars, cellvars, filename, name,
firstlineno, lnotab);
}
else
v = NULL;
Py_XDECREF(code);
Py_XDECREF(consts);
Py_XDECREF(names);
Py_XDECREF(varnames);
Py_XDECREF(freevars);
Py_XDECREF(cellvars);
Py_XDECREF(filename);
Py_XDECREF(name);
Py_XDECREF(lnotab);
}
return v;
default:
/* Bogus data got written, which isn't ideal.
This will let you keep working and recover. */
PyErr_SetString(PyExc_ValueError, "bad marshal data");
return NULL;
}
}
int _PyMarshal_ReadShortFromFile(FILE *fp)
{
RFILE rf;
rf.fp = fp;
return r_short(&rf);
}
long _PyMarshal_ReadLongFromFile(FILE *fp)
{
RFILE rf;
rf.fp = fp;
return r_long(&rf);
}
/* Return size of file in bytes; < 0 if unknown. */
static off_t getfilesize(FILE *fp)
{
struct stat st;
if (fstat(fileno(fp), &st) != 0)
return -1;
else
return st.st_size;
}
/* If we can get the size of the file up-front, and it's reasonably small,
* read it in one gulp and delegate to ...FromString() instead. Much quicker
* than reading a byte at a time from file; speeds .pyc imports.
* CAUTION: since this may read the entire remainder of the file, don't
* call it unless you know you're done with the file.
*/
PyObject *_PyMarshal_ReadLastObjectFromFile(FILE *fp)
{
/* 75% of 2.1's .pyc files can exploit SMALL_FILE_LIMIT.
* REASONABLE_FILE_LIMIT is by defn something big enough for Tkinter.pyc.
*/
#define SMALL_FILE_LIMIT (1L << 14)
#define REASONABLE_FILE_LIMIT (1L << 18)
off_t filesize;
if (PyErr_Occurred())
{
fprintf(stderr, "XXX rd_object called with exception set\n");
return NULL;
}
filesize = getfilesize(fp);
if (filesize > 0) {
char buf[SMALL_FILE_LIMIT];
char* pBuf = NULL;
if (filesize <= SMALL_FILE_LIMIT)
pBuf = buf;
else if (filesize <= REASONABLE_FILE_LIMIT)
pBuf = (char *)PyMem_MALLOC(filesize);
if (pBuf != NULL) {
PyObject* v;
size_t n = fread(pBuf, 1, filesize, fp);
v = PyMarshal_ReadObjectFromString(pBuf, n);
if (pBuf != buf)
PyMem_FREE(pBuf);
return v;
}
}
/* We don't have fstat, or we do but the file is larger than
* REASONABLE_FILE_LIMIT or malloc failed -- read a byte at a time.
*/
return _PyMarshal_ReadObjectFromFile(fp);
#undef SMALL_FILE_LIMIT
#undef REASONABLE_FILE_LIMIT
}
PyObject * _PyMarshal_ReadObjectFromFile(FILE *fp)
{
RFILE rf;
if (PyErr_Occurred()) {
fprintf(stderr, "XXX rd_object called with exception set\n");
return NULL;
}
rf.fp = fp;
return r_object(&rf);
}
PyObject * _PyMarshal_ReadObjectFromString(char *str, int len)
{
RFILE rf;
if (PyErr_Occurred()) {
fprintf(stderr, "XXX rds_object called with exception set\n");
return NULL;
}
rf.fp = NULL;
rf.str = NULL;
rf.ptr = str;
rf.end = str + len;
return r_object(&rf);
}

8
src/ScriptLib/PythonMarshal.h
View File

@@ -1,8 +0,0 @@
#ifndef __INC_ETERMARSHAL_H__
#define __INC_ETERMARSHAL_H__
extern PyObject * _PyMarshal_ReadObjectFromFile(FILE* fp);
extern PyObject * _PyMarshal_ReadLastObjectFromFile(FILE* fp);
extern long _PyMarshal_ReadLongFromFile(FILE *fp);
#endif

71
src/ScriptLib/PythonUtils.h
View File

@@ -32,4 +32,73 @@ bool PyCallClassMemberFunc(PyObject* poClass, PyObject* poFunc, PyObject* poArgs
PyObject * Py_BuildException(const char * c_pszErr = NULL, ...);
PyObject * Py_BadArgument();
PyObject * Py_BuildNone();
PyObject * Py_BuildEmptyTuple();
// Compatibility functions between Python 2 and 3
inline int PyString_Check(PyObject* obj) {
return obj && (PyUnicode_Check(obj) || PyBytes_Check(obj));
}
inline char* PyString_AsString(PyObject* obj) {
if (!obj) {
PyErr_SetString(PyExc_TypeError, "NULL Python object");
return nullptr;
}
if (PyUnicode_Check(obj))
return const_cast<char*>(PyUnicode_AsUTF8(obj));
if (PyBytes_Check(obj))
return PyBytes_AsString(obj);
PyErr_SetString(PyExc_TypeError, "Expected str or bytes object");
return nullptr;
}
inline char* PyString_AS_STRING(PyObject* obj) {
return PyString_AsString(obj);
}
inline PyObject* PyString_FromStringAndSize(const char* str, Py_ssize_t size) {
return PyBytes_FromStringAndSize(str, size);
}
inline PyObject* Py_InitModule(const char* name, PyMethodDef* methods) {
PyModuleDef* moduleDef = new (std::nothrow) PyModuleDef{
PyModuleDef_HEAD_INIT,
name,
nullptr,
-1,
methods,
nullptr,
nullptr,
nullptr,
nullptr
};
if (!moduleDef)
return PyErr_NoMemory();
PyObject* module = PyModule_Create(moduleDef);
if (!module) {
delete moduleDef;
return nullptr;
}
PyObject* modules = PyImport_GetModuleDict();
if (PyDict_SetItemString(modules, name, module) < 0) {
Py_DECREF(module);
return nullptr;
}
Py_DECREF(module);
return PyDict_GetItemString(modules, name);
}
#define PyInt_Check PyLong_Check
#define PyInt_AsLong PyLong_AsLong
#define PyInt_FromLong PyLong_FromLong
#define PyString_FromString PyUnicode_FromString
#define PyString_InternFromString PyUnicode_InternFromString

6
src/ScriptLib/StdAfx.h
View File

@@ -11,13 +11,8 @@
#else
#include <python/python.h>
#endif
#include <python/node.h>
#include <python/grammar.h>
#include <python/token.h>
#include <python/parsetok.h>
#include <python/errcode.h>
#include <python/compile.h>
#include <python/eval.h>
#include <python/marshal.h>
#ifdef BYTE
@@ -26,7 +21,6 @@
#include "PythonUtils.h"
#include "PythonLauncher.h"
#include "PythonMarshal.h"
#include "Resource.h"
void initdbg();