PyObject *
PyNumber_Long(PyObject *o)
{
PyNumberMethods *m;
const char *buffer;
int buffer_len;
if (o == NULL)
return null_error();
if (PyLong_Check(o)) {
Py_INCREF(o);
return o;
}
if (PyString_Check(o))
/* need to do extra error checking that PyLong_FromString()
* doesn't do. In particular long('9.5') must raise an
* exception, not truncate the float.
*/
return long_from_string(PyString_AS_STRING(o),
PyString_GET_SIZE(o));
if (PyUnicode_Check(o))
/* The above check is done in PyLong_FromUnicode(). */
return PyLong_FromUnicode(PyUnicode_AS_UNICODE(o),
PyUnicode_GET_SIZE(o),
10);
m = o->ob_type->tp_as_number;
if (m && m->nb_long)
return m->nb_long(o);
if (!PyObject_AsCharBuffer(o, &buffer, &buffer_len))
return long_from_string(buffer, buffer_len);
return type_error("object can't be converted to long");
}
bool embedding_simple_script(int argc, char* argv[])
#endif
{
if (argc < 3)
{
std::cerr << "Usage: call pythonfile funcname [args]" << std::endl;
std::cerr << "\te.g.) embedding.exe arithmetic add 3 2" << std::endl;
return false;
}
Py_Initialize();
#if defined(_UNICODE) || defined(UNICODE)
PyObject *pName = PyUnicode_FromUnicode(argv[1], std::wcslen(argv[1]));
#else
//PyObject *pName = PyString_FromString(argv[1]);
PyObject *pName = PyUnicode_FromString(argv[1]);
#endif
// Error checking of pName left out
PyObject *pModule = PyImport_Import(pName);
Py_DECREF(pName);
if (pModule != NULL)
{
#if defined(_UNICODE) || defined(UNICODE)
PyObject *pTmp = PyUnicode_FromWideChar(argv[2], std::wcslen(argv[2]));
PyObject *pFunc = PyObject_GetAttr(pModule, pTmp);
Py_DECREF(pTmp);
#else
PyObject *pFunc = PyObject_GetAttrString(pModule, argv[2]);
#endif
// pFunc is a new reference
if (pFunc && PyCallable_Check(pFunc))
{
PyObject *pValue = NULL;
PyObject *pArgs = PyTuple_New(argc - 3);
for (int i = 0; i < argc - 3; ++i)
{
// TODO [check] >> is it correct?
#if defined(_UNICODE) || defined(UNICODE)
pValue = PyLong_FromUnicode(argv[i + 3], std::wcslen(argv[i + 3]), 0);
#else
pValue = PyLong_FromLong(atoi(argv[i + 3]));
//pValue = PyLong_FromString(argv[i + 3], NULL, 0);
#endif
if (!pValue)
{
Py_DECREF(pArgs);
Py_DECREF(pModule);
std::cerr << "Cannot convert argument" << std::endl;
return false;
}
// pValue reference stolen here
PyTuple_SetItem(pArgs, i, pValue);
}
pValue = PyObject_CallObject(pFunc, pArgs);
Py_DECREF(pArgs);
if (pValue != NULL)
{
std::cout << "Result of call: " << PyLong_AsLong(pValue) << std::endl;
Py_DECREF(pValue);
}
else
{
Py_DECREF(pFunc);
Py_DECREF(pModule);
PyErr_Print();
std::cerr << "Call failed" << std::endl;
return false;
}
}
else
{
if (PyErr_Occurred())
PyErr_Print();
std::cerr << "Cannot find function \"" << argv[2] << "\"" << std::endl;
}
Py_XDECREF(pFunc);
Py_DECREF(pModule);
}
else
{
PyErr_Print();
std::cerr << "Failed to load \"" << argv[1] << "\"" << std::endl;
return false;
}
Py_Finalize();
return true;
}
static PyObject *next(PyObject *self)
{
ligolw_Tokenizer *tokenizer = (ligolw_Tokenizer *) self;
PyObject *type;
PyObject *token;
Py_UNICODE *start, *end;
/*
* Identify the start and end of the next token.
*/
do {
type = next_token(tokenizer, &start, &end);
if(!type)
return NULL;
} while(type == Py_None);
/*
* Extract token as desired type.
*/
if(start == NULL) {
/*
* unquoted zero-length string == None
*/
Py_INCREF(Py_None);
token = Py_None;
} else if(type == (PyObject *) &PyFloat_Type) {
char ascii_buffer[end - start + 1];
char *ascii_end;
if(PyUnicode_EncodeDecimal(start, end - start, ascii_buffer, NULL))
return NULL;
token = PyFloat_FromDouble(strtod(ascii_buffer, &ascii_end));
if(ascii_end == ascii_buffer || *ascii_end != 0) {
/*
* strtod() couldn't convert the token, emulate
* float()'s error message
*/
Py_XDECREF(token);
PyErr_Format(PyExc_ValueError, "invalid literal for float(): '%s'", ascii_buffer);
token = NULL;
}
} else if(type == (PyObject *) &PyUnicode_Type) {
token = PyUnicode_FromUnicode(start, end - start);
} else if(type == (PyObject *) &PyString_Type) {
token = PyUnicode_Encode(start, end - start, NULL, NULL);
} else if(type == (PyObject *) &PyInt_Type) {
token = PyInt_FromUnicode(start, end - start, 0);
} else if(type == (PyObject *) &PyLong_Type) {
token = PyLong_FromUnicode(start, end - start, 0);
} else {
token = PyObject_CallFunction(type, "u#", start, end - start);
}
/*
* Done.
*/
return token;
}