Notre première fonction
Très bien, nous avons donc 3 fichiers de créé, nous allons commencer par celui qui permet de générer la configuration de compilation. Voici le fichier config.m4:
PHP_ARG_ENABLE(tutorial, whether to enable tutorial support,
[ --enable-tutorial Enable tutorial support])
if test "$PHP_TUTORIAL" = "yes"; then
AC_DEFINE(HAVE_TUTORIAL, 1, [Whether you have tutorial])
PHP_NEW_EXTENSION(tutorial, tutorial.c, $ext_shared)
fi
En fait, ce fichier va être utilisé pour générer les script "configure" et les makefiles... La macro PHP_NEW_EXTENSION enregistre une nouvelle extension nommée "tutorial" basé sur notre fichier tutorial.c
L'option qui sera nécessaire au script "configure" est "--enable-tutorial"
Jusque là, rien de bien méchant, on passe à la suite.
Nous allons maintenant créer notre fichier tutorial.h, celui qui défini ce que PHP pourra utiliser:
#ifndef PHP_TUTORIAL_H
#define PHP_TUTORIAL_H 1
#define PHP_TUTORIAL_VERSION "1.0"
#define PHP_TUTORIAL_EXTNAME "tutorial"
/* déclaration de fonction à créer */
ZEND_FUNCTION(tutorial_function1);
/*Il nous faut aussi enregistrer les entrée de module*/
extern zend_module_entry tutorial_module_entry;
#define phpext_tutorial_ptr &tutorial_module_entry
#endif
Ici, nous avons déclaré deux constante non obligatoires mais utiles: notre version et le nom de notre module. Ce sera toujours plus agréable à utiliser. Ensuite vient la déclaration de notre première fonction que nous appelons "tutorial_function1". Cette fonction sera accessible dans PHP si et seulement si nous l'enregistrons dans le registre de PHP. C'est ce à quoi servira notre variable tutorial_module_entry de type zend_module_entry.
Reste maintenant à coder... voici le fichier tutorial.c:
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "php.h"
#include "tutorial.h"
/* La liste des fonctions que zend va rendre accessible par ce module */
static zend_function_entry tutorial_functions[] =
{
ZEND_FE(tutorial_function1, NULL)
{NULL, NULL, NULL}
};
/* Informations sur notre module
On commence simple, on ne donne que des entetes standards
un nom de module et la liste des méthodes...
On laisse 5 valeurs à null (vous verrez plus tard)
on donne une version et des propriétés par défaut
*/
zend_module_entry tutorial_module_entry =
{
STANDARD_MODULE_HEADER,
PHP_TUTORIAL_EXTNAME,
tutorial_functions,
NULL,
NULL,
NULL,
NULL,
NULL,
PHP_TUTORIAL_VERSION,
STANDARD_MODULE_PROPERTIES
};
#if COMPILE_DL_TUTORIAL
ZEND_GET_MODULE(tutorial)
#endif
/* Reste à coder notre fonction qui va donner un fabuleux "hello" */
ZEND_FUNCTION(tutorial_function1)
{
RETURN_STRING("Hello World !!!\n", 1);
}
Très bien, on va reprendre calemement. D'abord la traditionnelle inclusion de config.h, puis nous incluons php.h et tutorial.h qui permettent d'avoir les prototypes de l'api PHP (et ZEND) anisi que nos prototypes.
Nous aurons besoin d'assigner un registre de fonctions au module, ce registre est un tableau de type zend_function_entry que nous donnerons au registre tutorial_module_entry.
Dans ce registre de fonctions, nous enregistrons tutorial_function1. Souvenez vous de la macro ZEND_FE pour zend function entry.
Nous avions déclaré une variable externe tutorial_module_entry dans notre fichier tutorial.h, c'est notre registre de module!, nous lui assignons des entêtes standards, notre nom de module, la liste des fonctions que nous avons créé, et en dernier lieur la version de notre module et enfin des propriétés par défaut.
Les 5 valeur NULL seront vu par la suite, pour le moment cela conviendra parfaitement.
Ensuite, nous enregistrons le module tutorial avec la macro ZEND_GET_MODULE.
Reste à coder la fonction que nous avons déclaré: tutorial_function1. Le prototype passe par une macro, ZEND_FUNCTION(), inutile donc de se tracasser à savoir ce que nous devons retourner... c'est d'ailleurs une autre macro qui gère les retours: RETURN_* où * correspond au type de retour. Cela pourra être
- RETURN_STRING
- RETURN_LONG
- RETURN_ARRAY
- RETURN_TRUE
- RETURN_NULL
- ...
Bref, résumons les étapes:
- on crée un fichier m4 (vous allez voir à quoi il va servir)
- on crée un fichier d'entête (.h) qui défini
- nos fonction PHP à déclarer (ZEND_FUNCTION)
- le registre de module (de type extern zend_module_entry)
- on crée un fichier source (.c) qui défini
- les registres de fonctions (de type static zend_function_entry)
- le registre de module (déclaré dans le .h)
- charge le module dans le moteur ZEND (avec ZEND_GET_MODULE)
- on développe les fonctions déclarées dans les entêtes (dans le fichier .h)
Alors à quoi sert ce fameux config.m4, → tout simplement à générer une batterie de fichiers, dont le fameux config.h... et comment on fait ? simplement en tapant la commande:
phpize
A partir de là, plein de fichiers sont générés: configure, makefiles, entêtes... bref tout ce qu'il faut !
Vous pouvez d'ors et déjà compiler votre module:
./configure --enable-tutorial
make
su -
make install
Le module est compilé et enfin il est installé ! sur Fedora, il se retrouve donc dans /usr/lib/php/modules ou pour les 64 bits /usr/lib64/php/modules. Avant de le charger dans php.ini, vous pouvez tester notre extension de cette manière:
[pafer@localhost tutoext]$ php -r "dl('tutorial.so'); echo tutorial_function1();"
Hello World !!!
Si une erreur apparait, revérifié le code, que la compilation se soit bien passé, et que l'installation est bien effectuée... sinon, vous avez réussi votre première extension !
← Précédent - Aller à Introduction || Suivant - Gérer les paramètres →
4 commentaire(s)