php扩展

版权声明：原创作品，允许转载，转载时请务必以超链接形式标明文章原始出版、作者信息和本声明。否则将追究法律责任。http://blog.csdn.net/mayongzhan - 马永占,myz,mayongzhan

php扩展分为两种.一种是php的扩展,一种是zend扩展.(传说中的,这是programing php里讲的).真的希望能有人发表一些关于zend扩展的东西.这才是真正的核心.
本来是要读下源码的.但是似乎php的源码很多.目前只能扫扫边边角角.如果有机会的话,会去读一下源码的.
其实扩展并不是很难,php已经给好了例子和扩展的工具.使用一下就可以了.
先下php源码,解压
然后到解压目录,ext下 执行./ext_stel --extname=myz
然后到解压目录,执行
./buildconf --force
./configure --with-myz=shared --其他的
make
make install
然后就能看到phpinfo()里面多了个myz了.

这里编译了好几次.好象每次都有新问题.多调试几次一定会成功的."妻儿"不舍

附:php源码包中两个重要的文件内容
README.EXT_SKEL
README.SELF-CONTAINED-EXTENSIONS

README.EXT_SKEL

(NOTE: you may also want to take a look at the pear package
PECL_Gen, a PHP-only alternative for this script that
supports way more extension writing tasks and is
supposed to replace ext_skel completely in the long run ...)

WHAT IT IS

It's a tool for automatically creating the basic framework for a PHP module
and writing C code handling arguments passed to your functions from a simple
configuration file. See an example at the end of this file.

HOW TO USE IT

Very simple. First, change to the ext/ directory of the PHP 4 sources. If
you just need the basic framework and will be writing all the code in your
functions yourself, you can now do

./ext_skel --extname=module_name

and everything you need is placed in directory module_name.

[ Note that GNU awk is likely required for this script to work. Debian
systems seem to default to using mawk, so you may need to change the
#! line in skeleton/create_stubs and the cat $proto | awk line in
ext_skel to use gawk explicitly. ]

If you don't need to test the existence of any external header files,
libraries or functions in them, the module is already almost ready to be
compiled in PHP. Just remove 3 comments in your_module_name/config.m4,
change back up to PHP sources top directory, and do

./buildconf; ./configure --enable-module_name; make

But if you already have planned the overall scheme of your module, what
functions it will contain, their return types and the arguments they take
(a very good idea) and don't want to bother yourself with creating function
definitions and handling arguments passed yourself, it's time to create a
function definitions file, which you will give as an argument to ext_skel
with option

--proto=filename.

FORMAT OF FUNCTION DEFINITIONS FILE

All the definitions must be on one line. In it's simplest form, it's just
the function name, e.g.

my_function

but then you'll be left with an almost empty function body without any
argument handling.

Arguments are given in parenthesis after the function name, and are of
the form 'argument_type argument_name'. Arguments are separated from each
other with a comma and optional space. Argument_type can be one of int,
bool, double, float, string, array, object or mixed.

An optional argument is separated from the previous by an optional space,
then '[' and of course comma and optional space, like all the other
arguments. You should close a row of optional arguments with same amount of
']'s as there where '['s. Currently, it does not harm if you forget to do it
or there is a wrong amount of ']'s, but this may change in the future.

An additional short description may be added after the parameters.
If present it will be filled into the 'proto' header comments in the stubs
code and the <refpurpose> tag in the XML documentation.

An example:

my_function(int arg1, int arg2 [, int arg3 [, int arg4]]) this is my 1st

Arguments arg3 and arg4 are optional.

If possible, the function definition should also contain it's return type
in front of the definition. It's not actually used for any C code generating
purposes but PHP in-source documentation instead, and as such, very useful.
It can be any of int, double, string, bool, array, object, resource, mixed
or void.

The file must contain nothing else but function definitions, no comments or
empty lines.

OTHER OPTIONS

--no-help

By default, ext_skel creates both comments in the source code and a test
function to help first time module writers to get started and testing
configuring and compiling their module. This option turns off all such things
which may just annoy experienced PHP module coders. Especially useful with

--stubs=file

which will leave out also all module specific stuff and write just function
stubs with function value declarations and passed argument handling, and
function entries and definitions at the end of the file, for copying and
pasting into an already existing module.

--assign-params
--string-lens

By default, function proto 'void foo(string bar)' creates the following:
...
zval **bar;
... (zend_get_parameters_ex() called in the middle...)
convert_to_string_ex(bar);

Specifying both of these options changes the generated code to:
...
zval **bar_arg;
int bar_len;
char *bar = NULL;
... (zend_get_parameters_ex() called in the middle...)
convert_to_string_ex(bar_arg);
bar = Z_STRVAL_PP(bar_arg);
bar_len = Z_STRLEN_PP(bar_arg);

You shouldn't have to ask what happens if you leave --string-lens out. If you
have to, it's questionable whether you should be reading this document.

--with-xml[=file]

Creates the basics for phpdoc .xml file.

--full-xml

Not implemented yet. When or if there will ever be created a framework for
self-contained extensions to use phpdoc system for their documentation, this
option enables it on the created xml file.

CURRENT LIMITATIONS, BUGS AND OTHER ODDITIES

Only arguments of types int, bool, double, float, string and array are
handled. For other types you must write the code yourself. And for type
mixed, it wouldn't even be possible to write anything, because only you
know what to expect.

It can't handle correctly, and probably never will, variable list of
of arguments. (void foo(int bar [, ...])

Don't trust the generated code too much. It tries to be useful in most of
the situations you might encounter, but automatic code generation will never
beat a programmer who knows the real situation at hand. ext_skel is generally
best suited for quickly generating a wrapper for c-library functions you
might want to have available in PHP too.

This program doesn't have a --help option. It has --no-help instead.

EXAMPLE

The following _one_ line

bool my_drawtext(resource image, string text, resource font, int x, int y [, int color])

will create this function definition for you (note that there are a few
question marks to be replaced by you, and you must of course add your own
value definitions too):

/* {{{ proto bool my_drawtext(resource image, string text, resource font, int x, int y[, int color])
*/
PHP_FUNCTION(my_drawtext)
{
zval **image, **text, **font, **x, **y, **color;
int argc;
int image_id = -1;
int font_id = -1;

argc = ZEND_NUM_ARGS();
if (argc < 5 || argc > 6 || zend_get_parameters_ex(argc, &image, &text, &font, &x, &y, &color) == FAILURE) {
WRONG_PARAM_COUNT;
}

ZEND_FETCH_RESOURCE(???, ???, image, image_id, "???", ???_rsrc_id);
ZEND_FETCH_RESOURCE(???, ???, font, font_id, "???", ???_rsrc_id);

switch (argc) {
case 6:
convert_to_long_ex(color);
/* Fall-through. */
case 5:
convert_to_long_ex(y);
convert_to_long_ex(x);
/* font: fetching resources already handled. */
convert_to_string_ex(text);
/* image: fetching resources already handled. */
break;
default:
WRONG_PARAM_COUNT;
}

php_error(E_WARNING, "my_drawtext: not yet implemented");
}
/* }}} */

README.SELF-CONTAINED-EXTENSIONS

$Id: README.SELF-CONTAINED-EXTENSIONS,v 1.12 2002/10/23 21:35:17 jon Exp $
=============================================================================

HOW TO CREATE A SELF-CONTAINED PHP EXTENSION

A self-contained extension can be distributed independently of
the PHP source. To create such an extension, two things are
required:

- Configuration file (config.m4)
- Source code for your module

We will describe now how to create these and how to put things
together.

PREPARING YOUR SYSTEM

While the result will run on any system, a developer's setup needs these
tools:

GNU autoconf
GNU automake
GNU libtool
GNU m4

All of these are available from

ftp://ftp.gnu.org/pub/gnu/

CONVERTING AN EXISTING EXTENSION

Just to show you how easy it is to create a self-contained
extension, we will convert an embedded extension into a
self-contained one. Install PHP and execute the following
commands.

$ mkdir /tmp/newext
$ cd /tmp/newext

You now have an empty directory. We will copy the files from
the mysql extension:

$ cp -rp php-4.0.X/ext/mysql/* .

It is time to finish the module. Run:

$ phpize

You can now ship the contents of the directory - the extension
can live completely on its own.

The user instructions boil down to

$ ./configure \
[--with-php-config=/path/to/php-config] \
[--with-mysql=MYSQL-DIR]
$ make install

The MySQL module will either use the embedded MySQL client
library or the MySQL installation in MYSQL-DIR.

DEFINING THE NEW EXTENSION

Our demo extension is called "foobar".

It consists of two source files "foo.c" and "bar.c"
(and any arbitrary amount of header files, but that is not
important here).

The demo extension does not reference any external
libraries (that is important, because the user does not
need to specify anything).

LTLIBRARY_SOURCES specifies the names of the sources files. You can
name an arbitrary number of source files here.

CREATING THE M4 CONFIGURATION FILE

The m4 configuration can perform additional checks. For a
self-contained extension, you do not need more than a few
macro calls.

------------------------------------------------------------------------------
PHP_ARG_ENABLE(foobar,whether to enable foobar,
[ --enable-foobar Enable foobar])

if test "$PHP_FOOBAR" != "no"; then
PHP_NEW_EXTENSION(foobar, foo.c bar.c, $ext_shared)
fi
------------------------------------------------------------------------------

PHP_ARG_ENABLE will automatically set the correct variables, so
that the extension will be enabled by PHP_NEW_EXTENSION in shared mode.

The first argument of PHP_NEW_EXTENSION describes the name of the
extension. The second names the source-code files. The third passes
$ext_shared which is set by PHP_ARG_ENABLE/WITH to PHP_NEW_EXTENSION.

Please use always PHP_ARG_ENABLE or PHP_ARG_WITH. Even if you do not
plan to distribute your module with PHP, these facilities allow you
to integrate your module easily into the main PHP module framework.

CREATING SOURCE FILES

ext_skel can be of great help when creating the common code for all modules
in PHP for you and also writing basic function definitions and C code for
handling arguments passed to your functions. See README.EXT_SKEL for further
information.

As for the rest, you are currently alone here. There are a lot of existing
modules, use a simple module as a starting point and add your own code.

CREATING THE SELF-CONTAINED EXTENSION

Put config.m4 and the source files into one directory. Then, run phpize
(this is installed during make install by PHP 4.0).

For example, if you configured PHP with --prefix=/php, you would run

$ /php/bin/phpize

This will automatically copy the necessary build files and create
configure from your config.m4.

And that's it. You now have a self-contained extension.

INSTALLING A SELF-CONTAINED EXTENSION

An extension can be installed by running:

$ ./configure \
[--with-php-config=/path/to/php-config]
$ make install

ADDING SHARED MODULE SUPPORT TO A MODULE

In order to be useful, a self-contained extension must be loadable
as a shared module. I will explain now how you can add shared module
support to an existing module called foo.

1. In config.m4, use PHP_ARG_WITH/PHP_ARG_ENABLE. Then you will
automatically be able to use --with-foo=shared[,..] or
--enable-foo=shared[,..].

2. In config.m4, use PHP_NEW_EXTENSION(foo,.., $ext_shared) to enable
building the extension.

3. Add the following lines to your C source file:

#ifdef COMPILE_DL_FOO
ZEND_GET_MODULE(foo)
#endif