sibling of the 
PC
and 
Include
directories. Do all your work from within this new
location.
2. Open the project — From VC++, use the File ‣ Open Solution dialog (not File ‣
Open!). Navigate to and select the file 
example.sln
, in the copy of the 
example_nt
directory you made above. Click Open.
3. Build the example DLL — In order to check that everything is set up right, try
building:
4. Select a configuration. This step is optional. Choose Build ‣ Configuration Manager ‣
Active Solution Configuration and select either Release or Debug. If you skip this
step, VC++ will use the Debug configuration by default.
5. Build the DLL. Choose Build ‣ Build Solution. This creates all intermediate and result
files  in  a  subdirectory  called  either 
Debug
or 
Release
 depending  on  which
configuration you selected in the preceding step.
6. Testing the debug-mode DLL — Once the Debug build has succeeded, bring up a
DOS box, and change to the 
example_nt\Debug
directory. You should now be able to
repeat the following session (
C>
is the DOS prompt, 
>>>
is the Python prompt; note
that build information and various debug output from Python may not match this
screen dump exactly):
C>..\..\PCbuild\python_d
Adding parser accelerators ...
Done.
Python 2.2 (#28, Dec 19 2001, 23:26:37) [MSC 32 bit (Intel)] on win32
Type "copyright", "credits" or "license" for more information.
>>> import example
[4897 refs]
>>> example.foo()
Hello, world
[4903 refs]
>>>
Congratulations! You’ve successfully built your first Python extension module.
7. Creating your own project — Choose a name and create a directory for it. Copy
your C sources into it. Note that the module source file name does not necessarily
have to match the module name, but the name of the initialization function should
match the module name — you can only import a module 
spam
if its initialization
function is called 
initspam()
, and it should call 
Py_InitModule()
with the string
"spam"
as its first argument (use the minimal 
example.c
in this directory as a guide).
By convention, it lives in a file called 
spam.c
or 
spammodule.c
. The output file should
Pdf file security - C# PDF Digital Signature Library: add, remove, update PDF digital signatures in C#.net, ASP.NET, MVC, WPF
Help to Improve the Security of Your PDF File by Adding Digital Signatures
pdf secure signature; convert secure pdf to word
Pdf file security - VB.NET PDF Digital Signature Library: add, remove, update PDF digital signatures in vb.net, ASP.NET, MVC, WPF
Guide VB.NET Programmers to Improve the Security of Your PDF File by Adding Digital Signatures
decrypt a pdf file online; change pdf document security
be  called 
spam.pyd
(in  Release  mode)  or 
spam_d.pyd
(in Debug  mode). The
extension 
.pyd
was chosen to avoid confusion with a system library 
spam.dll
to
which your module could be a Python interface.
Changed in version 2.5: Previously, file names like 
spam.dll
(in release mode) or
spam_d.dll
(in debug mode) were also recognized.
Now your options are:
8. Copy 
example.sln
and 
example.vcproj
, rename them to 
spam.*
, and edit them by
hand, or
9. Create a brand new project; instructions are below.
In either case, copy 
example_nt\example.def
to 
spam\spam.def
, and edit the new
spam.def
so its second line contains the string ‘
initspam
‘. If you created a new
project yourself, add the file 
spam.def
to the project now. (This is an annoying little
file with only two lines. An alternative approach is to forget about the 
.def
file, and
add the option /export:initspam somewhere to the Link settings, by manually editing
the setting in Project Properties dialog).
10. Creating a brand new project — Use the File ‣ New ‣ Project dialog to create a
new Project Workspace. Select Visual C++ Projects/Win32/ Win32 Project, enter the
name (
spam
), and make sure the Location is set to parent of the 
spam
directory you
have created (which should be a direct subdirectory of the Python build tree, a sibling
of 
Include
and 
PC
). Select Win32 as the platform (in my version, this is the only
choice). Make sure the Create new workspace radio button is selected. Click OK.
You should now create the file 
spam.def
as instructed in the previous section. Add
the source files to the project, using Project ‣ Add Existing Item. Set the pattern to
*.*
and select both 
spam.c
and 
spam.def
and click OK. (Inserting them one by one
is fine too.)
Now open the Project ‣ spam properties dialog. You only need to change a few
settings. Make sure All Configurations is selected from the Settings for: dropdown
list. Select the C/C++ tab. Choose the General category in the popup menu at the
top. Type the following text in the entry box labeled Additional Include Directories:
..\Include,..\PC
Then, choose the General category in the Linker tab, and enter
VB.NET PDF Password Library: add, remove, edit PDF file password
Remove password from PDF. Set PDF security level. This Visual Basic coding example will help you open an encrypted PDF file. ' Define input file path.
pdf unlock; add security to pdf file
C# PDF Password Library: add, remove, edit PDF file password in C#
advanced PDF password remover component can help users unlock PDF file without password. PDF document in C# project, XDoc.PDF provides some PDF security settings
change security on pdf; secure pdf
..\PCbuild
in the text box labelled Additional library Directories.
Now you need to add some mode-specific settings:
Select Release in the Configuration dropdown list. Choose the Link tab, choose the
Input category, and append 
pythonXY.lib
to the list in the Additional Dependencies
box.
Select Debug in the Configuration dropdown list, and append 
pythonXY_d.lib
to the
list  in  the Additional Dependencies  box. Then click the C/C++ tab, select Code
Generation, and select Multi-threaded Debug DLL from the Runtime library dropdown
list.
Select Release again from the Configuration dropdown list. Select Multi-threaded
DLL from the Runtime library dropdown list.
If your module creates a new type, you may have trouble with this line:
PyObject_HEAD_INIT(&PyType_Type)
Static type object initializers in extension modules may cause compiles to fail with an
error message like “initializer not a constant”. This shows up when building DLL under
MSVC. Change it to:
PyObject_HEAD_INIT(NULL)
and add the following to the module initialization function:
if (PyType_Ready(&MyObject_Type) < 0)
return NULL;
4.2. Differences Between Unix and Windows
Unix and Windows use completely different paradigms for run-time loading of code.
Before you try to build a module that can be dynamically loaded, be aware of how your
system works.
In Unix, a shared object (
.so
) file contains code to be used by the program, and also the
names of functions and data that it expects to find in the program. When the file is joined
to the program, all references to those functions and data in the file’s code are changed
to point to the actual locations in the program where the functions and data are placed in
Online Split PDF file. Best free online split PDF tool.
You can use our .NET PDF SDK to set file split settings for your PDF You can receive the PDF files by simply clicking download and you are good to Web Security.
pdf secure; pdf security
Online Remove password from protected PDF file
You can receive the unlocked PDF by simply clicking download and you are good to go! Web Security. When you upload a file it is transmitted using a secure
create pdf the security level is set to high; creating secure pdf files
memory. This is basically a link operation.
In Windows, a dynamic-link library (
.dll
) file has no dangling references. Instead, an
access to functions or data goes through a lookup table. So the DLL code does not have
to be fixed up at runtime to refer to the program’s memory; instead, the code already
uses the DLL’s lookup table, and the lookup table is modified at runtime to point to the
functions and data.
In Unix, there is only one type of library file (
.a
) which contains code from several object
files (
.o
). During the link step to create a shared object file (
.so
), the linker may find that
it doesn’t know where an identifier is defined. The linker will look for it in the object files in
the libraries; if it finds it, it will include all the code from that object file.
In Windows, there are two types of library, a static library and an import library (both
called 
.lib
). A static library is like a Unix 
.a
file; it contains code to be included as
necessary. An import library is basically used only to reassure the linker that a certain
identifier is legal, and will be present in the program when the DLL is loaded. So the linker
uses the information from the import library to build the lookup table for using identifiers
that are not included in the DLL. When an application or a DLL is linked, an import library
may be generated, which will need to be used for all future DLLs that depend on the
symbols in the application or DLL.
Suppose you are building two dynamic-load modules, B and C, which should share
another block of code A. On Unix, you would not pass 
A.a
to the linker for 
B.so
and
C.so
; that would cause it to be included twice, so that B and C would each have their own
copy. In Windows, building 
A.dll
will also build 
A.lib
. You do pass 
A.lib
to the linker for
B and C. 
A.lib
does not contain code; it just contains information which will be used at
runtime to access A’s code.
In Windows, using an import library is sort of like using 
import spam
; it gives you access
to spam’s names, but does not create a separate copy. On Unix, linking with a library is
more like 
from spam import *
; it does create a separate copy.
4.3. Using DLLs in Practice
Windows Python is built in Microsoft Visual C++; using other compilers may or may not
work (though Borland seems to). The rest of this section is MSVC++ specific.
When creating DLLs in Windows, you must pass 
pythonXY.lib
to the linker. To build two
DLLs, spam and ni (which uses C functions found in spam), you could use these
commands:
Online Convert PDF file to Word. Best free online PDF Conversion
Your word file is converted to look just the same as it does in your office We try to make it as easy as possible to convert your PDF files to Docx Web Security.
copy text from locked pdf; decrypt a pdf
Online Convert PDF file to Tiff. Best free online PDF Tif
Your Tiff file is converted to look just the same as it does in your office We try to make it as easy as possible to convert your PDF files to Tiff Web Security.
decrypt pdf password online; create secure pdf
cl /LD /I/python/include spam.c ../libs/pythonXY.lib
cl /LD /I/python/include ni.c spam.lib ../libs/pythonXY.lib
The first command created three files: 
spam.obj
spam.dll
and 
spam.lib
Spam.dll
does
not contain any Python functions (such as 
PyArg_ParseTuple()
), but it does know how to
find the Python code thanks to 
pythonXY.lib
.
The second command created 
ni.dll
(and 
.obj
and 
.lib
), which knows how to find the
necessary functions from spam, and also from the Python executable.
Not every identifier is exported to the lookup table. If you want any other modules
(including  Python)  to  be  able  to  see  your  identifiers,  you  have  to  say
_declspec(dllexport)
, as in 
void _declspec(dllexport) initspam(void)
or 
PyObject
_declspec(dllexport) *NiGetSpamData(void)
.
Developer Studio will throw in a lot of import libraries that you do not really need, adding
about 100K to your executable. To get rid of them, use the Project Settings dialog, Link
tab, to specify ignore default libraries. Add the correct 
msvcrtxx.lib
to the list of libraries.
index
modules |
next |
previous |
Python » Python v2.7.6 documentation » Extending and Embedding the Python Interpreter
»
© Copyright
1990-2013, Python Software Foundation. 
The Python Software Foundation is a non-profit corporation. Please donate.
Last updated on Nov 10, 2013. Found a bug
Created using Sphinx
1.0.7.
Online Change your PDF file Permission Settings
You can receive the locked PDF by simply clicking download and you are good to go!. Web Security. When you upload a file it is transmitted using a secure
change security settings pdf; decrypt pdf file
Online Convert PDF file to Word. Best free online PDF Conversion
Your PDF file is converted to look just the same as it does in your office to make it as easy as possible to convert your Tiff/Tif files to PDF. Web Security.
change pdf document security properties; convert secure webpage to pdf
index
modules |
next |
previous |
5. Embedding Python in Another Application
The previous chapters discussed how to extend Python, that is, how to extend the
functionality of Python by attaching a library of C functions to it. It is also possible to do it
the other way around: enrich your C/C++ application by embedding Python in it.
Embedding  provides  your  application  with  the  ability  to  implement  some  of  the
functionality of your application in Python rather than C or C++. This can be used for
many purposes; one example would be to allow users to tailor the application to their
needs by writing some scripts in Python. You can also use it yourself if some of the
functionality can be written in Python more easily.
Embedding Python is similar to extending it, but not quite. The difference is that when you
extend Python, the main program of the application is still the Python interpreter, while if
you embed Python, the main program may have nothing to do with Python — instead,
some parts of the application occasionally call the Python interpreter to run some Python
code.
So if you are embedding Python, you are providing your own main program. One of the
things this main program has to do is initialize the Python interpreter. At the very least,
you have to call the function 
Py_Initialize()
. There are optional calls to pass command
line arguments to Python. Then later you can call the interpreter from any part of the
application.
There are several different ways to call the interpreter: you can pass a string containing
Python statements to 
PyRun_SimpleString()
, or you can pass a stdio file pointer and a
file name (for identification in error messages only) to 
PyRun_SimpleFile()
. You can also
call the lower-level operations described in the previous chapters to construct and use
Python objects.
A simple demo of embedding Python can be found in the directory 
Demo/embed/
of the
source distribution.
See also:
Python/C API Reference Manual
The details of Python’s C interface are given in this manual. A great deal of
necessary information can be found here.
Python » Python v2.7.6 documentation » Extending and Embedding the Python Interpreter
»
Online Convert PowerPoint to PDF file. Best free online export
Your PDF file is converted to look just the same as it does in your office to make it as easy as possible to convert your PPTX/PPT files to PDF. Web Security.
decrypt pdf online; change security settings on pdf
5.1. Very High Level Embedding
The simplest form of embedding Python is the use of the very high level interface. This
interface is intended to execute a Python script without needing to interact with the
application directly. This can for example be used to perform some operation on a file.
#include <Python.h>
int
main(int argc, char *argv[])
{
Py_SetProgramName(argv[0]); /* optional but recommended */
Py_Initialize();
PyRun_SimpleString("from time import time,ctime\n"
"print 'Today is',ctime(time())\n");
Py_Finalize();
return 0;
}
The 
Py_SetProgramName()
function should be called before 
Py_Initialize()
to inform
the interpreter about paths to Python run-time libraries. Next, the Python interpreter is
initialized with 
Py_Initialize()
, followed by the execution of a hard-coded Python script
that prints the date and time. Afterwards, the 
Py_Finalize()
call shuts the interpreter
down, followed by the end of the program. In a real program, you may want to get the
Python script from another source, perhaps a text-editor routine, a file, or a database.
Getting the Python code from a file can better be done by using the 
PyRun_SimpleFile()
function, which saves you the trouble of allocating memory space and loading the file
contents.
5.2. Beyond Very High Level Embedding: An overview
The high level interface gives you the ability to execute arbitrary pieces of Python code
from your application, but exchanging data values is quite cumbersome to say the least.
If you want that, you should use lower level calls. At the cost of having to write more C
code, you can achieve almost anything.
It should be noted that extending Python and embedding Python is quite the same
activity, despite the different intent. Most topics discussed in the previous chapters are
still valid. To show this, consider what the extension code from Python to C really does:
1. Convert data values from Python to C,
2. Perform a function call to a C routine using the converted values, and
3. Convert the data values from the call from C to Python.
When embedding Python, the interface code does:
1. Convert data values from C to Python,
2. Perform a function call to a Python interface routine using the converted values, and
3. Convert the data values from the call from Python to C.
As you can see, the data conversion steps are simply swapped to accommodate the
different direction of the cross-language transfer. The only difference is the routine that
you call between both data conversions. When extending, you call a C routine, when
embedding, you call a Python routine.
This chapter will not discuss how to convert data from Python to C and vice versa. Also,
proper use of references and dealing with errors is assumed to be understood. Since
these aspects do not differ from extending the interpreter, you can refer to earlier
chapters for the required information.
5.3. Pure Embedding
The first program aims to execute a function in a Python script. Like in the section about
the very high level interface, the Python interpreter does not directly interact with the
application (but that will change in the next section).
The code to run a function defined in a Python script is:
#include <Python.h>
int
main(int argc, char *argv[])
{
PyObject *pName, *pModule, *pDict, *pFunc;
PyObject *pArgs, *pValue;
int i;
if (argc < 3) {
fprintf(stderr,"Usage: call pythonfile funcname [args]\n");
return 1;
}
Py_Initialize();
pName = PyString_FromString(argv[1]);
/* Error checking of pName left out */
pModule = PyImport_Import(pName);
Py_DECREF(pName);
if (pModule != NULL) {
pFunc = PyObject_GetAttrString(pModule, argv[2]);
/* pFunc is a new reference */
if (pFunc && PyCallable_Check(pFunc)) {
pArgs = PyTuple_New(argc - 3);
for (i = 0; i < argc - 3++i) {
pValue = PyInt_FromLong(atoi(argv[i + 3]));
if (!pValue) {
Py_DECREF(pArgs);
Py_DECREF(pModule);
fprintf(stderr, "Cannot convert argument\n");
return 1;
}
/* pValue reference stolen here: */
PyTuple_SetItem(pArgs, i, pValue);
}
pValue = PyObject_CallObject(pFunc, pArgs);
Py_DECREF(pArgs);
if (pValue != NULL) {
printf("Result of call: %ld\n", PyInt_AsLong(pValue));
Py_DECREF(pValue);
}
else {
Py_DECREF(pFunc);
Py_DECREF(pModule);
PyErr_Print();
fprintf(stderr,"Call failed\n");
return 1;
}
}
else {
if (PyErr_Occurred())
PyErr_Print();
fprintf(stderr, "Cannot find function \"%s\"\n", argv[2]);
}
Py_XDECREF(pFunc);
Py_DECREF(pModule);
}
else {
PyErr_Print();
fprintf(stderr, "Failed to load \"%s\"\n", argv[1]);
return 1;
}
Py_Finalize();
return 0;
}
This code loads a Python script using 
argv[1]
, and calls the function named in 
argv[2]
.
Its integer arguments are the other values of the 
argv
array. If you compile and link this
program (let’s call the finished executable call), and use it to execute a Python script,
such as:
def multiply(a,b):
print "Will compute", a, "times", b
= 0
for i in range(0, a):
= c + b
return c
then the result should be:
$ call multiply multiply 3 2
Will compute 3 times 2
Result of call: 6
Although the program is quite large for its functionality, most of the code is for data
conversion between Python and C, and for error reporting. The interesting part with
respect to embedding Python starts with
Py_Initialize();
pName = PyString_FromString(argv[1]);
/* Error checking of pName left out */
pModule = PyImport_Import(pName);
After initializing the interpreter, the script is loaded using 
PyImport_Import()
. This routine
needs  a  Python  string  as  its  argument,  which  is  constructed  using  the
PyString_FromString()
data conversion routine.
pFunc = PyObject_GetAttrString(pModule, argv[2]);
/* pFunc is a new reference */
if (pFunc && PyCallable_Check(pFunc)) {
...
}
Py_XDECREF(pFunc);
Once  the  script  is  loaded,  the  name  we’re  looking  for  is  retrieved  using
PyObject_GetAttrString()
. If the name exists, and the object returned is callable, you
can safely assume that it is a function. The program then proceeds by constructing a
tuple of arguments as normal. The call to the Python function is then made with:
pValue = PyObject_CallObject(pFunc, pArgs);
Upon return of the function, 
pValue
is either NULL or it contains a reference to the return
value of the function. Be sure to release the reference after examining the value.
5.4. Extending Embedded Python
Until now, the embedded Python interpreter had no access to functionality from the
application itself. The Python API allows this by extending the embedded interpreter. That
is, the embedded interpreter gets extended with routines provided by the application.
While it sounds complex, it is not so bad. Simply forget for a while that the application
starts the Python interpreter. Instead, consider the application to be a set of subroutines,
and write some glue code that gives Python access to those routines, just like you would
write a normal Python extension. For example:
Documents you may be interested
Documents you may be interested