static PyObject *
load_cert (PyObject *self, PyObject *args, PyObject *keywords)
{
const char *file_name = NULL;
const char *pem = NULL;
static char *keywordlist[] = { "file", "pem", NULL };
if (!PyArg_ParseTupleAndKeywords (args, keywords, "|ss", keywordlist,
&file_name, &pem)) {
return NULL;
}
BIO *bio;
if (pem != NULL) {
bio = BIO_new_mem_buf ((void *) pem, strlen (pem));
} else {
bio = BIO_new_file (file_name, "r");
}
X509 *x509 = PEM_read_bio_X509 (bio, NULL, NULL, NULL);
BIO_free (bio);
if (x509 == NULL) {
Py_INCREF (Py_None);
return Py_None;
}
certificate_x509 *py_x509 =
(certificate_x509 *) _PyObject_New (&certificate_x509_type);
py_x509->x509 = x509;
return (PyObject *) py_x509;
}
PyObject *BitmapObject_FromMMBitmap(MMBitmapRef bitmap)
{
BitmapObject *newBitmap = (BitmapObject *)_PyObject_New(&Bitmap_Type);
if (newBitmap == NULL) return NULL;
newBitmap->bitmap = bitmap;
return (PyObject *)newBitmap;
}
static PyObject *
NDF_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
NDF *self;
self = (NDF *) _PyObject_New( type );
if (self != NULL) {
self->_ndfid = NDF__NOID;
self->_place = NDF__NOPL;
}
return (PyObject *)self;
}
static PyObject *
HDS_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
HDSObject *self;
self = (HDSObject *) _PyObject_New( type );
if (self != NULL) {
self->_locator = Py_None;
if (self->_locator == NULL) {
Py_DECREF(self);
return NULL;
}
}
return (PyObject *)self;
}
static PyObject *devlist_get(struct cp_devlist *self, Py_ssize_t i)
{
struct cp_dev *dev;
if ( i >= self->nmemb )
return NULL;
dev = (struct cp_dev*)_PyObject_New(&dev_pytype);
if ( dev ) {
Py_INCREF(self);
dev->owner = self;
dev->idx = i;
dev->dev = NULL;
}
return (PyObject *)dev;
}
static PyObject *
NDFMapped_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
{
NDFMapped *self;
self = (NDFMapped *) _PyObject_New( type );
if (self != NULL) {
self->ndf = NULL;
(self->mode)[0] = '\0';
(self->type)[0] = '\0';
(self->comp)[0] = '\0';
self->_pntr = NULL;
self->nelem = 0;
}
return (PyObject *)self;
}
/* ---[ CCI wrapper */
static PyObject *Py_cci_New(PyTypeObject *type,
struct cp_ccid *owner, cci_t cci,
unsigned int idx)
{
struct cp_cci *cc;
cc = (struct cp_cci *)_PyObject_New(type);
if ( NULL == cc ) {
PyErr_SetString(PyExc_MemoryError,
"Allocating chipcard interface");
return NULL;
}
cc->owner = (PyObject *)owner;
cc->slot = cci;
cc->index = idx;
Py_INCREF(cc->owner);
return (PyObject *)cc;
}
PyObject * PyPreprocessor_scanHeaders( PyPreprocessor * self, PyObject * args, PyObject * kwds )
{
static char * kwlist[] = { "pp_ctx", "filename", NULL };
PyObject * pObject = 0;
PyObject * filename = 0;
assert( self->pp );
if ( !PyArg_ParseTupleAndKeywords( args, kwds, "OO", kwlist, &pObject, &filename ) )
return NULL;
if ( !pObject || ( (PyTypeObject *)PyObject_Type( pObject ) != &PyPreprocessingContextType ) )
{
PyErr_SetString( PyExc_Exception, "Invalid preprocessing context parameter." );
return NULL;
}
PyPreprocessingContext const * ppContext( reinterpret_cast<PyPreprocessingContext *>( pObject ) );
if ( filename && !PyUnicode_Check( filename ) )
{
PyErr_SetString( PyExc_Exception, "Expected a string as 'filename' parameter." );
return NULL;
}
Headers headers;
HeaderList missing;
PyThreadState * _save;
bool result;
try
{
Py_UNBLOCK_THREADS
result = self->pp->scanHeaders( *ppContext->ppContext, PyUnicode_AsUTF8( filename ), headers, missing );
}
catch ( std::runtime_error const & error )
{
Py_BLOCK_THREADS
PyErr_SetString( PyExc_RuntimeError, error.what() );
return NULL;
}
catch ( std::exception const & error )
{
Py_BLOCK_THREADS
PyErr_SetString( PyExc_Exception, error.what() );
return NULL;
}
catch ( ... )
{
Py_BLOCK_THREADS
PyErr_SetString( PyExc_Exception, "Unhandled exception" );
return NULL;
}
if ( !result )
{
Py_BLOCK_THREADS
PyErr_SetString( PyExc_Exception, "Failed to preprocess file." );
return NULL;
}
// Group result by dir.
typedef std::vector<Header const *> HeaderPtrList;
typedef std::unordered_map<Dir, HeaderPtrList> DirsAndHeaders;
DirsAndHeaders dirsAndHeaders;
for ( Header const & header : headers )
dirsAndHeaders[ header.dir ].push_back( &header );
Py_BLOCK_THREADS
PyObject * dirsTuple = PyTuple_New( dirsAndHeaders.size() );
std::size_t dirIndex( 0 );
for ( DirsAndHeaders::value_type const & dirAndHeaders : dirsAndHeaders )
{
PyObject * headersInDirTuple = PyTuple_New( dirAndHeaders.second.size() );
std::size_t headersInDirTupleIndex( 0 );
for ( Header const * header : dirAndHeaders.second )
{
PyObject * headerEntry = PyTuple_New( 3 );
PyTuple_SET_ITEM( headerEntry, 0, PyUnicode_FromStringAndSize( header->name.get().data(), header->name.get().size() ) );
PyObject * const isRelative( header->relative ? Py_True : Py_False );
Py_INCREF( isRelative );
PyTuple_SET_ITEM( headerEntry, 1, isRelative );
PyContentEntry * contentEntry( (PyContentEntry *)_PyObject_New( &PyContentEntryType ) );
contentEntry->ptr = header->contentEntry.get();
intrusive_ptr_add_ref( contentEntry->ptr );
PyTuple_SET_ITEM( headerEntry, 2, (PyObject *)contentEntry );
PyTuple_SET_ITEM( headersInDirTuple, headersInDirTupleIndex++, headerEntry );
}
PyObject * dirTuple = PyTuple_New( 2 );
llvm::StringRef const dirStr( dirAndHeaders.first.get() );
PyObject * dir = PyUnicode_FromStringAndSize( dirStr.data(), dirStr.size() );
PyTuple_SET_ITEM( dirTuple, 0, dir );
PyTuple_SET_ITEM( dirTuple, 1, headersInDirTuple );
PyTuple_SET_ITEM( dirsTuple, dirIndex++, dirTuple );
}
PyObject * missingHeadersTuple = PyTuple_New( missing.size() );
std::size_t missingIndex( 0 );
for ( HeaderList::value_type const & missingHeader : missing )
{
PyObject * val = PyUnicode_FromStringAndSize( missingHeader.data(), missingHeader.size() );
PyTuple_SET_ITEM( missingHeadersTuple, missingIndex++, val );
}
PyObject * resultTuple = PyTuple_New( 2 );
PyTuple_SET_ITEM( resultTuple, 0, dirsTuple );
PyTuple_SET_ITEM( resultTuple, 1, missingHeadersTuple );
return resultTuple;
}
pcm_FrameList*
FrameList_create(void)
{
return (pcm_FrameList*)_PyObject_New(&pcm_FrameListType);
}
/*
* ============================================================================
*
* Module Initialization
*
* ============================================================================
*/
#define MODULE_DOC "C implementations of the infinity, segment, and segmentlist classes from the segments module."
static PyModuleDef moduledef = {
PyModuleDef_HEAD_INIT,
MODULE_NAME, MODULE_DOC, -1, NULL
};
PyMODINIT_FUNC PyInit___segments(void); /* Silence -Wmissing-prototypes */
PyMODINIT_FUNC PyInit___segments(void)
{
PyObject *module = NULL;
if(PyType_Ready(&segments_Infinity_Type) < 0)
goto done;
if(!segments_Segment_Type.tp_hash)
segments_Segment_Type.tp_hash = PyTuple_Type.tp_hash;
if(PyType_Ready(&segments_Segment_Type) < 0)
goto done;
if(PyType_Ready(&segments_SegmentList_Type) < 0)
goto done;
/*
* Initialize module
*/
module = PyModule_Create(&moduledef);
if (!module)
goto done;
/*
* Create infinity class
*/
Py_INCREF(&segments_Infinity_Type);
PyModule_AddObject(module, "infinity", (PyObject *) &segments_Infinity_Type);
/*
* Create positive and negative infinity instances
*/
segments_PosInfinity = (segments_Infinity *) _PyObject_New(&segments_Infinity_Type);
segments_NegInfinity = (segments_Infinity *) _PyObject_New(&segments_Infinity_Type);
Py_INCREF(segments_PosInfinity);
Py_INCREF(segments_NegInfinity);
PyModule_AddObject(module, "PosInfinity", (PyObject *) segments_PosInfinity);
PyModule_AddObject(module, "NegInfinity", (PyObject *) segments_NegInfinity);
/*
* Create segment class. Ideally the .tp_hash field would be
* initialized along with the other fields in the initializer in
* segment.c, but something about PyTuple_Type makes the compiler
* unhappy with that.
*/
Py_INCREF(&segments_Segment_Type);
PyModule_AddObject(module, "segment", (PyObject *) &segments_Segment_Type);
/* uninherit tp_print from tuple class */
segments_Segment_Type.tp_print = NULL;
/*
* Create segmentlist class
*/
Py_INCREF(&segments_SegmentList_Type);
PyModule_AddObject(module, "segmentlist", (PyObject *) &segments_SegmentList_Type);
done:
return module;
}
extern "C" PyObject* _PyObject_GC_New(PyTypeObject* cls) {
return _PyObject_New(cls);
}
