c# pdf to tiff converter : Create pdf signature box software application dll winforms azure windows web forms pcb366-part461

15.12. Turning a Function Pointer into a Callable
Problem
You have (somehow) obtained the memory address of a compiled function, but want
to turn it into a Python callable that you can use as an extension function.
Solution
The ctypes module can be used to create Python callables that wrap around arbitrary
memory addresses. The following example shows how to obtain the raw, low-level ad‐
dress of a C function and how to turn it back into a callable object:
>>> import ctypes
>>> lib = ctypes.cdll.LoadLibrary(None)
>>> # Get the address of sin() from the C math library
>>> addr = ctypes.cast(lib.sinctypes.c_void_p).value
>>> addr
140735505915760
>>> # Turn the address into a callable function
>>> functype = ctypes.CFUNCTYPE(ctypes.c_doublectypes.c_double)
>>> func = functype(addr)
>>> func
<CFunctionType object at 0x1006816d0>
>>> # Call the resulting function
>>> func(2)
0.9092974268256817
>>> func(0)
0.0
>>>
Discussion
To make a callable, you must first create a CFUNCTYPE instance. The first argument to
CFUNCTYPE() is the return type. Subsequent arguments are the types of the arguments.
Once you have defined the function type, you wrap it around an integer memory address
to create a callable object. The resulting object is used like any normal function accessed
through ctypes.
This recipe might look rather cryptic and low level. However, it is becoming increasingly
common for programs and libraries to utilize advanced code generation techniques like
just in-time compilation, as found in libraries such as LLVM.
For example, here is a simple example that uses the llvmpy extension  to make a small
assembly function, obtain a function pointer to it, and turn it into a Python callable:
15.12. Turning a Function Pointer into a Callable  |  643
Create pdf signature box - C# PDF File Permission Library: add, remove, update PDF file permission in C#.net, ASP.NET, MVC, WPF
Tell C# users how to set PDF file permissions, like printing, copying, modifying, extracting, annotating, form filling, etc
add signature to pdf document; adding signature to pdf file
Create pdf signature box - VB.NET PDF File Permission Library: add, remove, update PDF file permission in vb.net, ASP.NET, MVC, WPF
VB.NET Tutorial for How to Set PDF File Access Permissions Using XDoc.PDF for .NET
add jpg signature to pdf; sign pdf
>>> from llvm.core import ModuleFunctionTypeBuilder
>>> mod = Module.new('example')
>>> f = Function.new(mod,Type.function(Type.double(), \
[Type.double(), Type.double()], False), 'foo')
>>> block = f.append_basic_block('entry')
>>> builder = Builder.new(block)
>>> x2 = builder.fmul(f.args[0],f.args[0])
>>> y2 = builder.fmul(f.args[1],f.args[1])
>>> r = builder.fadd(x2,y2)
>>> builder.ret(r)
<llvm.core.Instruction object at 0x10078e990>
>>> from llvm.ee import ExecutionEngine
>>> engine = ExecutionEngine.new(mod)
>>> ptr = engine.get_pointer_to_function(f)
>>> ptr
4325863440
>>> foo = ctypes.CFUNCTYPE(ctypes.c_doublectypes.c_doublectypes.c_double)(ptr)
>>> # Call the resulting function
>>> foo(2,3)
13.0
>>> foo(4,5)
41.0
>>> foo(1,2)
5.0
>>>
It goes without saying that doing anything wrong at this level will probably cause the
Python interpreter to die a horrible death. Keep in mind that you’re directly working
with  machine-level  memory  addresses  and  native  machine  code—not  Python
functions.
15.13. Passing NULL-Terminated Strings to C Libraries
Problem
You are writing an extension module that needs to pass a NULL-terminated string to a
C library. However, you’re not entirely sure how to do it with Python’s Unicode string
implementation.
Solution
Many C libraries include functions that operate on NULL-terminated strings declared
as type char *. Consider the following C function that we will use for the purposes of
illustration and testing:
void print_chars(char *s) {
while (*s) {
printf("%2x ", (unsigned char*s);
644  |  Chapter 15: C Extensions
C# PDF Digital Signature Library: add, remove, update PDF digital
Barcode Read. Barcode Create. OCR. Twain. Edit Digital Signatures. |. Home ›› XDoc.PDF ›› C# PDF: Edit PDF Digital Signature.
adding a signature to a pdf; export pdf to word sign in
VB.NET PDF Digital Signature Library: add, remove, update PDF
Barcode Read. Barcode Create. OCR. Twain. Edit Digital Signatures. |. Home ›› XDoc.PDF ›› VB.NET PDF: Edit PDF Digital Signature.
export pdf sign in; adding signature to pdf in preview
s++;
}
printf("\n");
}
This function simply prints out the hex representation of individual characters so that
the passed strings can be easily debugged. For example:
print_chars("Hello");   // Outputs: 48 65 6c 6c 6f
For calling such a C function from Python, you have a few choices. First, you could
restrict it to only operate on bytes using "y" conversion code to PyArg_ParseTuple()
like this:
static PyObject *py_print_chars(PyObject *selfPyObject *args) {
char *s;
if (!PyArg_ParseTuple(args"y"&s)) {
return NULL;
}
print_chars(s);
Py_RETURN_NONE;
}
The resulting function operates as follows. Carefully observe how bytes with embedded
NULL bytes and Unicode strings are rejected:
>>> print_chars(b'Hello World')
48 65 6c 6c 6f 20 57 6f 72 6c 64
>>> print_chars(b'Hello\x00World')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeErrormust be bytes without null bytes, not bytes
>>> print_chars('Hello World')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError'str' does not support the buffer interface
>>>
If you want to pass Unicode strings instead, use the "s" format code to PyArg_Parse
Tuple() such as this:
static PyObject *py_print_chars(PyObject *selfPyObject *args) {
char *s;
if (!PyArg_ParseTuple(args"s"&s)) {
return NULL;
}
print_chars(s);
Py_RETURN_NONE;
}
15.13. Passing NULL-Terminated Strings to C Libraries  |  645
C# PDF insert image Library: insert images into PDF in C#.net, ASP
Create high resolution PDF file without image quality users to insert vector images to PDF file. Import graphic picture, digital photo, signature and logo into
create pdf with signature field; create transparent signature stamp for pdf
C# WinForms Viewer: Load, View, Convert, Annotate and Edit PDF
Add text box to PDF file in preview. • Draw PDF markups. PDF Protection. • Sign PDF document with signature. • Erase PDF text. • Erase PDF images.
pdf export sign in; pdf will signature
When used, this will automatically convert all strings to a NULL-terminated UTF-8
encoding. For example:
>>> print_chars('Hello World')
48 65 6c 6c 6f 20 57 6f 72 6c 64
>>> print_chars('Spicy Jalape\u00f1o' # Note: UTF-8 encoding
53 70 69 63 79 20 4a 61 6c 61 70 65 c3 b1 6f
>>> print_chars('Hello\x00World')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeErrormust be str without null characters, not str
>>> print_chars(b'Hello World')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeErrormust be str, not bytes
>>>
If for some reason, you are working directly with a PyObject * and can’t use PyArg_Par
seTuple(), the following code samples show how you can check and extract a suitable
char * reference, from both a bytes and string object:
/* Some Python Object (obtained somehow) */
PyObject *obj;
/* Conversion from bytes */
{
char *s;
s = PyBytes_AsString(o);
if (!s) {
return NULL  /* TypeError already raised */
}
print_chars(s);
}
/* Conversion to UTF-8 bytes from a string */
{
PyObject *bytes;
char *s;
if (!PyUnicode_Check(obj)) {
PyErr_SetString(PyExc_TypeError"Expected string");
return NULL;
}
bytes = PyUnicode_AsUTF8String(obj);
s = PyBytes_AsString(bytes);
print_chars(s);
Py_DECREF(bytes);
}
Both of the preceding conversions guarantee NULL-terminated data, but they do not
check for embedded NULL bytes elsewhere inside the string. Thus, that’s something
that you would need to check yourself if it’s important.
646  |  Chapter 15: C Extensions
How to C#: Basic SDK Concept of XDoc.PDF for .NET
create, load, combine, and split PDF file(s), and add, create, insert, delete, re To be specific, you can edit PDF password and digital signature, and set
pdf signature stamp; create signature from pdf
VB.NET PDF: Basic SDK Concept of XDoc.PDF
create, load, combine, and split PDF file(s), and add, create, insert, delete, re To be specific, you can edit PDF password and digital signature, and set
pdf signature field; add a signature to a pdf file
Discussion
If it all possible, you should try to avoid writing code that relies on NULL-terminated
strings since Python has no such requirement. It is almost always better to handle strings
using the combination of a pointer and a size if possible. Nevertheless, sometimes you
have to work with legacy C code that presents no other option.
Although it is easy to use, there is a hidden memory overhead associated with using the
"s" format code to PyArg_ParseTuple() that is easy to overlook. When you write code
that uses this conversion, a UTF-8 string is created and permanently attached to the
original string object. If the original string contains non-ASCII characters, this makes
the size of the string increase until it is garbage collected. For example:
>>> import sys
>>> s = 'Spicy Jalape\u00f1o'
>>> sys.getsizeof(s)
87
>>> print_chars(s    # Passing string
53 70 69 63 79 20 4a 61 6c 61 70 65 c3 b1 6f
>>> sys.getsizeof(s  # Notice increased size
103
>>>
If this growth in memory use is a concern, you should rewrite your C extension code
to use the PyUnicode_AsUTF8String() function like this:
static PyObject *py_print_chars(PyObject *selfPyObject *args) {
PyObject *o*bytes;
char *s;
if (!PyArg_ParseTuple(args"U"&o)) {
return NULL;
}
bytes = PyUnicode_AsUTF8String(o);
s = PyBytes_AsString(bytes);
print_chars(s);
Py_DECREF(bytes);
Py_RETURN_NONE;
}
With this modification, a UTF-8 encoded string is created if needed, but then discarded
after use. Here is the modified behavior:
>>> import sys
>>> s = 'Spicy Jalape\u00f1o'
>>> sys.getsizeof(s)
87
>>> print_chars(s)
53 70 69 63 79 20 4a 61 6c 61 70 65 c3 b1 6f
>>> sys.getsizeof(s)
87
>>>
15.13. Passing NULL-Terminated Strings to C Libraries  |  647
C# Create PDF Library SDK to convert PDF from other file formats
What's more, you can also protect created PDF file by adding digital signature (watermark) on PDF using C# code. Create PDF Document from Existing Files Using
add signature pdf online; pdf add signature field
VB.NET PDF Library SDK to view, edit, convert, process PDF file
Password, digital signature and PDF text, image and page added to a specific location on PDF file page. In addition, you can easily create, modify, and delete
create pdf signature field; pdf signature
If you are trying to pass NULL-terminated strings to functions wrapped via ctypes, be
aware that ctypes only allows bytes to be passed and that it does not check for embedded
NULL bytes. For example:
>>> import ctypes
>>> lib = ctypes.cdll.LoadLibrary("./libsample.so")
>>> print_chars = lib.print_chars
>>> print_chars.argtypes = (ctypes.c_char_p,)
>>> print_chars(b'Hello World')
48 65 6c 6c 6f 20 57 6f 72 6c 64
>>> print_chars(b'Hello\x00World')
48 65 6c 6c 6f
>>> print_chars('Hello World')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ctypes.ArgumentError: argument 1: <class 'TypeError'>wrong type
>>>
If you want to pass a string instead of bytes, you need to perform a manual UTF-8
encoding first. For example:
>>> print_chars('Hello World'.encode('utf-8'))
48 65 6c 6c 6f 20 57 6f 72 6c 64
>>>
For other extension tools (e.g., Swig, Cython), careful study is probably in order should
you decide to use them to pass strings to C code.
15.14. Passing Unicode Strings to C Libraries
Problem
You are writing an extension module that needs to pass a Python string to a C library
function that may or may not know how to properly handle Unicode.
Solution
There are many issues to be concerned with here, but the main one is that existing C
libraries won’t understand Python’s native representation of Unicode. Therefore, your
challenge is to convert the Python string into a form that can be more easily understood
by C libraries.
For the purposes of illustration, here are two C functions that operate on string data
and output it for the purposes of debugging and experimentation. One uses bytes pro‐
vided in the form char *, int, whereas the other uses wide characters in the form
wchar_t *, int:
void print_chars(char *sint len) {
int n = 0;
648  |  Chapter 15: C Extensions
.NET PDF Document Viewing, Annotation, Conversion & Processing
programmatically. Document Protect. Apply password to protect PDF. Allow to create digital signature. Easy to set PDF file permission. Easy
add signature to pdf file; add signature to pdf preview
VB.NET PDF insert image library: insert images into PDF in vb.net
Create high resolution PDF file without image quality losing in users to insert images to PDF file in Import graphic picture, digital photo, signature and logo
pdf to word converter sign in; create signature pdf
while (n < len) {
printf("%2x ", (unsigned chars[n]);
n++;
}
printf("\n");
}
void print_wchars(wchar_t *sint len) {
int n = 0;
while (n < len) {
printf("%x "s[n]);
n++;
}
printf("\n");
}
For the byte-oriented function print_chars(), you need to convert Python strings into
a suitable byte encoding such as UTF-8. Here is a sample extension function that does
this:
static PyObject *py_print_chars(PyObject *selfPyObject *args) {
char *s;
Py_ssize_t  len;
if (!PyArg_ParseTuple(args"s#"&s, &len)) {
return NULL;
}
print_chars(slen);
Py_RETURN_NONE;
}
For library functions that work with the machine native wchar_t type, you can write
extension code such as this:
static PyObject *py_print_wchars(PyObject *selfPyObject *args) {
wchar_t *s;
Py_ssize_t  len;
if (!PyArg_ParseTuple(args"u#"&s, &len)) {
return NULL;
}
print_wchars(s,len);
Py_RETURN_NONE;
}
Here is an interactive session that illustrates how these functions work:
>>> s = 'Spicy Jalape\u00f1o'
>>> print_chars(s)
53 70 69 63 79 20 4a 61 6c 61 70 65 c3 b1 6f
>>> print_wchars(s)
53 70 69 63 79 20 4a 61 6c 61 70 65 f1 6f
>>>
15.14. Passing Unicode Strings to C Libraries  |  649
Carefully observe how the byte-oriented function print_chars() is receiving UTF-8
encoded data, whereas print_wchars() is receiving the Unicode code point values.
Discussion
Before considering this recipe, you should first study the nature of the C library that
you’re accessing. For many C libraries, it might make more sense to pass bytes instead
of a string. To do that, use this conversion code instead:
static PyObject *py_print_chars(PyObject *selfPyObject *args) {
char *s;
Py_ssize_t  len;
/* accepts bytes, bytearray, or other byte-like object */
if (!PyArg_ParseTuple(args"y#"&s, &len)) {
return NULL;
}
print_chars(slen);
Py_RETURN_NONE;
}
If you decide that you still want to pass strings, you need to know that Python 3 uses an
adaptable string representation that is not entirely straightforward to map directly to C
libraries using the standard types char * or wchar_t * See PEP 393 for details. Thus,
to present string data to C, some kind of conversion is almost always necessary. The s#
and u# format codes to PyArg_ParseTuple() safely perform such conversions.
One potential downside is that such conversions cause the size of the original string
object to permanently increase. Whenever a conversion is made, a copy of the converted
data is kept and attached to the original string object so that it can be reused later. You
can observe this effect:
>>> import sys
>>> s = 'Spicy Jalape\u00f1o'
>>> sys.getsizeof(s)
87
>>> print_chars(s)
53 70 69 63 79 20 4a 61 6c 61 70 65 c3 b1 6f
>>> sys.getsizeof(s)
103
>>> print_wchars(s)
53 70 69 63 79 20 4a 61 6c 61 70 65 f1 6f
>>> sys.getsizeof(s)
163
>>>
For small amounts of string data, this might not matter, but if you’re doing large amounts
of text processing in extensions, you may want to avoid the overhead. Here is an
alternative implementation of the first extension function that avoids these memory
inefficiencies:
650  |  Chapter 15: C Extensions
static PyObject *py_print_chars(PyObject *selfPyObject *args) {
PyObject *obj*bytes;
char *s;
Py_ssize_t   len;
if (!PyArg_ParseTuple(args"U"&obj)) {
return NULL;
}
bytes = PyUnicode_AsUTF8String(obj);
PyBytes_AsStringAndSize(bytes&s, &len);
print_chars(slen);
Py_DECREF(bytes);
Py_RETURN_NONE;
}
Avoiding memory overhead for wchar_t handling is much more tricky. Internally,
Python stores strings using the most efficient representation possible. For example,
strings containing nothing but ASCII are stored as arrays of bytes, whereas strings con‐
taining characters in the range U+0000 to U+FFFF use a two-byte representation. Since
there isn’t a single representation of the data, you can’t just cast the internal array to
wchar_t * and hope that it works. Instead, a wchar_t array has to be created and text
copied into it. The "u#" format code to PyArg_ParseTuple() does this for you at the
cost of efficiency (it attaches the resulting copy to the string object).
If you want to avoid this long-term memory overhead, your only real choice is to copy
the Unicode data into a temporary array, pass it to the C library function, and then
deallocate the array. Here is one possible implementation:
static PyObject *py_print_wchars(PyObject *selfPyObject *args) {
PyObject *obj;
wchar_t *s;
Py_ssize_t len;
if (!PyArg_ParseTuple(args"U"&obj)) {
return NULL;
}
if ((s = PyUnicode_AsWideCharString(obj, &len)) == NULL) {
return NULL;
}
print_wchars(slen);
PyMem_Free(s);
Py_RETURN_NONE;
}
In this implementation, PyUnicode_AsWideCharString() creates a temporary buffer of
wchar_t characters and copies data into it. That buffer is passed to C and then released
afterward. As of this writing, there seems to be a possible bug related to this behavior,
as described at the Python issues page.
15.14. Passing Unicode Strings to C Libraries  |  651
If, for some reason you know that the C library takes the data in a different byte encoding
than UTF-8, you can force Python to perform an appropriate conversion using exten‐
sion code such as the following:
static PyObject *py_print_chars(PyObject *selfPyObject *args) {
char *s = 0;
int   len;
if (!PyArg_ParseTuple(args"es#", "encoding-name", &s, &len)) {
return NULL;
}
print_chars(slen);
PyMem_Free(s);
Py_RETURN_NONE;
}
Last, but not least, if you want to work directly with the characters in a Unicode string,
here is an example that illustrates low-level access:
static PyObject *py_print_wchars(PyObject *selfPyObject *args) {
PyObject *obj;
int nlen;
int kind;
void *data;
if (!PyArg_ParseTuple(args"U"&obj)) {
return NULL;
}
if (PyUnicode_READY(obj< 0) {
return NULL;
}
len = PyUnicode_GET_LENGTH(obj);
kind = PyUnicode_KIND(obj);
data = PyUnicode_DATA(obj);
for (n = 0n < lenn++) {
Py_UCS4 ch = PyUnicode_READ(kinddatan);
printf("%x "ch);
}
printf("\n");
Py_RETURN_NONE;
}
In this code, the PyUnicode_KIND() and PyUnicode_DATA() macros are related to the
variable-width storage of Unicode, as described in PEP 393. The kind variable encodes
information about the underlying storage (8-bit, 16-bit, or 32-bit) and data points the
buffer. In reality, you don’t need to do anything with these values as long as you pass
them to the PyUnicode_READ() macro when extracting characters.
A few final words: when passing Unicode strings from Python to C, you should probably
try to make it as simple as possible. If given the choice between an encoding such as
652  |  Chapter 15: C Extensions
Documents you may be interested
Documents you may be interested