Join Up! 92494 members and counting!

Login To PHPBuilder User Name: Password: Register A New Site Account * NOTE: This is for logging into the main site only! To login to the forums, click here

PHP Manual All Mail Lists Entire Site

Linux Today Enterprise Linux Today Apache Today JustLinux.com Linux Planet PHPBuilder All Linux Devices Hiermenus DatabaseJournal Technology Jobs IT Developer Internet News Small Business Personal Technology International Search internet.com Advertise Corporate Info Newsletters Tech Jobs E-mail Offers Covalent Extends Apache 2.0 to Microsoft ASP.NET ShopWorX - Support for Windows PHP Security Advisory: Vulnerability in PHP versions 4.2.0 and 4.2.1 Network Risk Assessment Full-Featured, Java-Based Apache GUI Partners & Affiliates Comprehensible PHP Code In Case You Missed It... The Month of February, 2007 In Case You Missed It...The Week of January 30, 2006 So you want to use a database in your site? Sending Mail With PHP3

Index: phpdoc/fr/appendices/debugger.xml diff -u phpdoc/fr/appendices/debugger.xml:1.8 phpdoc/fr/appendices/debugger.xml:1.9 --- phpdoc/fr/appendices/debugger.xml:1.8 Mon Aug 6 08:14:44 2001 +++ phpdoc/fr/appendices/debugger.xml Mon Nov 12 00:17:51 2001 @@ -1,259 +1 @@ - - - - - - - PHP 3 inclut le support d'un serveur de débuggage. - - - PHP 4 n'inclut aucun support de débuggage. - - - - - - Le débuggeur PHP sert à repérer les bugs - récalcitrants. Le débuggeur fonctionne en se - connectant à un port TCP à chaque - démarrage de PHP. Tous les messages d'erreur seront - envoyés sur cette connexion. Cette page est faite pour un - "serveur de débuggage", qui peut fonctionner avec un - IDE ou un éditeur programmable (tel que Emacs). - - - Comment paramétrer le débuggeur : - - - - Réservez un port TCP pour le débuggeur dans le fichier - de configuration - (debugger.port) et activez le - (debugger.enabled). - - - - - Configurer un client TCP sur ce port (par exemple - socket -l -s 1400 sous UNIX). - - - - - Dans votre code, placez la ligne "debugger_on(host)", - où host est l'IP ou le nom de l'hôte qui - supporte le client TCP. - - - - Désormais, toutes les alertes, notes, ... seront envoyées - sur la socket client, même si vous avez inactivé - le rapport d'erreur avec error_reporting. - - - - - - Le protocole de débugage est ligne par ligne. Chaque ligne a un type - type et plusieurs lignes composent un message - Chaque message commence avec une ligne du type start et se - termine avec une ligne de type end. PHP peut envoyer des - lignes de plusieurs messages simultanément. - - - Voici un exemple de ligne à ce format : - - -date time -host(pid) -type: -message-data - - - - - date - - - Les dates sont au format ISO 8601 - (yyyy-mm-dd) - - - - - time - - Les heures, y compris les micro-secondes: - hh:mm:uuuuuu - - - - - host - - - Le nom DNS ou adresse IP de l'hôte qui a généré - l'erreur. - - - - - pid - - - PID (process id) sur l'hôte host, qui a - généré - l'erreur. - - - - - type - - - Type de la ligne. Indique au programme client comment traiter les - données suivantes : -

- - - - - Nom - Signification - - - - - start - - Indique au programme client que le message du débuggeur - commence ici. Le contenu de data sera un type - d'erreur, comme listé ci-dessous. - - - - message - Le message d'erreur PHP. - - - location - - Nom du fichier et numéro de ligne, où l'erreur est - survenue. La première occurrence de location - contiendra toujours la localisation générale. - data contiendra : - file:line. - Il y a toujours une indication de location - après un message et après chaque - function. - - - - - frames - - Nombre de frames dans le dump de la pile. S'il y a 4 frames, attendez - vous à des informations sur 4 niveaux de fonctions. Si la ligne - "frame" n'existe pas, la profondeur doit être 0 (une erreur - est survenue au niveau général). - - - - - function - - Nom de la fonction qui a généré l'erreur. Elle sera - répétée à chaque niveau de la pile d'appel. - - - - end - - Indique au client que le message du débuggeur se termine ici. - - - - - - - - - - data - - Ligne de données. - - - - - - - - - Débuggeur - Interne PHP - - - - - alerte (warning) - E_WARNING - - - erreur - E_ERROR - - - analyse (parse) - E_PARSE - - - note (notice) - E_NOTICE - - - core-error - E_CORE_ERROR - - - core-warning - E_CORE_WARNING - - - inconnue - (toutes les autres) - - - - - - - -1998-04-05 23:27:400966 lucifer.guardian.no(20481) start: notice -1998-04-05 23:27:400966 lucifer.guardian.no(20481) message: Uninitialized variable -1998-04-05 23:27:400966 lucifer.guardian.no(20481) location: (&null;):7 -1998-04-05 23:27:400966 lucifer.guardian.no(20481) frames: 1 -1998-04-05 23:27:400966 lucifer.guardian.no(20481) function: display -1998-04-05 23:27:400966 lucifer.guardian.no(20481) location: /home/ssb/public_html/test.php3:10 -1998-04-05 23:27:400966 lucifer.guardian.no(20481) end: notice - - - - - - + PHP 3 inclut le support d'un serveur de débuggage. PHP 4 n'inclut aucun support de débuggage. Le débuggeur PHP sert à repérer les bugs récalcitrants. Le débuggeur fonctionne en se connectant à un port TCP à chaque démarrage de PHP. Tous les messages d'erreur seront envoyés sur cette connexion. Cette page est faite pour un "serveur de débuggage", qui peut fonctionner avec un IDE ou un éditeur programmable (tel que Emacs). Comment paramétrer le débuggeur : Réservez un port TCP pour le débuggeur dans le fichier de configuration (debugger.port) et activez-le (debugger.enabled). Configurer un client TCP sur ce port (par exemple socket -l -s 1400 sous UNIX). Dans votre code, placez la ligne "debugger_on(host)", où host est l'IP ou le nom de l'hôte qui supporte le client TCP. Désormais, toutes les alertes, notes, ... seront envoyées sur la socket client, même si vous avez inactivé le rapport d'erreur avec error_reporting. Le protocole de débugage PHP 3 fonctionne ligne par ligne. Chaque ligne a un type type et plusieurs lignes composent un message Chaque message commence avec une ligne du type start et se termine avec une ligne de type end. PHP peut envoyer des lignes de plusieurs messages simultanément. Voici un exemple de ligne à ce format : date timehost(pid)type:message-data date Les dates sont au format ISO 8601 (yyyy-mm-dd) time Les heures, y compris les micro-secondes: hh:mm:uuuuuu host Le nom DNS ou adresse IP de l'hôte qui a généré l'erreur. pid PID (process id) sur l'hôte host, qui a généré l'erreur. type Type de la ligne. Indique au programme client comment traiter les données suivantes : Nom Signification start Indique au programme client que le message du débuggeur commence ici. Le contenu de data sera un type d'erreur, comme listé ci-dessous. message Le message d'erreur PHP 3. location Nom du fichier et numéro de ligne, où l'erreur est survenue. La première occurrence de location contiendra toujours la localisation générale. data contiendra : file:line. Il y a toujours une indication de location après un message et après chaque function. frames Nombre de frames dans le dump de la pile. S'il y a 4 frames, attendez vous à des informations sur 4 niveaux de fonctions. Si la ligne "frame" n'existe pas, la profondeur doit être 0 (une erreur est survenue au niveau général). function Nom de la fonction qui a généré l'erreur. Elle sera répétée à chaque niveau de la pile d'appel. end Indique au client que le message du débuggeur se termine ici. data Ligne de données. Débuggeur Interne PHP 3 alerte (warning) E_WARNING erreur E_ERROR analyse (parse) E_PARSE note (notice) E_NOTICE core-error E_CORE_ERROR core-warning E_CORE_WARNING inconnue (toutes les autres) 1998-04-05 23:27:400966 lucifer.guardian.no(20481) start: notice1998-04-05 23:27:400966 lucifer.guardian.no(20481) message: Uninitialized variable1998-04-05 23:27:400966 lucifer.guardian.no(20481) location: (&null;):71998-04-05 23:27:400966 lucifer.guardian.no(20481) frames: 11998-04-05 23:27:400966 lucifer.guardian.no(20481) function: display1998-04-05 23:27:400966 lucifer.guardian.no(20481) location: /home/ssb/public_html/test.php3:101998-04-05 23:27:400966 lucifer.guardian.no(20481) end: notice \ No newline at end of file Index: phpdoc/fr/appendices/escaping.xml diff -u phpdoc/fr/appendices/escaping.xml:1.3 phpdoc/fr/appendices/escaping.xml:1.4 --- phpdoc/fr/appendices/escaping.xml:1.3 Mon Aug 6 08:14:44 2001 +++ phpdoc/fr/appendices/escaping.xml Mon Nov 12 00:17:51 2001 @@ -1,6 +1 @@ - -Escaping data -PHP string escape chars -URL encoding (GET) -POST method -Escaping for databases +Escaping dataPHP string escape charsURL encoding (GET)POST methodEscaping for databases \ No newline at end of file Index: phpdoc/fr/appendices/history.xml diff -u phpdoc/fr/appendices/history.xml:1.3 phpdoc/fr/appendices/history.xml:1.4 --- phpdoc/fr/appendices/history.xml:1.3 Mon Aug 6 08:14:44 2001 +++ phpdoc/fr/appendices/history.xml Mon Nov 12 00:17:51 2001 @@ -1,3 +1 @@ - -PHP's history -Overview of PHP's development +PHP's historyOverview of PHP's development \ No newline at end of file Index: phpdoc/fr/appendices/http-stuff.xml diff -u phpdoc/fr/appendices/http-stuff.xml:1.3 phpdoc/fr/appendices/http-stuff.xml:1.4 --- phpdoc/fr/appendices/http-stuff.xml:1.3 Mon Aug 6 08:14:44 2001 +++ phpdoc/fr/appendices/http-stuff.xml Mon Nov 12 00:17:51 2001 @@ -1,5 +1 @@ - -Proxies, caching and misc. HTTP stuff -Setting an expiry date on generated pages -Using phpLastModified -CGI version: why does images break (w/solution) +Proxies, caching and misc. HTTP stuffSetting an expiry date on generated pagesUsing phpLastModifiedCGI version: why does images break (w/solution) \ No newline at end of file Index: phpdoc/fr/appendices/phpdevel.xml diff -u phpdoc/fr/appendices/phpdevel.xml:1.15 phpdoc/fr/appendices/phpdevel.xml:1.16 --- phpdoc/fr/appendices/phpdevel.xml:1.15 Mon Aug 6 08:14:45 2001 +++ phpdoc/fr/appendices/phpdevel.xml Mon Nov 12 00:17:51 2001 @@ -1 +1,944 @@ - Toutes les fonctions suivent le schéma suivant : void php3_foo(INTERNAL_FUNCTION_PARAMETERS) {} Même si votre fonction ne prend aucun argument, c'est comme cela qu'elle doit être appelée. Les arguments sont toujours de type val. Ce type contient un membre de type union, qui indique le type reél d'argument. De cette façon, si votre fonction prend deux arguments, elle ressemble à ceci : pval *arg1, *arg2;if (ARG_COUNT(ht) != 2 || getParameters(ht,2,&arg1,&arg2)==FAILURE) { WRONG_PARAM_COUNT;} NOTE: Les arguments peuvent être passé par valeur ou par référence. Dans les deux cas, vous devez passer &(pval *) à getParameters. Si vous voulez vérifier que le n-ième paramètre a été passé par référence ou par valeur, vous devez utiliser la fonction ParameterPassedByReference(ht,n). Elle retournera 1 ou 0. Lorsque vous modifiez l'un des paramètres, qu'ils soient envoyés par référence ou par valeur, vous pouvez le passer à pval_destructor pour le réinitialiser, ou, s'il s'agit d'un tableau et que vous voulez ajouter des valeurs, vous pouvez utiliser des fonctions similaires à celles qui sont dans internal_functions.h, qui manipule return_value comme tableau. Par ailleurs, si vous modifiez un paramètre en IS_STRING, assurez-vous que vous avez bien assigné un nouvelle chaîne avec estrdup() et une nouvelle longueur de chaîne. Seulement après, vous pouvez modifier le type en IS_STRING. Si vous modifiez une chaîne en IS_STRING ou IS_ARRAY vous devez d'abord appeler le destructeur pval_destructor. Une fonction peut prendre un nombre variable d'arguments. Si votre fonction peut prendre deux ou trois arguments, utiliser la syntaxe suivante : pval *arg1, *arg2, *arg3;int arg_count = ARG_COUNT(ht);if (arg_count < 2 || arg_count > 3 || getParameters(ht,arg_count,&arg1,&arg2,&arg3)==FAILURE) { WRONG_PARAM_COUNT;} De type de chaque argument est stocké dans le champs pval. Ce champs peut prendre les valeurs suivantes : IS_STRING Chaîne de caractères IS_DOUBLE Nombre à virgule flottante, en précision double IS_LONG Entier long IS_ARRAY Tableau IS_EMPTY Aucune IS_USER_FUNCTION ?? IS_INTERNAL_FUNCTION ?? (Si ce type ne peut pas être passé à une fonction, effacez-le) IS_CLASS ?? IS_OBJECT ?? Si vous recevez un argument d'un type, et que vous voulez l'utiliser avec un autre type, ou si vous voulez simplement forcer le type, vous pouvez utiliser l'une des fonctions de conversion suivantes : convert_to_long(arg1);convert_to_double(arg1);convert_to_string(arg1);convert_to_boolean_long(arg1);/* Si la chaîne est "" ou "0" elle devient 0, 1 sinon */convert_string_to_number(arg1);/* Convertit une chaîne en LONG ou DOUBLE suivant la chaîne */ Ces fonctions convertissent sur place : elles ne retournent aucune valeur. La valeur de l'argument est enregistrée dans une union. Les membres sont : IS_STRING: arg1->value.str.val IS_LONG: arg1->value.lval IS_DOUBLE: arg1->value.dval Toute la mémoire nécessaire à une fonction doit être allouée avec emalloc() ou estrdup(). Ces fonctions ont le goût et l'odeur des fonctions C classiques malloc() et strdup(). La mémoire doit être libérée avec efree(). Il y a deux types de mémoire dans ce programme : la mémoire qui est retournée à l'analyseur, et la mémoire qui nécessaire pour le stockage temporaire dans la fonction. Lorsque vous assignez une chaîne dans une variable qui est retournée à l'analyseur, assurez-vous de bien allouer la mémoire avec emalloc() ou estrdup(). Cette mémoire ne doit JAMAIS être libérée, sauf si vous réécrivez votre original plus loin, dans la même fonction (mais ce n'est pas de la programmation propre). Pour tous vos besoins en mémoire temporaire/permanante dont vous avez besoin dans vos fonctions/librairies, vous devez utiliser les fonctions emalloc(), estrdup() et efree(). Elles se comportent EXACTEMENT comme leurs homologues. Tout ce qui est créé avec emalloc() ou estrdup() doit être libéré avec efree() à un moment ou un autre, à moins que ce ne soit utile ailleurs dans le programme; sinon, il va y avoir une fuite de mémoire. La signification de "Elles se comportent EXACTEMENT comme leurs homologues" est que si vous libérez une variable qui n'a pas été créée avec emalloc() ou estrdup(), vous courez droit à au crash ("segmentation fault"). Soyez alors extrêmement prudent, et libérez toute votre mémoire inutilisée. Si vous compilez avec "-DDEBUG", PHP 3 affichera la liste de tous les appels à emalloc() et estrdup() mais jamais à efree() lorsque celui-ci intervient dans un script spécifié. Un grand nombre de macros sont disponibles pour rendre plus facile l'insertion de variables dans la table des symboles : SET_VAR_STRING(name,value) SET_VAR_DOUBLE(name,value) SET_VAR_LONG(name,value)

Soyez prudent. La valeur doit être placée dans une portion de mémoire créée avec malloc(), sinon le gestionnaire de mémoire essayera de libérer le pointeur plus tard. Ne passez aucune mémoire allouée statiquement à SET_VAR_STRING.

Les tables des symboles de PHP 3 est une table de hash. A n'importe quel moment, &symbol_table est un pointeur sur la table principale, et active_symbol_table pointe sur la table actuellement utilisée. (ces deux tables peuvent être identiques au démarrage, ou différent, suivant que vous êtes dans une fonction ou non). Les exemples suivants utilisent 'active_symbol_table'. Vous devriez la remplacer par &symbol_table si vous voulez travailler sur la table principale. De plus, les mêmes fonctions peuvent être appliquées à des tableaux, comme expliqué ci-dessous. if (hash_exists(active_symbol_table,"foo",sizeof("foo"))) { // existe...} else { // n'existe pas} hash_find(active_symbol_table,"foo",sizeof("foo"),&pvalue);check(pvalue.type); En PHP 3.0, les tableaux sont implémentés en utilisant les mêmes tables de hash que les variables. Cela signifie que les deux fonctions ci-dessus peuvent être appelées pour vérifier la présence de variables dans un tableau. Si vous voulez définir un nouveau tableau dans la table des symboles, utilisez le code suivant. D'abord, vous devez vérifier qu'il n'existe pas, avec hash_exists() ou hash_find(). Puis, initialisez le tableau : pval arr;if (array_init(&arr) == FAILURE) { /*Initialiation échouée*/ };hash_update(active_symbol_table,"foo",sizeof("foo"),&arr,sizeof(pval),NULL); Ce code déclare un nouveau tableau, appelé $foo, dans la table de symbole. Ce tableau est vide. Voici comment ajouter deux nouvelles entrées dans ce tableau : pval entry;entry.type = IS_LONG;entry.value.lval = 5;/* définit $foo["bar"] = 5 */hash_update(arr.value.ht,"bar",sizeof("bar"),&entry,sizeof(pval),NULL);/* définit $foo[7] = 5 */hash_index_update(arr.value.ht,7,&entry,sizeof(pval),NULL);/* définit la prochaine place libre dans $foo[], * $foo[8], qui sera 5 (comme en php2) */hash_next_index_insert(arr.value.ht,&entry,sizeof(pval),NULL); Si vous voulez modifier une valeur que vous avez inséré dans une table de hash, vous devez d'abord la lire dans la table. Pour éviter cette recherche, vous pouvez fournir une pval ** à la fonction d'ajout dans la table de hash, et elle modifiera la valeur à l'adresse pval *, avec la valeur donnée. Si cette valeur est &null;, (comme dans tous les exemples ci dessus), ce paramètre sera ignoré. hash_next_index_insert() utiliser plus ou moins la même logique que "$foo[] = bar;" in PHP 2.0. Si vous construisez un tableau, pour le retourner, vous pouvez l'initialiser comme ceci : if (array_init(return_value) == FAILURE) { échec...; } puis ajouter les valeurs grâces aux macros: add_next_index_long(return_value,long_value);add_next_index_double(return_value,double_value);add_next_index_string(return_value,estrdup(string_value)); Bien sûr, si l'ajout n'est pas fait juste après l'initialisation, vous devrez d'abord rechercher le tableau : pval *arr;if (hash_find(active_symbol_table,"foo",sizeof("foo"),(void **)&arr)==FAILURE){ introuvable... }else{ utilisez arr->value.ht... } Notez que hash_find reçoit un pointeur sur un pointeur sur pval, et pas un pointeur sur pval. Toutes les fonctions d'accès aux hash retourne &true; (SUCCES) ou &false; (FAILURE), excepté hash_exists(), qui retourne un booléen. Un grand nombre de macros sont disponible pour simplifier le retour des valeurs. La macro RETURN_* fixe la valeur de retour, et termine la fonction : RETURN RETURN_FALSE RETURN_TRUE RETURN_LONG(l) RETURN_STRING(s,dup) Si dup est &true;, duplique la chaîne. RETURN_STRINGL(s,l,dup) retourne la chaîne (s) en spécifiant la longueur (l). RETURN_DOUBLE(d) La macro RETVAL_* macros fixe la valeur de retour, mais ne termine pas la fonction. RETVAL_FALSE RETVAL_TRUE RETVAL_LONG(l) RETVAL_STRING(s,dup) Si dup est &true;, duplique la chaîne RETVAL_STRINGL(s,l,dup) retourne la chaîne (s) en spécifiant la longueur (l). RETVAL_DOUBLE(d) Les macros ci-dessus vont utiliser estrdup() sur les arguments passés. Cela vous permet de libérer tranquillement les arguments après avoir appelé cette fonction, ou bien, utiliser de la mémoire allouée statiquement. Si votre fonction retourne un booléen de succès/erreur, utilisez toujours RETURN_TRUE et RETURN_FALSE respectivement. Votre fonction peut aussi retourner des valeurs complexes, tels que des objets ou tableaux. Retourner un objet: Appeler object_init(return_value). Remplissez les valeurs. Les fonctions utilisables sont listées ci dessous. Eventuellement, enregistrez les fonctions pour cet objet. Afin de lire des valeurs de cet objet, la fonction doit lire dans "this", dans la table de symbole active active_symbol_table. Son type doit être IS_OBJECT, et c'est une table de hash basique. (i.e., vous pouvez utiliser les fonctions habituelles de .value.ht). L'enregistrement reél peut être fait comme suit : add_method( return_value, function_name, function_ptr ); Les fonctions d'accès aux objets sont : add_property_long( return_value, property_name, l ) - Ajoute un membre nommé 'property_name', de type long, égal à 'l' add_property_double( return_value, property_name, d ) - Idem, ajoute un double add_property_string( return_value, property_name, str ) - Idem, ajoute une chaîne add_property_stringl( return_value, property_name, str, l ) - Idem, ajoute une chaîne de longueur 'l'. Retournez un tableau : Appelez array_init(return_value). Remplissez les valeurs. Les fonctions disponibles sont listées ci-dessous. Les fonctions utilisées pour accéder à un tableau sont : add_assoc_long(return_value,key,l) - Ajoute une entrée associative avec la clé 'key' et la valeur 'l', de type long add_assoc_double(return_value,key,d) - Ajoute une entrée associative avec la clé 'key' et la valeur 'l', de type double add_assoc_string(return_value,key,str,duplicate) add_assoc_stringl(return_value,key,str,length,duplicate) spécifie la taille d'une chaîne add_index_long(return_value,index,l) - Ajoute une entrée d'index index' avec la valeur 'l', de type long add_index_double(return_value,index,d) add_index_string(return_value,index,str) add_index_stringl(return_value,index,str,length) - spécifie la longueur de la chaîne. add_next_index_long(return_value,l) - ajoute une entrée tableau, dans le prochain offset libre, de longueur 'l', de type long add_next_index_double(return_value,d) add_next_index_string(return_value,str) add_next_index_stringl(return_value,str,length) - spécifie la taille d'une chaîne PHP 3.0 dispose de standards pour traiter un certains nombre de ressources. Ils remplacent tous les listes de PHP 2.0. Fonctions accessibles : php3_list_insert(ptr, type) - retourne l'identifiant 'id' de la nouvelle ressource insérée. php3_list_delete(id) - efface la ressource d'identifiant id php3_list_find(id,*type) - retourne le pointeur de la ressource d'identifiant id, et modifie le type 'type' Typiquement, ces fonctions sont utilisées pour les pilotes SQL, mais elles peuvent servir n'importe quoi d'autre. Par exemple, conserver un pointeur de fichier. La liste standard de code ressemble à ceci : RESOURCE *resource;/* ...alloue de la mémoire pour la ressource, et l'acquiert ... *//* Ajoute la nouvelle ressource dans la liste */return_value->value.lval = php3_list_insert((void *) resource, LE_RESOURCE_TYPE);return_value->type = IS_LONG; pval *resource_id;RESOURCE *resource;int type;convert_to_long(resource_id);resource = php3_list_find(resource_id->value.lval, &type);if (type != LE_RESOURCE_TYPE) { php3_error(E_WARNING,"resource index %d has the wrong type",resource_id->value.lval); RETURN_FALSE;}/* ...utiliser la ressource... */ pval *resource_id;RESOURCE *resource;int type;convert_to_long(resource_id);php3_list_delete(resource_id->value.lval); Les types de ressources doivent être enregistré dans le fichier php3_list.h, dans l'énumération list_entry_type. En plus, il faut penser à ajouter une fonction de terminaison, pour chaque type de ressource défini, dans le fichier list.c, pour la fonction list_entry_destructor() (même si vous n'avez rien de particulier à faire lors de la terminaison, vous devez au moins ajouter un cas vide. PHP 3.0 dispose d'une lieu de stockage des ressources persistantes (i.e., les ressources qui doivent être conservées d'un hit à l'autre). Le premier module a utiliser cette capacité a été MySQL, et mSQL suivi, ce qui fait que l'on peut se faire une impression du fonctionnement de cette fonction avec mysql.c. Les fonctions ressemblent à ceci : php3_mysql_do_connect php3_mysql_connect() php3_mysql_pconnect() L'idée conductrice de ces modules est la suivante : Programmez tout votre module pour qu'il travaille avec les ressources standard, comme mentionné dans la section (9). Ajoutez une autre fonction de connexion, qui vérifie d'abord que la ressource existe dans la liste des ressources persistantes. Si c'est le cas, enregistrez cette ressource comme pour les ressources standard (et grâce à la première étape, cela va fonctionner immédiatement). Si la ressource n'existe pas, créez la, ajoutez la à la liste de ressources persistantes, et ajoutez la à la liste de ressources, ce qui fait que le code va fonctionner, et que le prochain appel renverra une ressource existante. Vous devez enregistrer ces fonctions avec un type différent (LE_MYSQL_LINK pour les liens non persistants, et LE_MYSQL_PLINK pour les liens persistants). Si vous jetez un oeil dans mysql.c, vous verrez que, hormis la fonction de connexion complexe, rien n'a du être changé dans le module. La même interface existe pour la liste des ressources standard, et pour la liste des ressources persistantes, seule la 'list' est remplacée par 'plist': php3_plist_insert(ptr, type) - retourne l'identifiant 'id' de la nouvelle ressource insérée. php3_plist_delete(id) - efface la ressource d'identifiant id php3_plist_find(id,*type) - retourne le pointeur de la ressource d'identifiant id, et modifie le type 'type' Cependant, il est probable que ces fonctions seront inutiles pour vous, lorsque vous essayerez d'implémentez un module persistant. Typiquement, on utiliser le fait que la liste de ressources persistantes est une table de hash. Par exemple, dans les modules MySQL/mSQL, lors d'un appel à pconnect(), la fonction construit une chaîne avec l'hôte/utilisateur/mot_de_passe, et l'utilise pour enregistrer dans la table de hash. Au prochain appel, avec les mêmes hôte/utilisateur/mot_de_passe, la même clé sera générée, et la ressource associée sera retrouvée. Jusqu'à ce que la documentation s'étoffe, jetez un oeil aux fichiers mysql.c ou msql.c pour voir comment implémentez vos accès aux ressources persistantes. Une chose importante à noter : les ressources qui sont enregistrées dans la liste de ressource persistante ne DOIVENT PAS être allouée avec le gestionnaire de mémoire PHP, c'est-à-dire qu'elles ne doivent pas être créée avec emalloc(), estrdup(), etc. Au contraire, il faut utiliser les fonctions standard malloc(), strdup(), etc. La raison est for simple : à la fin de la requête, la mémoire sera supprimée par le gestionnaire. Etant donné que les liens persistants doivent être conservés, il ne faut pas utiliser le gestionnaire de mémoire. Lorsque vous enregistrez une ressource qui sera placé dans la liste de ressources persistantes, il faut ajouter les destructeurs dans les deux listes de ressources, persistantes ou pas. Le destructeur de la liste de ressources non persistantes ne doit rien faire du tout, tandis que celui de la liste de ressources persistantes doit libérer proprement toutes les ressources acquises (mémoire, lien SQL...). Commep pour les ressources non persistantes vous DEVEZ ajouter un destructeur, même s'il ne fait rien. N'oubliez pas que emalloc() et compagnie ne doivent pas être utilisé en conjonction avec la liste de ressources persistantes, et donc, vous ne devez pas utiliser efree() non plus. De nombreuses caractéristiques de PHP 3 peuvent être configurée à l'éxécution. Ces directives peuvent apparaître dans le fichier php3.ini, ou, dans le cas du module Apache, dans le fichier .conf. L'avantage de l'avoir dans le fichier .conf, est que ces caractéristiques peuvent être configurées dossier par dossier. Cela signifie qu'un dossier peut avoir un safe mode exec dir, tandis qu'un autre en aura un autre. Cette granularité de la configuration peut être extrêmement pratique lorsque le serveur supporte plusieurs serveurs virtuels. Les étapes de configuration d'une nouvelle directive sont : Ajouter la directive à la structure php3_ini_structure dans le fichier mod_php3.h. Dans main.c, éditez la fonction php3_module_startup et ajoutez l'appel aproprié à cfg_get_string() ou cfg_get_long(). Ajoutez la directive, ses restrictions et un commentaire dans la structure php3_commands du fichier mod_php3.c. Notez la partie restrictions RSRC_CONF sont des directives qui ne peuvent être disponibles que dans le fichier de configuration Apache. Toutes les directives OR_OPTIONS peuvent être placées n'importe où, y compris dans un fichier .htaccess. Soit dans php3take1handler(), soit dans php3flaghandler(), ajoutez l'entrée appropriée pour votre directive. Dans la section de configuration, de _php3_info(), dans le fichier functions/info.c, vous devez ajouter votre configuration. Finalement, vous devez utiliser votre configuration quelque part. Elle sera accessible par php3_ini.directive. Pour appeler des fonctions utilisateurs depuis une fonction interne, vous devez utiliser la fonction call_user_function(). call_user_function() retourne SUCCESS en cas de succès, et FAILURE en cas d'échec, ou si la fonction n'a pas été trouvée. Vous devez vérifier cette valeur. Si la réponse est SUCCESS, vous êtes responsable de la destruction de retval (ou alors, retournez la comme valeur de réponse de votre fonction). Si la réponse est FAILURE, la valeur de retval est indéfinie, et vous ne devez pas y toucher. Toutes les fonctions internes qui appellent une fonction utilisateur, DOIVENT être réentrante. En particulier, elles ne doivent pas utiliser de valeurs globales, ou de variables statiques. call_user_function() prend 6 arguments : La table de hash dans laquelle le fonction doit être recherchée. Un pointeur sur un objet sur lequel la fonction est invoquée. Il devrait être à &null;, si on invoque une fonction globale. Si il n'est pas à &null; (ie, il pointe sur un objet), l'argument function_table est ignorée, et la liste des fonctions sera lue dans l'objet, plutôt que dans l'argument. L'objet PEUT être modifié par la fonction qui est appelée (la fonction y aura accès via $this). Si, vous quelque raison, vous ne le voulez pas, envoyez une copie de l'objet à la place. Le nom de la fonction à appeler. Elle doit être de type pval, IS_STRING, avec les valeurs de function_name.str.val et function_name.str.len correctes. function_name est modifié par call_user_function() - il est converti en minuscule. Si vous voulez préserver la casse, envoyez une copie du nom de la fonction. Un pointeur sur une structure pval, dans laquelle la valeur de retour de la fonction sera placée. La structure doit avoir été allouée au préalable, - call_user_function() ne l'allouera pas. Le nombre de paramètre passé à la fonction. Un tableau de pointeur sur les valeurs qui vont être passées comme arguments à la fonction. Le premier argument est à l'offset 0, le second à l'offset 1,... Le tableau est un tableau de pointeurs sur pval; Les pointeurs sont envoyés tels quels à la fonction, ce qui signifie que si la fonction modifie les arguments, les valeurs originales seront modifiées. Si vous voulez l'éviter, passez une copie à la place. Pour signaler les erreurs d'une fonction interne, vous devez appelez la fonction php3_error(). Cette fonction prend deux arguments au moins : le niveau de l'erreur, et le message d'erreur, sous forme de chaîne de caractères. Tous les arguments suivants sont des paramètres de formats de chaîne. Les niveaux d'erreurs sont : Les notes ne sont pas affichées par défaut, et indique que le script a rencontré quelque chose qui peut être une erreur, mais peut aussi être un événement normal dans la vie du script. Par exemple, essayer d'accéder à une valeur qui n'a pas été déclarée, ou appeler stat sur un fichier qui n'existe pas. Les alertes sont affichées par défaut, mais n'interrompent pas l'éxécution du script. Elles indiquent un problème qui doit être intercepté par le script avant que l'appel. Par exemple, appeler ereg avec une regex invalide. Les erreurs sont aussi affichées par défaut, et l'exécution du script est interrompue. Elles indiquent des erreurs qui ne peuvent pas être ignorées, comme des problèmes d'allocation de mémoire, par exemple. Les erreurs d'analyse de doivent être générées que par l'analyseur. Elles ne sont citées ici que dans le but d'être exhaustif. Elles sont similaires aux erreurs E_ERROR, mais elles sont générées par le code de PHP. Les fonctions ne doivent pas générer ce genre d'erreur. Elles sont similaires à E_WARNING, mais elles sont générées par le code de PHP. Les fonctions ne doivent pas générer ce genre d'erreur. Elles sont similaires à E_ERROR, mais elles sont générées par Zend Scripting Engine. Les fonctions ne doivent pas générer ce genre d'erreur. Elles sont similaires à E_WARNING, mais elles sont générées par Zend Scripting Engine. Les fonctions ne doivent pas générer ce genre d'erreur. E_USER_ERROR est comparable à E_ERROR. Elle est générée en PHP par l'utilisation de la fonction trigger_error. Les fonctions ne doivent pas générer ce genre d'erreur. E_USER_WARNING est comparable à E_WARNING. Elle est générée en PHP par l'utilisation de la fonction trigger_error. Les fonctions ne doivent pas générer ce genre d'erreur. E_USER_WARNING est comparable à E_NOTICE. Elle est générée en PHP par l'utilisation de la fonction trigger_error. Les fonctions ne doivent pas générer ce genre d'erreur. \ No newline at end of file + + + + + + + + + + Toutes les fonctions suivent le schéma suivant : + +void php3_foo(INTERNAL_FUNCTION_PARAMETERS) { +} + + Même si votre fonction ne prend aucun argument, c'est comme cela + qu'elle doit être appelée. + + + + + + Les arguments sont toujours de type val. Ce type contient un membre de type + union, qui indique le type reél d'argument. De cette façon, + si votre fonction prend deux arguments, elle ressemble à ceci : + + + + + +pval *arg1, *arg2; +if (ARG_COUNT(ht) != 2 || getParameters(ht,2,&arg1,&arg2)==FAILURE) { + WRONG_PARAM_COUNT; +} + + + NOTE: Les arguments peuvent être passé par valeur ou par + référence. Dans les deux cas, vous devez passer &(pval *) + à getParameters. Si vous voulez vérifier que le n-ième + paramètre a été passé par référence + ou par valeur, vous devez utiliser la fonction + ParameterPassedByReference(ht,n). Elle retournera 1 ou 0. + + + Lorsque vous modifiez l'un des paramètres, qu'ils soient envoyés + par référence ou par valeur, vous pouvez le passer à + pval_destructor pour le réinitialiser, ou, s'il s'agit d'un tableau et + que vous voulez ajouter des valeurs, vous pouvez utiliser des fonctions + similaires à celles qui sont dans internal_functions.h, qui manipule + return_value comme tableau. + + + Par ailleurs, si vous modifiez un paramètre en IS_STRING, assurez-vous + que vous avez bien assigné un nouvelle chaîne avec estrdup() + et une nouvelle longueur de chaîne. Seulement après, vous pouvez + modifier le type en IS_STRING. Si vous modifiez une chaîne en IS_STRING + ou IS_ARRAY vous devez d'abord appeler le destructeur pval_destructor. + + + + + + Une fonction peut prendre un nombre variable d'arguments. Si votre fonction peut + prendre deux ou trois arguments, utiliser la syntaxe suivante : + + + + + +pval *arg1, *arg2, *arg3; +int arg_count = ARG_COUNT(ht); +if (arg_count < 2 || arg_count > 3 || + getParameters(ht,arg_count,&arg1,&arg2,&arg3)==FAILURE) { + WRONG_PARAM_COUNT; +} + + + + + + + + De type de chaque argument est stocké dans le champs pval. Ce champs peut + prendre les valeurs suivantes : + + + + + + IS_STRING + Chaîne de caractères + + + IS_DOUBLE + Nombre à virgule flottante, en précision double + + + IS_LONG + Entier long + + + IS_ARRAY + Tableau + + + IS_EMPTY + Aucune + + + IS_USER_FUNCTION + ?? + + + IS_INTERNAL_FUNCTION + ?? (Si ce type ne peut pas être passé à + une fonction, effacez-le) + + + + IS_CLASS + ?? + + + IS_OBJECT + ?? + + + + + + + Si vous recevez un argument d'un type, et que vous voulez l'utiliser + avec un autre type, ou si vous voulez simplement forcer le type, vous + pouvez utiliser l'une des fonctions de conversion suivantes : + +convert_to_long(arg1); +convert_to_double(arg1); +convert_to_string(arg1); +convert_to_boolean_long(arg1); +/* Si la chaîne est "" ou "0" elle devient 0, 1 sinon */ +convert_string_to_number(arg1); +/* Convertit une chaîne en LONG ou DOUBLE suivant la chaîne */ + + + + Ces fonctions convertissent sur place : elles ne retournent aucune valeur. + + + La valeur de l'argument est enregistrée dans une union. Les membres sont : + + IS_STRING: arg1->value.str.val + IS_LONG: arg1->value.lval + IS_DOUBLE: arg1->value.dval + + + + + + + Toute la mémoire nécessaire à une fonction doit être + allouée avec emalloc() ou estrdup(). Ces fonctions ont le goût et l'odeur + des fonctions C classiques malloc() et strdup(). La mémoire doit être + libérée avec efree(). + + + Il y a deux types de mémoire dans ce programme : la mémoire qui est + retournée à l'analyseur, et la mémoire qui nécessaire + pour le stockage temporaire dans la fonction. Lorsque vous assignez une + chaîne dans une variable qui est retournée à l'analyseur, + assurez-vous de bien allouer la mémoire avec emalloc() ou estrdup(). + Cette mémoire ne doit JAMAIS être libérée, sauf si + vous réécrivez votre original plus loin, dans la même + fonction (mais ce n'est pas de la programmation propre). + + + Pour tous vos besoins en mémoire temporaire/permanante dont vous avez + besoin dans vos fonctions/librairies, vous devez utiliser les fonctions + emalloc(), estrdup() et efree(). Elles se comportent EXACTEMENT comme leurs + homologues. Tout ce qui est créé avec emalloc() ou estrdup() + doit être libéré avec efree() à un moment ou un + autre, à moins que ce ne soit utile ailleurs dans le programme; + sinon, il va y avoir une fuite de mémoire. La signification de + "Elles se comportent EXACTEMENT comme leurs homologues" est que si vous + libérez une variable qui n'a pas été créée + avec emalloc() ou estrdup(), vous courez droit à au crash + ("segmentation fault"). Soyez alors extrêmement prudent, et + libérez toute votre mémoire inutilisée. + + + Si vous compilez avec "-DDEBUG", PHP 3 affichera la liste de tous les appels + à emalloc() et estrdup() mais jamais à efree() lorsque celui-ci + intervient dans un script spécifié. + + + + + + Un grand nombre de macros sont disponibles pour rendre plus facile l'insertion de + variables dans la table des symboles : + + SET_VAR_STRING(name,value) + SET_VAR_DOUBLE(name,value) + SET_VAR_LONG(name,value) + + + +

+ + + Soyez prudent. La valeur doit être placée dans une portion de + mémoire créée avec malloc(), sinon le gestionnaire de + mémoire essayera de libérer le pointeur plus tard. Ne passez + aucune mémoire allouée statiquement à SET_VAR_STRING. + +

+ + + Les tables des symboles de PHP 3 est une table de hash. A n'importe quel moment, + &symbol_table est un pointeur sur la table principale, et + active_symbol_table pointe sur la table actuellement utilisée. + (ces deux tables peuvent être identiques au démarrage, ou + différent, suivant que vous êtes dans une fonction ou non). + + + Les exemples suivants utilisent 'active_symbol_table'. Vous devriez la remplacer + par &symbol_table si vous voulez travailler sur la table principale. + De plus, les mêmes fonctions peuvent être appliquées + à des tableaux, comme expliqué ci-dessous. + + + + + +if (hash_exists(active_symbol_table,"foo",sizeof("foo"))) { + // existe... +} else { + // n'existe pas +} + + + + + +hash_find(active_symbol_table,"foo",sizeof("foo"),&pvalue); +check(pvalue.type); + + + En PHP 3.0, les tableaux sont implémentés en utilisant les + mêmes tables de hash que les variables. Cela signifie que les deux + fonctions ci-dessus peuvent être appelées pour vérifier + la présence de variables dans un tableau. + + + Si vous voulez définir un nouveau tableau dans la table des symboles, + utilisez le code suivant. + + + D'abord, vous devez vérifier qu'il n'existe pas, avec hash_exists() ou + hash_find(). + + + Puis, initialisez le tableau : + + + + + +pval arr; +if (array_init(&arr) == FAILURE) { /*Initialiation échouée*/ }; +hash_update(active_symbol_table,"foo",sizeof("foo"),&arr,sizeof(pval),NULL); + + + Ce code déclare un nouveau tableau, appelé $foo, dans la table + de symbole. Ce tableau est vide. + + + Voici comment ajouter deux nouvelles entrées dans ce tableau : + + + + + +pval entry; +entry.type = IS_LONG; +entry.value.lval = 5; +/* définit $foo["bar"] = 5 */ +hash_update(arr.value.ht,"bar",sizeof("bar"),&entry,sizeof(pval),NULL); +/* définit $foo[7] = 5 */ +hash_index_update(arr.value.ht,7,&entry,sizeof(pval),NULL); +/* définit la prochaine place libre dans $foo[], + * $foo[8], qui sera 5 (comme en php2) + */ +hash_next_index_insert(arr.value.ht,&entry,sizeof(pval),NULL); + + + Si vous voulez modifier une valeur que vous avez inséré dans une + table de hash, vous devez d'abord la lire dans la table. Pour éviter + cette recherche, vous pouvez fournir une pval ** à la fonction d'ajout + dans la table de hash, et elle modifiera la valeur à l'adresse pval *, + avec la valeur donnée. Si cette valeur est &null;, (comme dans tous les + exemples ci dessus), ce paramètre sera ignoré. + + + hash_next_index_insert() utiliser plus ou moins la même logique que + "$foo[] = bar;" in PHP 2.0. + + + Si vous construisez un tableau, pour le retourner, vous pouvez l'initialiser + comme ceci : + + +if (array_init(return_value) == FAILURE) { échec...; } + + + puis ajouter les valeurs grâces aux macros: + + +add_next_index_long(return_value,long_value); +add_next_index_double(return_value,double_value); +add_next_index_string(return_value,estrdup(string_value)); + + + Bien sûr, si l'ajout n'est pas fait juste après l'initialisation, + vous devrez d'abord rechercher le tableau : + +pval *arr; +if (hash_find(active_symbol_table,"foo",sizeof("foo"),(void **)&arr)==FAILURE) +{ introuvable... } +else +{ utilisez arr->value.ht... } + + + + Notez que hash_find reçoit un pointeur sur un pointeur sur pval, et pas un + pointeur sur pval. + + + Toutes les fonctions d'accès aux hash retourne &true; (SUCCES) ou + &false; (FAILURE), excepté hash_exists(), qui retourne un booléen. + + + + + + Un grand nombre de macros sont disponible pour simplifier le retour des valeurs. + + + La macro RETURN_* fixe la valeur de retour, et termine la fonction : + + RETURN + RETURN_FALSE + RETURN_TRUE + RETURN_LONG(l) + + + RETURN_STRING(s,dup) Si dup est &true;, duplique la chaîne. + + + + + RETURN_STRINGL(s,l,dup) retourne la chaîne (s) en spécifiant + la longueur (l). + + + RETURN_DOUBLE(d) + + + + La macro RETVAL_* macros fixe la valeur de retour, mais ne termine pas la fonction. + + RETVAL_FALSE + RETVAL_TRUE + RETVAL_LONG(l) + + + RETVAL_STRING(s,dup) Si dup est &true;, duplique la + chaîne + + + + + RETVAL_STRINGL(s,l,dup) retourne la chaîne (s) en + spécifiant la longueur (l). + + + RETVAL_DOUBLE(d) + + + + Les macros ci-dessus vont utiliser estrdup() sur les arguments passés. + Cela vous permet de libérer tranquillement les arguments après + avoir appelé cette fonction, ou bien, utiliser de la mémoire + allouée statiquement. + + + Si votre fonction retourne un booléen de succès/erreur, + utilisez toujours RETURN_TRUE et RETURN_FALSE respectivement. + + + + + + Votre fonction peut aussi retourner des valeurs complexes, tels que des objets ou + tableaux. + + + Retourner un objet: + + + + Appeler object_init(return_value). + + + + + Remplissez les valeurs. Les fonctions utilisables sont listées ci + dessous. + + + + + Eventuellement, enregistrez les fonctions pour cet objet. + Afin de lire des valeurs de cet objet, la fonction doit lire dans "this", + dans la table de symbole active active_symbol_table. Son type doit être + IS_OBJECT, et c'est une table de hash basique. (i.e., vous pouvez utiliser + les fonctions habituelles de .value.ht). L'enregistrement reél + peut être fait comme suit : + +add_method( return_value, function_name, function_ptr ); + + + + + + + Les fonctions d'accès aux objets sont : + + + + add_property_long( return_value, property_name, l ) + - Ajoute un membre nommé 'property_name', de type long, + égal à 'l' + + + + + add_property_double( return_value, property_name, d ) + - Idem, ajoute un double + + + + + add_property_string( return_value, property_name, str ) + - Idem, ajoute une chaîne + + + + + add_property_stringl( return_value, property_name, str, l ) + - Idem, ajoute une chaîne de longueur 'l'. + + + + + + Retournez un tableau : + + + + Appelez array_init(return_value). + + + + + Remplissez les valeurs. Les fonctions disponibles sont listées + ci-dessous. + + + + + + Les fonctions utilisées pour accéder à un tableau sont : + + add_assoc_long(return_value,key,l) - Ajoute une entrée + associative avec la clé 'key' et la valeur 'l', de type long + add_assoc_double(return_value,key,d) - Ajoute une entrée + associative avec la clé 'key' et la valeur 'l', de type double + add_assoc_string(return_value,key,str,duplicate) + add_assoc_stringl(return_value,key,str,length,duplicate) + spécifie la taille d'une chaîne + add_index_long(return_value,index,l) - Ajoute + une entrée d'index index' avec la valeur 'l', de type long + add_index_double(return_value,index,d) + add_index_string(return_value,index,str) + add_index_stringl(return_value,index,str,length) + - spécifie la longueur de la chaîne. + add_next_index_long(return_value,l) - ajoute une entrée tableau, + dans le prochain offset libre, de longueur 'l', de type long + add_next_index_double(return_value,d) + add_next_index_string(return_value,str) + add_next_index_stringl(return_value,str,length) + - spécifie la taille d'une chaîne + + + + + + + PHP 3.0 dispose de standards pour traiter un certains nombre de ressources. + Ils remplacent tous les listes de PHP 2.0. + + + Fonctions accessibles : + + php3_list_insert(ptr, type) - retourne l'identifiant 'id' + de la nouvelle ressource insérée. + php3_list_delete(id) - efface la ressource + d'identifiant id + php3_list_find(id,*type) + - retourne le pointeur de la ressource d'identifiant id, + et modifie le type 'type' + + Typiquement, ces fonctions sont utilisées pour les pilotes SQL, mais elles peuvent + servir n'importe quoi d'autre. Par exemple, conserver un pointeur de fichier. + + + La liste standard de code ressemble à ceci : + + + + + +RESOURCE *resource; +/* ...alloue de la mémoire pour la ressource, et l'acquiert ... */ +/* Ajoute la nouvelle ressource dans la liste */ +return_value->value.lval = php3_list_insert((void *) resource, LE_RESOURCE_TYPE); +return_value->type = IS_LONG; + + + + + +pval *resource_id; +RESOURCE *resource; +int type; +convert_to_long(resource_id); +resource = php3_list_find(resource_id->value.lval, &type); +if (type != LE_RESOURCE_TYPE) { + php3_error(E_WARNING,"resource index %d has the wrong type",resource_id->value.lval); + RETURN_FALSE; +} +/* ...utiliser la ressource... */ + + + + + +pval *resource_id; +RESOURCE *resource; +int type; +convert_to_long(resource_id); +php3_list_delete(resource_id->value.lval); + + + Les types de ressources doivent être enregistré dans le fichier + php3_list.h, dans l'énumération list_entry_type. En plus, il + faut penser à ajouter une fonction de terminaison, pour chaque type + de ressource défini, dans le fichier list.c, pour la fonction + list_entry_destructor() (même si vous n'avez rien de particulier + à faire lors de la terminaison, vous devez au moins ajouter un cas vide. + + + + + + PHP 3.0 dispose d'une lieu de stockage des ressources persistantes (i.e., + les ressources qui doivent être conservées d'un hit à + l'autre). Le premier module a utiliser cette capacité a été + MySQL, et mSQL suivi, ce qui fait que l'on peut se faire une impression + du fonctionnement de cette fonction avec mysql.c. Les fonctions ressemblent + à ceci : + + + php3_mysql_do_connect + + + php3_mysql_connect() + + + php3_mysql_pconnect() + + + + + L'idée conductrice de ces modules est la suivante : + + + + Programmez tout votre module pour qu'il travaille avec les + ressources standard, comme mentionné dans la section (9). + + + + + Ajoutez une autre fonction de connexion, qui vérifie d'abord que + la ressource existe dans la liste des ressources persistantes. Si + c'est le cas, enregistrez cette ressource comme pour les ressources + standard (et grâce à la première étape, + cela va fonctionner immédiatement). Si la ressource n'existe + pas, créez la, ajoutez la à la liste de ressources + persistantes, et ajoutez la à la liste de ressources, ce + qui fait que le code va fonctionner, et que le prochain appel + renverra une ressource existante. Vous devez enregistrer + ces fonctions avec un type différent (LE_MYSQL_LINK pour + les liens non persistants, et LE_MYSQL_PLINK pour les liens persistants). + + + + + + Si vous jetez un oeil dans mysql.c, vous verrez que, hormis la fonction de + connexion complexe, rien n'a du être changé dans le module. + + + La même interface existe pour la liste des ressources standard, et pour + la liste des ressources persistantes, seule la 'list' est remplacée par + 'plist': + + + php3_plist_insert(ptr, type) - retourne l'identifiant 'id' + de la nouvelle ressource insérée. + php3_plist_delete(id) - efface la ressource + d'identifiant id + php3_plist_find(id,*type) + - retourne le pointeur de la ressource d'identifiant id, + et modifie le type 'type' + + + Cependant, il est probable que ces fonctions seront inutiles pour vous, + lorsque vous essayerez d'implémentez un module persistant. Typiquement, + on utiliser le fait que la liste de ressources persistantes est une table de + hash. Par exemple, dans les modules MySQL/mSQL, lors d'un appel à + pconnect(), la fonction construit une chaîne avec + l'hôte/utilisateur/mot_de_passe, et l'utilise pour enregistrer + dans la table de hash. Au prochain appel, avec les mêmes + hôte/utilisateur/mot_de_passe, la même clé sera + générée, et la ressource associée sera + retrouvée. + + + Jusqu'à ce que la documentation s'étoffe, jetez un oeil aux + fichiers mysql.c ou msql.c pour voir comment implémentez vos + accès aux ressources persistantes. + + + Une chose importante à noter : les ressources qui sont + enregistrées dans la liste de ressource persistante ne DOIVENT PAS + être allouée avec le gestionnaire de mémoire PHP, + c'est-à-dire qu'elles ne doivent pas être créée + avec emalloc(), estrdup(), etc. Au contraire, il faut utiliser les fonctions + standard malloc(), strdup(), etc. La raison est for simple : à la fin + de la requête, la mémoire sera supprimée par le + gestionnaire. Etant donné que les liens persistants doivent être + conservés, il ne faut pas utiliser le gestionnaire de mémoire. + + + Lorsque vous enregistrez une ressource qui sera placé dans la liste de + ressources persistantes, il faut ajouter les destructeurs dans les deux listes + de ressources, persistantes ou pas. Le destructeur de la liste de ressources + non persistantes ne doit rien faire du tout, tandis que celui de la liste de + ressources persistantes doit libérer proprement toutes les ressources + acquises (mémoire, lien SQL...). Commep pour les ressources non + persistantes vous DEVEZ ajouter un destructeur, même s'il ne fait + rien. N'oubliez pas que emalloc() et compagnie ne doivent pas être + utilisé en conjonction avec la liste de ressources persistantes, et + donc, vous ne devez pas utiliser efree() non plus. + + + + + + De nombreuses caractéristiques de PHP 3 peuvent être configurée + à l'éxécution. Ces directives peuvent apparaître dans le + fichier php3.ini, ou, dans le cas du module Apache, dans + le fichier .conf. L'avantage de l'avoir dans le fichier + .conf, est que ces caractéristiques peuvent + être configurées dossier par dossier. Cela signifie qu'un + dossier peut avoir un safe mode exec dir, tandis qu'un autre en aura un + autre. Cette granularité de la configuration peut être + extrêmement pratique lorsque le serveur supporte plusieurs serveurs + virtuels. + + + Les étapes de configuration d'une nouvelle directive sont : + + + + Ajouter la directive à la structure php3_ini_structure dans le + fichier mod_php3.h. + + + + + Dans main.c, éditez la fonction php3_module_startup + et ajoutez l'appel aproprié à cfg_get_string() ou cfg_get_long(). + + + + + Ajoutez la directive, ses restrictions et un commentaire dans + la structure php3_commands du fichier mod_php3.c. Notez la partie + restrictions RSRC_CONF sont des directives qui ne peuvent être + disponibles que dans le fichier de configuration Apache. Toutes les + directives OR_OPTIONS peuvent être placées n'importe + où, y compris dans un fichier .htaccess. + + + + + Soit dans php3take1handler(), soit dans php3flaghandler(), ajoutez + l'entrée appropriée pour votre directive. + + + + + Dans la section de configuration, de _php3_info(), dans le fichier + functions/info.c, vous devez ajouter votre configuration. + + + + + Finalement, vous devez utiliser votre configuration quelque part. + Elle sera accessible par php3_ini.directive. + + + + + + + + + + Pour appeler des fonctions utilisateurs depuis une fonction interne, vous + devez utiliser la fonction call_user_function(). + + + call_user_function() retourne SUCCESS en cas de succès, et FAILURE + en cas d'échec, ou si la fonction n'a pas été + trouvée. Vous devez vérifier cette valeur. Si la + réponse est SUCCESS, vous êtes responsable de la destruction de + retval (ou alors, retournez la comme valeur de réponse de votre + fonction). Si la réponse est FAILURE, la valeur de retval est + indéfinie, et vous ne devez pas y toucher. + + + Toutes les fonctions internes qui appellent une fonction utilisateur, + DOIVENT être réentrante. En + particulier, elles ne doivent pas utiliser de valeurs globales, ou + de variables statiques. + + + call_user_function() prend 6 arguments : + + + + + La table de hash dans laquelle le fonction doit être recherchée. + + + + + + Un pointeur sur un objet sur lequel la fonction est invoquée. + Il devrait être à &null;, si on invoque une fonction globale. + Si il n'est pas à &null; (ie, il pointe sur un objet), l'argument + function_table est ignorée, et la liste des fonctions sera lue + dans l'objet, plutôt que dans l'argument. L'objet PEUT être + modifié par la fonction qui est appelée (la fonction y aura + accès via $this). Si, vous quelque raison, vous ne le voulez pas, + envoyez une copie de l'objet à la place. + + + + + + Le nom de la fonction à appeler. Elle doit être de type pval, + IS_STRING, avec les valeurs de function_name.str.val et function_name.str.len + correctes. function_name est modifié par call_user_function() - + il est converti en minuscule. Si vous voulez préserver la casse, + envoyez une copie du nom de la fonction. + + + + + + Un pointeur sur une structure pval, dans laquelle la valeur de retour de + la fonction sera placée. La structure doit avoir été + allouée au préalable, - call_user_function() ne l'allouera pas. + + + + + + Le nombre de paramètre passé à la fonction. + + + + + + Un tableau de pointeur sur les valeurs qui vont être passées + comme arguments à la fonction. Le premier argument est à + l'offset 0, le second à l'offset 1,... Le tableau est un tableau + de pointeurs sur pval; Les pointeurs sont envoyés tels quels à la + fonction, ce qui signifie que si la fonction modifie les arguments, les valeurs + originales seront modifiées. Si vous voulez l'éviter, passez une + copie à la place. + + + + + + + Pour signaler les erreurs d'une fonction interne, vous devez appelez la fonction + php3_error(). Cette fonction prend deux arguments au moins : le niveau de l'erreur, + et le message d'erreur, sous forme de chaîne de caractères. Tous les + arguments suivants sont des paramètres de formats de chaîne. Les + niveaux d'erreurs sont : + + + + + Les notes ne sont pas affichées par défaut, et indique que + le script a rencontré quelque chose qui peut être une erreur, + mais peut aussi être un événement normal dans la vie + du script. Par exemple, essayer d'accéder à une valeur qui + n'a pas été déclarée, ou appeler + stat sur un fichier qui n'existe pas. + + + + + + Les alertes sont affichées par défaut, mais n'interrompent pas + l'éxécution du script. Elles indiquent un problème qui + doit être intercepté par le script avant que l'appel. + Par exemple, appeler ereg avec une regex invalide. + + + + + + Les erreurs sont aussi affichées par défaut, et + l'exécution du script est interrompue. Elles indiquent des erreurs + qui ne peuvent pas être ignorées, comme des + problèmes d'allocation de mémoire, par exemple. + + + + + + Les erreurs d'analyse de doivent être générées que + par l'analyseur. Elles ne sont citées ici que dans le but d'être + exhaustif. + + + + + + Elles sont similaires aux erreurs E_ERROR, mais elles sont + générées par le code de PHP. Les fonctions ne + doivent pas générer ce genre d'erreur. + + + + + + Elles sont similaires à E_WARNING, mais elles sont + générées par le code de PHP. Les fonctions ne + doivent pas générer ce genre d'erreur. + + + + + + Elles sont similaires à E_ERROR, mais elles sont + générées par Zend Scripting Engine. + Les fonctions ne doivent pas générer ce genre d'erreur. + + + + + + Elles sont similaires à E_WARNING, mais elles sont + générées par Zend Scripting Engine. + Les fonctions ne doivent pas générer ce genre d'erreur. + + + +