diff --git a/fr_FR.ISO8859-1/books/developers-handbook/Makefile b/fr_FR.ISO8859-1/books/developers-handbook/Makefile
new file mode 100644
index 0000000000..fa024f4a6a
--- /dev/null
+++ b/fr_FR.ISO8859-1/books/developers-handbook/Makefile
@@ -0,0 +1,35 @@
+#
+# The FreeBSD Documentation Project
+# The FreeBSD French Documentation Project
+#
+# Compilation du Manuel du Developpeur de FreeBSD
+#
+#
+#
+# $FreeBSD$
+# Original revision: 1.25
+#
+#
+
+MAINTAINER=gioria@FreeBSD.org
+
+DOC?= book
+
+FORMATS?= html-split
+
+INSTALL_COMPRESSED?= gz
+INSTALL_ONLY_COMPRESSED?=
+
+#
+# SRCS lists the individual SGML files that make up the document. Changes
+# to any of these files will force a rebuild
+#
+
+# SGML content
+SRCS= book.sgml
+
+# Entities
+
+DOC_PREFIX?= ${.CURDIR}/../../..
+
+.include "${DOC_PREFIX}/share/mk/doc.project.mk"
diff --git a/fr_FR.ISO8859-1/books/developers-handbook/book.sgml b/fr_FR.ISO8859-1/books/developers-handbook/book.sgml
new file mode 100644
index 0000000000..3a855cbf8a
--- /dev/null
+++ b/fr_FR.ISO8859-1/books/developers-handbook/book.sgml
@@ -0,0 +1,547 @@
+
+ %man;
+ %urls;
+ %bookinfo;
+ %translators;
+ %chapters;
+ %authors
+ %mailing-lists;
+
+
+
+
+
+
+
+]>
+
+
+ Livre de chevet du développeur FreeBSD
+
+ Le groupe du projet de documentation FreeBSD
+
+ Août 2000
+
+
+ 2000
+ 2001
+ Le groupe du projet de documentation FreeBSD
+
+
+ &bookinfo.legalnotice;
+
+
+ Bienvenue dans le livre de chevet du développeur
+ &trans.a.praca;
+ N.d.T.: La version française est publiée sur le
+ serveur World Wide Web du groupe de
+ traduction en langue française de la documentation de
+ FreeBSD.
+
+ N.d.T.: Contactez la &a.fr-doc si vous voulez collaborer
+ à la traduction.
+
+ La traduction de ce manuel est “en cours”. Dans la
+ table des matières ci-dessous:
+
+
+
+ Les chapitres marqués de deux astérisques
+ sont en cours de traduction.
+
+
+
+ Les chapitres marqués de trois astérisques
+ sont à traduire.
+
+
+
+ L'astérisque simple est réservé aux
+ chapitres et sections en cours de rédaction dans la
+ version U.S.
+
+
+
+
+
+
+
+
+ Introduction
+
+
+ Développer sous FreeBSD
+
+ Ce document a pour but de décrire FreeBSD comme une plateforme
+ de développement, la vision de BSD, un survol de l'architecture, l'agencement
+ de /usr/src, l'histoire, etc.
+
+ Merci d'adopter FreeBSD comme votre plateforme
+ de développement ! Nous espérons qu'elle ne vous laissera pas tomber.
+
+
+
+ La vision BSD
+
+
+
+
+
+ Survol de l'architecture
+
+
+
+
+
+ L'agencement de /usr/src
+
+ Le code source complet de FreeBSD est disponible depuis notre
+ base CVS publique. Le code source est normalement installé sous
+ /usr/src qui contient les
+ sous-répertoires suivants.
+
+
+
+
+
+
+ Répertoire
+ Description
+
+
+
+
+
+ bin/
+ Sources des fichiers de
+ /bin
+
+
+
+ contrib/
+ Sources des fichiers des logiciels fournis ("contributed").
+
+
+
+ crypto/
+ Sources du DES
+
+
+
+ etc/
+ Sources des fichiers de /etc
+
+
+
+ games/
+ Sources des fichiers de /usr/games
+
+
+
+ gnu/
+ Utilitaires sous licence publique GNU
+
+
+
+ include/
+ Sources des fichiers de /usr/include
+
+
+
+ kerberosIV/
+ Sources de Kerbereros version IV
+
+
+
+ kerberos5/
+ Sources de Kerbereros version 5
+
+
+
+ lib/
+ Sources des fichiers de /usr/lib
+
+
+
+ libexec/
+ Sources des fichiers de /usr/libexec
+
+
+
+ release/
+ Fichiers requis pour la production d'une version
+ stable de FreeBSD
+
+
+
+ sbin/
+ Sources des fichiers de /sbin
+
+
+
+ secure/
+ Sources de FreeSec
+
+
+
+ share/
+ Sources des fichiers de /sbin
+
+
+
+ sys/
+ Fichiers source du noyau
+
+
+
+ tools/
+ Outils utilisés pour la maintenance et les tests de
+ FreeBSD
+
+
+
+ usr.bin/
+ Sources des fichiers de /usr/bin
+
+
+
+ usr.sbin/
+ Sources des fichiers de /usr/sbin
+
+
+
+
+
+
+
+
+
+
+
+ Les fondamentaux
+
+ &chap.tools;
+ &chap.secure;
+
+
+
+
+ Le noyau
+
+
+ Histoire du noyau Unix
+
+ Un peu d'histoire sur le noyau Unix/BSD, les appels système, comment
+ fonctionnent les processus, bloquer, planifier, les threads (noyau),
+ le basculement de contexte, les signaux, les interruptions, les modules, etc.
+
+
+
+
+ &chap.locking;
+
+
+
+
+ Mémoire et mémoire virtuelle
+
+
+ La mémoire virtuelle
+
+ MV, gestion par page, gestion sur disque, allouer de la mémoire, tester les
+ fuites de mémoires, mmap, vnodes, etc.
+
+
+
+
+
+
+ Système E/S (Entrées/Sorties)
+
+
+ UFS
+
+ UFS, FFS, Ext2FS, JFS, inodes, mémoire tampon, mettre à jour les données d'un disque,
+ verrouillage, metadata, soft-updates, LFS, portalfs, procfs,
+ vnodes, partage de mémoire, objets en mémoire, TLBs, mettre en cache
+
+
+
+
+
+ Communication InterProcessus (IPC)
+
+
+ Les signaux
+
+ Signaux, tubes, sémaphores, files de message, segments de mémoire partagée,
+ ports, prises, portes
+
+
+
+
+
+ Le réseau
+
+
+ Les prises
+
+ Prises, bpf, IP, TCP, UDP, ICMP, OSI, ponts,
+ pare-feux, translation d'adresses (NAT), séparation de réseaux, etc
+
+
+
+
+
+ Systèmes de fichiers en réseau
+
+
+ AFS
+
+ AFS, NFS, SANs etc]
+
+
+
+
+
+ Gestion du terminal
+
+
+ Syscons
+
+ Syscons, tty, PCVT, console en liaison série, économiseurs d'écran,
+ etc
+
+
+
+
+
+ Le son
+
+
+ OSS
+
+ OSS, formes d'ondes, etc
+
+
+
+
+
+ Pilotes de périphérique
+
+ &chap.driverbasics;
+ &chap.pci;
+ &chap.scsi;
+ &chap.usb;
+
+
+ NewBus
+
+ Ce chapître traitera de l'architecture NewBus de FreeBSD.
+
+
+
+
+
+ Architectures
+
+
+ IA-32
+
+ Traite des spécificités de l'architecture x86 sous FreeBSD.
+
+
+
+
+ Alpha
+
+ Traite des spécificités de l'architecture Alpha sous FreeBSD.
+
+ Explication des erreurs d'alignements, comment les réparer,
+ comment les ignorer.
+
+ Exemple de code assembleur pour FreeBSD/alpha.
+
+
+
+ IA-64
+
+ Traite des spécificités de l'architecture IA-64 sous FreeBSD.
+
+
+
+
+
+ Déverminage
+
+
+ Truss
+
+ diverses descriptions sur les méthodes de déverminage de certains aspects
+ du système utilisant truss, ktrace, gdb, kgdb, etc
+
+
+
+
+
+ Les couches de compatibilité
+
+
+ Linux
+
+ Linux, SVR4, etc
+
+
+
+
+
+ Bibligraphie
+
+
+
+
+
+
+ Dave
+ A
+ Patterson
+
+
+ John
+ L
+ Hennessy
+
+
+ 1998Morgan Kaufmann Publishers,
+ Inc.
+ 1-55860-428-6
+
+ Morgan Kaufmann Publishers, Inc.
+
+ Computer Organization and Design
+ The Hardware / Software Interface
+ 1-2
+
+
+
+
+
+ W.
+ Richard
+ Stevens
+
+
+ 1993Addison Wesley Longman,
+ Inc.
+ 0-201-56317-7
+
+ Addison Wesley Longman, Inc.
+
+ Advanced Programming in the Unix Environment
+ 1-2
+
+
+
+
+
+ Marshall
+ Kirk
+ McKusick
+
+
+ Keith
+ Bostic
+
+
+ Michael
+ J
+ Karels
+
+
+ John
+ S
+ Quarterman
+
+
+ 1996Addison-Wesley Publishing Company,
+ Inc.
+ 0-201-54979-4
+
+ Addison-Wesley Publishing Company, Inc.
+
+ The Design and Implementation of the 4.4 BSD Operating System
+ 1-2
+
+
+
+
+
+ Aleph
+ One
+
+
+ Phrack 49; "Smashing the Stack for Fun and Profit"
+
+
+
+
+
+ Chrispin
+ Cowan
+
+
+ Calton
+ Pu
+
+
+ Dave
+ Maier
+
+
+ StackGuard; Automatic Adaptive Detection and Prevention of
+ Buffer-Overflow Attacks
+
+
+
+
+
+ Todd
+ Miller
+
+
+ Theo
+ de Raadt
+
+
+ strlcpy and strlcat -- consistent, safe string copy and
+ concatenation.
+
+
+
+
+
+
+
diff --git a/fr_FR.ISO8859-1/books/developers-handbook/chapters.ent b/fr_FR.ISO8859-1/books/developers-handbook/chapters.ent
new file mode 100644
index 0000000000..5c2bbaa870
--- /dev/null
+++ b/fr_FR.ISO8859-1/books/developers-handbook/chapters.ent
@@ -0,0 +1,64 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/fr_FR.ISO8859-1/books/developers-handbook/driverbasics/chapter.sgml b/fr_FR.ISO8859-1/books/developers-handbook/driverbasics/chapter.sgml
new file mode 100644
index 0000000000..11dc47762c
--- /dev/null
+++ b/fr_FR.ISO8859-1/books/developers-handbook/driverbasics/chapter.sgml
@@ -0,0 +1,383 @@
+
+
+
+ Ecrire des pilotes de périphériques pour FreeBSD
+
+ Ce chapître a été écrit par &.murray avec des sélections
+ depuis une variété de codes source inclus dans la page de manuel d'intro(4) de Joerg
+ Wunsch.
+
+
+ Introduction
+ Ce chapître fournit une brêve introduction sur l'écriture
+ de pilotes de périphériques pourFreeBSD.
+ Un périphérique, dans ce contexte, est un terme utilisé
+ le plus souvent pour tout ce qui est lié au matériel et qui dépend
+ du système, comme les disques, imprimantes, ou un écran avec son clavier.
+ Un pilote de périphérique est un composant logiciel du système
+ d'exploitation qui contrôle un périphérique spécifique. Il y a aussi
+ ce que l'on apelle les pseudo-périphériques ("pseudo-devices") où un pilote
+ de périphérique émule le comportement d'un périphérique dans un logiciel sans
+ matériel particulier sous-jacent. Les pilotes de périphériques peuvent être compilés
+ dans le ystème statiquement ou chargé à la demande via l'éditeur de liens dynamique du
+ noyau `kld'.
+
+ La plupart des périphériques dans un système d'exploitation de type Unix
+ sont accessibles au travers de fichiers spéciaux de périphérique (device-nodes), appelés parfois
+ fichiers spéciaux. Ces fichiers sont habituellement stockés dans le répertoire
+ /dev de la hiérarchie du système de fichiers. Jusqu'à ce que
+ devfs soit totalement intégré dans FreeBSD, chaque fichier spécial de périphérique doit être
+ créé statiquement et indépendamment de l'existence du pilote de périphérique associé.
+ La plupart des fichiers spéciaux de périphérique du système sont créés en exécutant MAKEDEV.
+
+ Les pilotes de périphérique peuvent être en gros séparés en deux catégories;
+ les pilotes de périphérique en mode caractère et les pilotes de périphériques réseau.
+
+
+
+
+ L'éditeur de liens dynamiques du noyau - KLD
+
+
+ L'interface kld permet aux administrateurs système d'ajouter
+ et d'enlever dynamiquement une fonctionnalité à un système en marche.
+ Cela permet aux développeurs de pilote de périphérique de charger leurs nouveaux changements
+ dans le noyau en fonctionnement sans redémarrer constamment pour tester ces derniers.
+
+
+ L'interface kld est utilisé au travers des commandes d'administrateur suivantes :
+
+
+ kldload - charge un nouveau module dans le noyau
+ kldunload - décharge un module du noyau
+ kldstat - liste les modules chargés dans le noyau
+
+
+
+ Structure squelettique d'un module de noyau
+
+/*
+ * Squelette KLD
+ * Inspiré de l'article d'Andrew Reiter paru sur Daemonnews
+ */
+
+#include <sys/types.h>
+#include <sys/module.h>
+#include <sys/systm.h> /* uprintf */
+#include <sys/errno.h>
+#include <sys/param.h> /* defines utilise dans kernel.h */
+#include <sys/kernel.h> /* types utilise dans le module d'initialisation */
+
+/*
+ * charge le gestionnaire quit traite du chargement et déchargement d'un KLD.
+ */
+
+static int
+skel_loader(struct module *m, int what, void *arg)
+{
+ int err = 0;
+
+ switch (what) {
+ case MOD_LOAD: /* kldload */
+
+ uprintf("Skeleton KLD charge.\n");
+ break;
+ case MOD_UNLOAD:
+ uprintf("Skeleton KLD decharge.\n");
+ break;
+ default:
+ err = EINVAL;
+ break;
+ }
+ return(err);
+}
+
+/* Declare ce module au reste du noyau */
+
+DECLARE_MODULE(skeleton, skel_loader, SI_SUB_KLD, SI_ORDER_ANY);
+
+
+
+ Makefile
+
+ FreeBSD fournit un fichier d'inclusion "makefile" que vous pouvez utiliser pour
+ compiler rapidement votre ajout au noyau.
+
+ SRCS=skeleton.c
+KMOD=skeleton
+
+.include <bsd.kmod.mk>
+
+ Lancer simplement la commande make avec ce fichier Makefile
+ créera un fichier skeleton.ko qui peut
+ être chargé dans votre système en tapant :
+ &prompt.root
+ kldload -v ./skeleton.ko
+
+
+
+
+
+
+ Accéder au pilote d'un périphérique
+
+ Unix fournit un ensemble d'appels sytème communs utilisable par
+ les applications de l'utilisateur. Les couches supérieures du noyau renvoient
+ ces appels au pilote de périphérique correspondant quand un utilisateur
+ accède au fichier spécial de périphérique. Le script /dev/MAKEDEV
+ crée la plupart des fichiers spéciaux de périphérique pour votre système mais si vous
+ faites votre propre développement de pilote, il peut être nécessaire de créer
+ vos propres fichiers spéciaux de périphérique avec la commande mknod
+
+
+
+ Créer des fichiers spéciaux de périphériques statiques
+
+ La commande mknod nécessite quatre
+ arguments pou créer un fichier spécial de périphérique. Vous devez spécifier le nom
+ de ce fichier spécial de périphérique, le type de périphérique, le numéro majeur
+ et le numéro mineur du périphérique.
+
+
+
+ Les fichiers spéciaux de périphérique dynamiques
+
+ Le périphérique système de fichiers, ou devfs, fournit l'accès à
+ l'espace des noms des périphériques du noyau dans l'espace du système de fichiers global.
+ Ceci élimine les problèmes de pilote sans fichier spécial statique, ou de fichier spécial sans pilote installé.
+ Devfs est toujours un travail en cours mais il fonctionne déjà assez bien.
+
+
+
+
+
+ Les périphériques caractères
+
+ Un pilote de périphérique caractère est un pilote qui tranfère les données
+ directement au processus utilisateur ou vers celui-ci. Il s'agit du plus commun
+ des types de pilote de périphérique et il y en a plein d'exemples simples dans
+ l'arbre des sources.
+
+ Cet exemple simple de pseudo-périphérique enregistre toutes les valeurs
+ que vous lui avez écrites et peut vous les renvoyer quand vous les lui
+ demandez.
+
+/*
+ * un simple pseudo-périphérique `echo' KLD
+ *
+ * Murray Stokely
+ */
+
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+
+#include <sys/types.h>
+#include <sys/module.h>
+#include <sys/systm.h> /* uprintf */
+#include <sys/errno.h>
+#include <sys/param.h> /* defines utilises dans kernel.h */
+#include <sys/kernel.h> /* types utilises dans me module d'initialisation */
+#include <sys/conf.h> /* cdevsw struct */
+#include <sys/uio.h> /* uio struct */
+#include <sys/malloc.h>
+
+#define BUFFERSIZE 256
+
+/* Prototypes des fonctions */
+d_open_t echo_open;
+d_close_t echo_close;
+d_read_t echo_read;
+d_write_t echo_write;
+
+/* Points d'entrée du périphérique Caractère */
+static struct cdevsw echo_cdevsw = {
+ echo_open,
+ echo_close,
+ echo_read,
+ echo_write,
+ noioctl,
+ nopoll,
+ nommap,
+ nostrategy,
+ "echo",
+ 33, /* reserve pour lkms - /usr/src/sys/conf/majors */
+ nodump,
+ nopsize,
+ D_TTY,
+ -1
+};
+
+typedef struct s_echo {
+ char msg[BUFFERSIZE];
+ int len;
+} t_echo;
+
+/* variables */
+static dev_t sdev;
+static int len;
+static int count;
+static t_echo *echomsg;
+
+MALLOC_DECLARE(M_ECHOBUF);
+MALLOC_DEFINE(M_ECHOBUF, "echobuffer", "cache pour le module echo");
+
+/*
+ * Cette fonction est appele par les appels systeme kld[un]load(2) pour
+ * determiner quelles actions doivent etre faites quand le
+ * module est charge ou decharge
+ */
+
+static int
+echo_loader(struct module *m, int what, void *arg)
+{
+ int err = 0;
+
+ switch (what) {
+ case MOD_LOAD: /* kldload */
+ sdev = make_dev(&echo_cdevsw,
+ 0,
+ UID_ROOT,
+ GID_WHEEL,
+ 0600,
+ "echo");
+ /* aloocation de mémoire noyau pour l'utilisation de ce module */
+ /* malloc(256,M_ECHOBUF,M_WAITOK); */
+ MALLOC(echomsg, t_echo *, sizeof(t_echo), M_ECHOBUF, M_WAITOK);
+ printf("Peripherique Echo charge.\n");
+ break;
+ case MOD_UNLOAD:
+ destroy_dev(sdev);
+ FREE(echomsg,M_ECHOBUF);
+ printf("Peripherique Echo decharge.\n");
+ break;
+ default:
+ err = EINVAL;
+ break;
+ }
+ return(err);
+}
+
+int
+echo_open(dev_t dev, int oflags, int devtype, struct proc *p)
+{
+ int err = 0;
+
+ uprintf("Peripherique \"echo\" ouvert avec succes.\n");
+ return(err);
+}
+
+int
+echo_close(dev_t dev, int fflag, int devtype, struct proc *p)
+{
+ uprintf("Fermeture du peripherique \"echo.\"\n");
+ return(0);
+}
+
+/*
+ * La fonction read prend juste comme parametre
+ * le cache qui a ete sauve par l'appel à echo_write()
+ * et le retourne a l'utilisateur pour acces.
+ * uio(9)
+ */
+
+int
+echo_read(dev_t dev, struct uio *uio, int ioflag)
+{
+ int err = 0;
+ int amt;
+
+ /* De quelle taille est cette operation read ? Aussi grande que l'utilisateur le veut,
+ ou aussi grande que les donnees restantes */
+ amt = MIN(uio->uio_resid, (echomsg->len - uio->uio_offset > 0) ? echomsg->len - uio->uio_offset : 0);
+ if ((err = uiomove(echomsg->msg + uio->uio_offset,amt,uio)) != 0) {
+ uprintf("uiomove echoue!\n");
+ }
+
+ return err;
+}
+
+/*
+ * echo_write prend un caractere en entree et le sauve
+ * dans le cache pour une utilisation ulterieure.
+ */
+
+int
+echo_write(dev_t dev, struct uio *uio, int ioflag)
+{
+ int err = 0;
+
+ /* Copie la chaine d'entree de la memoire de l'utilisateur a la memoire du noyau*/
+ err = copyin(uio->uio_iov->iov_base, echomsg->msg, MIN(uio->uio_iov->iov_len,BUFFERSIZE));
+
+ /* Maintenant nous avons besoin de terminer la chaine par NULL */
+ *(echomsg->msg + MIN(uio->uio_iov->iov_len,BUFFERSIZE)) = 0;
+ /* Enregistre la taille */
+ echomsg->len = MIN(uio->uio_iov->iov_len,BUFFERSIZE);
+
+ if (err != 0) {
+ uprintf("Ecriture echouee: mauvaise adresse!\n");
+ }
+
+ count++;
+ return(err);
+}
+
+DEV_MODULE(echo,echo_loader,NULL);
+
+ Pour installer ce pilote, vous devrez d'abord créer un fichier spécial dans
+ votre système de fichiers avec une commande comme :
+
+
+ &prompt.root mknod /dev/echo c 33 0
+
+
+ Avec ce pilote chargé, vous devriez maintenant êtr capable de taper
+ quelque chose comme :
+
+
+ &prompt.root echo -n "Test Donnees" > /dev/echo
+ &prompt.root cat /dev/echo
+ Test Donnees
+
+
+ Périphériques réels dans le chapître suivant.
+
+ Informations additionnelles
+
+ Dynamic
+ Kernel Linker (KLD) Facility Programming Tutorial -
+ Daemonnews October 2000
+ How
+ to Write Kernel Drivers with NEWBUS - Daemonnews July
+ 2000
+
+
+
+
+
+ Pilotes Réseau
+
+ Les pilotes pour périphérique réseau n'utilisent pas les fichiers spéciaux pour
+ pouvoir être acessibles. Leur sélection est basée sur d'autres décisions
+ faites à l'intérieur du noyau et plutôt que d'appeler open(), l'utilisation
+ d'un périphérique réseau se fait généralement en se servant de l'appel système
+ socket(2).
+
+ man ifnet(), périphérique "en boucle", drivers de Bill Paul,
+ etc..
+
+
+
+
diff --git a/fr_FR.ISO8859-1/books/developers-handbook/locking/chapter.sgml b/fr_FR.ISO8859-1/books/developers-handbook/locking/chapter.sgml
new file mode 100644
index 0000000000..ac8cb9094a
--- /dev/null
+++ b/fr_FR.ISO8859-1/books/developers-handbook/locking/chapter.sgml
@@ -0,0 +1,335 @@
+
+
+
+
+ Notes sur le verrouillage
+
+ Ce chapître est maintenu par The FreeBSD SMP Next
+ Generation Project
+ freebsd-smp@FreeBSD.org.
+
+
+ Ce document souligne le verrouillage utilisé dans le noyau FreeBSD
+ pour permettre d'utiliser du vrai multi-processeur à l'intérieur du noyau.
+ Le verrouillage peut être réalisé par différents moyens.
+ Les structures de données puvent être protégées par des mutex ou &man.lockmgr.9; verrous.
+ Quelques variables sont protégées simplement par l'utilisation continuelle d'opérations
+ atomiques pour y accéder.
+
+
+
+ Les mutex
+
+ Un mutex est simplement un verrou utilisé pour garantir exclusion mutuelle.
+ Spécifiquement, un mutex ne peut appartenir qu'à une entité à la fois.
+ Si une autre entité désire obtenir un mutex déjà pris
+ , elle doit attendre jusqu'à ce que le mutex soit relaché. Dans le noyau
+ FreeBSD, les mutex appartiennent aux processus.
+
+ Les mutex peuvent être acquis récursivement, mais ils sont conçus
+ pour n'être pris que pendant une courte période. Spécifiquement, le détenteur
+ ne doit pas se suspendre pendant qu'il retient un mutex. Si vous avez besoin de
+ maintenir un verrouillage pendant une suspension, utilisez un &man.lockmgr.9; verrou ("lock").
+
+ Chaque mutex a plusieurs intérêts :
+
+
+
+ Nom de la variable
+
+ Nom de la variable struct mtx dans
+ le code source du noyau.
+
+
+
+
+ Nom logique
+
+ Le nom du mutex lui est assigné par
+ mtx_init. Ce nom est affiché dans
+ les messages de trace KTR, témoigne des erreurs et avertissements et est
+ utilisé pour distinguer les mutex dans les traces.
+
+
+
+
+ Type
+
+ Le type du mutex en termes de constantes nommées
+ MTX_*. La signification de chaque
+ constante nommée est documentée dans &man.mutex.9;.
+
+
+
+ MTX_DEF
+
+ Un mutex endormi
+
+
+
+
+ MTX_SPIN
+
+ Un mutex tournant
+
+
+
+
+ MTX_COLD
+
+ Ce mutex est initialisé très tard. Toutefois, il
+ doit être déclaré via
+ MUTEX_DECLARE, et la constante nommée
+ MTX_COLD doit être passée à
+ mtx_init.
+
+
+
+
+ MTX_TOPHALF
+
+ Ce mutex tournant ne désactive pas les
+ interruptions.
+
+
+
+
+ MTX_NORECURSE
+
+ Ce mutex n'a pas la permission d'être recursif.
+
+
+
+
+
+
+
+ Protégés
+
+ Une liste de structures de données ou des membres de structure de données
+ que cette entrée protège. Pour les membres de structures de données,
+ le nom sera de la forme
+
+
+
+
+ Fonctions dépendantes
+
+ Les fonctions qui peuvent seulement être appelées si ce mutex est
+ pris.
+
+
+
+
+
+
+
+
+ Les verrous du gestionnaire de verrous (Lock Manager)
+
+ Les verrous qui sont fournis par l'interface &man.lockmgr.9;
+ sont les verrous du gestionnaire de verrous. Ces verrous sont des verrous
+ lecture-écriture et peuvent être retenus par un process suspendu.
+
+
+
+ &man.lockmgr.9; List de verrou
+
+
+
+
+ Nom de la variable
+ Protégés
+
+
+
+
+ allproc_lock
+
+ allproc
+ zombproc
+ pidhashtbl
+ nextpid
+
+ proctree_lock
+
+
+
+
+
+
+
+
+
+ Variables protégées atomiquement
+
+ Une variable protégée atomiquement est une variable spéciale qui
+ n'est pas protégé par un verrou explicite. Toutefois, tous les accès de
+ données aux variables utilisent des opérations atomiques spéciales
+ comme décrit dans &man.atomic.9;. Très peu de variables sont traitées
+ de cette façon, bien que les autres primitives de synchronisation comme
+ les mutex soient implémentées avec des variables protégées atomiquement.
+
+
+
+ astpending
+
+
+
+
+
+
+
+
diff --git a/fr_FR.ISO8859-1/books/developers-handbook/pci/chapter.sgml b/fr_FR.ISO8859-1/books/developers-handbook/pci/chapter.sgml
new file mode 100644
index 0000000000..15815aa180
--- /dev/null
+++ b/fr_FR.ISO8859-1/books/developers-handbook/pci/chapter.sgml
@@ -0,0 +1,376 @@
+
+
+
+ Les périphériques PCI
+
+ Ce chapître traitera des mécanismes de FreeBSD pour
+ écrire un pilote de périphérique pour un périphérique sur
+ bus PCI.
+
+
+ Rechercher et rattacher
+
+ Informations ici sur comment le code du bus PCI fait un cycle
+ sur les périphériques non rattachés et voir si le nouvellement chargé
+ pilote de périphérique chargeable dans le noyau (kld)
+ sera rattaché à l'un d'eux.
+
+/*
+ * Simple KLD pour jouer avec les fonctions PCI.
+ *
+ * Murray Stokely
+ */
+
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+
+#include <sys/types.h>
+#include <sys/module.h>
+#include <sys/systm.h> /* uprintf */
+#include <sys/errno.h>
+#include <sys/param.h> /* defines used in kernel.h */
+#include <sys/kernel.h> /* types used in module initialization */
+#include <sys/conf.h> /* cdevsw struct */
+#include <sys/uio.h> /* uio struct */
+#include <sys/malloc.h>
+#include <sys/bus.h> /* structs, prototypes for pci bus stuff */
+
+#include <pci/pcivar.h> /* For get_pci macros! */
+
+/* Prototypes des fonctions */
+d_open_t mypci_open;
+d_close_t mypci_close;
+d_read_t mypci_read;
+d_write_t mypci_write;
+
+/* Points d'entrée du pilote de périphérique caractère */
+
+static struct cdevsw mypci_cdevsw = {
+ mypci_open,
+ mypci_close,
+ mypci_read,
+ mypci_write,
+ noioctl,
+ nopoll,
+ nommap,
+ nostrategy,
+ "mypci",
+ 36, /* reserved for lkms - /usr/src/sys/conf/majors */
+ nodump,
+ nopsize,
+ D_TTY,
+ -1
+};
+
+/* variables */
+static dev_t sdev;
+
+/* Nous sommes plus interresses dans la recherche/attachement
+que dans l'ouverture/fermeture/lecture/ecriture a ce point */
+
+int
+mypci_open(dev_t dev, int oflags, int devtype, struct proc *p)
+{
+ int err = 0;
+
+ uprintf("Peripherique \"monpci\" ouvert avec succes.\n");
+ return(err);
+}
+
+int
+mypci_close(dev_t dev, int fflag, int devtype, struct proc *p)
+{
+ int err=0;
+
+ uprintf("Peripherique \"monpci.\ "ferme\n");
+ return(err);
+}
+
+int
+mypci_read(dev_t dev, struct uio *uio, int ioflag)
+{
+ int err = 0;
+
+ uprintf("lecture dans monpci!\n");
+ return err;
+}
+
+int
+mypci_write(dev_t dev, struct uio *uio, int ioflag)
+{
+ int err = 0;
+
+ uprintf("Ecriture dans monpci!\n");
+ return(err);
+}
+
+/* PCI Support Functions */
+
+/*
+ * Retourne la chaine d'identification si ce peripherique est le notre
+ */
+static int
+mypci_probe(device_t dev)
+{
+ uprintf("MonPCI Probe\n"
+ "ID Fabricant: 0x%x\n"
+ "ID Peripherique : 0x%x\n",pci_get_vendor(dev),pci_get_device(dev));
+
+ if (pci_get_vendor(dev) == 0x11c1) {
+ uprintf("Nous avons le WinModem, recherche reussi!\n");
+ return 0;
+ }
+
+ return ENXIO;
+}
+
+/* La fonction Attach n'est appelée que si
+la recherche est reussie*/
+
+static int
+mypci_attach(device_t dev)
+{
+ uprintf("Rattachement de MonPCI pour: ID Peripherique: 0x%x\n",pci_get_vendor(dev));
+ sdev = make_dev(&mypci_cdevsw,
+ 0,
+ UID_ROOT,
+ GID_WHEEL,
+ 0600,
+ "monpci");
+ uprintf("Peripherique Monpci charge.\n");
+ return ENXIO;
+}
+
+/* Detach le peripherique. */
+
+static int
+mypci_detach(device_t dev)
+{
+ uprintf("Monpci detache!\n");
+ return 0;
+}
+
+/* Appele lors de l'arret du systeme apres sync. */
+
+static int
+mypci_shutdown(device_t dev)
+{
+ uprintf("Monpci arrete!\n");
+ return 0;
+}
+
+/*
+ * routine de suspension du peripherique
+ */
+static int
+mypci_suspend(device_t dev)
+{
+ uprintf("Monpci suspendu!\n");
+ return 0;
+}
+
+/*
+ * routine de reprise du peripherique
+ */
+
+static int
+mypci_resume(device_t dev)
+{
+ uprintf("Monpci resume!\n");
+ return 0;
+}
+
+static device_method_t mypci_methods[] = {
+ /* Interface Peripherique*/
+ DEVMETHOD(device_probe, mypci_probe),
+ DEVMETHOD(device_attach, mypci_attach),
+ DEVMETHOD(device_detach, mypci_detach),
+ DEVMETHOD(device_shutdown, mypci_shutdown),
+ DEVMETHOD(device_suspend, mypci_suspend),
+ DEVMETHOD(device_resume, mypci_resume),
+
+ { 0, 0 }
+};
+
+static driver_t mypci_driver = {
+ "monpci",
+ mypci_methods,
+ 0,
+ /* sizeof(struct mypci_softc), */
+};
+
+static devclass_t mypci_devclass;
+
+DRIVER_MODULE(mypci, pci, mypci_driver, mypci_devclass, 0, 0);
+
+ Informations complémentaires
+
+ PCI
+ Special Interest Group
+
+ PCI System Architecture, Fourth Edition by
+ Tom Shanley, et al.
+
+
+
+
+
+
+ Les ressources du bus
+
+ FreeBSD fournit un mécanisme orienté objet pour demander
+ des ressources du bus parent. Pratiquement tous les périphériques
+ seront un fils membre d'un type de bus (PCI, ISA, USB, SCSI, etc)
+ et ces périphériques nécessite des ressources issues de leur bus parent
+ (comme des segments de mémoire, des interruptions or des canaux DMA).
+
+
+ Registres d'adresse de base
+
+ Pour faire de particulièrement utile avec un périphérique PCI,
+ vous aurez besoin d'obtenir les registres d'adresse de base
+ (Base Address Registers ou BARs) de l'espace de configuration PCI.
+ Les détails spécifiques au PCI sur l'obtention du registre d'adresse de base
+ sont masqués dans la fonction bus_alloc_resource().
+
+ Par exemple, un pilote typique aura sa fonction attach()
+ similaire à ceci :
+
+ sc->bar0id = 0x10;
+ sc->bar0res = bus_alloc_resource(dev, SYS_RES_MEMORY, &(sc->bar0id),
+ 0, ~0, 1, RF_ACTIVE);
+ if (sc->bar0res == NULL) {
+ uprintf("Allocation memoire du registre PCI de base 0 echouee!\n");
+ error = ENXIO;
+ goto fail1;
+ }
+
+ sc->bar1id = 0x14;
+ sc->bar1res = bus_alloc_resource(dev, SYS_RES_MEMORY, &(sc->bar1id),
+ 0, ~0, 1, RF_ACTIVE);
+ if (sc->bar1res == NULL) {
+ uprintf("Allocation memoire du registre PCI de base 1 echouee!\n");
+ error = ENXIO;
+ goto fail2;
+ }
+ sc->bar0_bt = rman_get_bustag(sc->bar0res);
+ sc->bar0_bh = rman_get_bushandle(sc->bar0res);
+ sc->bar1_bt = rman_get_bustag(sc->bar1res);
+ sc->bar1_bh = rman_get_bushandle(sc->bar1res);
+
+
+
+ Des références pour chaque registre d'adresse de base sont gardées
+ dans la structure softc afin qu'elle puisse
+ être utilisée pour écrire dans le périphérique plus tard.
+
+ Ces références peuvent alors être utilisées pour lire ou écrire
+ dans les registres du périphérique avec les fonctions bus_space_*.
+ Par exemple, un pilote peut contenir une fonction raccourci
+ pour lire dans un registre spécifique à une carte comme cela :
+
+
+uint16_t
+board_read(struct ni_softc *sc, uint16_t address) {
+ return bus_space_read_2(sc->bar1_bt, sc->bar1_bh, address);
+}
+
+
+ De façon similaire, une autre peut écrire dans les registres avec :
+
+void
+board_write(struct ni_softc *sc, uint16_t address, uint16_t value) {
+ bus_space_write_2(sc->bar1_bt, sc->bar1_bh, address, value);
+}
+
+
+ Ces fonctions existent en versions 8bit, 16bit et 32bit
+ et vous devriez utiliser
+ bus_space_{read|write}_{1|2|4}
+ en conséquence.
+
+
+
+ Les interruptions
+
+ Les interruptions sont alloués à partir du code orienté objet du
+ bus de façon similaire aux ressources mémoire. D'abord une ressource
+ IRQ doit être allouée à partir du bus parent, et alors le
+ gestionnaire d'interruption doit être règlé pour traiter cet IRQ.
+
+ A nouveau, un exemple de fonction
+ attach() en dit plusqu'un long discours.
+
+/* Recupere la ressource IRQ */
+
+ sc->irqid = 0x0;
+ sc->irqres = bus_alloc_resource(dev, SYS_RES_IRQ, &(sc->irqid),
+ 0, ~0, 1, RF_SHAREABLE | RF_ACTIVE);
+ if (sc->irqres == NULL) {
+ uprintf("Allocation IRQ echouee!\n");
+ error = ENXIO;
+ goto fail3;
+ }
+
+ /* Maitnenant nous choisissons notre gestionnaire d'interruption */
+
+ error = bus_setup_intr(dev, sc->irqres, INTR_TYPE_MISC,
+ my_handler, sc, &(sc->handler));
+ if (error) {
+ printf("Ne peut regler l'IRQ\n");
+ goto fail4;
+ }
+
+ sc->irq_bt = rman_get_bustag(sc->irqres);
+ sc->irq_bh = rman_get_bushandle(sc->irqres);
+
+
+
+
+
+ DMA
+ Sur les PC, les périphériques qui veulent utiliser la gestion de
+ bus DMA doivent travailler avec des adresses physiques. C'est un problème
+ puisque FreeBSD utilise une mémoire virtuelle et travaille presque
+ exclusivement avec des adresses virtuelles. Heureusement, il y a une
+ fonction vtophys() pour nous aider.
+
+#include <vm/vm.h>
+#include <vm/pmap.h>
+
+#define vtophys(virtual_address) (...)
+
+
+ La solution est toutefois un peu différente sur Alpha, et
+ ce que nous voulons réellement est une fonction appelée
+ vtobus().
+
+#if defined(__alpha__)
+#define vtobus(va) alpha_XXX_dmamap((vm_offset_t)va)
+#else
+#define vtobus(va) vtophys(va)
+#endif
+
+
+
+
+
+ Désallouer les resources
+
+ Il est très important de désallouer toutes les ressources
+ qui furent allouées pendant attach().
+ Unsoin tout particulier doit être pris pour désallouer
+ les bonnes choses même lors d'un échec afin que le système reste
+ utilisable lorsque votre driver meurt.
+
+
+
+
+
+
diff --git a/fr_FR.ISO8859-1/books/developers-handbook/scsi/chapter.sgml b/fr_FR.ISO8859-1/books/developers-handbook/scsi/chapter.sgml
new file mode 100644
index 0000000000..1e7e5ea990
--- /dev/null
+++ b/fr_FR.ISO8859-1/books/developers-handbook/scsi/chapter.sgml
@@ -0,0 +1,16 @@
+
+
+
+
+ Contrôleurs SCSI Common Access Method (CAM) **
+ En cours de traduction
+ En cours de traduction
+
+
diff --git a/fr_FR.ISO8859-1/books/developers-handbook/secure/chapter.sgml b/fr_FR.ISO8859-1/books/developers-handbook/secure/chapter.sgml
new file mode 100644
index 0000000000..d96cd814a5
--- /dev/null
+++ b/fr_FR.ISO8859-1/books/developers-handbook/secure/chapter.sgml
@@ -0,0 +1,425 @@
+
+
+
+ Programmation sécurisée
+
+ Ce chapître a été écrit par Murray Stokely.
+
+ Synopsis
+
+ Ce chapître décrit quelques problèmes de sécurité qui
+ ont tourmenté les programmeurs Unix depuis des dizaines d'années
+ et quelques uns des nouveaux outils disponibles pour aider
+ les programmeurs à éviter l'écriture de code non sécurisé.
+
+
+
+ Méthodologie de développement
+ sécurisé
+
+ Ecrire des applications sécurisées demande une très minutieuse
+ et pessimiste vision de la vie. Les applications devrait fonctionner
+ avec le principe du privilège moindre de façon à ce
+ qu'aucun processus ne fonctionne avec plus que le strict minimum dont
+ il a besoin pour accomplir sa tâche. Le code pré-testé devrait être
+ réutilisé autant que possible pour éviter les erreurs communes que
+ d'autres peuvent déjà avoir réparées.
+
+ Un des pièges de l'environnement Unix est qu'il est facile
+ d'affecter la stabilité de l'environnement.
+ Les applications ne devraient jamais avoir confiance dans la saisie
+ de l'utilisateur (sous toutes ses formes),
+ les ressources système, la communication inter-processus, ou l'enchaînement
+ des évènements. Les processus Unix n'exécutent pas de manière synchrone
+ aussi, logiquement, les opérations sont rarement atomiques.
+
+
+ Dépassement de capacité
+
+ Les dépassements de capacité ("Buffer Overflows") existent depuis
+ les débuts de l'architecture de Von-Neuman .
+ Ils gagnèrent une grande notoriété en 1988 avec le ver pour Internet
+ de Morris. Malheureusement, la même attaque basique reste effective
+ aujourd'hui. Des 17 rapports de sécurité du CERT de 1999, 10
+ furent causés directement des bogues logiciels de dépassement de
+ capacité. De loin la plus commune de types d'attaques par dépassement de
+ capacité est basée sur la corruption de la pile.
+
+ La plupart des systèmes informatiques modernes utilise une pile
+ pour passer les arguments aux procédures et stocker les variables locales
+ Une pile est une zone mémoire dernier entré-premier sorti (Last In-First
+ Out : LIFO) dans la zone de mémoire haute de l'image d'un processus.
+ Quand un programme invoque une fonction une nouvelle structure pile est
+ créée. Cette structure pile consiste dans les arguments passés à la
+ fonction aussi bien que dans une quantité dynamique d'espace pour
+ la variable locale. Le pointeur de pile est un registre qui référence la
+ position courante du sommet de la pile. Etant donné que cette valeur
+ change constamment au fur et à mesure que de nouvelles valeurs sont
+ ajoutées au sommet de la pile, beaucoup d'implémentations fournissent
+ aussi un pointeur de structure qui est positionné dans le voisinage du
+ début de la structure pile de façon à ce que les variables locales soient
+ plus facilement adressables relativement à cette valeur.
+ L'adresse de retour des appels de fonction est aussi
+ stocké dans la pile, et cela est la cause des découvertes des
+ dépassements de pile puisque faire déborder une variable locale dans une
+ fonction peut écraser l'adresse de retour de cette fonction, permettant
+ potentiellement à un utilisateur malveillant d'exécuter le code qu'il ou
+ elle désire.
+
+ Bien que les attaques basées sur les dépassements de pile soient
+ de loin les plus communes, il serait aussi possible de faire exploser
+ la pile avec une attaque du tas (malloc/free).
+
+ Le langage de programmation C ne réalise pas de vérifications
+ automatiques des limites sur les tableaux ou pointeurs comme d'autres
+ langages le font. De plus, la librairie standard du C est remplie d'une
+ poignée de fonctions très dangereuses.
+
+
+
+
+ strcpy(char *dest, const char
+ *src)
+ Peut faire déborder le tampon dest
+
+
+ strcat(char *dest, const char
+ *src)
+ Peut faire déborder le tampon dest
+
+
+ getwd(char *buf)
+ Peut faire déborder le tampon buf
+
+
+ gets(char *s)
+ Peut faire déborder le tampon s
+
+
+ [vf]scanf(const char *format,
+ ...)
+ Peut faire déborder ses arguments.
+
+
+ realpath(char *path, char
+ resolved_path[])
+ Peut faire déborder le tampon path
+
+
+ [v]sprintf(char *str, const char
+ *format, ...)
+ Peut faire déborder le tampon str.
+
+
+
+
+
+ Exemple de dépassement de capacité
+
+ L'exemple de code suivant contient un dépassement de capacité
+ conçu pour écraser l'adresse de retour et "sauter" l'instruction suivant
+ immédiatement l'appel de la fonction. (Inspiré
+ par )
+
+#include stdio.h
+
+void manipulate(char *buffer) {
+ char newbuffer[80];
+ strcpy(newbuffer,buffer);
+}
+
+int main() {
+ char ch,buffer[4096];
+ int i=0;
+
+ while ((buffer[i++] = getchar()) != '\n') {};
+
+ i=1;
+ manipulate(buffer);
+ i=2;
+ printf("La valeur de i est : %d\n",i);
+ return 0;
+}
+
+ Examinons quel serait l'aspect de l'image mémoire de ce processus
+ si nous avions entré 160 espaces dans notre petit programme avant
+ d'appuyer sur Entrée.
+
+ [XXX Schéma ici!]
+
+ Evidemment une entrée plus malveillante pourrait être imaginée pour
+ exécuter des instructions déjà compilées (comme exec(/bin/sh)).
+
+
+ Eviter les dépassements de capacité
+
+ La solution la plus simple au problème de débordement de pile
+ est de toujours utiliser de la mémoire restreinte en taille et
+ les fonctions de copie de chaîne de caractères. strncpy
+ et strncat font parties de la libraire standard du
+ C. Ces fonctions acceptent une valeur de longueur comme paramètre qui
+ qui ne devrait pas être plus grande que la taille du tampon de
+ destination. Ces fonctions vont ensuite copier `taille' octets de la
+ source vers la destination. Toutefois, il y a un certain nombre de
+ problèmes avec ces fonctions. Aucune fonction ne garantit une terminaison
+ par le caractère NULL si la taille du tampon d'entrée est aussi grand
+ que celui de destination. Le paramètre taille est aussi utilisé de façon
+ illogique entre strncpy et strncat
+ aussi il est facile pour les programmeurs d'être déroutés sur leur
+ utilisation convenable. Il y a aussi une perte significative des
+ performances comparé à strcpy lorsque l'on copie
+ une courte chaîne dans un grand tampon puisque strncpy
+ remplit de caractères NULL jusqu'à la taille spécifiée.
+
+ Dans OpenBSD, une autre implémentation de la copie de mémoire
+ a été créée pour contourner ces problèmes. Les fonctions strlcpy
+ et strlcat garantissent qu'elles termineront
+ toujours le tampon de destination par un caractère NULL losque l'argument
+ de taille est différent de zéro. Pour plus d'informations sur ces
+ fonctions, voir . Les fonctions strlcpy et
+ strlcat d'OpenBSD ont été inclues dans FreeBSD
+ depuis la version 3.5.
+
+ V#233;rifications des limites en fonctionnement basées sur le compilateur
+
+
+ Malheureusement il y a toujours un très important assortiment de
+ code en utilisation publique qui copie aveuglément la mémoire sans
+ utiliser une des routines de copie limitée dont nous venons juste de
+ discuter. Heureusement, il y a une autre solution. Plusieurs produits
+ complémentaires pour compilateur et librairies existent pour faire
+ de la vérification de limites pendant le fonctionnement en C/C++.
+
+ StackGuard est un de ces produits qui est implémenté comme un
+ petit correctif ("patch") pour le générateur de code gcc. Extrait du
+ site Internet de StackGuard, http://immunix.org/stackguard.html :
+
"StackGuard détecte et fait échouer les attaques
+ par débordement de pile en empêchant l'adresse de retour sur la pile
+ d'être altérée. StackGuard place un mot "canari"
+ NDT : Jaune de préférence pour être bien visible
+ à côté de l'adresse de retour quand la fontion est appelée. Si le mot
+ "canari" a été altéré au retour de la fonction, alors une attaque par
+ débordement de pile a été tentée et le programme répond en envoyant
+ une alerte d'intrusion dans la trace système (syslog) et
+ s'arrête alors."
+
+
"StackGuard est implémenté comme un petit correctif
+ au générateur de code gcc, spécifiquement sur les routines
+ function_prolog() et function_epilog(). function_prolog() a été
+ amélioré pour laisser des "canaris" sur la pile quand les fonctions
+ démarrent, et function_epilog vérifie l'intégrité des "canaris" quand
+ la fonction se termine. Tout essai pour corrompre l'adresse de retour
+ est alors détectée avant que la fonction ne retourne."
+
+
+ Recompiler votre application avec StackGuard est un
+ moyen efficace pour stopper la plupart des attques par dépassement de
+ capacité, mais cela peut toujours être compromis.
+
+
+
+ Vérifications des limites en fonctionnement basées sur les librairies
+
+ Les mécanismes basés sur le compilateur sont totalement inutiles
+ pour logiciel seulement binaire que vous ne pouvez recompiler. Pour
+ ces situations, il existe un nombre de librairies qui re-implémente
+ les fonctions peu sûres de la librairie C
+ (strcpy, fscanf,
+ getwd, etc..) et assurent que ces
+ fonctions ne peuvent pas écrire plus loin que le pointeur de pile.
+
+
+ libsafe
+ libverify
+ libparnoia
+
+
+ Malheureusement ces défenses basées sur les librairies possèdent
+ un certain nombre de défauts. Ces librairies protègent seulement d'un
+ très petit ensemble de problèmes liés à la sécurité et oublient de
+ réparer le problème actuel. Ces défenses peuvent échouer si
+ l'application a été compilée avec -fomit-frame-pointer. De même, les
+ variables d'environnement LD_PRELOAD et LD_LIBRARY_PATH peuvent être
+ réécrites/non définies par l'utilisateur.
+
+
+
+
+
+ Les problèmes liés à SetUID
+
+ Il y a au moins 6 differents ID (identifiants) associés à un
+ processus donné. A cause de cela, vous devez être très attentif avec
+ l'accès que votre processus possède à un instant donné. En particulier,
+ toutes les applications ayant reçu des privilèges par seteuid doivent
+ les abandonnés dès qu'ils ne sont plus nécessaires.
+
+ L'identifiant de l'utilisateur réel (real user ID) peut seulement
+ être changé par un processus super-utilisateur. Le programme login
+ met celui à jour quand un utilisateur se connecte et il est rarement
+ changé.
+
+ L'identifiant de l'utilisateur effectif (effective user ID) est mis
+ à jour par les fonctions exec() si un programme
+ possède son bit seteuid placé. Une application peut appeler
+ seteuid() à n'importe quel moment pour règler
+ l'identifiant de l'utilisateur effectif sur l'identifiant d'un
+ utilisateur réel ou sur le "set-user-ID" sauvé.
+ Quand l'identifiant de l'utilisateur effectif est placé par les
+ fonctions exec(), la valeur précédente est sauvée
+ dans le "set-user-ID" sauvé.
+
+
+
+ Limiter l'environnement de votre programme
+
+ La méthode traditionnelle pour restreindre l'accès d'un processus
+ se fait avec l'appel système chroot(). Cet appel
+ système change le répertoire racine depuis lequel tous les autres chemins
+ sont référencés pour un processus et ses fils. Pour que cet appel
+ réussisse, le processus doit avoir exécuté (recherché)
+ la permission dans le répertoire référencé. Le nouvel environnement
+ environment ne prend pas effet que lorsque vous appelez chdir()
+ dans celui-ci.
+ Il doit être aussi noté qu'un processus peut facilement s'échapper
+ d'un environnement chroot s'il a les privilèges du super-utilisateur.
+ Cela devrait être accompli en créant des fichiers spéciaux de
+ périphérique pour la mémoire du noyau, en attachant un dévermineur à un
+ processus depuis l'extérieur de sa "prison", ou par d'autres manières
+ créatrices.
+
+ Le comportement de l'appel système chroot()
+ peut être un peu contrôlé avec la commande sysctl et
+ la variable kern.chroot_allow_open_directories.
+ Quand cette valeur est règlée à 0, chroot() échouera
+ avec EPERM s'il y a un répertoire d'ouvert. Si la variable est règlée sur
+ la valeur par défaut 1, alors chroot() échouera
+ avec EPERM s'il y a un répertoire d'ouvert et que le processus est déjà
+ sujet à un appel chroot(). Pour toute autre valeur, la
+ vérification des répertoires ouverts sera totalement court-circuitée.
+
+ La fonctionnalité "prison" de FreeBSD
+
+ Le concept de Prison ("Jail") étend
+ chroot() en limitant les droits du
+ super-utilisateur pour créer un véritable `serveur virtuel'. Une fois
+ qu'une prison est mise en place, toute communication réseau doit avoir lieu
+ au travers de l'adresse IP spécifiée, et le droit du
+ "privilège super-utilisateur" dans cette prison est sévèrement gêné.
+
+ Tant qu'il se trouve en prison, tout test avec les droits du
+ super-utilisateur dans le noyau au travers d'un appel à
+ suser() échouera.
+ Toutefois, quelques appels à suser() ont été
+ changés par la nouvelle interface suser_xxx().
+ Cette fonction est responsable de fournir ou de retirer les accès
+ aux droits du super-utilisateur pour les processus emprisonnés.
+
+ Un processus super-utilisateur dans un environnement emprisonné
+ a le pouvoir de :
+
+ Manipuler les identitifications avec
+ setuid, seteuid,
+ setgid, setegid,
+ setgroups, setreuid,
+ setregid, setlogin
+ Règler les limites en ressources avec setrlimit
+ Modifier quelques variables du noyau par sysctl
+ (kern.hostname)
+ chroot()
+ Règler les paramètres d'un noeud virtuel (vnode):
+ chflags,
+ fchflags
+ Règler les attributs d'un noeud virtuel comme
+ les permissions d'un fichier, le propriétaire, le groupe, la taille,
+ la date d'accès, et la date de modification.
+ Se lier à des ports privilégiés sur Internet
+ (ports < 1024)
+
+
+ Jail est un outil très utile pour exécuter
+ des applications dans un environnement sécurisé mais il a des
+ imperfections. Actuellement, les mécanismes IPC (Inter-Process
+ Communications) n'ont pas été convertis pour utiliser suser_xxx
+ aussi des applications comme MySQL ne peuvent être exécutée dans une prison.
+ L'accès super-utilisateur peut avoir un sens très limité dans une prison,
+ mais il n'y aucune façon de spécifier exactement ce que très limité
+ veut dire.
+
+
+ Les capacitès des processus POSIX.1e
+
+ Posix a réalisé un document de travail qui ajoute l'audit
+ d'évènement, les listes de contrôle d'accès, les privilèges fins,
+ l'étiquetage d'information, et le contrôle d'accès mandaté.
+ Il s'agit d'un travail en cours et c'est l'objectif du projet TrustedBSD. Une partie
+ du travail initial a été intégré dans FreeBSD-current
+ (cap_set_proc(3)).
+
+
+
+
+
+ La confiance
+
+ Une application ne devrait jamais supposer que tout est sain
+ dans l'environnement des utilisateurs. Cela inclut (mais n'est
+ certainement pas limité à) : la saisie de l'utilisateur, les signaux,
+ les variables d'environnement, les ressources, les communication
+ inter-processus, les mmaps, le répertoire de travail du système de
+ fichiers, les descripteurs de fichier, le nombre de fichiers ouverts,
+ etc.
+
+ Vous ne devriez jamais supposer que vous pouvez gérer toutes les
+ formes de saisie invalide qu'un utilisateur peut entrer. Votre
+ application devrait plutôt utiliser un filtrage positif pour
+ seulement permettre un sous-ensemble spécifique que vous jugez
+ sain. Une mauvaise validation des entrées a été la cause de beaucoup
+ découvertes de bogues, spécialement avec les scripts CGI sur le web.
+ Pour les noms de fichier, vous devez être tout particulièrement attentif
+ aux chemins ("../", "/"), liens symboliques et caractères d'échappement
+ de l'interpréteur de commandes.
+
+ Perl possède une caractéristique tès sympathique appelée mode
+ "Taint" qui peut être utilisée pour empêcher les scripts d'utiliser
+ des données externes au programme par un moyen non sûr. Ce mode vérifiera
+ les arguments de la ligne de commandes, les variables d'environnement,
+ les informations localisées (propres aux pays), les résultats de certains
+ appels système (readdir(),
+ readlink(),
+ getpwxxx()) et toute entrée de fichier.
+
+
+
+ Les conditions de course
+
+ Une condition de course est un comportement anormal causé par
+ une dépendance inattendue sur le séquencement relatif des évènements. En
+ d'autres mots, un programmeur a supposé à tort qu'un évènement
+ particulier se passerait avant un autre.
+
+ Quelques causes habituelles de conditions de course sont les
+ signaux, les vérifications d'accès et les fichiers ouverts.
+ Les signaux sont des évènements asynchrones par nature aussi un soin
+ particulier doit être pris pour les utiliser.
+ Vérifier les accès avec access(2) puis
+ open(2) n'est clairement pas atomique.
+ Les utilisateurs peuvent déplacer des fichiers entre les deux appels.
+ Les applications privilégiées devraient plutôt faire un appel à
+ seteuid() puis appeler open()
+ directement. Dans le même esprit, une application devrait toujours règler
+ un umask correct avant un appel à open() pour
+ prévenir le besoin d'appels non valides à chmod().
+
+
+
+
diff --git a/fr_FR.ISO8859-1/books/developers-handbook/tools/chapter.sgml b/fr_FR.ISO8859-1/books/developers-handbook/tools/chapter.sgml
new file mode 100644
index 0000000000..d89526b9f8
--- /dev/null
+++ b/fr_FR.ISO8859-1/books/developers-handbook/tools/chapter.sgml
@@ -0,0 +1,2312 @@
+
+
+
+ Outils de programmation
+
+ Ce chapître a été écrit par James Raynard.
+ Les modifications pour le livre de chevet du développeur par Murray Stokely.
+
+
+ Synopsis
+
+ Ce document est une introduction à l'utilisation de quelques
+ outils de programmation fournis avec FreeBSD, toutefois tout sera applicable
+ à beaucoup d'autres versions d'Unix. Cette introduction n'essaye
+ pas de décrire la programmation dans le détail.
+ La plupart du document suppose que vous possédez peu ou pas de connaissances
+ en programmation, espérant que les programmeurs trouveront un
+ intérêt dans ce document.
+
+
+
+ Introduction
+
+ FreeBSD offre un excellent environnement de développement.
+ Des compilateurs pour C, C++ et Fortran ainsi qu'un assembleur sont fournis avec
+ le système de base, sans parler de l'interpréteur PERL ni des
+ outils classiques Unix comme sed et awk.
+ Si cela n'est pas suffisant, il y a encore plus de compilateurs et
+ d'interpréteurs dans la collection des logiciels portés.
+ FreeBSD est compatible avec les standards comme POSIX et C
+ ANSI, aussi bien qu'avec son propre héritage BSD,
+ aussi il est possible d'écrire des applications qui se compileront
+ et s'exécuteront avec peu ou pas de modifications sur un grand nombre de
+ plateformes.
+
+ Toutefois, toute cette puissance peut être plutôt écrasante
+ au premier abord si vous n'avez jamais écrit de programmes sur une
+ plateforme Unix auparavant. Ce document a pour but de vous aider à commencer,
+ sans entrer trop loin dans des sujets plus avancés. L'intention est
+ que ce document devrait vous donner assez de bases pour être capable de
+ donner du sens à la documentation.
+
+ La majeure partie du document requiert peu ou pas de connaissance
+ de la programmation, bien qu'il suppose une compétence de base dans
+ l'utilisation d'Unix et dans la bonne volonté d'apprendre !
+
+
+
+
+ Introduction à la programmation
+
+ Un programme est un ensemble d'instructions qui disent à l'ordinateur
+ de faire diverses choses; quelques fois, l'instruction qu'il a à exécuter
+ dépend de ce qui s'est passé lors de l'exécution d'une instruction
+ précédente. Cette section donne un aperçu des deux manières par lesquelles
+ vous pouvez donner ces instructions, ou
+ commandes comme elles sont habituellement nommées.
+ Une façon utilise un interpréteur, l'autre
+ un compilateur. Comme les langages humains sont
+ trop difficiles à comprendre sans ambiguïté par un ordinateur,
+ les commandes sont habituellement écrites dans un langage ou un autre
+ spécialement conçus pour cet usage.
+
+
+ Les interpréteurs
+
+ Avec un interpréteur, le langage va avec un environnement
+ où vous entrez des commandes à un invite de commandes et l'environnement
+ les exécute pour vous. Pour des programmes plus compliqués, vous pouvez
+ entrer les commandes dans un fichier et demander à l'interpréteur de charger
+ le fichier et d'exécuter les commandes qui sont à l'intérieur.
+ Si quoique ce soit se passe mal, beaucoup d'interpréteurs vous enverrons
+ dans un dévermineur pour vous aider à débusquer le problème.
+
+ L'avantage de cela est que vous pouvez voir les résultats de
+ vos commandes immédiatement, et les erreurs peuvent être corrigées
+ facilement. Le plus gros désavantage arrive quand vous voulez partager
+ vos programmes avec d'autres personnes. Ils doivent avoir le même
+ interpréteur ou bien vous devez avoir un moyen de leur donner,
+ et ils doivent comprendre comment l'utiliser. Par ailleurs, les
+ utilisateurs pourraient ne pas apprécier d'être renvoyés dans un
+ dévermineur s'ils ont appuyé sur la mauvaise touche !
+ D'un point de vue performance, les interpréteurs peuvent utiliser
+ beaucoup de mémoire et généralement ne génèrent pas un code aussi
+ efficace que les compilateurs.
+
+ A mon avis, les langages interprétés sont le meilleur moyen
+ pour démarrer si vous n'avez jamais programmé. Ce genre
+ d'environnement se trouve typiquement avec des langages comme Lisp,
+ Smalltalk, Perl et Basic. Il peut aussi être dit que l'interpréteur de
+ commandes Unix (sh, csh) est
+ lui-même un interpréteur, et beaucoup de gens écrivent en fait des
+ scripts (procédures) pour l'interpréteur pour les aider
+ dans diverses tâches domestiques sur leur machine.
+ En effet, une partie de la philosophie d'origine d'Unix était de
+ fournir plein de petits programmes utilitaires qui pouvaient être liés
+ ensemble dans des procédures pour effectuer des tâches utiles.
+
+
+
+ Les interpréteurs disponibles avec FreeBSD
+
+ Voici la liste des interpréteurs qui sont disponibles sous la forme
+ de
+ logiciels pré-compilés pour FreeBSD, avec une brève description
+ de quelques uns des langages interprétés les plus populaires.
+
+ Pour obtenir un de ces logiciels pré-compilés, tout ce que vous
+ avez à faire est de cliquer sur le lien du logiciel et d'exécuter
+
+ &prompt.root; pkg_add nom du logiciel
+
+
+ en tant que super-utilisateur. Evidemment, vous aurez besoin d'un
+ FreeBSD 2.1.0 ou plus en état de marche pour que le logiciel fonctionne !
+
+
+
+ BASIC
+
+
+ Abbréviation de "Beginner's All-purpose Symbolic
+ Instruction Code" (code d'instruction symbolique tout usage
+ pour le débutant). Développé dans les années 50 pour apprendre
+ aux étudiants d'université à programmer et fourni avec tout
+ ordinateur qui se respecte dans les années 80,
+ BASIC a été le premier langage de
+ programmation pour beaucoup de programmeurs. Il est aussi le
+ fondement même du Visual Basic.
+
+ L'interpréteur Basic Bywater
+ et l'interpréteur Basic de Phil
+ Cockroft (anciennement Rabbit
+ Basic) sont disponibles pour FreeBSD sous forme de logiciels pré-compilés
+
+
+
+
+
+ Lisp
+
+
+ Un langage qui a été développé à la fin des années 50 comme
+ une alternative aux langages dévoreurs de calculs
+ qui étaient très populaires à l'époque. Plutôt qu'être basé
+ sur les nombres, Lisp est basé sur les listes; en fait
+ le nom est l'abbréviation de List Processing.
+ Très populaire en IA (Intelligence Artificielle).
+
+ Lisp est un langage extrèmement puissant et sophistiqué
+ , mais peut être assez lourd et peu maniable.
+
+ FreeBSD a GNU
+ Common Lisp de disponible sous la forme d'un logiciel pré-compilé.
+
+
+
+
+ Perl
+
+
+ Très populaire auprès des administrateurs système pour la rédaction
+ de procédures; aussi souvent utilisé sur les serveurs Internet pour
+ l'écriture de procédures CGI.
+
+ La dernière version (version 5) est fournie avec FreeBSD.
+
+
+
+
+ Scheme
+
+
+ Un dérivé du Lisp qui est plutôt plus compact et
+ plus propre que le Common Lisp. Populaire dans les universités étant
+ suffisamment simple à apprendre aux étudiants comme premier langage
+ , il possède un niveau d'abstraction suffisamment important pour être
+ utilisé dans le travail de recherche.
+
+ On trouve pour FreeBSD les logiciels pré-compilés interpréteur
+ Scheme Elk, l'interpréteur
+ Scheme du MIT et l'interpréteur Scheme
+ SCM.
+
+
+
+
+ Icon
+
+
+ Le langage
+ de programmation Icon.
+
+
+
+
+ Logo
+
+
+ l'interpréteur Logo
+ de Brian Harvey.
+
+
+
+
+ Python
+
+
+ Le
+ langage orienté objet Python
+
+
+
+
+
+
+ Les compilateurs
+
+ Les compilateurs sont plutôt différents entre eux. Tout d'abord, vous écrivez
+ votre code dans un fichier (ou des fichiers) en utilisant un éditeur de texte. Vous
+ exécutez ensuite le compilateur et vérifiez qu'il accepte votre programme. S'il ne
+ compile pas, grincez des dents et retournez à l'éditeur; s'il compile et
+ vous donne un programme, vous pouvez exécuter ce dernier à l'invite de commande ou
+ dans un dévermineur pour voir s'il fonctionne correctement.
+
+
+ Si vous l'exécuter à l'invite de commande, vous pouvez recevoir un fichier
+ d'image mémoire (NDT: le désormais célèbre "core dump").
+
+
+ Evidemment, ce n'est pas aussi direct que d'utiliser un interpréteur.
+ Toutefois cela vous permet de faire beaucoup de choses qui sont difficiles
+ ou même impossibles avec un interpréteur, comme écrire du code qui interagit
+ de façon proche du système d'exploitation ou même d'écrire votre propre
+ système d'exploitation ! C'est aussi utile si vous avez besoin d'écrire du code
+ très efficace, étant donné que le compilateur peut prendre son temps et
+ optimiser le code, ce qui ne serait pas acceptable avec un interpréteur.
+ Et distribuer un programme écrit pour un compilateur est habituellement
+ plus évident qu'un écrit pour un interpréteur—vous pouvez juste donner
+ une copie de l'exécutable, en supposant que l'utilisateur possède le même
+ système d'exploitation que vous.
+
+ Les langages compilés incluent Pascal, C et C++. C et C++
+ sont des langages plutôt impitoyables et conviennent mieux
+ aux programmeurs expérimentés; Pascal, d'autre part, a été
+ conçu comme un langage éducatif, et est un assez bon langage
+ pour commencer. Malheureusement, FreeBSD ne possède aucun
+ support Pascal, excepté pour un convertisseur Pascal vers C
+ dans les logiciels portés.
+
+ Le cycle édition-compilation-exécution-déverminage étant relativement pénible
+ lors de l'utilisation de programmes séparés, beaucoup de fabricants de compilateur
+ ont produit des environnements de développement intégrés (ou IDE pour
+ Integrated Development Environments et EDI dans la langue de
+ Molière). FreeBSD ne possède pas d'EDI
+ tel quel; toutefois il est possible d'utiliser Emacs à cet effet.
+ Ceci est vu dans .
+
+
+
+
+
+ Compiler avec <command>cc</command>
+
+ Cette section traite uniquement du compilateur GNU pour C et C++,
+ celui-ci faisant partie du système FreeBSD de base. Il peut être invoqué
+ soit par cc ou gcc. Les
+ détails de production d'un programme avec un interpréteur varient
+ considérablement d'un interpréteur à l'autre, et sont habituellement
+ bien couverts par la documentation et l'aide en ligne de l'interpréteur.
+
+ Une fois que vous avez écrit votre chef d'oeuvre, la prochaine étape est
+ de le convertir en quelque chose qui s'exécutera (espérons !) sur FreeBSD.
+ Cela implique normalement plusieurs étapes, réalisées chacune par un programme
+ différent.
+
+
+
+ Pré-traiter votre code source pour retirer les commentaires et faire
+ d'autres trucs comme développer (expanser) les macros en C.
+
+
+
+ Vérifier la syntaxe de votre code source pour voir si vous avez
+ obéi aux règles du langage. Si vous ne l'avez pas fait, il se plaindra !
+
+
+
+ Convertir le code source en langage assembleur—
+ cela est vraiment proche du code machine, mais reste
+ compréhensible par des humains. Prétendument.
+
+
+ Pour être vraiment précis, cc convertit à ce niveau le
+ code source dans son propre p-code indépendant de la
+ machine plutôt qu'en langage assembleur.
+
+
+
+
+ Convertir le langage assembleur en code machine
+ —ouais, on parle de bits et d'octets, de uns et
+ de zéros.
+
+
+
+ Vérifier que vous avez utilisé des choses comme des fonctions et
+ des variables globales de façon consistente. Par exemple, si vous
+ avez appelé une fonction inexistente, le compilateur se plaindra.
+
+
+
+ Si vous essayez de produire un exécutable depuis plusieurs
+ fichiers de code source, résoudre comment les faire fonctionner
+ ensemble.
+
+
+
+ Résoudre comment produire quelque chose que le chargeur au vol
+ du système sera capable de charger en mémoire et exécuter.
+
+
+
+ Finalement, écrire l'exécutable dans le système de fichiers.
+
+
+
+ Le mot compilation est souvent utilisé pour
+ les étapes 1 à 4 seules—les autres correspondent au terme
+ liaison. Quelquefois, l'étape 1 est appelée
+ pre-traitement et les étapes 3-4 assemblage.
+
+ Heureusement, la plupart de ces détails vous sont cachés, étant donné que
+ cc est un frontal qui s'occupe d'appeler tous les
+ programmes avec les arguments corrects pour vous; tapez simplement
+
+ &prompt.user; cc foobar.c
+
+
+ compilera foobar.c avec toutes les étapes au-dessus.
+ Si vous avez plus d'un fichier à compiler, faites simplement
+ quelque chose comme
+
+ &prompt.user; cc foo.c bar.c
+
+
+ Notez que la vérification de syntaxe n'est que cela—vérifier
+ la syntaxe. Cela ne vérifiera pas les erreurs de logique que vous pouvez
+ avoir faites, comme mettre le programme en boucle infinie ou
+ utiliser un tri à bulles quand vous devriez utiliser un tri binaire.
+
+
+ Au cas où vous ne le sauriez pas, un tri binaire est un manière
+ efficace de trier les éléments et le tri à bulles n'en est pas une.
+
+
+ Il y a beaucoup d'options pour cc, qui
+ qui se trouvent toutes dans les pages de manuel en ligne.
+ Voici quelques unes des plus importantes, avec des exemples illustrant leur
+ utilisation.
+
+
+
+
+
+
+ Le nom de sortie du fichier. Si vous n'utilisez pas cette option,
+ cc produira un exécutable appelé
+ a.out.
+
+
+ Les raisons de ceci sont enterrées dans les brumes de l'histoire.
+
+
+
+ &prompt.user; cc foobar.c l'exécutable est a.out
+&prompt.user; cc -o foobar foobar.c l'exécutable est foobar
+
+
+
+
+
+
+
+
+
+ Compile juste le fichier, ne le lie pas. Utile pour les
+ programmes jouets dont vous voulez juste vérifier la syntaxe,
+ ou si vous utilisez un Makefile.
+
+
+ &prompt.user; cc -c foobar.c
+
+
+
+ Cela va produire un fichier objet (pas un
+ exécutable) appelé foobar.o. Celui-ci
+ peut être lié ensuite avec d'autres fichiers objets pour produire un
+ exécutable.
+
+
+
+
+
+
+
+ Crée une version de déverminage de l'exécutable. Cela oblige
+ le compilateur à placer des informations dans l'exécutable comme
+ telle ligne du fichier source correspond à tel appel de fonction.
+ Un dévermineur peut utiliser cette information pour vous montrer
+ le code source au fur et à mesure que vous avancez pas à pas dans le programme,
+ ce qui est très utile; le désavantage est que
+ toutes ces informations supplémentaires rendent le programme plus gros.
+ Normalement, vous compilez avec l'option quand vous
+ êtes en train de développer un programme et compilez ensuite une
+ version de production sans quand vous êtes
+ satisfait du fonctionnement.
+
+
+ &prompt.user; cc -g foobar.c
+
+
+
+ Cela va produire une version de déverminage du programme foobar.
+
+
+ Notez, nous n'avons pas utilisé l'option
+ pour spécifier le nom de l'exécutable, aussi nous obtiendrons un
+ exécutable du nom de a.out.
+ Produire une version de déverminage du nom de
+ foobar est laissé en exercice pour le lecteur!
+
+
+
+
+
+
+
+
+ Crée une version optimisée de l'exécutable. Le compilateur
+ effectue différents trucs malins pour essayer de produire
+ un exécutable qui s'exécute plus rapidement que normal.
+ Vous pouvez ajouter un nombre après l'option
+ pour spécifier un niveau d'optimisation plus important, mais cela vous expose
+ souvent aux bogues dans l'optimiseur du compilateur. Par exemple, la version de
+ cc fournit avec la version 2.1.0 FreeBSD est connue
+ pour produire du mauvais code avec l'option
+ dans certaines circonstances.
+
+ L'optimisation est habituellement activée uniquement lors de
+ la compilation d'une version de production.
+
+
+ &prompt.user; cc -O -o foobar foobar.c
+
+
+
+ Cela va produire une version optimisée de
+ foobar.
+
+
+
+
+ Les trois prochaines options vont forcer cc
+ à vérifier que votre code est conforme au standard international en cours,
+ se référant souvent à la norme ANSI, qui pour dire précisement
+ est un standard ISO.
+
+
+
+
+
+
+ Active tous les avertissements que les auteurs de
+ cc pensent valoir le coup. Malgré le nom, il
+ n'active pas tous les avertissements dont cc
+ est capable.
+
+
+
+
+
+
+
+ Désactive la plupart, mais pas toutes, des caractéristiques
+ du C fournies par cc qui sont non-ANSI . Malgré
+ le nom, cela ne garantit pas strictement que votre code sera conforme au standard.
+
+
+
+
+
+
+
+ Désactive toutes
+ les caractéristiques de cc qui ne sont pas ANSI .
+
+
+
+
+ Sans ces options, cc vous permettrait d'utiliser
+ quelques extensions au standard non-standards. Quelques unes de celles-ci
+ sont très utiles, mais ne fonctionneront pas avec d'autres compilateurs
+ —en fait, un des principaux buts du standard est de permettre aux gens
+ d'écrire du code qui fonctionnera avec n'importe quel compilateur sur
+ n'importe quel système. Cela est connu sous le nom de code portable.
+
+ Generalement, vous devriez essayer de faire votre code aussi portable
+ que possible, sinon vous pourriez avoir a ré-écrire totalement votre
+ programme plus tard pour le faire fonctionner autre part—et qui
+ sait ce que vous utiliserez dans quelques années?
+
+
+ &prompt.user; cc -Wall -ansi -pedantic -o foobar foobar.c
+
+
+
+ Cela produira un exécutable foobar
+ après avoir vérifié que foobar.c est conforme au standard.
+
+
+
+
+
+
+ Spécifie une librairie de fonctions à utiliser lors
+ de l'édition des liens.
+
+ L'exemple le plus commun de cela est lors de la compilation
+ d'un programme qui utilise quelques fonctions mathématiques en C.
+ A l'inverse de la plupart des plateformes, celles-ci se trouvent dans
+ une librairie standard du C et vous devez dire au compilateur de l'ajouter.
+
+
+ La règle est que si une librairie est appelée
+ libquelque_chose.a,
+ vous donnez à cc l'argument
+ .
+ Par exemple, la librairie des fonctions mathématiques est
+ libm.a, aussi vous donnez à
+ cc le paramètre .
+ Un piège habituel avec la librairie math est
+ qu'elle doit être la dernière sur la ligne de commande.
+
+
+ &prompt.user; cc -o foobar foobar.c -lm
+
+
+
+ Cela va lier les fonctions de la librairie math à l'interieur de
+ foobar.
+
+ Si vous compilez du C++; vous devrez ajouter
+ , ou si
+ vous utilisez FreeBSD 2.2 ou ultérieur, à la ligne de commande de
+ cc pour lier avec les fonctions de la librairie C++.
+ Alternativement, vous pouvez utiliser c++ plutôt
+ que cc, qui fait tout cela pour vous.
+ c++ peut aussi être invoqué par
+ g++ sur FreeBSD.
+
+
+ &prompt.user; cc -o foobar foobar.cc -lg++Pour FreeBSD 2.1.6 et antérieur
+&prompt.user; cc -o foobar foobar.cc -lstdc++Pour FreeBSD 2.2 et ultérieur
+&prompt.user; c++ -o foobar foobar.cc
+
+
+
+ Chacune de ces commandes va produire un exécutable
+ foobar à partir du fichier source C++
+ foobar.cc. Notez que, sur les systèmes Unix
+ , les fichiers source C++ se terminent traditionnellement en
+ .C, .cxx ou
+ .cc, plutôt que le style MS-DOS
+ .cpp (qui était déjà
+ utilisé pour autre chose). gcc a utilisé cela
+ pour trouver le type de compilateur à utiliser sur le fichier source;
+ toutefois, cette restriction ne s'applique plus,
+ aussi vous pouvez maintenant appeler vos fichiers C++
+ .cpp en toute impunité !
+
+
+
+
+
+ Questions et problèmes usuels sur <command>cc</command>
+
+
+
+
+ J'essaye d'écrire un programme qui utilise la fonction
+ sin() et je reçois l'erreur suivante.
+ Que cela signifie-t-il ?
+
+
+ /var/tmp/cc0143941.o: Undefined symbol `_sin' referenced from text segment
+
+
+
+
+
+ Lors de l'utilisation des fonctions mathématiques comme
+ sin(), vous devez dire à
+ cc de lier avec la librairie math, comme :
+
+
+ &prompt.user; cc -o foobar foobar.c -lm
+
+
+
+
+
+
+
+ J'ai écrit un programme simple pour m'exercer à
+ l'utilisation de l'option . Tout ce qu'il fait
+ est d'élever 2,1 à la puissance 6.
+
+
+ #include <stdio.h>
+
+int main() {
+ float f;
+
+ f = pow(2.1, 6);
+ printf("2.1 ^ 6 = %f\n", f);
+ return 0;
+}
+
+
+
+ j'ai effectué la compilation comme suit :
+
+
+ &prompt.user; cc temp.c -lm
+
+
+
+ et comme expliqué ici, mais j'obtiens ceci
+ quand je l'exécute :
+
+
+ &prompt.user; ./a.out
+2.1 ^ 6 = 1023.000000
+
+
+
+ Ce n'est pas la réponse correcte !
+ Que se passe-t-il ?
+
+
+
+ Quand le compilateur voit que vous appelez une fonction, il
+ vérifie s'il a déjà un prototype pour celle-ci.
+ S'il ne l'a pas vu, il suppose que la fonction retourne un int,
+ ce qui n'est absolument pas ce que vous voulez ici.
+
+
+
+
+
+
+ Alors comment puis-je le réparer?
+
+
+
+ Les prototypes des fonctions mathématiques sont dans
+ math.h. Si vous incluez ce fichier,
+ le compilateur sera capable de trouver le prototype et il
+ arrêtera de faire des trucs étranges à vos calculs!
+
+
+
+ #include <math.h>
+#include <stdio.h>
+
+int main() {
+...
+
+
+
+ Après avoir recompilé comme précédemment,
+ exécutez :
+
+
+
+ &prompt.user; ./a.out
+2.1 ^ 6 = 85.766121
+
+
+
+ Si vous utilisez quelques fonctions mathématiques que ce soit,
+ incluez toujoursmath.h et n'oubliez pas
+ de lier avec la librairie math.
+
+
+
+
+
+ J'ai compilé un fichier appelé
+ foobar.c et je ne trouve pas d'exécutable
+ appelé foobar. Où est-il parti?
+
+
+
+ Souvenez-vous, cc appellera
+ l'exécutable a.out sauf si vous lui dites
+ de faire autrement. Utilisez l'option
+ :
+
+
+ &prompt.user; cc -o foobar foobar.c
+
+
+
+
+
+
+
+ OK, j'ai un exécutable appelé
+ foobar, je peux le voir en exécutant
+ ls, mais quand je tape
+ foobar à l'invite de commandes, la réponse
+ est qu'il n'y a pas de tel fichier. Pourquoi le système ne le trouve pas?
+
+
+
+
+ A l'inverse de MS-DOS, Unix ne regarde pas dans le
+ répertoire courant lorsqu'il essaye de trouver un
+ exécutable que vous voulez exécuter, sauf si
+ vous lui avez dit de le faire.
+ Vous pouvez soit taper ./foobar, ce qui
+ signifie exécute le fichier nommé
+ foobar dans le répertoire courant,
+ soit changer votre variable d'environnement PATH
+ de façon à ce qu'elle ressemble à quelque chose comme
+
+
+
+ bin:/usr/bin:/usr/local/bin:.
+
+
+
+ Le point à la fin signifie regarde dans le repertoire
+ courant s'il n'est dans aucun autre.
+
+
+
+
+
+ J'ai appelé mon exécutable test,
+ mais rien ne se passe quand je l'exécute. Que se passe-t-il?
+
+
+
+
+ La plupart des systèmes Unix ont un programme appelé
+ test dans /usr/bin
+ et l'interpréteur prend celui-ci avant de vérifier dans
+ le répertoire courant. Soit vous tapez
+
+
+
+ &prompt.user; ./test
+
+
+
+ soit vous choisissez un meilleur nom pour votre programme !!
+
+
+
+
+
+
+ J'ai compilé mon programme et il semble fonctionner au premier abord,
+ puis il y a une erreur et le système a dit quelque chose comme
+ core dumped. Que cela signifie-t-il?
+
+
+
+ Le nom core dump date
+ des tous premiers jours d'Unix, quand les machines utilisaient
+ la mémoire centraleNDT: je n'ai pas trouvé
+ de meilleure traduction pour core memorypour stocker
+ les données.
+ Simplement, si le programme a échoué sous certaines conditions,
+ le système va écrire le contenu de la mémoire centrale
+ sur le disque dans un fichier appelé
+ core, que le programmeur peut ensuite
+ examiner de près pour trouver ce qui s'est mal passé.
+
+
+
+
+
+
+ Fascinant, mais que suis-je supposé faire ?
+
+
+
+ Utilisez gdb pour analyser le fichier core
+ (voir ).
+
+
+
+
+
+ Quand mon programme a généré un fichier core,
+ il a parlé d'une erreur segmentation fault.
+ Qu'est-ce que c'est ?
+
+
+
+ Cela signifie simplement que votre programme a essayé
+ d'effectuer une opération illégale sur la mémoire;
+ Unix est conçu pour protéger le système d'exploitation
+ et les autres programmes des programmes crapuleux.
+
+
+ Les causes habituelles de cela sont :
+
+
+
+ Essayer d'écrire dans un pointeur NULL,
+ par exemple
+
+
+ char *foo = NULL;
+strcpy(foo, "bang!");
+
+
+
+
+ Utiliser un pointeur qui n'a pas été initialisé,
+ par exemple
+
+ char *foo;
+strcpy(foo, "bang!");
+
+
+ Le pointeur va avoir une valeur aléatoire qui
+ avec de la chance, pointera dans une zone de la mémoire qui
+ n'est pas disponible pour votre programme et le noyau va tuer
+ votre programme avant qu'il ne fasse des dommages. Si
+ vous êtes malchanceux, il pointera quelque part dans votre
+ propre programme et altèrera une de vos structures de données,
+ faisant planter votre programme mystérieusement.
+
+
+
+
+ Essayer d'accèder la mémoire au-delà de la fin
+ d'un tableau,
+ par exemple
+
+ int bar[20];
+bar[27] = 6;
+
+
+
+
+ Essayer de stocker quelque chose dans la mémoire en lecture seule,
+ par exemple
+
+ char *foo = "Ma chaine";
+strcpy(foo, "bang!");
+
+
+ Les compilateurs Unix mettent souvent les chaînes comme
+ "Ma chaine" dans des zones de mémoire
+ en lecture seule.
+
+
+
+
+ Faire des trucs sales avec
+ malloc() et
+ free(), par exemple
+
+ char bar[80];
+free(bar);
+
+
+ ou
+
+ char *foo = malloc(27);
+free(foo);
+free(foo);
+
+
+
+
+ Faire une de ces fautes ne conduit pas toujours
+ à une erreur, mais elles sont toujours de mauvais entrainements.
+ Certains systèmes et compilateurs sont plus tolérants que d'autres,
+ ce qui explique pourquoi des programmes qui fonctionnent bien sur un système
+ peuvent planter si vous les essayer sur un autre.
+
+
+
+
+
+
+ Des fois quand je reçoit une erreur core dump,
+ il est précisé bus error.
+ Il est dit dans mon livre Unix qu'il s'agit d'un problème matériel
+ mais l'ordinateur semble toujours fonctionner. Est-ce vrai ?
+
+
+
+
+ Non, heureusement non (sauf si bien sûr vous avez réellement
+ un problème matériel…). Cela est habituellement une
+ manière de dire que vous avez accédé à la mémoire
+ d'une façon que vous n'auriez pas dû.
+
+
+
+
+
+
+ Toute cette affaire de fichier core semble être
+ assez utile, si je peux le faire apparaître quand je le désire.
+ Puis-je faire cela, ou dois-je attendre la prochaine erreur ?
+
+
+
+ Oui, ouvrez une autre console ou xterm, faites
+
+ &prompt.user; ps
+
+
+ pour trouver l'identifiant du processus de votre programme, et faites
+
+
+ &prompt.user; kill -ABRT identifiant
+
+
+ où
+ identifiant est
+ l'identifiant du processus que vous avez trouvé.
+
+ Ceci est utile si votre programme est bloqué dans une boucle
+ infinie, par exemple. Si votre programme arrive à bloquer le signal
+ SIGABRT, il y a d'autres signaux qui ont des effets
+ similaires.
+
+
+ Alternativement, vous pouvez créer un fichier core depuis
+ votre programme, en appelant la fonction abort().
+ Voir la page de manuel en ligne de &man.abort.3; pour en savoir plus.
+
+
+ Si vous voulez créer un fichier core depuis
+ l'extérieur de votre programme, mais ne voulez pas que le processus
+ s'arrêt,vous pouvez utiliser le programme gcore.
+ Voir la page de manuel en ligne de &man.gcore.1 pour plus d'informations.
+
+
+
+
+
+
+
+
+
+ Make
+
+
+ Qu'est-ce que <command>make</command>?
+
+ Quand vous travaillez sur un programme simple avec seulement
+ un ou deux fichiers source, taper
+
+
+ &prompt.user; cc fichier1.c fichier2.c
+
+
+ n'est pas si mal, mais cela devient rapidement fastidieux quand
+ il y a plusieurs fichiers—et cela peut prendre du temps à compiler aussi.
+
+
+ Une façon de contourner cela est d'utiliser les fichiers objet
+ et de recompiler le fichier source seulement si le code source a changé.
+ Aussi, nous pourrions avoir quelque chose comme ça:
+
+
+ &prompt.user; cc fichier1.o fichier2.o … fichier37.c &hellip
+
+
+ si nous avions changé le fichier fichier37.c mais aucun
+ des autres depuis la dernère compilation. Cela pourrait accélerer assez bien
+ la compilation mais cela ne resoud pas le problème de la frappe au clavier.
+
+
+ Ou nous pourrions écrire une procédure pour résoudre ce
+ problème de frappe, mais celle-ci devrait tout re-compiler, devenant
+ ainsi inefficace sur un gros projet.
+
+
+ Que se passe-t-il si nous avons des centaines de fichiers source ?
+ Que se passe-t-il si nous travaillons dans une équipe avec
+ d'autres personnes qui oublient de nous dire quand ils ont changé
+ un de leurs fichiers source que nous utilisons ?
+
+
+ Peut-être pourrions nous mettre ensemble les deux solutions et
+ écrire quelque chose comme une procédure qui contiendrait
+ quelque règle magique disant quand notre fichier source doit être
+ compilé. Maintenant, tout ce dont nous avons besoin est un programme
+ qui comprend ces règles, alors que c'est trop compliqué pour
+ l'interpréteur.
+
+
+ Ce programme s'appelle make. Il lit
+ dans un fichier, appelé un makefile,
+ qui lui dit comment les différents fichiers dépendent les
+ uns des autres, et détermine quels fichiers ont besoin d'être
+ recompilés et quels n'en ont pas besoin.
+ Par exemple, une règle pourrait dire quelque chose comme
+ si fromboz.o est plus ancien que
+ fromboz.c, cela signifie que quelqu'un a dû
+ changer fromboz.c, aussi il a besoin d'être
+ recompilé. Le makefile possède aussi des règles
+ pour dire à makecomment
+ re-compiler un fichier source, en faisant ainsi un outil encore plus
+ puissant.
+
+
+ Les Makefiles sont typiquement stockés dans le même
+ répertoire que le source auxquels il s'appliquent, et peuvent être
+ appelés makefile, Makefile
+ ou MAKEFILE. La plupart des programmeurs utilise le nom
+ Makefile, celui-ci se trouvant proche du début de la
+ liste du contenu du répertoire où il peut être facilement vu.
+
+
+ Ils n'utilisent pas la forme MAKEFILE
+ car les bloques de majuscules sont souvent utilisés pour les
+ fichiers de documentation comme README.
+
+
+
+
+
+
+ Exemple d'utilisation de <command>make</command>
+
+ Voici un exemple très simple de Makefile:
+
+ foo: foo.c
+ cc -o foo foo.c
+
+ Il consiste en deux lignes, une ligne de dépendance et une ligne
+ de création.
+
+
+ La ligne de dépendance ici consiste en le nom du programme (connu comme
+ cible), suivi de deux-points puis un espace et enfin
+ le nom du fichier source.
+ Quand make lit cette ligne, il vérifie si
+ foo existe; s'il existe, il compare la date à laquelle
+ foo a été modifié la dernière fois
+ avec la date de dernière modification de foo.c.
+ Si foo n'existe pas ou est plus ancien que foo.c,
+ il regarde la ligne de création pour trouver ce qu'il doit faire.
+ En d'autres termes, il s'agit de la règle à utiliser quand
+ foo.c a besoin d'être re-compilé.
+
+
+ La ligne de création commence avec un tab (appuyez
+ sur la touche tab) suivi de la commande que vous taperiez
+ pour créer foo si vous deviez le faire à l'invite
+ de commandes. Si foo n'est pas à jour ou n'existe
+ pas, make exécute alors cette commande pour
+ le créer. En d'autres termes, il s'agit de la règle permettant
+ à make de re-compiler foo.c.
+
+
+ Aussi, quand vous tapez make, il vérifiera
+ que foo est à jour en respect de vos derniers
+ changements sur foo.c. Ce principe peut être
+ étendu à des Makefiles de plusieurs
+ centaines de cibles—en fait, sur FreeBSD, il est possible de
+ compiler un système d'exploitation entier en tapant juste
+ make world dans le répertoire approprié !
+
+
+ Une autre propriété utile des makefiles est que les cibles
+ n'ont pas nécessairement besoin d'être des programmes.
+ Par exemple, nous pourrions avoir un Makefile
+ qui ressemble à cela:
+
+
+ foo: foo.c
+ cc -o foo foo.c
+
+install:
+ cp foo /home/moi
+
+ Nous pouvons dire à make quelle cible nous
+ voulons en tapant:
+
+
+ &prompt.user; make cible
+
+
+ make ira seulement voir cette cible
+ et ingorera les autres. Par exemple, si nous tapons
+ make foo avec le Makefile du dessus,
+ make ignorera la cible install.
+
+
+ Si nous tapons juste make,
+ make regardera toujours la première cible et s'arrêtera
+ sans regarder aucune autre. Aussi, si nous avions tapé make
+ seul, make serait juste allé à la cible foo,
+ aurait recompilé foo si nécessaire et se
+ serait arrêté sans aller à la cible install.
+
+
+ Notez que la cible install ne dépend pour l'instant
+ de rien ! Cela signifie que la commande qui suit est toujours exécutée
+ lorsque nous essayons de créer cette cible en tapant make install.
+ Dans ce cas, make va copier foo dans le
+ répertoire de l'utilisateur. Cela est souvent utilisé par les
+ Makefiles des applications, ainsi l'application
+ peut être installée dans le répertoire correct
+ quand elle a été correctement compilée
+
+
+ Il s'agit d'un sujet légèrement embrouillant à essayer
+ et expliquer.
+ Si vous ne comprenez pas bien comment make
+ fonctionne, la meilleure chose à faire est d'écrire un petit
+ programme comme bonjour monde et un fichier Makefile
+ comme le précédent et de le tester. Ensuite continuez en
+ utilisant plus d'un fichier source ou en ayant un fichier source
+ incluant un fichier d'en-tête. La commande touch est
+ très utile ici—elle change la date sur un fichier sans avoir
+ à l'éditer.
+
+
+
+
+ Les <filename>Makefiles</filename>de FreeBSD
+
+ Les Makefiles peuvent être plutôt compliqués
+ à écrire. Heureusement, les systèmes BSD comme FreeBSD sont fournis avec
+ des fichiers très puissants comme partie intégrante du système.
+ Un très bon exemple est le système des logiciels portés. Voici
+ la partie essentielle d'un Makefile typique des logiciels portés:
+
+
+ MASTER_SITES= ftp://freefall.cdrom.com/pub/FreeBSD/LOCAL_PORTS/
+DISTFILES= scheme-microcode+dist-7.3-freebsd.tgz
+
+.include <bsd.port.mk>
+
+ Maintenant, si nous allons dans le répertoire de ce logiciel porté et
+ tapons make, la chose suivante se passe :
+
+
+
+
+ Une vérification est faite pour voir si le code source de ce logiciel porté
+ est déjà dans le système.
+
+
+
+
+ Si celui-ci n'y est pas, une connexion FTP à l'URL dans
+ MASTER_SITES est faite pour télécharger le source.
+
+
+
+
+ La somme de contrôle (checksum) du source est calculée
+ et comparée avec celle d'une bonne et connue copie du source. Cela est fait pour
+ être sûr que le source n'a pas été corrompu pendant le transfert.
+
+
+
+
+ Tout changement requis pour faire fonctionner le source sur FreeBSD est appliqué—
+ cela est connu sous le nom de correctifNDT: On entendra plus souvent parler de
+ patch..
+
+
+
+
+ Toute configuration spéciale nécessaire pour le source est faite.
+ (Beaucoup de distributions de programmes Unix essaye de fonctionner quelle que soit
+ la version d'Unix sur laquelle elles sont compilées et quelles que soient les
+ caractéristiques optionnelles qui sont présentes—c'est ce qui se trouve
+ dans le scénario des logiciels portés pour FreeBSD).
+
+
+
+
+
+ Le code source pour ce programme est compilé. En effet, nous changeons
+ de répertoire pour le répertoire où le source a été
+ décompressé et faisons make—le fichier Makefile
+ du programme contient les informations nécessaires pour construire le programme.
+
+
+
+
+ Nous avons maintenant une version compilée du programme. Si nous le désirons,
+ nous pouvons le tester maintenant; quand nous sommes confiant dans le programme, nous pouvons
+ taper make install. Cela va installer le programme et ses fichiers de
+ soutien nécessaires au bon endroit; une entrée est aussi créée dans
+ la base de données des logiciels pré-compilés, ainsi
+ le logiciel porté peut être facilement désinstallé plus tard si
+ nous changeons d'avis sur ce programme.
+
+
+
+
+ Maintenant je pense que vous serez d'accord que c'est plus impressionnant qu'une
+ procédure de quatre lignes !
+
+
+ Le secret réside dans la dernière ligne qui dit à
+ make de regarder dans le Makefile système
+ appelé bsd.port.mk. Il est facile de fermer les yeux sur cette
+ ligne mais c'est ici que tous les trucs forts se passent—quelqu'un a écrit un Makefile
+ qui dit à make de faire tout ce qu'il y a au-dessus (plus un couple d'autres choses
+ que je n'ai pas mentionnées, comme la gestion des erreurs) et n'importe qui peut avoir accès
+ à cela simplement est ajoutant une simple ligne dans son propre fichier Makefile !
+
+
+ Si vous voulez jeter un regard sur ces Makefiles système,
+ ils se trouvent /usr/share/mk mais il est probablement mieux
+ d'attendre un moment jusqu'à ce que vous ayez un peu d'entrainement avec les
+ Makefiles car ceux-ci sont très compliqués (et
+ si vous les lisez, soyez sûr d'avoir un thermos de café fort à portée
+ de main !)
+
+
+
+
+ Utilisations plus avancées de <command>make</command>
+
+ Make est un outil très puissant et peut
+ faire beaucoup plus que le simple exemple précédent ne l'a montré.
+ Malheureusement, il y a différentes versions de make
+ et elles diffèrent considérablement.
+ Le meilleur moyen d'apprendre ce qu'elles peuvent faire est probablement de lire
+ la documentation—heureusement cette introduction vous donnera la base
+ à partir de laquelle vous pourrez faire cela.
+
+
+ La version de make fournies avec FreeBSD est le
+ Berkeley make(make de Berkeley); il y a un cours d'instruction
+ pour celui-ci dans /usr/share/doc/psd/12.make. Pour le voir, faites
+
+
+ &prompt.user; zmore paper.ascii.gz
+
+
+ dans ce répertoire.
+
+ Beaucoup d'applications dans les logiciels portés utilisent
+ GNU make, qui possède un très bon ensemble de page
+ d'info. Si vous avez installé un de ces logiciels portés,
+ GNU make aura été automatiquement installé
+ sous le nom de gmake. Il est aussi disponible comme logiciel porté ou
+ logiciel pré-compilé seul.
+
+
+ Pour voir les pages d'info pour GNU make, vous devrez
+ editer le fichier dir dans le répertoire
+ /usr/local/info pour ajouter une entrée pour celui-ci.
+ Cela implique d'ajouter une ligne
+
+
+ * Make: (make). l'utilitaire GNU Make.
+
+ au fichier. Une fois que vous avez fait ceci, vous pouvez taper
+ info et ensuite sélectionner
+ make dans le menu (ou dans Emacs,
+ faites C-h i).
+
+
+
+
+
+
+ Déverminer
+
+
+ Le dévermineur
+
+ Le dévermineur fourni avec FreeBSD est appelé
+ gdb (GNU
+ debugger). Vous pouvez le démarrer en tapant
+
+
+ &prompt.user; gdb nomprog
+
+
+ bien que la plupart des gens préfèrent le démarrer au
+ sein d'Emacs. Vous pouvez faire cela avec:
+
+
+ M-x gdb RET nomprog RET
+
+
+ Utiliser un dévermineur vous permet d'exécuter le programme
+ dans des circonstances plus contrôlées. Typiquement, vous pouvez
+ exécuter le programme ligne à ligne, inspecter la valeur des
+ variables, changer cette dernière, dire au dévermineur d'exécuter jusqu'à
+ un certain point puis de s'arrêter etc... Vous pouvez même vous brancher
+ sur un programme en fonctionnement, ou charger un fichier core
+ pour enquêter sur le plantage du programme. Il est même possible de
+ déverminer le noyau, quoique ce soit un peu plus rusé que de
+ déverminer des applications utilisateur dont nous discuterons
+ dans cette section.
+
+
+ gdb dispose d'une assez bonne aide en ligne
+ comme d'un ensemble de pages d'info, aussi cette section va se concentrer sur
+ quelques commandes basiques.
+
+
+ Finalement, si vous trouvez son interface texte non fonctionnelle,
+ il y a une interface graphique pour celui-ci, xxgdb,
+ dans la collection des logiciels portés.
+
+
+ Cette section a pour but d'être une introduction
+ à l'utilisation de gdb et ne couvre pas les sujets
+ très spécialisés comme le déverminage du noyau.
+
+
+
+
+ Exécuter un programme dans le dévermineur
+
+ Vous devrez avoir compilé le programme avec l'option
+ pour avoir la meilleure utilisation de gdb. Il fonctionnera sans
+ mais vous ne verrez que le nom de la fonction dans laquelle vous vous trouvez plutôt
+ que son code source. Si vous voyez une ligne comme:
+
+
+ … (no debugging symbols found) …
+
+
+ quand gdb démarre, vous saurez que le programme
+ n'a pas été compilé avec l'option .
+
+
+ A l'invite de gdb, tapez
+ break main. Cela dira au dévermineur
+ de passer le code préliminaire d'initialisation du programme
+ et de démarrer au début de votre code. Maintenant tapez
+ run pour démarrer le programme—cela va
+ démarrer au début du code d'initialisation et ensuite s'arrêtera
+ lors de l'appel à main().
+ (Si vous vous êtes toujours demandé où main()
+ était appelé, maintenant vous le savez !).
+
+
+ Vous pouvez maintenant vous déplacer dans le programme ligne par ligne en
+ pressant n. Si vous arrivez à l'appel d'une fonction,
+ vous pouvez entrer dans celle-ci en appuyant sur s. Une fois
+ que vous êtes dans l'appel de la fonction, vous pouvez retourner dans le code
+ appelant en appuyant sur f. Vous pouvez aussi utiliser
+ up et down pour avoir une vue rapide de l'appelant.
+
+
+ Voici un exemple simple de comment détecter une erreur dans un programme avec
+ gdb. Voici notre programme (avec une erreur délibérée):
+
+
+ #include <stdio.h>
+
+int bazz(int anint);
+
+main() {
+ int i;
+
+ printf("C'est mon programme\n");
+ bazz(i);
+ return 0;
+}
+
+int bazz(int anint) {
+ printf("Vous m'avez fourni %d\n", anint);
+ return anint;
+}
+
+ Le programme met i à 5 et le passe à une
+ fonction bazz() qui imprime le nombre que nous lui avons donné.
+
+
+ Puis nous compilons et exécutons le programme obtenu
+
+
+ &prompt.user; cc -g -o temp temp.c
+&prompt.user; ./temp
+C'est mon programme
+Vous m'avez fourni 4231
+
+
+ Ce n'était pas ce que nous attendions ! Il est temps de voir ce qui se passe !
+
+
+ &prompt.user; gdb temp
+GDB is free software and you are welcome to distribute copies of it
+ under certain conditions; type "show copying" to see the conditions.
+There is absolutely no warranty for GDB; type "show warranty" for details.
+GDB 4.13 (i386-unknown-freebsd), Copyright 1994 Free Software Foundation, Inc.
+(gdb) break main passe le code d'initialisation
+Breakpoint 1 at 0x160f: file temp.c, line 9. gdb met un point d'arrêt sur main()
+(gdb) run Exécute jusqu'à main()
+Starting program: /home/james/tmp/temp Le programme démarre
+
+Breakpoint 1, main () at temp.c:9 gdb s'arrête à main()
+(gdb) n Va à la ligne suivante
+C'est mon programme Le programme écrit
+(gdb) s entre dans bazz()
+bazz (anint=4231) at temp.c:17 gdb montre la pile
+(gdb)
+
+
+ Arrêtons-nous une minute! Comment anint a eu la valeur
+ 4231? Ne l'avons-nous pas mis à 5
+ dans main()? Remontons dans main()
+ et regardons.
+
+
+ (gdb) up Remonte la pile des appels
+#1 0x1625 in main () at temp.c:11 gdb montre la pile
+(gdb) p i Montre la valeur de i
+$1 = 4231 gdb montre 4231
+
+
+ Oh ! En regardant dans le code, nous avons oublié d'initialiser i.
+ Nous aurions dû mettre
+
+
+ …
+main() {
+ int i;
+
+ i = 5;
+ printf("C'est mon programme\n");
+&hellip
+
+ mais nous n'avions pas mis la ligne i=5;. Comme
+ nous n'avons pas initialisé i, il a pris le nombre se trouvant
+ dans la zone de mémoire quand le programme a démarré,
+ ce qui dans ce cas était 4231.
+
+
+
+ gdb montre la pile chaque fois que nous entrons ou sortons
+ d'une fonction, même si nous avons utilisé up et
+ down pour nous déplacer dans la pile des appels.
+ Cela montre le nom de la fonction et les valeurs de ses arguments, ce qui nous aide
+ à garder une trace d'où nous sommes et de ce qui se passe.
+ (La pile est une zone de stockage où le programme stocke les informations
+ sur les arguments passés aux fonctions et où il doit aller
+ quand il revient d'une fonction).
+
+
+
+
+
+ Examiner un fichier <filename>core</filename>
+
+ Un fichier core est basiquement un fichier qui contient
+ l'état complet du processus quand il s'est planté.
+ Dans le bon vieux temps, les programmeurs devait imprimer des
+ listings en hexadécimal de fichiers core et transpirer
+ sur leur manuels de code machine, mais la vie est maintenant un peu plus facile.
+ Par chance, sous FreeBSD et les autres systèmes 4.4BSD, un fichier core
+ est appelé nomprog.core
+ plutôt que juste core, pour mieux savoir à quel
+ programme appartient un fichier core.
+
+
+ Pour examiner un fichier core, démarrez gdb
+ de façon habituel. Plutôt que de taper break ou
+ run, tapez
+
+
+ (gdb) core nomprog.core
+
+
+ Si vous n'êtes pas dans le même répertoire que le fichier
+ core, vous devrez faire dir /path/to/core/file
+ d'abord.
+
+
+ Vous devriez voir quelque chose comme cela:
+
+
+ &prompt.user; gdb a.out
+GDB is free software and you are welcome to distribute copies of it
+ under certain conditions; type "show copying" to see the conditions.
+There is absolutely no warranty for GDB; type "show warranty" for details.
+GDB 4.13 (i386-unknown-freebsd), Copyright 1994 Free Software Foundation, Inc.
+(gdb) core a.out.core
+Core was generated by `a.out'.
+Program terminated with signal 11, Segmentation fault.
+Cannot access memory at address 0x7020796d.
+#0 0x164a in bazz (anint=0x5) at temp.c:17
+(gdb)
+
+
+ Dans ce cas, le programme a été appelé a.out,
+ aussi le fichier core s'appelle a.out.core.
+ Nous pouvons voir que le programme s'est planté car il a essayé
+ d'accèder à une zone dans la mémoire qui n'était pas
+ disponible dans la fonction appelée bazz.
+
+
+ Quelquefois il est utile de pouvoir voir comment une fonction a été
+ appelée car le problème peut avoir eu lieu bien avant
+ dans la pile des appels dans un programme complexe. La commande bt
+ demande à gdb d'afficher une trace inverse de la pile
+ des appels:
+
+
+ (gdb) bt
+#0 0x164a in bazz (anint=0x5) at temp.c:17
+#1 0xefbfd888 in end ()
+#2 0x162c in main () at temp.c:11
+(gdb)
+
+
+ La fonction end() est appelée lorsque le programme se plante;
+ dans ce cas, la fonction bazz() a été appelée
+ main().
+
+
+
+
+ Se brancher sur un programme en cours d'exécution
+
+ Une des plus belles caractéristiques de gdb
+ est qu'il peut se brancher sur un programme qui s'exécute déjà.
+ Bien sûr, cela suppose que vous ayez les privilèges suffisants pour
+ le faire. Un problème habituel est quand vous vous déplacez dans
+ un programme qui se dédouble et que vous voulez tracer le programme fils
+ cependant le dévermineur ne vous laissera seulement tracer le père.
+
+
+ Ce que vous devez faire est de démarrer un autre gdb,
+ utiliser ps pour trouver l'ID du processus fils et faire
+
+
+ (gdb) attach identifiant_processus
+
+
+ dans gdb, et déverminer ensuite comme d'habitude.
+
+
+ C'est tout simple, pensez-vous certainement,
+ mais pendant le temps que je faisais ça, le processus fils
+ sera déjà parti loin. Ne vous en faites pas,
+ noble lecteur, voici comment faire (avec l'appui des pages d'info
+ de gdb):
+
+
+ &hellip
+if ((pid = fork()) < 0) /* _Toujours_ verifier cela */
+ error();
+else if (pid == 0) { /* le fils */
+ int PauseMode = 1;
+
+ while (PauseMode)
+ sleep(10); /* Attendre jusqu'a ce que quelqu'un se brache sur nous */
+ &hellip
+} else { /* le pere */
+ &hellip
+
+
+ Maintenant tout ce que nous avons à faire est de nous brancher sur le processus fils,
+ de mettre PauseMode à 0 et d'attendre
+ que l'appel à la fonction sleep() retourne !
+
+
+
+
+
+ Utiliser Emacs comme environnement de développement
+
+
+ Emacs
+
+ Malheureusement, les systèmes Unix ne sont pas fournis avec des sortes
+ d'environnements de développement intégrés
+ tout-ce-que-vous-avez-toujours-voulu-et-beaucoup-plus-dans-un-ensemble-gigantesque
+ que d'autres sytèmes ont.
+
+
+ Sauf si vous payez des sommes importantes.
+
+
+
+ Toutefois, il est possible de se faire son propre environnement.
+ Cela n'est pas forcément aussi joli et il peut ne pas être
+ autant intégré mais vous pouvez le personnaliser comme
+ vous voulez. Et c'est gratuit. Et vous en avez les sources.
+
+
+ La clé de tout cela est Emacs. Maintenant il y a des gens qui le détestent,
+ mais beaucoup l'aiment. Si vous êtes un du premier groupe, j'ai peur que cette section
+ ait peu d'intérêt pour vous. Vous aurez besoin d'une quantité
+ moyenne de mémoire pour le faire fonctionner—Je recommenderai 8Mo en mode
+ texte et 16Mo dans X pour avoir un minimum de performances.
+
+
+ Emacs est basiquement un éditeur hautement personnalisable
+ —en effet, il a été personnalisé au point de ressembler
+ plus à un système d'exploitation qu'à un éditeur!
+ Beaucoup de développeurs et d'administrateurs système passent
+ en fait pratiquement tout leur temps à travailler dans Emacs,
+ en ne le quittant qu'à leur déconnexion.
+
+
+ Il est impossible de dire tout ce qu'Emacs peut faire ici,
+ mais voici quelques unes des caractéristiques d'intérêt
+ pour les développeurs:
+
+
+
+
+ Un très puissant éditeur, permettant le chercher-remplacer sur
+ les chaînes et les expressions régulières (motifs),
+ sauter à la fin ou au début d'un bloc, etc, etc.
+
+
+
+
+ Menus déroulants et aide en ligne.
+
+
+
+
+ Colorisation syntaxique en fonction du langage et indentation.
+
+
+
+
+ Totalement personnalisable.
+
+
+
+
+ Vous pouvez compiler et déverminer des programmes dans Emacs.
+
+
+
+
+ Sur erreur de compilation, vous pouvez aller directement
+ à la ligne de code source fautive.
+
+
+
+
+ Une interface amicale au programme info
+ utilisé pour lire la documentation hypertexte GNU,
+ incluant la documentation sur Emacs elle-même.
+
+
+
+
+ Une interface agréable à gdb, vous permettant
+ de voir le code source au fur et à mesure que vous vous déplacez
+ dans votre programme.
+
+
+
+
+ Vous pouvez lire les nouvelles Usenet et envoyer des e-mails pendant que
+ votre programme est en compilation.
+
+
+
+
+ Et sans doute beaucoup plus que je n'ai survolé.
+
+
+ Emacs peut être installé sur FreeBSD en utilisant Emacs
+ le logiciel porté Emacs.
+
+
+ Une fois installé, démarrez-le et faites C-h t
+ pour lire un cours sur Emacs—cela signifie maintenir la touche control,
+ presser h, relâcher la touche control
+ et presser t. (Alternativement, vous pouvez utiliser la souris
+ pour sélectionner Emacs Tutorial dans le menu
+ Help).
+
+
+ Bien que Emacs possède des menus, il est valable d'apprendre les raccourcis
+ clavier, étant plus rapide quand vous éditez quelque chose
+ d'appuyer sur un couple de touches que de reprendre la souris et de cliquer
+ au bon endroit. Et, quand vous discutez avec des utilisateurs expérimentés
+ d'Emacs, vous trouverez qu'ils parlent souvent de choses comme
+ M-x replace-s RET foo RET bar RET aussi il est utile
+ de savoir ce que cela veut dire. Et dans tous les cas, Emacs possède beaucoup trop
+ de fonctions pour qu'elles soient dans les barres de menus.
+
+
+ Heureusement, il est assez simple de récupérer les raccourcis
+ clavier car ils sont affichés à côté des éléments
+ des menus déroulants. Mon conseil est d'utiliser un élément de menu
+ pour, disons, ouvrir un fichier jusqu'à ce que vous sachiez comment cela fonctionne
+ et que quand vous vous sentez à l'aise avec, essayez C-x C-f.
+ Quand vous serez content avec ça, passez à une autre commande du menu.
+
+
+ Si vous ne pouvez pas vous rappeler de ce qu'une combinaison de touches particulières
+ fait, sélectionnez Describe Key dans le menu
+ Help et tapez-la—Emacs vous dira ce qu'elle fait.
+ Vous pouvez aussi utiliser l'élément de menu Command Apropos
+ pour trouver toutes les commandes qui contiennent un mot particulier, avec leur
+ raccourci clavier.
+
+
+ De cette manière, l'expression ci-dessus signifie maintenir la touche
+ Meta, taper x, relâcher
+ la touche Meta, taper replace-s
+ (raccourci pour replace-string—
+ une autre caractéristique d'Emacs est que vous pouvez abréger
+ les commandes), appuyer sur la touche Entrée, taper
+ foo (la chaîne que vous voulez remplacer), presser
+ la touche Entrée, taper bar (la chaîne
+ que vous voulez substituer à foo) puis appuyer sur
+ Entrée une dernière fois. Emacs va alors faire
+ l'opération chercher-remplacer que vous avez demandé.
+
+
+ Si vous vous demandez ce qu'est cette touche Meta,
+ il s'agit d'une touche spéciale que beaucoup de stations de travail Unix
+ possèdent. Malheureusement, les PC n'en ont pas, aussi c'est habituellement
+ la touche alt (ou si vous n'avez pas de chance, la touche échap).
+
+
+ Oh, et pour sortir d'Emacs, faites C-x C-c
+ (ce qui signifie maintenir la touche control appuyée,
+ appuyer c et relâcher la touche control.
+ Si vous avez des fichiers non sauvegardés ouverts, Emacs vous demandera si
+ vous voulez les sauvegarder. (Ignorez le bout de documentation où il est dit
+ que C-z est la manière habituelle de quitter Emacs—
+ qui quitte Emacs en le laissant tourner en tâche de fond et qui n'est
+ vraiment utile que si vous avez un système sans terminal virtuel).
+
+
+
+
+ Configurer Emacs
+
+ Emacs fait des choses merveilleuses; une partie est intégrée
+ directement, une autre doit être configurée.
+
+
+ Plutôt que d'utiliser un macro langage propriétaire pour la configuration,
+ Emacs utilise une version du Lisp spécialement adaptée pour les
+ éditeurs, connue sous le nom d'Emacs Lisp. Celui-ci peut être assez utile si
+ vous voulez poursuivre et apprendre quelque chose comme le Common Lisp,
+ car il est considérablement plus petit que le Common Lisp (bien que
+ déjà assez gros!).
+
+
+ La meilleure façon d'apprendre l'Emacs Lisp est de télécharger
+ le cours d'Emacs
+
+
+ Toutefois, il n'y a pas besoin de connaître le Lisp pour commencer
+ la configuration d'Emacs, car j'ai inclus un exemple de fichier .emacs
+ qui devrait être suffisant pour commencer. Copiez juste celui-ci dans votre
+ répertoire utilisateur et redémarrez Emacs si celui-ci s'exécute,
+ il lira les commandes du fichier et (si tout va bien!) vous donnera une configuration
+ basique utile.
+
+
+
+
+ Un fichier exemple <filename>.emacs</filename>
+
+ Malheureusement, il y a beaucoup trop de choses ici pour les expliquer en détail;
+ toutefois, il y a un ou deux points qui valent d'être mentionnés.
+
+
+
+
+ Tout ce qui commence avec un ; est un commentaire et est
+ ignoré par Emacs.
+
+
+
+
+ A la première ligne, le -*- Emacs-Lisp -*-
+ est tel que vous pouvez éditer le fichier .emacs lui-même
+ à l'intérieur d'Emacs et d'obtenir tous les fantaisistes dispositifs
+ pour l'édition en Emacs Lisp. Emacs essaye habituellement de deviner cela
+ en se basant sur le nom du fichier, et ne trouvera peut-être pas pour
+ .emacs.
+
+
+
+
+ La touche tab est liée à la fonction d'indentation
+ dans certains modes, aussi quand vous l'enfoncez, cela va indenter la ligne courante
+ de code. Si vous voulez mettre un caractère tab dans quoique ce soit
+ que vous tapiez, maintenez la touche control enfoncée pendant
+ que vous appuyez sur tab.
+
+
+
+
+ Ce fichier supporte la colorisation de syntaxe pour les langages C, C++, Perl, Lisp
+ et Scheme en devinant le langage par leur nom.
+
+
+
+
+ Emacs possède déjà une fonction pré-définie
+ appelée next-error. Dans la fenêtre de sortie d'une
+ compilation, cela vous permet de vous déplacer d'une erreur de compilation
+ à la suivante en faisant M-n; nous définissons une
+ fonction complémentaire previous-error, qui vous permet
+ d'aller à l'erreur précédente en faisant M-p.
+ Le plus beau dispositif de tous est que C-c C-c
+ va ouvrir le fichier source dans lequel l'erreur a eu lieu et sautera à la ligne
+ appropriée.
+
+
+
+
+ Nous autorisons la capacité d'Emacs à agir comme un serveur
+ ainsi si vous faites quelque chose en dehors d'Emacs et voulez éditer un
+ fichier, tapez juste
+
+
+ &prompt.user; emacsclient nomfichier
+
+
+ et alors vous pouvez éditer le fichier dans votre Emacs!
+
+ Beaucoup d'utilisateurs d'Emacs mettent leur variable d'environnement
+ EDITOR à emacsclient ainsi cela se passe
+ à chaque fois qu'ils ont besoin d'éditer un fichier.
+
+
+
+
+
+
+
+ Un fichier exemple <filename>.emacs</filename>
+
+ ;; -*-Emacs-Lisp-*-
+
+;; Ce fichier est concu pour etre reevalue, utiliser la variable first-time
+;; pour eviter tout probleme.
+(defvar first-time t
+ "Valeur signifiant que c'est la premiere fois que .emacs a ete evalue"
+ )
+
+;; Meta
+(global-set-key "\M- " 'set-mark-command)
+(global-set-key "\M-\C-h" 'backward-kill-word)
+(global-set-key "\M-\C-r" 'query-replace)
+(global-set-key "\M-r" 'replace-string)
+(global-set-key "\M-g" 'goto-line)
+(global-set-key "\M-h" 'help-command)
+
+;; Function keys
+(global-set-key [f1] 'manual-entry)
+(global-set-key [f2] 'info)
+(global-set-key [f3] 'repeat-complex-command)
+(global-set-key [f4] 'advertised-undo)
+(global-set-key [f5] 'eval-current-buffer)
+(global-set-key [f6] 'buffer-menu)
+(global-set-key [f7] 'other-window)
+(global-set-key [f8] 'find-file)
+(global-set-key [f9] 'save-buffer)
+(global-set-key [f10] 'next-error)
+(global-set-key [f11] 'compile)
+(global-set-key [f12] 'grep)
+(global-set-key [C-f1] 'compile)
+(global-set-key [C-f2] 'grep)
+(global-set-key [C-f3] 'next-error)
+(global-set-key [C-f4] 'previous-error)
+(global-set-key [C-f5] 'display-faces)
+(global-set-key [C-f8] 'dired)
+(global-set-key [C-f10] 'kill-compilation)
+
+;; Keypad bindings
+(global-set-key [up] "\C-p")
+(global-set-key [down] "\C-n")
+(global-set-key [left] "\C-b")
+(global-set-key [right] "\C-f")
+(global-set-key [home] "\C-a")
+(global-set-key [end] "\C-e")
+(global-set-key [prior] "\M-v")
+(global-set-key [next] "\C-v")
+(global-set-key [C-up] "\M-\C-b")
+(global-set-key [C-down] "\M-\C-f")
+(global-set-key [C-left] "\M-b")
+(global-set-key [C-right] "\M-f")
+(global-set-key [C-home] "\M-<")
+(global-set-key [C-end] "\M->")
+(global-set-key [C-prior] "\M-<")
+(global-set-key [C-next] "\M->")
+
+;; Souris
+(global-set-key [mouse-3] 'imenu)
+
+;; Divers
+(global-set-key [C-tab] "\C-q\t") ; Control tab quotes a tab.
+(setq backup-by-copying-when-mismatch t)
+
+;; Traite 'y' ou <CR> comme yes, 'n' comme no.
+(fset 'yes-or-no-p 'y-or-n-p)
+ (define-key query-replace-map [return] 'act)
+ (define-key query-replace-map [?\C-m] 'act)
+
+;; Charge les ajouts
+(require 'desktop)
+(require 'tar-mode)
+
+;; Diff mode sympa
+(autoload 'ediff-buffers "ediff" "Intelligent Emacs interface to diff" t)
+(autoload 'ediff-files "ediff" "Intelligent Emacs interface to diff" t)
+(autoload 'ediff-files-remote "ediff"
+ "Intelligent Emacs interface to diff")
+
+(if first-time
+ (setq auto-mode-alist
+ (append '(("\\.cpp$" . c++-mode)
+ ("\\.hpp$" . c++-mode)
+ ("\\.lsp$" . lisp-mode)
+ ("\\.scm$" . scheme-mode)
+ ("\\.pl$" . perl-mode)
+ ) auto-mode-alist)))
+
+;; Mode de verrouillage automatique de la police de caracteres
+(defvar font-lock-auto-mode-list
+ (list 'c-mode 'c++-mode 'c++-c-mode 'emacs-lisp-mode 'lisp-mode 'perl-mode 'scheme-mode)
+ "List of modes to always start in font-lock-mode")
+
+(defvar font-lock-mode-keyword-alist
+ '((c++-c-mode . c-font-lock-keywords)
+ (perl-mode . perl-font-lock-keywords))
+ "Associations between modes and keywords")
+
+(defun font-lock-auto-mode-select ()
+ "Automatically select font-lock-mode if the current major mode is
+in font-lock-auto-mode-list"
+ (if (memq major-mode font-lock-auto-mode-list)
+ (progn
+ (font-lock-mode t))
+ )
+ )
+
+(global-set-key [M-f1] 'font-lock-fontify-buffer)
+
+;; New dabbrev stuff
+;(require 'new-dabbrev)
+(setq dabbrev-always-check-other-buffers t)
+(setq dabbrev-abbrev-char-regexp "\\sw\\|\\s_")
+(add-hook 'emacs-lisp-mode-hook
+ '(lambda ()
+ (set (make-local-variable 'dabbrev-case-fold-search) nil)
+ (set (make-local-variable 'dabbrev-case-replace) nil)))
+(add-hook 'c-mode-hook
+ '(lambda ()
+ (set (make-local-variable 'dabbrev-case-fold-search) nil)
+ (set (make-local-variable 'dabbrev-case-replace) nil)))
+(add-hook 'text-mode-hook
+ '(lambda ()
+ (set (make-local-variable 'dabbrev-case-fold-search) t)
+ (set (make-local-variable 'dabbrev-case-replace) t)))
+
+;; mode C++ et C...
+(defun my-c++-mode-hook ()
+ (setq tab-width 4)
+ (define-key c++-mode-map "\C-m" 'reindent-then-newline-and-indent)
+ (define-key c++-mode-map "\C-ce" 'c-comment-edit)
+ (setq c++-auto-hungry-initial-state 'none)
+ (setq c++-delete-function 'backward-delete-char)
+ (setq c++-tab-always-indent t)
+ (setq c-indent-level 4)
+ (setq c-continued-statement-offset 4)
+ (setq c++-empty-arglist-indent 4))
+
+(defun my-c-mode-hook ()
+ (setq tab-width 4)
+ (define-key c-mode-map "\C-m" 'reindent-then-newline-and-indent)
+ (define-key c-mode-map "\C-ce" 'c-comment-edit)
+ (setq c-auto-hungry-initial-state 'none)
+ (setq c-delete-function 'backward-delete-char)
+ (setq c-tab-always-indent t)
+;; Style d'indentation BSD
+ (setq c-indent-level 4)
+ (setq c-continued-statement-offset 4)
+ (setq c-brace-offset -4)
+ (setq c-argdecl-indent 0)
+ (setq c-label-offset -4))
+
+;; mode Perl
+(defun my-perl-mode-hook ()
+ (setq tab-width 4)
+ (define-key c++-mode-map "\C-m" 'reindent-then-newline-and-indent)
+ (setq perl-indent-level 4)
+ (setq perl-continued-statement-offset 4))
+
+;; mode Scheme...
+(defun my-scheme-mode-hook ()
+ (define-key scheme-mode-map "\C-m" 'reindent-then-newline-and-indent))
+
+;; mode Emacs-Lisp...
+(defun my-lisp-mode-hook ()
+ (define-key lisp-mode-map "\C-m" 'reindent-then-newline-and-indent)
+ (define-key lisp-mode-map "\C-i" 'lisp-indent-line)
+ (define-key lisp-mode-map "\C-j" 'eval-print-last-sexp))
+
+;; Ajoute tout le reste...
+(add-hook 'c++-mode-hook 'my-c++-mode-hook)
+(add-hook 'c-mode-hook 'my-c-mode-hook)
+(add-hook 'scheme-mode-hook 'my-scheme-mode-hook)
+(add-hook 'emacs-lisp-mode-hook 'my-lisp-mode-hook)
+(add-hook 'lisp-mode-hook 'my-lisp-mode-hook)
+(add-hook 'perl-mode-hook 'my-perl-mode-hook)
+
+;; Le complement a next-error
+(defun previous-error (n)
+ "Visit previous compilation error message and corresponding source code."
+ (interactive "p")
+ (next-error (- n)))
+
+;; Divers...
+(transient-mark-mode 1)
+(setq mark-even-if-inactive t)
+(setq visible-bell nil)
+(setq next-line-add-newlines nil)
+(setq compile-command "make")
+(setq suggest-key-bindings nil)
+(put 'eval-expression 'disabled nil)
+(put 'narrow-to-region 'disabled nil)
+(put 'set-goal-column 'disabled nil)
+
+;; Recherche des archives Elisp
+(autoload 'format-lisp-code-directory "lispdir" nil t)
+(autoload 'lisp-dir-apropos "lispdir" nil t)
+(autoload 'lisp-dir-retrieve "lispdir" nil t)
+(autoload 'lisp-dir-verify "lispdir" nil t)
+
+;; Mode de verrouillage de police
+(defun my-make-face (face colour &optional bold)
+ "Create a face from a colour and optionally make it bold"
+ (make-face face)
+ (copy-face 'default face)
+ (set-face-foreground face colour)
+ (if bold (make-face-bold face))
+ )
+
+(if (eq window-system 'x)
+ (progn
+ (my-make-face 'blue "blue")
+ (my-make-face 'red "red")
+ (my-make-face 'green "dark green")
+ (setq font-lock-comment-face 'blue)
+ (setq font-lock-string-face 'bold)
+ (setq font-lock-type-face 'bold)
+ (setq font-lock-keyword-face 'bold)
+ (setq font-lock-function-name-face 'red)
+ (setq font-lock-doc-string-face 'green)
+ (add-hook 'find-file-hooks 'font-lock-auto-mode-select)
+
+ (setq baud-rate 1000000)
+ (global-set-key "\C-cmm" 'menu-bar-mode)
+ (global-set-key "\C-cms" 'scroll-bar-mode)
+ (global-set-key [backspace] 'backward-delete-char)
+ ; (global-set-key [delete] 'delete-char)
+ (standard-display-european t)
+ (load-library "iso-transl")))
+
+;; X11 ou PC utilisant les ecritures directes a l'ecran
+(if window-system
+ (progn
+ ;; (global-set-key [M-f1] 'hilit-repaint-command)
+ ;; (global-set-key [M-f2] [?\C-u M-f1])
+ (setq hilit-mode-enable-list
+ '(not text-mode c-mode c++-mode emacs-lisp-mode lisp-mode
+ scheme-mode)
+ hilit-auto-highlight nil
+ hilit-auto-rehighlight 'visible
+ hilit-inhibit-hooks nil
+ hilit-inhibit-rebinding t)
+ (require 'hilit19)
+ (require 'paren))
+ (setq baud-rate 2400) ; For slow serial connections
+ )
+
+;; Terminal de type TTY
+(if (and (not window-system)
+ (not (equal system-type 'ms-dos)))
+ (progn
+ (if first-time
+ (progn
+ (keyboard-translate ?\C-h ?\C-?)
+ (keyboard-translate ?\C-? ?\C-h)))))
+
+;; Sous Unix
+(if (not (equal system-type 'ms-dos))
+ (progn
+ (if first-time
+ (server-start))))
+
+;; Add any face changes here
+(add-hook 'term-setup-hook 'my-term-setup-hook)
+(defun my-term-setup-hook ()
+ (if (eq window-system 'pc)
+ (progn
+;; (set-face-background 'default "red")
+ )))
+
+;; Restaure le "desktop" - faire cela le plus tard possible
+(if first-time
+ (progn
+ (desktop-load-default)
+ (desktop-read)))
+
+;; Indique que ce fichier a ete lu au moins une fois
+(setq first-time nil)
+
+;; Pas besoin de deverminer quoique ce soit maintenant
+
+(setq debug-on-error nil)
+
+;; Tout est fait
+(message "All done, %s%s" (user-login-name) ".")
+
+
+
+
+
+ Etendre la palette de langages qu'Emacs comprend
+
+ Maintenant, Emacs est très bien si vous voulez seulement programmer
+ dans des langages déjà fournis dans le fichier .emacs
+ (C, C++, Perl, Lisp et Scheme), mais qu'arrive-t-il si un nouveau langage appelé
+ whizbang sort, plein d'excitantes fonctionnalités ?
+
+
+ La première chose à faire est de savoir si whizbang est fourni avec
+ des fichiers de configuration pour Emacs. Ceux-ci se terminent habituellement
+ par .el, raccourci pour Emacs Lisp.
+ Par exemple, si whizbang est un logiciel porté FreeBSD, nous pouvons
+ localiser ces fichiers en faisant
+
+
+ &prompt.user; find /usr/ports/lang/whizbang -name "*.el" -print
+
+
+ et les installer en les copiant dans le répertoire Lisp d'Emacs.
+ Sur FreeBSD 2.1.0-RELEASE, il s'agit de /usr/local/share/emacs/site-lisp
+ NDT : Sur FreeBSD 4.2-RELEASE aussi..
+
+
+ Aisni par exemple, si la sortie de la commande find était
+
+
+ /usr/ports/lang/whizbang/work/misc/whizbang.el
+
+
+ nous ferions
+
+
+ &prompt.root; cp /usr/ports/lang/whizbang/work/misc/whizbang.el /usr/local/share/emacs/site-lisp
+
+
+ Ensuite, nous devons décider quel extension les fichiers source whizbang ont. Disons
+ qu'il s'agit de fichiers se terminant par .wiz. Nous devons
+ ajouter une entrée dans notre fichier .emacs pour être sûr
+ qu'Emacs sera capable d'utiliser les informations dans whizbang.el.
+
+
+ Trouvez l'entrée auto-mode-alist dans
+ .emacs et ajoutez une ligne pour whizbang, comme :
+
+
+ …
+("\\.lsp$" . lisp-mode)
+("\\.wiz$" . whizbang-mode)
+("\\.scm$" . scheme-mode)
+…
+
+ Cela signifie qu'Emacs ira automatiquement dans la fonction
+ whizbang-mode quand vous éditerez un fichier se terminant
+ par .wiz.
+
+
+ Juste en-dessous, vous trouverez l'entrée font-lock-auto-mode-list.
+ Ajoutez whizbang-mode à celle-ci comme ceci :
+
+
+ ;; Auto font lock mode
+(defvar font-lock-auto-mode-list
+ (list 'c-mode 'c++-mode 'c++-c-mode 'emacs-lisp-mode 'whizbang-mode 'lisp-mode 'perl-mode 'scheme-mode)
+ "List of modes to always start in font-lock-mode")
+
+ Cela signifie qu'Emacs autorisera toujours font-lock-mode
+ (ie colorisation de la syntaxe) pendant l'édition d'un fichier .wiz.
+
+
+ Et c'est tout ce qui est nécessaire. S'il y a quoique ce soit que
+ vous voulez de fait automatiquement quand vous ouvrez un fichier
+ .wiz, vous pouvez ajouter un whizbang-mode hook
+ (voir my-scheme-mode-hook pour un exemple simple
+ qui ajoute auto-indent, l'auto-indentation).
+
+
+
+
+
+ Pour aller plus loin
+
+
+
+ Brian Harvey and Matthew Wright
+ Simply Scheme
+ MIT 1994.
+ ISBN 0-262-08226-8
+
+
+
+ Randall Schwartz
+ Learning Perl
+ O'Reilly 1993
+ ISBN 1-56592-042-2
+
+
+
+ Patrick Henry Winston and Berthold Klaus Paul Horn
+ Lisp (3rd Edition)
+ Addison-Wesley 1989
+ ISBN 0-201-08319-1
+
+
+
+ Brian W. Kernighan and Rob Pike
+ The Unix Programming Environment
+ Prentice-Hall 1984
+ ISBN 0-13-937681-X
+
+
+
+ Brian W. Kernighan and Dennis M. Ritchie
+ The C Programming Language (2nd Edition)
+ Prentice-Hall 1988
+ ISBN 0-13-110362-8
+
+
+
+ Bjarne Stroustrup
+ The C++ Programming Language
+ Addison-Wesley 1991
+ ISBN 0-201-53992-6
+
+
+
+ W. Richard Stevens
+ Advanced Programming in the Unix Environment
+ Addison-Wesley 1992
+ ISBN 0-201-56317-7
+
+
+
+ W. Richard Stevens
+ Unix Network Programming
+ Prentice-Hall 1990
+ ISBN 0-13-949876-1
+
+
+
+
+
diff --git a/fr_FR.ISO8859-1/books/developers-handbook/usb/chapter.sgml b/fr_FR.ISO8859-1/books/developers-handbook/usb/chapter.sgml
new file mode 100644
index 0000000000..17b8e8486a
--- /dev/null
+++ b/fr_FR.ISO8859-1/books/developers-handbook/usb/chapter.sgml
@@ -0,0 +1,21 @@
+
+
+
+ Périphériques USB ***
+
+ Ce chapître a été écrit par &a.nhibma;. Les modifications pour le
+ manuel par &a.murray;.
+
+
+ Introduction
+ Chapître à traduire.
+
+
+
\ No newline at end of file