/usr/share/doc/HOWTO/fr-html/VMS-to-Linux-HOWTO.html

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<HTML>
<HEAD>
 <META NAME="GENERATOR" CONTENT="LinuxDoc-Tools 0.9.69">
 <TITLE>HOWTO Comment migrer de VMS &agrave; Linux</TITLE>
</HEAD>
<BODY>
<H1>HOWTO Comment migrer de VMS &agrave; Linux</H1>

<H2>Auteur&nbsp;: 
<A HREF="mailto:guido@ibogeo.df.unibo.it">Guido Gonzato</A>
et 
<A HREF="mailto:miller5@uiuc.edu">Mike Miller</A><BR>
Traducteur&nbsp;:
<A HREF="mailto:dimitri.ara@wanadoo.fr">Dimitri Ara</A><BR> </H2>v1.1.3, 17 Septembre 1999
<HR>
<EM>Ce HOWTO est destin&eacute; &agrave; toutes les personnes qui utilisent VMS et qui ont
maintenant besoin ou envie de passer &agrave; Linux, le clone libre d'Unix.
Nous effectuerons la transition --- je l'esp&egrave;re, sans douleur --- en
comparant les commandes et les outils disponibles sur ces
deux syst&egrave;mes. </EM>
<HR>
<H2><A NAME="Introduction"></A> <A NAME="s1">1. Introduction</A></H2>

<H2><A NAME="ss1.1">1.1 Pourquoi Linux&nbsp;?</A>
</H2>


<P>Vous avez entendu dire qu'Unix est difficile et vous &ecirc;tes h&eacute;sitant &agrave; la
perspective d'abandonner VMS&nbsp;?
Pas de panique. Linux, l'un des meilleurs clones d'Unix, n'est pas plus
difficile &agrave; utiliser que VMS. En fait, je le trouve m&ecirc;me plus facile.
D'ailleurs, la plupart des gens trouve Linux beaucoup plus puissant et
versatile que VMS (&eacute;videmment les aficionados de VMS ne sont pas de cet avis).</P>
<P>Linux et VMS sont tous les deux de bons syst&egrave;mes d'exploitation et
accomplissent essentiellement les m&ecirc;mes taches. Cependant, les outils de
Linux sont &agrave; mon humble avis sup&eacute;rieurs. Leur syntaxe est souvent plus concise
et ils ont souvent les quelques fonctionnalit&eacute;s de plus qui font la diff&eacute;rence
et  
permettent de gagner du temps (vous entendrez souvent que VMS et Unix ont
des philosophies diff&eacute;rentes). De plus, Linux est disponible sur les
PC alors que ce n'est pas le cas de VMS (les derniers PC &eacute;tant d'ailleurs
plus puissants que les VAX). Et, cerise sur le
g&acirc;teau, les excellentes performances des nouvelles cartes graphiques
transforment votre tite bo&icirc;te Linux, gr&acirc;ce &agrave; X, en une puissante station
de travail graphique bien souvent plus rapide
qu'une machine sp&eacute;cialement pr&eacute;vue pour cette t&acirc;che.</P>
<P>J'ai plusieurs raisons de croire que la combinaison Pentium/Linux est
pr&eacute;f&eacute;rable &agrave; celle de VAX/VMS, mais ces pr&eacute;f&eacute;rences sont strictement
personnelles et vous ne serez peut-&ecirc;tre pas d'accord. Vous en d&eacute;ciderez
de vous-m&ecirc;me dans quelques mois.</P>
<P>Je prends en hypoth&egrave;se que vous &ecirc;tes une &eacute;tudiant ou un chercheur &agrave;
l'universit&eacute; et que vous utilisez r&eacute;guli&egrave;rement VMS pour les t&acirc;ches suivantes&nbsp;:</P>
<P>
<UL>
<LI> &eacute;crire des papiers avec TeX/LaTeX&nbsp;;</LI>
<LI> programmer en Fortran&nbsp;;</LI>
<LI> faire des graphiques&nbsp;;</LI>
<LI> utiliser Internet&nbsp;;</LI>
<LI> etc.</LI>
</UL>
</P>
<P>Dans la section suivante je vais vous expliquer comment faire ces t&acirc;ches
sous Linux en utilisant votre exp&eacute;rience de VMS. Mais avant tout v&eacute;rifiez que&nbsp;:</P>
<P>
<UL>
<LI> Linux et le <I>Syst&egrave;me X Window</I> sont correctement install&eacute;s&nbsp;;</LI>
<LI> vous avez un administrateur syst&egrave;me pour s'occuper des d&eacute;tails
techniques (s'il-vous-pla&icirc;t, demandez de l'aide &agrave; eux, pas &agrave; moi :-)&nbsp;;</LI>
<LI> votre <I>shell</I> --- l'&eacute;quivalent de <CODE>DCL</CODE> --- est <CODE>bash</CODE> 
(demandez &agrave; votre administrateur). </LI>
</UL>
</P>
<P>Notez que ce HOWTO n'est pas suffisant pour faire de vous un linuxien
pur et dur&nbsp;: il contient seulement le strict
n&eacute;cessaire pour vous permettre de commencer. Vous devriez
en apprendre plus sur Linux pour pouvoir en tirer le maximum (fonctionnalit&eacute;s
avanc&eacute;es de <CODE>bash</CODE>, programmation, expressions r&eacute;guli&egrave;res, etc.).</P>
<P>Les documents du <I>Linux Documentation Project</I> (projet de documentation de
Linux), disponibles sur
<A HREF="ftp://metalab.unc.edu:/pub/Linux/docs/LDP">metalab.unc.edu:/pub/Linux/docs/LDP</A>, sont une importante 
source d'informations. </P>
<P>NDT&nbsp;: je vous sugg&egrave;re &eacute;galement de lire le <I>Guide du rootard</I> d'&Eacute;ric Dumas
et plus g&eacute;n&eacute;ralement tout ce que l'on peut trouver sur
<CODE>
<A HREF="http://www.freenix.fr/linux">http://www.freenix.fr/linux</A></CODE> et
<CODE>
<A HREF="http://www.traduc.org">http://www.traduc.org</A></CODE>.</P>
<P>Et maintenant, c'est parti&nbsp;!</P>

<H2><A NAME="ss1.2">1.2 Commandes et fichiers comparables</A>
</H2>


<P>Ce tableau compare les commandes les plus utilis&eacute;es sous VMS et Linux.
Gardez &agrave; l'esprit que leur syntaxe est souvent tr&egrave;s diff&eacute;rente&nbsp;; pour
plus de d&eacute;tails allez faire un tour dans les sections suivantes.</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
VMS                           Linux                   Notes
-------------------------------------------------------------------------------
@COMMAND                      command                    (doit &ecirc;tre ex&eacute;cutable)
COPY fichier1 fichier2        cp fichier1 fichier2
CREATE/DIR [.r&eacute;pertoire]      mkdir r&eacute;pertoire           (seulement un par un)
CREATE/DIR [.r&eacute;p1.r&eacute;p2]       mkdirhier r&eacute;p/r&eacute;p
DELETE fichier                rm fichier
DIFF fichier1 fichier2        diff -c fichier1 fichier2
DIRECTORY                     ls
DIRECTORY [...]fichier        find . -name fichier
DIRECTORY/FULL                ls -al
EDIT fichier                  vi fichier,            (vous n'allez pas l'aimer)
                              emacs fichier,                   (compatible EDT)
                              jed fichier                (idem --- mon pr&eacute;f&eacute;r&eacute;)
FORTRAN prog.for              g77 prog.f,        (pas besoin de lier avec LINK)
                              f77 prog.f,
                              fort77 prog.f
HELP commande                 man commande     (la commande doit &ecirc;tre pr&eacute;cis&eacute;e)
                              info commande
LATEX fichier.tex             latex fichier.tex
LOGIN.COM                     .bash_profile,                    (fichier cach&eacute;)
                              .bashrc                                    (idem)
LOGOUT.COM                    .bash_logout                               (idem)
MAIL                          mail,                                (un peu cru)
                              elm,                             (beaucoup mieux)
                              pine                            (encore meilleur)
PRINT fichier.ps              lpr fichier.ps
PRINT/QUEUE=laser fichier.ps  lpr -Plaser fichier.ps
PHONE utilisateur             talk utilisateur
RENAME fichier1 fichier2      mv fichier1 fichier2      (ne marche pas avec des
                                                            fichiers multiples)
RUN progname                  programme
SEARCH fichier "motif"        grep motif fichier
SET DEFAULT [-]               cd ..
SET DEFAULT [.r&eacute;p.r&eacute;p]        cd r&eacute;p/r&eacute;p
SET HOST machine              telnet machine,            (pas exactement pareil)
                              rlogin machine 
SET FILE/OWNER_UIC=paul       chown paul fichier        (compl&egrave;tement diff&eacute;rent)
SET NOBROADCAST               mesg
SET PASSWORD                  passwd
SET PROT=(perm) fichier       chmod perm fichier       (compl&egrave;tement diff&eacute;rent)
SET TERMINAL                  export TERM=          (la syntaxe est diff&eacute;rente)
SHOW DEFAULT                  pwd
SHOW DEVICE                   du, df
SHOW ENTRY                    lpq
SHOW PROCESS                  ps -ax
SHOW QUEUE                    lpq
SHOW SYSTEM                   top
SHOW TIME                     date
SHOW USERS                    w
STOP                          kill
STOP/QUEUE                    kill,                        (pour les processus)
                              lprm                   (pour supprimer un travail
                                                       de la file d'impression)
SUBMIT commande               commande &amp;
SUBMIT/AFTER=dur&eacute;e commande   at dur&eacute;e commande
TEX fichier.tex               tex fichier.tex
TYPE/PAGE fichier             more fichier
                              less fichier                     (beaucoup mieux)
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Bien s&ucirc;r, les diff&eacute;rences des deux syst&egrave;mes ne se limitent pas aux noms des
commandes. Continuez donc &agrave; lire.</P>

<H2><A NAME="Petite introduction"></A> <A NAME="s2">2. Petite introduction</A></H2>


<P>Voila ce que vous devez absolument savoir avant de vous loguer pour la premi&egrave;re
fois. D&eacute;tendez-vous, il y a relativement peu de chose.</P>

<H2><A NAME="ss2.1">2.1 Fichiers</A>
</H2>


<P>
<UL>
<LI> Les noms des fichiers sous VMS on la forme
<CODE>fichier.extension.version</CODE>. 
Sous Linux, le num&eacute;ro de version n'existe pas (c'est une grosse limitation mais
on peut la compenser par d'astucieux moyens&nbsp;: jetez un oeil &agrave; la section 
<A HREF="#Numeros de version sous Linux">Num&eacute;ros de version sous Linux</A>)&nbsp;;
les noms des fichiers sont normalement limit&eacute;s &agrave; 255 caract&egrave;res et peuvent
contenir autant de points que vous le d&eacute;sirez. Par exemple,
<CODE>C_est.un.FICHIER.txt</CODE> est un nom de fichier valide.
</LI>
<LI> Linux fait la distinction entre les majuscules et les minuscules. Ainsi,
<CODE>FICHIER.txt</CODE> et <CODE>fichier.txt</CODE> sont deux fichiers 
diff&eacute;rents et <CODE>ls</CODE> est une commande alors que <CODE>LS</CODE> n'en est pas une.
</LI>
<LI> Un fichier dont le nom commence par un point est un fichier cach&eacute; (ce
qui veut dire qu'il ne sera normalement pas affich&eacute; quand on listera les
fichiers du r&eacute;pertoire) alors qu'un fichier dont le nom finit par un tilde
(« <CODE>~</CODE> ») repr&eacute;sente une sauvegarde de fichier (ou
<I>backup</I>).
</LI>
</UL>
</P>
<P>Maintenant, voici un tableau pr&eacute;sentant les correspondances entre les commandes
de VMS et celle de Linux en ce qui concerne la gestion des fichiers.</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>

VMS                                     Linux
---------------------------------------------------------------------

$ COPY fichier1.txt; fichier2.txt;      $ cp fichier1.txt fichier2.txt
$ COPY [.r&eacute;p]fichier.txt;1 []           $ cp r&eacute;p/fichier.txt .
$ COPY [.r&eacute;p]fichier.txt;1 [-]          $ cp r&eacute;p/fichier.txt ..
$ DELETE *.dat.*                        $ rm *dat
$ DIFF fichier1 fichier2                $ diff -c fichier1 fichier2
$ PRINT fichier                         $ lpr fichier
$ PRINT/queue=imprimante fichier        $ lpr -Pimprimante fichier
$ SEARCH *.tex.* "g&eacute;ologie"             $ grep g&eacute;ologie *tex
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Regardez en plus loin dans le document pour avoir d'autres exemples.
Si vous voulez vous attaquer aux notions
de droits, de propri&eacute;taires et aux sujets avanc&eacute;s,
reportez vous &agrave; la section 
<A HREF="#Sujets avances">Sujets avanc&eacute;s</A>.</P>

<H2><A NAME="ss2.2">2.2 R&eacute;pertoires</A>
</H2>


<P>
<UL>
<LI> Les noms des r&eacute;pertoires sous VMS sont de la forme
<CODE>[p&egrave;re.r&eacute;p.sousr&eacute;p]</CODE>. L'&eacute;quivalent sous Linux est&nbsp;:
<CODE>/p&egrave;re/r&eacute;p/sousr&eacute;p/</CODE>. 
Le p&egrave;re de tous les r&eacute;pertoires est le r&eacute;pertoire racine appel&eacute; <CODE>/</CODE>&nbsp;; il
contient d'autres r&eacute;pertoires comme <CODE>/bin</CODE>, <CODE>/usr</CODE>, <CODE>/tmp</CODE>,
<CODE>/etc</CODE>, et bien d'autres.
</LI>
<LI> Le r&eacute;pertoire <CODE>/home</CODE> contient les r&eacute;pertoires <I>home</I> (NDT&nbsp;:
« home » signifie « maison ») des
utilisateurs&nbsp;: par exemple, <CODE>/home/pierre</CODE>, <CODE>/home/paul</CODE> et ainsi
de suite. Quand un utilisateur se logue, il commence dans son r&eacute;pertoire
<I>home</I>&nbsp;;  c'est l'&eacute;quivalent de <CODE>SYS$LOGIN</CODE>. Il y a un raccourci
pour le 
r&eacute;pertoire <I>home</I>&nbsp;: le tilde (« <CODE>~</CODE> »). Ainsi, <CODE>cd
~/tmp</CODE> est &eacute;quivalent &agrave;, disons, <CODE>cd /home/paul/tmp</CODE>.
</LI>
<LI> Les noms des r&eacute;pertoires sont soumis aux m&ecirc;mes r&egrave;gles que ceux des
fichiers. En 
plus de cela, chaque r&eacute;pertoire a deux entr&eacute;es sp&eacute;ciales&nbsp;: l'une est <CODE>.</CODE>&nbsp;:
elle repr&eacute;sente le r&eacute;pertoire lui-m&ecirc;me (comme <CODE>[]</CODE>)&nbsp;; l'autre, <CODE>..</CODE>,
repr&eacute;sente le r&eacute;pertoire parent (comme <CODE>[-]</CODE>).
</LI>
</UL>
</P>
<P>Et maintenant quelques autres exemples&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>

VMS                                     Linux
---------------------------------------------------------------------

$ CREATE/DIR [.r&eacute;pertoire]              $ mkdir r&eacute;pertoire
$ CREATE/DIR [.dir1.dir2.dir3]          $ mkdirhier r&eacute;p1/r&eacute;p2/r&eacute;p3
   non/disponible                       $ rmdir r&eacute;pertoire
                                        (si le r&eacute;pertoire est vide)
                                        $ rm -R r&eacute;pertoire
$ DIRECTORY                             $ ls
$ DIRECTORY [...]fichier.*.*            $ find . -name "fichier*"
$ SET DEF SYS$LOGIN                     $ cd
$ SET DEF [-]                           $ cd ..
$ SET DEF [p&egrave;re.r&eacute;p.sousr&eacute;p]            $ cd /p&egrave;re/r&eacute;p/sousr&eacute;p
$ SET DEF [.r&eacute;p.sousr&eacute;p]                $ cd r&eacute;p/sousr&eacute;p
$ SHOW DEF                              $ pwd
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Si vous voulez en savoir plus sur les
droits, les propri&eacute;taires, ou tout simplement en savoir plus tout court,
sautez &agrave; la section 
<A HREF="#Sujets avances">Sujets avanc&eacute;s</A>.</P>

<H2><A NAME="ss2.3">2.3 Programmes</A>
</H2>


<P>
<UL>
<LI> Les commandes, les programmes compil&eacute;s et les scripts <I>shell</I>
(&eacute;quivalent 
des fichiers de commandes de VMS) n'ont pas forc&eacute;ment une extension comme
<CODE>.EXE</CODE> or <CODE>.COM</CODE> et peuvent s'appeler comme bon vous semble. Les
fichiers ex&eacute;cutables sont marqu&eacute;s d'un ast&eacute;risque (« <CODE>*</CODE> &raquo;)
lorsque 
vous ex&eacute;cutez <CODE>ls -F</CODE>.
</LI>
<LI> Pour lancer un fichier ex&eacute;cutable, il suffit de taper son nom (pas de
<CODE>RUN</CODE>, ni de <CODE>PROGRAM.EXE</CODE>, ni encore de <CODE>@COMMAND</CODE>). Il est donc
n&eacute;cessaire que le fichier soit situ&eacute; dans un r&eacute;pertoire du <I>path</I>, qui est
une liste de r&eacute;pertoires. En g&eacute;n&eacute;ral, le <I>path</I> contient des r&eacute;pertoires
comme 
<CODE>/bin</CODE>, <CODE>/usr/bin</CODE>, <CODE>/usr/X11R6/bin</CODE>, etc. Si vous
&eacute;crivez vos propres programmes, placez-les dans un r&eacute;pertoire de votre
<I>path</I> (pour savoir comment, reportez-vous &agrave; la section 
<A HREF="#Configurer">Configurer</A>). Vous pouvez aussi lancer un programme en indiquant son
chemin complet, par exemple <CODE>/home/paul/donn&eacute;es/monprog</CODE> ou
<CODE>./monprog</CODE> si le r&eacute;pertoire courant n'est pas dans le <I>path</I>.
</LI>
<LI> Les options des commandes sont pass&eacute;es sur la ligne de commande gr&acirc;ce &agrave;
<CODE>OPTION=</CODE> sous VMS et gr&acirc;ce &agrave; <CODE>-</CODE><I>une_option</I> ou
<CODE>--</CODE><I>une_option</I> sous Linux, <I>une_option</I> &eacute;tant une lettre, 
diff&eacute;rentes lettres combin&eacute;es ou un 
mot. En particulier, l'option <CODE>-R</CODE> (r&eacute;cursif) de plusieurs commandes de
Linux permet de faire la m&ecirc;me chose que le <CODE>[...]</CODE> de VMS.
</LI>
<LI> Vous pouvez lancer plusieurs commandes sur la ligne de commande&nbsp;:

<BLOCKQUOTE><CODE>
<PRE>
$ commande1 ; commande2 ; ... ; commande
</PRE>
</CODE></BLOCKQUOTE>

</LI>
<LI> Toute la flexibilit&eacute; de Linux repose sur deux fonctionnalit&eacute;s (l'une
n'existe pas sous VMS, l'autre est mal impl&eacute;ment&eacute;e)&nbsp;:
la redirection des entr&eacute;s/sorties et les
<I>pipes</I>. (Pour &ecirc;tre sinc&egrave;re, j'ai entendu que les versions r&eacute;centes de IDL
supportent la redirection et les <I>pipes</I> mais je n'ai pas ces versions.) La
redirection sous VMS n'est qu'un effet de bord (souvenez vous de l'option
<CODE>/OUTPUT=</CODE>) ou une t&acirc;che fastidieuse comme

<BLOCKQUOTE><CODE>
<PRE>
$ DEFINE /USER SYS$OUTPUT OUT 
$ DEFINE /USER SYS$INPUT IN
$ RUN PROG
</PRE>
</CODE></BLOCKQUOTE>


dont l'&eacute;quivalent sous Linux (Unix) est simplement&nbsp;:

<BLOCKQUOTE><CODE>
<PRE>
$ prog &lt; in > out
</PRE>
</CODE></BLOCKQUOTE>


Utiliser des <I>pipes</I> est tout simplement impossible sous VMS mais ils jouent
un r&ocirc;le cl&eacute; sous Unix. En voici un exemple typique&nbsp;:

<BLOCKQUOTE><CODE>
<PRE>
$ monprog &lt; donn&eacute;es | filtre1 | filtre2 >> r&eacute;sultat.dat 2> erreurs.log &amp;
</PRE>
</CODE></BLOCKQUOTE>


Traduisons. Le programme <CODE>monprog</CODE> utilise le fichier <CODE>donn&eacute;es</CODE> comme
entr&eacute;e, sa sortie est canalis&eacute;e (gr&acirc;ce &agrave; <CODE>|</CODE>) vers le programme
<CODE>filtre1</CODE> qui l'utilise en tant qu'entr&eacute;e et la traite. La sortie r&eacute;sultante
est canalis&eacute;e (<I>pip&eacute;e</I>) vers <CODE>filtre2</CODE> pour &ecirc;tre encore une fois trait&eacute;e.
La sortie finale 
est ajout&eacute;e (gr&acirc;ce &agrave; <CODE>>></CODE>) au fichier <CODE>r&eacute;sultat.dat</CODE>, et les
messages d'erreurs sont redirig&eacute;s (gr&acirc;ce &agrave; <CODE>2></CODE>) vers le fichier
<CODE>errors.log</CODE>.
Tout ceci est ex&eacute;cut&eacute; en arri&egrave;re-plan (gr&acirc;ce au <CODE>&amp;</CODE> &agrave; la fin de la ligne
de commande). Pour en savoir plus &agrave; ce sujet, reportez-vous &agrave; la section
<A HREF="#Exemples">Exemples</A>.
</LI>
</UL>
 </P>
<P>Pour le multit&acirc;che, les files, et tout ce qui s'y rapporte, reportez-vous &agrave; la
section 
<A HREF="#Sujets avances">Sujets avanc&eacute;s</A>.</P>

<H2><A NAME="Visite guidee"></A> <A NAME="ss2.4">2.4 Visite guid&eacute;e</A>
</H2>


<P>Maintenant vous &ecirc;tes pr&ecirc;t pour essayer Linux. Entrez votre identifiant et
votre mot de passe. Attention, Unix distingue les minuscules des majuscules. Ainsi,
si votre login et votre mot de passe 
sont <CODE>pierre</CODE> et <CODE>Mon_Code</CODE>, ne tapez <I>pas</I> <CODE>Pierre</CODE> ou
<CODE>mon_code</CODE>.</P>
<P>Une fois que vous &ecirc;tes logu&eacute;, le prompt s'affiche. Il y a des chances
pour que se soit quelque chose du genre
<CODE>nom_de_la_machine:$</CODE>. Si vous voulez le changer ou lancer
des programmes automatiquement, vous devrez &eacute;diter le fichier cach&eacute;
<CODE>.profile</CODE> ou <CODE>.bash_profile</CODE> (jetez un oeil aux
exemples dans la section 
<A HREF="#Configurer">Configurer</A>). C'est l'&eacute;quivalent de
<CODE>LOGIN.COM</CODE>.</P>
<P>Appuyer sur <SF>alt&nbsp;+&nbsp;F1</SF>, <SF>alt&nbsp;+&nbsp;F2</SF>, ..., <SF>alt&nbsp;+&nbsp;F6</SF> permet de changer
de console 
virtuelle. Quand une console virtuelle est occup&eacute;e avec une application
plein &eacute;cran, vous pouvez changer de console et continuer &agrave; travailler.
Essayez et loguez-vous sur une autre console virtuelle.</P>
<P>Maintenant, vous voulez peut-&ecirc;tre lancer le <I>Syst&egrave;me X Window</I> (que nous
appellerons maintenant X). X est un environnement graphique similaire
au DECWindows --- en fait, ce dernier d&eacute;rive de X. Tapez la commande
<CODE>startx</CODE> et attendez quelques secondes&nbsp;; vous verrez probablement
s'ouvrir un <CODE>xterm</CODE> ou un autre &eacute;mulateur de terminal, et peut-&ecirc;tre
une barre de boutons (cela d&eacute;pend de la mani&egrave;re dont votre
administrateur syst&egrave;me a configur&eacute; votre machine Linux). Cliquez sur le
menu (essayez les deux boutons de la souris) pour voir les menus.</P>
<P>Quand vous utilisez X, vous devez appuyez sur <SF>ctrl&nbsp;+&nbsp;alt&nbsp;+&nbsp;F1</SF>, ..., 
<SF>ctrl&nbsp;+&nbsp;alt&nbsp;+&nbsp;F6</SF> pour acc&eacute;der au mode texte (console). Essayez. Quand 
vous &ecirc;tes dans une console, vous pouvez revenir &agrave; X en appuyant sur
<SF>alt&nbsp;+&nbsp;F7</SF>. Pour quitter X, suivez les instructions de votre menu ou 
appuyez sur <SF>ctrl&nbsp;+&nbsp;alt&nbsp;+&nbsp;backspace</SF>.</P>
<P>Tapez la commande suivante pour obtenir une liste du contenu du
r&eacute;pertoire courant (incluant les fichiers cach&eacute;s)&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ ls -al
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Appuyez sur <SF>shift&nbsp;+&nbsp;page up</SF> pour faire d&eacute;filer l'&eacute;cran vers le haut.
Maintenant, pour obtenir de l'aide sur la commande <CODE>ls</CODE> tapez</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ man ls
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Appuyez sur <CODE>q</CODE> pour quitter. Pour finir notre tour
d'horizon, tapez <CODE>exit</CODE> pour quitter votre session. Si maintenant
vous voulez &eacute;teindre votre PC, appuyez sur <SF>ctrl&nbsp;+&nbsp;alt&nbsp;+&nbsp;suppr</SF> et attendez
quelques secondes (n'&eacute;teignez <I>jamais</I> votre PC tant que Linux
tourne&nbsp;; cela peut causer des dommages dans le syst&egrave;me de fichier).</P>
<P>Si vous pensez que vous &ecirc;tes pr&ecirc;t pour travailler, allez-y. Mais si
j'&eacute;tais vous, je passerais d'abord par la section 
<A HREF="#Sujets avances">Sujets avanc&eacute;s</A>.</P>

<H2><A NAME="Editer des fichiers"></A> <A NAME="s3">3. &Eacute;diter des fichiers</A></H2>


<P><CODE>EDT</CODE> ne tourne pas sous Linux, mais il y a beaucoup d'autres &eacute;diteurs
disponibles. Le seul qui soit s&ucirc;r d'&ecirc;tre pr&eacute;sent sur tout syst&egrave;me Unix
est <CODE>vi</CODE> --- oubliez-le, votre administrateur en a s&ucirc;rement 
install&eacute; un meilleur. L'&eacute;diteur le plus populaire est probablement
<CODE>emacs</CODE>, qui peut &eacute;muler <CODE>EDT</CODE> jusqu'&agrave; un certain degr&eacute;&nbsp;;
<CODE>jed</CODE> est un autre &eacute;diteur qui permet l'&eacute;mulation de <CODE>EDT</CODE>.</P>
<P>Ces deux &eacute;diteurs sont particuli&egrave;rement utiles pour &eacute;diter des
sources de programmes puisque qu'ils ont deux fonctionnalit&eacute;s
inconnue de <CODE>EDT</CODE>&nbsp;: la coloration syntaxique et l'indentation
automatique. De plus, vous pouvez compilez vos programmes &agrave; partir de
l'&eacute;diteur (gr&acirc;ce &agrave; <SF>M-x compile</SF> sous emacs --- pour comprendre la 
notation «&nbsp;M-x compile&nbsp;» lisez la suite&nbsp;; en cas
d'erreur de  syntaxe, le curseur se positionnera tout seul sur la ligne en
question. Je parie que vous ne voudrez plus jamais utiliser <CODE>EDT</CODE> apr&egrave;s.</P>
<P>Si vous avez <CODE>emacs</CODE>, lancez-le. Tout d'abord vous devez comprendre le
syst&egrave;me de notation de combinaison de touche d'<CODE>emacs</CODE>. <SF>C</SF> d&eacute;signe
contr&ocirc;le et <SF>M</SF> la touche m&eacute;ta (en g&eacute;n&eacute;ral <SF>alt</SF> ou <SF>&eacute;chap</SF>).
Maintenant, tapez  
<SF>M-x edt-emultation-on</SF>. <SF>M-x</SF> permet de lancer des commandes avec
<CODE>emacs</CODE> comme <SF>ctrl&nbsp;+&nbsp;z</SF> avec <CODE>EDT</CODE>. &Agrave; partir de maintenant,
<CODE>emacs</CODE> fait 
comme s'il &eacute;tait <CODE>EDT</CODE> &agrave; part pour quelques commandes&nbsp;:</P>
<P>
<UL>
<LI> n'appuyez <I>pas</I> sur <SF>ctrl&nbsp;+&nbsp;z</SF> pour lancer une commande. Si vous
l'avez fait, vous avez stopp&eacute; emacs. Tapez <CODE>fg</CODE> pour reprendre
votre session emacs&nbsp;;
</LI>
<LI> appuyez sur <SF>C-h&nbsp;?</SF> pour obtenir de l'aide ou sur <SF>C-h&nbsp;t</SF>
pour lancer un tutoriel&nbsp;;
</LI>
<LI> pour sauver un fichier, appuyez sur <SF>C-x&nbsp;C-s</SF>&nbsp;;
</LI>
<LI> pour quittez, appuyez sur <SF>C-x&nbsp;C-c</SF>&nbsp;;
</LI>
<LI> pour ins&eacute;rez un nouveau fichier dans un buffer (pour ouvrir un
fichier, en gros), appuyez sur <SF>C-x&nbsp;C-f</SF>, et ensuite <SF>C-x&nbsp;b</SF> pour
changer de buffer.
</LI>
</UL>
</P>
<P>Si vous avez <CODE>jed</CODE>, demandez &agrave; votre administrateur de le
configurer comme il faut. L'&eacute;mulation est active d&egrave;s que vous le
lancez. Utilisez les m&ecirc;me touches que sur <CODE>EDT</CODE> et appuyez sur
<SF>&eacute;chap&nbsp;?&nbsp;h</SF> pour obtenir l'aide. Les commandes
sont lanc&eacute;es de la m&ecirc;me mani&egrave;re que dans <CODE>emacs</CODE>. De plus, il y a quelques
raccourcis pratiques faisant d&eacute;faut &agrave; <CODE>EDT</CODE>&nbsp;; vous pouvez en plus
configurer ces raccourcis clavier. Demandez &agrave; votre administrateur.</P>
<P>Vous pouvez aussi utilisez un autre &eacute;diteur avec une interface
compl&egrave;tement diff&eacute;rente. <CODE>emacs</CODE> en mode natif est un choix
courant. Un autre &eacute;diteur populaire est <CODE>joe</CODE> qui peut &eacute;muler
d'autres &eacute;diteurs comme emacs lui-m&ecirc;me (en &eacute;tant m&ecirc;me plus facile &agrave;
utiliser) ou l'&eacute;diteur DOS. Lancez l'&eacute;diteur sous le nom <CODE>jmacs</CODE> ou
<CODE>jstar</CODE> et appuyez respectivement sur <SF>ctrl&nbsp;+&nbsp;x h</SF> ou <SF>ctrl&nbsp;+&nbsp;j</SF> pour
obtenir l'aide en ligne. <CODE>emacs</CODE> et <CODE>jed</CODE> sont <I>beaucoup</I>
plus puissants que ce bon vieux <CODE>EDT</CODE>.</P>

<H2><A NAME="TeXer"></A> <A NAME="s4">4. TeXer </A></H2>


<P>TeX et LaTeX sont identiques &agrave; leurs homologues de VMS --- seulement plus
rapides&nbsp;:-), mais les outils pour manipuler les fichiers <CODE>.dvi</CODE> et&nbsp;<CODE>.ps</CODE>
sont bien sup&eacute;rieurs&nbsp;: </P>
<P>
<UL>
<LI> Pour compiler un fichier TeX faites comme d'habitude <CODE>tex file.tex</CODE>.
</LI>
<LI> Pour convertir un fichier <CODE>.dvi</CODE> en&nbsp;<CODE>.ps</CODE>, tapez <CODE>dvips -o
fichier.ps fichier.dvi</CODE>.
</LI>
<LI> Pour visualiser un fichier <CODE>.dvi</CODE>, tapez lors d'une session X
<CODE>xdvi fichier.dvi &amp;</CODE>. Cliquez sur la page pour zoomer. Ce programme est
intelligent&nbsp;: si vous &eacute;ditez et lancez TeX pour produire une nouvelle version
de votre fichier <CODE>.dvi</CODE>, <CODE>xdvi</CODE> actualisera l'affichage.
</LI>
<LI> Pour visualiser un fichier <CODE>.ps</CODE>, taper lors d'une session X
<CODE>ghostview fichier.ps &amp;</CODE>. Cliquez sur la page pour zoomer. Le document
entier ou des pages s&eacute;lectionn&eacute;s peuvent &ecirc;tre imprim&eacute;s. Un programme plus
r&eacute;cent et meilleur permet &eacute;galement de faire &ccedil;a&nbsp;: <CODE>gv</CODE>&nbsp;;
</LI>
<LI> Pour imprimer un fichier&nbsp;<CODE>.ps</CODE> on utilise g&eacute;n&eacute;ralement la commande
<CODE>lpr fichier.ps</CODE>. Cependant si l'imprimante postscript s'appelle, par
exemple, « ps » (demandez &agrave; votre administrateur syst&egrave;me), il
faudra faire <CODE>lrp -Pps fichier.ps</CODE>. Pour plus d'informations au sujet des
files d'impressions, allez &agrave; la section 
<A HREF="#Files d'impressions">Files d'impressions</A>.
</LI>
</UL>
</P>

<H2><A NAME="Programmer"></A> <A NAME="s5">5. Programmer</A></H2>


<P>Programmer sous Linux est <I>beaucoup</I> plus agr&eacute;able&nbsp;: il existe un grand
nombre d'outils qui rendent la programmation plus facile et plus rapide. Par
exemple, la torture qu'est le cycle &eacute;dition, sauvegarde, sortie de l'&eacute;diteur,
compilation, r&eacute;&eacute;dition, etc. peut &ecirc;tre raccourci en utilisant des &eacute;diteurs
comme <CODE>emacs</CODE> ou <CODE>jed</CODE>, comme nous l'avons vu au dessus.</P>

<H2><A NAME="ss5.1">5.1 Fortran</A>
</H2>


<P>Il n'y a pas de r&eacute;elle diff&eacute;rence pour le fortran, mais sachez qu'au
moment o&ugrave; j'&eacute;cris ces lignes, les compilateurs (libres) ne sont pas
totalement compatibles avec ceux de VMS&nbsp;; attendez-vous &agrave; quelques probl&egrave;mes
mineurs (en fait, le compilateur de VMS utilise des extensions qui ne sont pas
standard). Jetez un oeil &agrave; <CODE>/usr/doc/g77/DOC</CODE> ou
<CODE>/usr/doc/f2c/d2c.ps</CODE> pour plus de d&eacute;tails.</P>
<P>Votre administrateur a sans doute install&eacute; soit le compilateur natif <CODE>g77</CODE>
(bien, mais, au jour de la version 0.5.21, toujours pas parfaitement compatible
avec le Fortran de DEC), soit le traducteur de Fortran en C, <CODE>f2c</CODE>, et un
des ses front-ends qui font de lui une imitation de compilateur natif. D'apr&egrave;s
mon exp&eacute;rience, le paquetage <CODE>yaf77</CODE> est celui qui donne les meilleurs
r&eacute;sultats.</P>
<P>Pour compiler un source en Fortran avec <CODE>g77</CODE>, &eacute;ditez le et sauvez le avec
l'extension <CODE>.f</CODE>, et faites</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ g77 monprog.f
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Cela va cr&eacute;er par d&eacute;faut un ex&eacute;cutable appel&eacute; <CODE>a.out</CODE> (vous n'avez pas &agrave;
effectuer les liens). Pour donner &agrave; l'ex&eacute;cutable un nom diff&eacute;rent et faire
quelques optimisations&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ g77 -O2 -o monprog monprog.f
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>M&eacute;fiez-vous des optimisations&nbsp;! Demandez &agrave; votre administrateur syst&egrave;me de lire
la documentation fournie avec le compilateur et de vous dire s'il y a des
probl&egrave;mes. </P>
<P>Pour compiler une sous-routine&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ g77 -c masub.f
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Un fichier <CODE>masub.o</CODE> sera cr&eacute;&eacute;. Pour lier cette sous-routine &agrave; un
programme, vous devrez faire</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ g77 -o monprog monprog.f masub.o
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Si vous avez plusieurs sous-routines externes et que vous voulez cr&eacute;er une
biblioth&egrave;que, faites</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ cd sousroutines/
$ cat *f > mabib.f ; g77 -c mabib.f
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Le fichier <CODE>mabib.o</CODE> cr&eacute;&eacute; pourra alors &ecirc;tre li&eacute; &agrave; vos programmes.</P>
<P>Pour finir, pour lier une biblioth&egrave;que externe appel&eacute;e, disons,
<CODE>liblambda.so</CODE>&nbsp;, utilisez</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ g77 -o monprog monprog.f -llambda
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Si vous avez <CODE>f2c</CODE>, vous n'aurez qu'&agrave; utiliser <CODE>f77</CODE> ou <CODE>fort77</CODE>
&agrave; la place de <CODE>g77</CODE>.</P>
<P>Un autre outil de programmation utile est <CODE>make</CODE>. Il est d&eacute;crit ci-dessous.</P>

<H2><A NAME="ss5.2">5.2 Utiliser <CODE>make</CODE></A>
</H2>


<P><CODE>make</CODE> est un outil pour g&eacute;rer la compilation de programmes divis&eacute;s en
plusieurs fichiers sources.</P>
<P>Supposons que vous ayez des fichiers sources contenant vos routines appel&eacute;s
<CODE>fichier_1.f, fichier_2.f et fichier_3.f</CODE>, et un fichier source 
principal qui utilise ces routines appel&eacute; <CODE>monprog.f</CODE>. Si vous compilez
votre programme &agrave; la main, quand vous modifierez un fichier source vous allez
devoir chercher quel fichier d&eacute;pend de quel fichier, et les recompiler en
tenant compte des d&eacute;pendances.</P>
<P>Plut&ocirc;t que de devenir fou, je vous propose d'&eacute;crire un <I>makefile</I>. C'est un
fichier texte qui contient les d&eacute;pendances entre les 
sources&nbsp;: quand un source est modifi&eacute;, seuls les sources qui d&eacute;pendent du
fichier modifi&eacute; seront recompil&eacute;es.</P>
<P>Dans notre cas, le <I>makefile</I> ressemblerait &agrave; ceci&nbsp;:</P>
<P>
<HR>
<PRE>

# Voici le Makefile
# Attention : appuyez sur la touche tabulation quand « &lt;TAB> »
# est &eacute;crit ! C'est tr&egrave;s important : n'utilisez pas d'espace &agrave; la place.

monprog: monprog.o fichier_1.o fichier_2.o fichier_3.o
&lt;TAB>g77 -o monprog monprog.o fichier_1.o fichier_2.o fichier_3.o
# monprog d&eacute;pend de quatre fichiers objets

monprog.o: monprog.f
&lt;TAB>g77 -c monprog.f
# monprog.o d&eacute;pend de son fichier source

fichier_1.o: fichier_1.f
&lt;TAB>g77 -c fichier_1.f
# fichier_1.o d&eacute;pend de son fichier source

fichier_2.o: fichier_2.f fichier_1.o
&lt;TAB>g77 -c fichier_2.f fichier_1.o
# fichier_2.o d&eacute;pend de son fichier source et d'un fichier objet

fichier_3.o: fichier_3.f fichier_2.o
&lt;TAB>g77 -c fichier_3.f fichier_2.o
# fichier_3.o d&eacute;pend de son fichier source et d'un fichier objet

# fin du Makefile
</PRE>
<HR>
</P>
<P>Enregistrez ce fichier sous le nom <CODE>Makefile</CODE> et tapez <CODE>make</CODE> pour
compiler votre
programme. Vous pouvez aussi l'appeler <CODE>monprog.mak</CODE> et taper <CODE>make -f
monprog.mak</CODE>. Et bien s&ucirc;r, si vous voulez en savoir plus&nbsp;: <CODE>info make</CODE>.</P>

<H2><A NAME="ss5.3">5.3 Scripts <I>shell</I></A>
</H2>


<P>Les scripts <I>shell</I> sont les &eacute;quivalents des fichiers de commandes de VMS
et, pour changer, sont beaucoup plus puissants.</P>
<P>Pour &eacute;crire un script, tout ce que vous avez &agrave; faire est d'&eacute;crire un fichier au
format ASCII contenant les commandes, l'enregistrer et le rendre ex&eacute;cutable
(<CODE>chmod +x fichier</CODE>). Pour le lancer, tapez son nom (pr&eacute;c&eacute;d&eacute; de <CODE>./</CODE>
s'il n'est pas dans le <I>path</I>).</P>
<P>&Eacute;crire des scripts avec <CODE>bash</CODE> est un sujet tellement vaste qu'il
n&eacute;cessiterait un livre entier, et je ne ne vais pas m'attarder sur le
sujet. Je vais juste vous donner un exemple plus ou moins compr&eacute;hensible et, je
l'esp&egrave;re, utile, &agrave; partir duquel vous pourrez comprendre quelques r&egrave;gles de
base. </P>
<P>
<HR>
<PRE>
#!/bin/sh
# exemple.sh
# Je suis un commentaire.
# Ne modifiez pas la premi&egrave;re ligne, elle doit &ecirc;tre pr&eacute;sente.
echo "Ce syst&egrave;me est : `uname -a`" # utilise la sortie de la commande
echo "Mon nom est $0" # variable interne
echo "Vous m'avez donn&eacute; les $# param&egrave;tres suivants : "$*
echo "Le premier param&egrave;tre est : "$1
echo -n "Quel est votre nom ? " ; read votre_name
echo remarquez la diff&eacute;rence : "Salut $votre_name" # cit&eacute; avec "
echo remarquez la diff&eacute;rence : 'Salut $votre_name' # cit&eacute; avec '
REPS=0 ; FICHIERS=0
for fichier in `ls .` ; do
  if [ -d ${fichier} ] ; then # si le fichier est un r&eacute;pertoire
    REPS=`expr $REPS + 1`  # REPS = REPS + 1
  elif [ -f ${fichier} ] ; then
    FICHIER=`expr $FICHIER + 1`
  fi
  case ${fichier} in
    *.gif|*jpg) echo "${fichier}: fichier graphique" ;;
    *.txt|*.tex) echo "${fichier}: fichier texte" ;;
    *.c|*.f|*.for) echo "${fichier}: fichier source" ;;
    *) echo "${fichier}: fichier quelconque" ;;
  esac
done
echo "Il y a ${REPS} r&eacute;pertoires et ${FICHIERS} fichiers"
ls | grep "ZxY--!!!WKW"
if [ $? != 0 ] ; then # valeur de sortie de la derni&egrave;re commande
  echo "ZxY--!!!WKW n'a pas &eacute;t&eacute; trouv&eacute;"
fi
echo "&Ccedil;a suffit... tapez 'man bash' si vous voulez plus d'informations."
echo "Note du traducteur : 'info bash' est plus complet."
</PRE>
<HR>
</P>

<H2><A NAME="C"></A> <A NAME="ss5.4">5.4 C </A>
</H2>


<P>Linux est un excellent environnement pour la programmation en C. Si vous
connaissez le C, voici quelques conseils pour vous d&eacute;brouiller sous Linux. Pour
compiler le c&eacute;l&egrave;bre <CODE>hello.c</CODE> vous utiliserez le compilateur <CODE>gcc</CODE>, qui
est standard dans le monde de Linux et qui a la m&ecirc;me syntaxe que <CODE>g77</CODE>&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ gcc -O2 -o hello hello.c
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Pour lier une biblioth&egrave;que &agrave; un programme, ajoutez l'option
<CODE>-lbiblioth&egrave;que</CODE>.
Par exemple pour lier la biblioth&egrave;que math et optimiser faites</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ gcc -O2 -o mathprog mathprog.c -lm
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>(L'option <CODE>-lbiblioth&egrave;que</CODE> force <CODE>gcc</CODE> &agrave; lier la biblioth&egrave;que
<CODE>/usr/lib/libbiblioth&egrave;que.a</CODE>&nbsp;; ainsi <CODE>-lm</CODE> lie <CODE>/usr/lib/libm.a</CODE>.)</P>
<P>Quand votre programme est divis&eacute; en plusieurs fichiers sources, vous aurez
besoin 
du programme <CODE>make</CODE> d&eacute;crit juste au dessus.</P>
<P>Vous pouvez obtenir de l'aide sur quelques fonctions de la libc dans la
section&nbsp;3 des pages man. Par exemple&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ man 3 printf
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Il existe beaucoup de biblioth&egrave;ques disponible. Parmi les premi&egrave;res que vous
voudrez 
probablement utiliser, il y a <CODE>ncurses</CODE>, qui permet de g&eacute;rer quelques effets
du mode texte et <CODE>svgalib</CODE> pour faire du graphisme.</P>

<H2><A NAME="Graphiques"></A> <A NAME="s6">6. Graphiques </A></H2>


<P>Parmi la masse de paquetages de graphiques disponibles, <CODE>gnuplot</CODE> sort du
lot 
pour sa puissance et sa facilit&eacute; d'utilisation. Cr&eacute;ez tout d'abord deux
fichiers de donn&eacute;es&nbsp;: <CODE>2D-data.dat</CODE> (deux donn&eacute;es par ligne) et
<CODE>3D-data.dat</CODE> (trois par ligne). Puis, sous X, lancez <CODE>gnuplot</CODE>.</P>
<P>Exemple d'un graphe en 2D&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
gnuplot> set title "mon premier graphe"
gnuplot> plot '2D-data.dat'
gnuplot> plot '2D-data.dat' with linespoints
gnuplot> plot '2D-data.dat', sin(x)
gnuplot> plot [-5:10] '2D-data.dat'
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Exemple d'un graphe en 3D (chaque « ligne » de <I>x</I> valeurs est suivie
d'une ligne vide)&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
gnuplot> set parametric ; set hidden3d ; set contour
gnuplot> splot '3D-data.dat' using 1:2:3 with linespoints
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Un fichier de donn&eacute;es d'une seule colonne (une s&eacute;rie de temps par exemple) peut
aussi &ecirc;tre dessin&eacute; comme un graphe en 2D&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
gnuplot> plot [-5:15] '2D-data-1col.dat' with linespoints
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>ou en 3D (avec des lignes vides dans le fichier comme au dessus)&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
gnuplot> set noparametric ; set hidden3d
gnuplot> splot '3D-data-1col.dat' using 1 with linespoints
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Pour imprimez un graphe, si la commande pour imprimer sur votre imprimante
postscript est <CODE>lpr -Pps fichier.ps</CODE>, faites</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
gnuplot> set term post
gnuplot> set out '| lpr -Pps'
gnuplot> replot
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Tapez ensuite <CODE>set term x11</CODE> pour r&eacute;afficher sur votre serveur X. Ne soyez
pas d&eacute;concert&eacute;&nbsp;: la derni&egrave;re impression se lancera seulement quand vous
quitterez <CODE>gnuplot</CODE>.</P>
<P>Pour plus d'informations, tapez <CODE>help</CODE> ou regardez le r&eacute;pertoire des exemples
(<CODE>/usr/lib/gnuplot/demos/</CODE>) s'il existe.</P>

<H2><A NAME="Mail et Outils pour Internet"></A> <A NAME="s7">7. Mail et outils pour Internet</A></H2>


<P>Du fait qu'Internet est n&eacute; sur des machines Unix, on trouve plein
d'applications 
de qualit&eacute; et facile d'utilisation sous Linux. En voici quelques-unes&nbsp;:</P>
<P>
<UL>
<LI> Mail&nbsp;: utilisez <CODE>elm</CODE> ou <CODE>pine</CODE> (NDT&nbsp;: mutt est tr&egrave;s bien
aussi) pour g&eacute;rer votre courrier. Ces deux programmes ont une aide en ligne.
Pour des messages courts, vous pouvez utilisez <CODE>mail</CODE> (<CODE>mail
-s "Salut" utilisateur@quelquepart &lt; msg.txt</CODE>). Vous pr&eacute;f&eacute;rez peut-&ecirc;tre d'autres
programmes comme <CODE>xmail</CODE> ou &eacute;quivalent.
</LI>
<LI> Newsgroups&nbsp;: utilisez <CODE>tin</CODE> ou <CODE>slrn</CODE>. Ils sont tous les deux
tr&egrave;s intuitifs.
</LI>
<LI> FTP&nbsp;: en plus de l'in&eacute;vitable <CODE>ftp</CODE>, demandez &agrave; votre
administrateur d'installer l'excellent <CODE>ncftp</CODE> ou un m&ecirc;me un client
graphique comme <CODE>xftp</CODE>.
</LI>
<LI> WWW&nbsp;: <CODE>netscape</CODE>, <CODE>xmosaic</CODE>, <CODE>chimera</CODE> et <CODE>arena</CODE> sont
des browsers graphiques&nbsp;; <CODE>lynx</CODE> quant &agrave; lui utilise la console et est
rapide et pratique.
</LI>
</UL>
</P>

<H2><A NAME="Sujets avances"></A> <A NAME="s8">8. Sujets avanc&eacute;s </A></H2>


<P>L&agrave;, le jeu devient coriace. Apprenez &ccedil;a, et ensuite vous pourrez dire que
vous « connaissez quelque chose &agrave; Linux » ;-)</P>

<H2><A NAME="Droits et propriete"></A> <A NAME="ss8.1">8.1 Droits et propri&eacute;t&eacute; </A>
</H2>


<P>Les fichiers et les r&eacute;pertoires ont des droits et des propri&eacute;taires, comme 
sous VMS. Si nous ne pouvez pas lancer un programme, ne pouvez pas modifier
un fichier ou ne pouvez pas acc&eacute;der &agrave; un r&eacute;pertoire, c'est parce vous n'avez
pas les droits ad&eacute;quats pour le faire et/ou parce que le fichier ne vous
appartient pas. Regardez l'exemple suivant&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ ls -l /bin/ls
-rwxr-xr-x   1 root     bin         27281 Aug 15  1995 /bin/ls*
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Le premier champ indique les droits du fichier <CODE>ls</CODE>. Il y a trois types de
propri&eacute;t&eacute;&nbsp;: le propri&eacute;taire, le groupe et les autres (comme le
propri&eacute;taire, le groupe et le reste du monde sous VMS) et trois droits&nbsp;:
lecture, &eacute;criture et ex&eacute;cution.</P>
<P>De gauche &agrave; droite, <CODE>-</CODE>&nbsp;est le type du fichier  (<CODE>-</CODE> d&eacute;signe un fichier
ordinaire, 
<CODE>d</CODE> un r&eacute;pertoire, <CODE>l</CODE> un lien, etc.)&nbsp;; <CODE>rwx</CODE>&nbsp;sont les droits du
propri&eacute;taire (lecture, &eacute;criture, ex&eacute;cution)&nbsp;;  <CODE>r-x</CODE>&nbsp;sont les droits du
groupe du propri&eacute;taire (lecture, ex&eacute;cution)&nbsp;; <CODE>r-x</CODE>&nbsp;sont les droits pour
tous les autres utilisateurs (lecture, &eacute;criture).</P>
<P>Pour changer les droits d'un fichier&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ chmod &lt;quiXdroit> &lt;fichier>
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Avec <I>qui</I> repr&eacute;sentant <CODE>u</CODE> (ce sont alors les droits du propri&eacute;taire
qui sont affect&eacute;s),&nbsp;<CODE>g</CODE> (ceux du groupe) ou&nbsp;<CODE>o</CODE> (ceux des « autres 
»). X est soit&nbsp;<CODE>+</CODE> (dans ce cas il donne les droits), soit&nbsp;<CODE>-</CODE> (il
les enl&egrave;ve). Et <I>droit</I> est <CODE>r</CODE>,&nbsp;<CODE>w</CODE> ou&nbsp;<CODE>x</CODE>. Voici un exemple&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ chmod u+x fichier
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Cela permet de rendre le fichier ex&eacute;cutable pour le propri&eacute;taire. Il existe un
petit raccourci <CODE>chmod +x fichier</CODE>.</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ chmod go-wx fichier
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>L&agrave;, on enl&egrave;ve les droits d'&eacute;criture et d'ex&eacute;cution au groupe et aux autres
(donc &agrave; tout le monde sauf au propri&eacute;taire).</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ chmod ugo+rwx fichier
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Tous les droits sont donn&eacute;s &agrave; tout le monde.</P>
<P>Une mani&egrave;re plus courte de pr&eacute;ciser les droits se base sur les nombres&nbsp;:
<CODE>rwxr-xr-x</CODE> peut &ecirc;tre exprim&eacute; par 755 (chaque lettre correspond &agrave; un bit&nbsp;:
<CODE>---</CODE> vaut 0, <CODE>--x</CODE> 1, <CODE>-w-</CODE> 2, etc).</P>
<P>Pour un r&eacute;pertoire, <CODE>rx</CODE> signifie que vous pouvez vous placer dans ce
r&eacute;pertoire et <CODE>w</CODE> que vous pouvez effacer un fichier dans ce r&eacute;pertoire (en
tenant compte des droits du fichier &eacute;videmment) ou le r&eacute;pertoire lui-m&ecirc;me. Tout
&ccedil;a n'est qu'une petit partie du sujet&nbsp;: man est votre ami.</P>
<P>Pour changer le propri&eacute;taire d'un fichier&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ chown &lt;utilisateur> &lt;fichier>
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Pour r&eacute;sumer, voici un tableau&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
VMS                             Linux           
------------------------------------------------------------------------------

SET PROT=(O:RW) fichier.txt     $ chmod u+rw fichier.txt
                                $ chmod 600 fichier.txt
SET PROT=(O:RWED,W) fichier     $ chmod u+rwx fichier
                                $ chmod 700 fichier
SET PROT=(O:RWED,W:RE) fichier  $ chmod 755 fichier
SET PROT=(O:RW,G:RW,W) fichier  $ chmod 660 fichier
SET FILE/OWNER_UIC=JOE fichier  $ chown joe fichier
SET DIR/OWNER_UIC=JOE [.dir]    $ chown joe rep/
</PRE>
</CODE></BLOCKQUOTE>
</P>


<H2><A NAME="Multitache"></A> <A NAME="ss8.2">8.2 Multit&acirc;che&nbsp;: processus et t&acirc;ches (<I>jobs</I>) </A>
</H2>


<P>En voici plus &agrave; propos de la mani&egrave;re de lancer les programmes. Il n'y a pas de
file 
d'attente sous Linux&nbsp;; le multit&acirc;che est g&eacute;r&eacute; tr&egrave;s diff&eacute;remment. Voici &agrave; quoi
ressemble une ligne de commande typique&nbsp;: </P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ commande -s1 -s2 ... -sn par1 par2 ... parn &lt; entr&eacute;e > sortie &amp;
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Maintenant, voyons comment marche le multit&acirc;che. Les programmes qui tournent en
avant-plan (<I>foreground</I>) ou arri&egrave;re-plan (<I>background</I>) sont appel&eacute;s des
processus. </P>
<P>
<UL>
<LI> Pour lancer un processus en arri&egrave;re plan&nbsp;:

<BLOCKQUOTE><CODE>
<PRE>
$ programme [option] [&lt; entr&eacute;e] [> sortie] &amp;
[1] 234
</PRE>
</CODE></BLOCKQUOTE>


Le shell vous donne le num&eacute;ro de <I>job</I> (le premier nombre&nbsp;; regardez
ci-dessus) et le PID (le num&eacute;ro du processus). Chaque processus est identifi&eacute;
par son PID.

Pour voir combien de processus sont lanc&eacute;s&nbsp;:

<BLOCKQUOTE><CODE>
<PRE>
$ ps -ax
</PRE>
</CODE></BLOCKQUOTE>


La liste des processus actifs va &ecirc;tre affich&eacute;e.
</LI>
<LI> Pour tuer un processus&nbsp;:

<BLOCKQUOTE><CODE>
<PRE>
$ kill &lt;PID>
</PRE>
</CODE></BLOCKQUOTE>


Vous aurez peut-&ecirc;tre besoin de tuer un processus quand vous ne savez pas le
quitter de la bonne mani&egrave;re... ;-) Parfois, une processus sera seulement tu&eacute;
par une des commandes suivantes&nbsp;:

<BLOCKQUOTE><CODE>
<PRE>
$ kill -15 &lt;PID>
$ kill -9 &lt;PID>
</PRE>
</CODE></BLOCKQUOTE>

</LI>
</UL>
</P>
<P>En plus de &ccedil;a, le shell vous permet de stopper ou de suspendre temporairement
un processus, envoyer un processus en arri&egrave;re-plan ou en ramener un en
avant-plan. Dans ce contexte, les processus sont appel&eacute;es <CODE>jobs</CODE>.</P>
<P>
<UL>
<LI> Pour voir combien de <I>jobs</I> sont actifs&nbsp;:

<BLOCKQUOTE><CODE>
<PRE>
$ jobs
</PRE>
</CODE></BLOCKQUOTE>


Les <I>jobs</I> sont identif&eacute;s par le nombre que le shell leur donne et non pas
par leur PID.
</LI>
<LI> Pour stopper un processus qui tourne en avant-plan appuyez sur
<SF>ctrl&nbsp;+&nbsp;c</SF>. (&Ccedil;a ne marche pas toujours.)
</LI>
<LI> Pour suspendre un processus tournant en avant-plan appuyez sur
<SF>ctrl&nbsp;+&nbsp;z</SF> (Idem.)
</LI>
<LI> Pour envoyer un processus suspendu en arri&egrave;re-plan (qui devient alors un
<I>job</I>)&nbsp;: 

<BLOCKQUOTE><CODE>
<PRE>
$ bg &lt;job>
</PRE>
</CODE></BLOCKQUOTE>

</LI>
<LI> Pour envoyer un <I>job</I> en avant-plan&nbsp;:

<BLOCKQUOTE><CODE>
<PRE>
$ fg &lt;job>
</PRE>
</CODE></BLOCKQUOTE>

</LI>
<LI> Pour tuer un <I>job</I>&nbsp;:

<BLOCKQUOTE><CODE>
<PRE>
$ kill %&lt;job>
</PRE>
</CODE></BLOCKQUOTE>

</LI>
</UL>
</P>

<H2><A NAME="ss8.3">8.3 Fichiers, deuxi&egrave;me</A>
</H2>


<P>Voici plus d'information sur les fichiers.</P>
<P>
<UL>
<LI> <I>stdin</I>, <I>stdout</I> et <I>stderr</I>&nbsp;: sous Unix, tous les composants
du syst&egrave;me 
sont assimil&eacute;s &agrave; des fichiers. Les commandes et les programmes
puisent leur entr&eacute;e dans un « fichier » appel&eacute; <I>stdin</I>
(l'entr&eacute;e standard&nbsp;: g&eacute;n&eacute;ralement le clavier), redirigent leur sortie vers un
« fichier » appel&eacute; <I>stdout</I> (g&eacute;n&eacute;ralement l'&eacute;cran) et leurs
erreurs vers un « fichier » appel&eacute; <I>stderr</I> (g&eacute;n&eacute;ralement 
l'&eacute;cran). 

En utilisant <CODE>&lt;</CODE> et <CODE>></CODE> vous redirigez l'entr&eacute;e et la sortie vers
un fichier diff&eacute;rent. De plus, <CODE>>></CODE> ajoute la sortie &agrave; un fichier &agrave; la
place de l'&eacute;craser&nbsp;; <CODE>2></CODE> redirige les messages d'erreur (<I>stderr</I>)&nbsp;;
2>&amp;1 redirige <I>stderr</I> vers <I>stdout</I>, alors que 1>&amp;2
redirige <I>stdout</I> vers <I>stderr</I>. Il y a un « trou noir » appel&eacute; <CODE>/dev/null</CODE>&nbsp;: tout ce qui est redirigez vers lui dispara&icirc;t.
</LI>
<LI> Jokers/&nbsp;: sur la ligne de commande <CODE>*</CODE> correspond &agrave; (et d&eacute;signe) tous
les fichiers sauf ceux qui sont cach&eacute;s&nbsp;; <CODE>.*</CODE> correspond &agrave; tous les fichiers
cach&eacute;s&nbsp;; <CODE>*.*</CODE> correspond seulement ceux qui ont un « . » au
milieu de leur nom suivi par d'autres caract&egrave;res&nbsp;; <CODE>l*c</CODE> correspondra &agrave;
« lo&iuml;c » et « luc »&nbsp;; <CODE>*c*</CODE> correspondra &agrave;
« piocher » et « picorer ». <CODE>%</CODE> devient <CODE>?</CODE>.
Il existe &eacute;galement un autre joker&nbsp;: <CODE>[]</CODE>. Par exemple&nbsp;:
<CODE>[abc]*</CODE> d&eacute;signe les fichiers commen&ccedil;ant par a, b ou c&nbsp;;
<CODE>*[I-N123]</CODE> d&eacute;signe les fichier finissant par I, J, K, L, M, N, 1, 2 ou 3.
</LI>
<LI><CODE>mv</CODE> (<CODE>RENAME</CODE>) ne permet pas de renommer plusieurs fichiers d'un
coup. Ainsi, <CODE>mv *.xxx *.yyy</CODE> ne marchera pas.
</LI>
<LI> Utilisez <CODE>cp -i</CODE> et <CODE>mv -i</CODE> pour &ecirc;tre pr&eacute;venu quand
un fichier va &ecirc;tre &eacute;cras&eacute;.
</LI>
</UL>
</P>

<H2><A NAME="Files d'impressions"></A> <A NAME="ss8.4">8.4 Files d'impression </A>
</H2>


<P>Vos fichiers &agrave; imprimer sont plac&eacute;s dans une file comme sous VMS.
Quand vous lancez une commande d'impression, vous aurez peut-&ecirc;tre
&agrave; pr&eacute;ciser le nom de l'imprimante. Par exemple</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ lpr fichier.txt # ce fichier est plac&eacute; dans la file de l'imprimante standard
$ lpr -Plaser fichier.ps # celui dans celle de l'imprimante « laser »
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Pour g&eacute;rer la file d'impression utilisez les commandes suivantes&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
VMS                                     Linux
------------------------------------------------------------------------------

$ PRINT fichier.ps                      $ lpr fichier.ps
$ PRINT/QUEUE=laser fichier.ps          $ lpr -Plaser fichier.ps
$ SHOW QUEUE                            $ lpq
$ SHOW QUEUE/QUEUE=laser                $ lpq -Plaser
$ STOP/QUEUE                            $ lprm &lt;num&eacute;ro de job>
</PRE>
</CODE></BLOCKQUOTE>
</P>

<H2><A NAME="Configurer"></A> <A NAME="s9">9. Configurer </A></H2>


<P>Votre administrateur syst&egrave;me a d&ucirc; vous fournir certains fichier de
configuration comme <CODE>.xinitrc</CODE>, <CODE>.bash_profile</CODE> et <CODE>.inputrc</CODE>. Ceux
que vous voudrez peut-&ecirc;tre modifier sont&nbsp;: </P>
<P>
<UL>
<LI> <CODE>.bash_profile</CODE> ou <CODE>.profile</CODE>&nbsp;: ce fichier est lu par le shell au
moment du login. C'est l'&eacute;quivalent de <CODE>LOGIN.COM</CODE>.
</LI>
<LI> <CODE>.bash_logout</CODE>&nbsp;: celui-ci est lu en fin de session. C'est
l'&eacute;quivalent 
de <CODE>LOGOUT.COM</CODE>.
</LI>
<LI> <CODE>.bashrc</CODE>&nbsp;: il est lu par les shells non interactifs
</LI>
<LI> <CODE>.inputrc</CODE>&nbsp;: ce fichier configure les r&ocirc;les des touches du
clavier et le comportement du shell.
</LI>
</UL>
</P>
<P>Pour vous donner un exemple, j'ai inclus une partie mon <CODE>.bash_profile</CODE>&nbsp;:</P>
<P>
<HR>
<PRE>
# $HOME/.bash_profile

# on ne red&eacute;finit pas le path si ce n'est pas n&eacute;cessaire
echo $PATH | grep $LOGNAME > /dev/null
if [ $? != 0 ]
then
  export PATH="$PATH:/home/$LOGNAME/bin"  # ajoute mon r&eacute;pertoire au path
fi

export PS1='LOGNAME:\w\$ '
export PS2='Continued...>'

# alias

alias bin="cd ~/bin" ; alias cp="cp -i" ; alias d="dir"
alias del="delete" ; alias dir="/bin/ls $LS_OPTIONS --format=vertical"
alias ed="jed" ; alias mv='mv -i'
alias u="cd .." ; alias undel="undelete"

# Quelques fonctions utiles

inst() # installe un tarball gzip&eacute; dans le r&eacute;pertoire courant
{
  tar xvfz $1
}
cz() # liste le contenu d'une archive .zip
{
  unzip -l $*
}
ctgz() # liste le contenu d'un tarball gzip&eacute;
{
  for fichier in $* ; do
    tar tfz ${fichier}
  done
}
tgz() # cr&eacute;e une archive .tgz &agrave; la zip.
{
  nom=$1 ; tar cvf $1 ; shift
  tar -rf ${nom} $* ; gzip -S .tgz ${nom}
}
</PRE>
<HR>
</P>
<P>Et voici mon <CODE>.inputrc</CODE>&nbsp;:</P>
<P>
<HR>
<PRE>
# $HOME/.inputrc
#
# Ce fichier est lu par bash et d&eacute;finit les fonctions attach&eacute;s aux touches
# par le shell ; ce qui suit permet d'avoir un comportement courant pour
# les touches &lt;it/fin/, &lt;it/home/ (la touche au dessus de fin), &lt;it/suppr/
# et les caract&egrave;res accentu&eacute;s. 
# Pour plus d'information, man readline.

"\e[1~": beginning-of-line
"\e[3~": delete-char
"\e[4~": end-of-line

set bell-style visible
set meta-flag On
set convert-meta Off
set output-meta On
set horizontal-scroll-mode On
set show-all-if-ambiguous On

# (F1 .. F5) sont "\e[[A" ... "\e[[E"

"\e[[A": "info "
</PRE>
<HR>
</P>

<H2><A NAME="Programmes utiles"></A> <A NAME="s10">10. Programmes utiles</A></H2>



<H2><A NAME="ss10.1">10.1 Visionneur de fichiers&nbsp;: <CODE>less</CODE></A>
</H2>


<P>Vous utiliserez un tel programme tous les jours, c'est pourquoi je vais vous
donner 
quelques astuces pour l'utiliser au mieux. Avant tout, demandez &agrave; votre
administrateur de configurer <CODE>less</CODE> pour qu'il puisse afficher non seulement
des fichiers textes mais aussi les fichiers compress&eacute;s, les archives, etc.</P>
<P>Comme les derni&egrave;res versions de <CODE>TYPE</CODE>, <CODE>less</CODE> vous permet de vous
d&eacute;placer dans le fichier dans les deux directions. Il accepte aussi plusieurs
commandes qui 
sont lanc&eacute;es en appuyant sur une touche. Les plus utilis&eacute;s sont&nbsp;:</P>
<P>
<UL>
<LI> tout d'abord, appuyez sur <SF>q</SF> pour quitter&nbsp;;
</LI>
<LI> <SF>h</SF> pour obtenir l'aide&nbsp;;
</LI>
<LI> <SF>g</SF> pour aller au d&eacute;but du fichier, <SF>G</SF> &agrave; la fin, un nombre suivi
de <CODE>g</CODE> pour aller &agrave; cette ligne (par exemple <CODE>125g</CODE>), un nombre suivi
de <CODE>%</CODE> pour aller &agrave; ce pourcentage du fichier&nbsp;;
</LI>
<LI> <CODE>/motif</CODE> recherche vers l'avant le motif&nbsp;; <CODE>n</CODE> recherche vers
l'avant la l'occurrence suivante&nbsp;; <CODE>?pattern</CODE> et <CODE>N</CODE> font la m&ecirc;me chose
vers l'arri&egrave;re&nbsp;;
</LI>
<LI> <CODE>m</CODE> suivi d'une lettre marque la position courante (par exemple
<CODE>ma</CODE>)&nbsp;;
<CODE>'</CODE> suivi de la m&ecirc;me lettre rappelle cette position&nbsp;;
</LI>
<LI> <CODE>:e</CODE> ouvre un autre fichier&nbsp;;
</LI>
<LI> <CODE>!commande</CODE> ex&eacute;cute un shell.
</LI>
</UL>
</P>


<H2><A NAME="Numeros de version sous Linux"></A> <A NAME="ss10.2">10.2 Num&eacute;ros de version sous Linux</A>
 </H2>


<P>H&eacute;las, Linux ne supporte toujours pas les num&eacute;ros de version nativement.
Cependant, on peut r&eacute;gler ce probl&egrave;me de deux mani&egrave;res. La premi&egrave;re est
d'utiliser RCS (Revision Control System) qui vous permet de garder la trace
des pr&eacute;c&eacute;dentes versions d'un fichier. RCS est trait&eacute; dans <I>Le mini-Howto
RCS</I>.</P>
<P>La seconde est d'utiliser un &eacute;diteur qui sait traiter les num&eacute;ros de version.
<CODE>emacs</CODE> ou <CODE>joe</CODE> feront l'affaire. Pour emacs, ajoutez ces lignes dans
votre <CODE>.emacs</CODE>.</P>
<P>
<HR>
<PRE>
(setq version-control t)
(setq kept-new-versions 15) ;;; ou toute autre valeur
(setq kept-old-versions 15)
(setq backup-by-copying-when-linked t)
(setq backup-by-copying-when-mismatch t)
</PRE>
<HR>
</P>
<P>Pour jed, v&eacute;rifiez que vous avez une version sup&eacute;rieure &agrave; la 0.98.7. Le patch
pour les num&eacute;ros de version est disponible sur <CODE>
<A HREF="http://ibogeo.df.unibo.it/guido/slang/backups.sl">http://ibogeo.df.unibo.it/guido/slang/backups.sl</A></CODE> </P>

<H2><A NAME="ss10.3">10.3 Archiver&nbsp;: tar et gzip</A>
</H2>


<P>Sous Unix il existe quelques applications tr&egrave;s r&eacute;pandues qui sont utilis&eacute;s pour
archiver et compresser des fichiers. <CODE>tar</CODE> est utilis&eacute; pour faire des
archives (c'est &agrave; dire un regroupement de fichiers). Pour faire une
archive&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ tar -cvf &lt;archive.tar> &lt;fichier> [fichier...]
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Pour extraire des fichiers d'une archive&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ tar -xpvf &lt;archive.tar> [fichier...]
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Pour lister le contenu d'une archive&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ tar -tf &lt;archive.tar> | less
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Les fichiers peuvent &ecirc;tre compress&eacute;s en utilisant <CODE>compress</CODE> ou <CODE>gzip</CODE>.
<CODE>compress</CODE> est aujourd'hui obsol&egrave;te et on n'utilise plus que <CODE>gzip</CODE>.</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ compress &lt;fichier>
$ gzip &lt;fichier>
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Ceci cr&eacute;era un fichier compress&eacute; avec l'extension&nbsp;.Z (pour <CODE>compress</CODE>)
ou&nbsp;.gz (pour <CODE>gzip</CODE>). Ces programmes ne font pas d'archives mais compressent
des fichiers individuellement. Pour d&eacute;compresser utilisez</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ compress -d &lt;fichier.Z>
$ gzip -d &lt;fichier.gz>
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Faites un tour du c&ocirc;t&eacute; de leurs pages man.</P>
<P>Les utilitaires <CODE>unarj</CODE>, <CODE>zip</CODE> et <CODE>unzip</CODE> sont aussi disponibles. </P>
<P>Les fichier avec l'extension <CODE>.tar.gz</CODE> ou <CODE>.tgz</CODE> (archiv&eacute;s par <CODE>tar</CODE>,
puis compress&eacute;s par <CODE>gzip</CODE>) sont
tr&egrave;s communs dans le monde Unix. Voici comment lister le contenu d'une telle
archive&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ tar -ztf &lt;fichier.tar.gz> | less
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Pour extraire les fichiers &agrave; partir d'un <CODE>.tar.gz</CODE>&nbsp;:</P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
$ tar -zxf &lt;fichier.tar.gz>
</PRE>
</CODE></BLOCKQUOTE>
</P>

<H2><A NAME="Exemples"></A> <A NAME="s11">11. Exemples du monde r&eacute;el </A></H2>


<P>Le principe central d'Unix est qu'il existe plusieurs commandes simples qui
peuvent &ecirc;tre li&eacute;es ensemble gr&acirc;ce aux <I>pipes</I> et aux redirections pour
accomplir 
des t&acirc;ches plus compliqu&eacute;es. Regardez les exemples suivants (je n'expliquerai
que les plus compliqu&eacute;s&nbsp;; pour les autres, reportez vous aux sections
pr&eacute;c&eacute;dentes ou aux pages man).</P>
<P>
<UL>
<LI><CODE>ls</CODE> est trop rapide et je ne peux pas lire le nom de tous
les fichiers.

<BLOCKQUOTE><CODE>
<PRE>
$ ls | less
</PRE>
</CODE></BLOCKQUOTE>

</LI>
<LI> J'ai un fichier qui contient une liste de mots. Je veux les
trier dans l'ordre inverse et les imprimer.

<BLOCKQUOTE><CODE>
<PRE>
$ cat fichier.txt | sort -r | lpr
</PRE>
</CODE></BLOCKQUOTE>

</LI>
<LI> Mon fichier de donn&eacute;es contient des doublons. Comment les
effacer&nbsp;?

<BLOCKQUOTE><CODE>
<PRE>
$ sort fichier.dat | uniq > nouveaufichier.dat
</PRE>
</CODE></BLOCKQUOTE>

</LI>
<LI> J'ai un fichier appel&eacute; papier.txt ou papier.tex ou quelques choses dans
le genre mais je ne m'en rappelle plus. Comment le retrouver&nbsp;?

<BLOCKQUOTE><CODE>
<PRE>
$ find ~ -name "papier*" 
</PRE>
</CODE></BLOCKQUOTE>


Expliquons. <CODE>find</CODE> est une commande tr&egrave;s utile qui liste tous les fichier
dans une arborescence (qui commence &agrave; partir du r&eacute;pertoire <I>home</I> dans ce
cas). Sa sortie peut-&ecirc;tre filtr&eacute;e selon plusieurs crit&egrave;res comme par exemple
<CODE>-name</CODE>. 
</LI>
<LI> J'ai un fichier texte qui contient le mot «&nbsp;entropie&nbsp;» dans
ce r&eacute;pertoire. Existe-t-il quelque chose de comparable &agrave; 
<CODE>SEARCH</CODE>&nbsp;?

Bien s&ucirc;r, essayez cela&nbsp;:

<BLOCKQUOTE><CODE>
<PRE>
$ grep -l 'entropie' *
</PRE>
</CODE></BLOCKQUOTE>

</LI>
<LI> Quelque part, j'ai un fichier texte qui contient le mot
«&nbsp;entropy&nbsp;» et j'aimerai le retrouver. Sous VMS j'aurais utilis&eacute;
<CODE>search entropy [...]*.*.*</CODE>, mais <CODE>grep</CODE> n'est pas r&eacute;cursif.

<BLOCKQUOTE><CODE>
<PRE>
$ find . -exec grep -l "entropy" {} \; 2> /dev/null
</PRE>
</CODE></BLOCKQUOTE>


<CODE>find .</CODE> sort tous les noms des fichiers &agrave; partir du
r&eacute;pertoire courant, <CODE>-exec grep -l "entropy"</CODE> lance une commande sur chacun
des fichiers (repr&eacute;sent&eacute;s par <CODE>{}</CODE>), <CODE>\</CODE> termine la
commande). Si vous pensez que la syntaxe est horrible... vous avez raison :-)

Vous auriez aussi pu &eacute;crire le script suivant&nbsp;:

<HR>
<PRE>
#!/bin/sh
# rgrep: grep r&eacute;cursif
if [ $# != 3 ]
then
  echo "Utilisation : rgrep &lt;param&egrave;tres> &lt;motif> &lt;r&eacute;pertoire>"
  exit 1
fi
find $3 -name "*" -exec grep $1 $2 {} \; 2> /dev/null
</PRE>
<HR>


Voici l'explication. <CODE>grep</CODE> marche comme <CODE>SEARCH</CODE> et combin&eacute; avec
<CODE>find</CODE> nous obtenons le meilleur des deux mondes.
</LI>
<LI> J'ai un fichier qui a deux lignes d'en-t&ecirc;te et qui a ensuite <I>n</I>
donn&eacute;es par ligne, pas n&eacute;cessairement espac&eacute;es de la m&ecirc;me mani&egrave;re. Je veux
extraire la deuxi&egrave;me et le cinqui&egrave;me champs de chaque ligne. Dois-je &eacute;crire un
programme en Fortran&nbsp;? 

Nan. Ceci est plus rapide&nbsp;:

<BLOCKQUOTE><CODE>
<PRE>
$ awk 'NL > 2 {print $2, "\t", $5}' fichier.dat > nouveaufichier.dat
</PRE>
</CODE></BLOCKQUOTE>


<CODE>awk</CODE> est en fait un langage de programmation. Pour chaque ligne &agrave; partir de
la troisi&egrave;me, on affiche le second et le cinqui&egrave;me champ en les s&eacute;parant par
une tabulation. Apprenez &agrave; vous servir de awk --- il vous fera gagner beaucoup
de temps.
</LI>
<LI> J'ai t&eacute;l&eacute;charg&eacute; le <CODE>ls-lR.gz</CODE> d'un FTP. Pour chaque sous
r&eacute;pertoire, il y a une ligne «&nbsp;total <I>x</I>&nbsp;», avec <I>x</I> la
taille en Kilo-octets du r&eacute;pertoire. J'aimerais avoir le total de toutes ces
valeurs.

<BLOCKQUOTE><CODE>
<PRE>
zcat ls-lR.gz | awk ' $1 == "total" { i += $2 } END {print i}'
</PRE>
</CODE></BLOCKQUOTE>


<CODE>zcat</CODE> sort le contenu du fichier <CODE>.gz</CODE>. La sortie est envoy&eacute;e
vers awk dont je vous recommande chaudement de lire la page man.
</LI>
<LI> J'ai &eacute;crit un programme en Fortran, <CODE>monprog</CODE>, pour
calculer un param&egrave;tre &agrave; partir d'un fichier de donn&eacute;es. Je voudrais le lancer
sur des centaines de fichiers et avoir la liste des r&eacute;sultats, mais c'est une
calamit&eacute; de demander chaque fois le nom du fichier. Sous VMS, j'aurais &eacute;crit un
long fichier de commande. Et sous Linux&nbsp;?

Un script tr&egrave;s court. Faites votre programme pour qu'il cherche
le programme mesdonn&eacute;es.dat et pour qu'il afficher le r&eacute;sultat sur l'&eacute;cran
(stdout) et &eacute;crivez ensuite ce petit script&nbsp;:

<HR>
<PRE>
#!/bin/sh
# monprog.sh: lance la m&ecirc;me commande sur plusieurs fichiers
# usage: monprog.sh *.dat
for fichier in $*  # pour tous les param&egrave;tres (e.g. *.dat)
do
  # ajouter le nom du fichier dans r&eacute;sultat.dat
  echo -n "${fichier}:    " >> r&eacute;sultats.dat
  # copie le param&egrave;tre courant dans mesdonn&eacute;es.dat et lance monprog 
  # et ajoute le sortie &agrave; r&eacute;sultats.dat
  cp ${fichier} mesdonn&eacute;es.dat ; monprog >> r&eacute;sultats.dat
done
</PRE>
<HR>

</LI>
<LI> Je veux remplacer «&nbsp;g&eacute;ologie&nbsp;» par
«&nbsp;g&eacute;ophysique&nbsp;» dans tous mes fichiers textes. Dois-je les &eacute;diter 
manuellement&nbsp;?

Nan. &Eacute;crivez ce script&nbsp;:

<HR>
<PRE>
#!/bin/sh
# remplace $1 par $2 dans $*
# utilisation : remplace "vieux-motif" "nouveau-motif" fichier [fichier...]
VIEUX=$1           # premier param&egrave;tre
NOUVEAU=$2         # second
shift ; shift      # enlever les deux premier param&egrave;tres ; les suivants sont
                   # les noms des fichiers
for fichier in $*  # pour tous les fichier donn&eacute;s en param&egrave;tres
do
# remplace toutes les occurrences de VIEUX par NOUVEAU et sauve cela
# dans un fichier temporaire
  sed "s/$VIEUX/$NOUVEAU/g" ${fichier} > ${fichier}.nouveau
# renommer le fichier temporaire
  /bin/mv ${fichier}.new ${fichier}
done
</PRE>
<HR>

</LI>
<LI> J'ai des fichier contenant des donn&eacute;es. Je ne connais pas leur
taille et je dois enlever leur avant-derni&egrave;re et leur avant-avant-derni&egrave;re
lignes. Heu... &agrave; la mimine&nbsp;?

Bien s&ucirc;r que non&nbsp;:

<HR>
<PRE>
#!/bin/sh
# prune.sh: efface les n-1&egrave;me et n-2&egrave;me ligne de fichiers
# utilisation : prune.sh fichier [fichier...]
for fichier in $*   # pour chaque param&egrave;tre
do
  LIGNES=`wc -l $fichier | awk '{print $1}'`  # nombre de ligne dans fichier
  LIGNES=`expr $LIGNES - 3`                   # LIGNES = LIGNES - 3
  head -n $LIGNES $fichier > $fichier.new     # sort les premi&egrave;res lignes
                                              # de LIGNES
  tail -n 1 $fichier >> $fichier.new          # ajoute la derni&egrave;re ligne
done
</PRE>
<HR>


NDT&nbsp;: il est tout de m&ecirc;me beaucoup plus &eacute;l&eacute;gant d'utiliser <CODE>ed</CODE>&nbsp;:

<HR>
<PRE>
#!/bin/sh
# prune.sh: efface les n-1&egrave;me et n-2&egrave;me ligne de fichiers
# utilisation : prune.sh fichier [fichier...]
for fichier in $*   # pour chaque param&egrave;tre
do
  printf '$-2,$-1d\nw\nq\n' | ed -s $fichier
done
</PRE>
<HR>

</LI>
</UL>
</P>
<P>J'esp&egrave;re que ces exemples vous auront ouvert l'app&eacute;tit.</P>

<H2><A NAME="s12">12. Astuces dont on ne peut se passer</A></H2>


<P>
<UL>
<LI> La compl&eacute;tion de commande&nbsp;: l'appui sur la touche tabulation quand
vous tapez une commande va compl&eacute;ter la ligne de commande. Par exemple, disons
que vous devez taper <CODE>less un_nom_de_fichier_tr&egrave;s_long</CODE>. Il vous suffira
de taper <CODE>less un</CODE> puis d'appuyer sur tabulation (si vous avez plusieurs
fichier qui commencent par les m&ecirc;mes caract&egrave;res tapez-en assez pour r&eacute;soudre
l'ambigu&iuml;t&eacute;).
</LI>
<LI> Faire d&eacute;filer l'&eacute;cran vers le haut&nbsp;: en appuyant sur Shift-Page_up 
vous pouvez faire d&eacute;filer l'&eacute;cran vers le haut de quelques pages (le nombre de
page d&eacute;pend de la m&eacute;moire vid&eacute;o de votre PC).
</LI>
<LI> R&eacute;tablir l'&eacute;cran&nbsp;: s'il vous arrive de faire un <CODE>more</CODE> ou un
<CODE>cat</CODE> sur un fichier binaire votre &eacute;cran pourra se retrouver plein de
symboles bizarres. Pour arranger les choses, &agrave; l'aveuglette tapez
<CODE>reset</CODE> ou cette s&eacute;quence de caract&egrave;res&nbsp;: <CODE>echo ctrl-v Echap c Entr&eacute;e</CODE>.
</LI>
<LI> Copier du texte sur la console&nbsp;: demandez &agrave; votre administrateur
d'installer <CODE>gpm</CODE>, un driver pour la souris en mode texte. Cliquez et
glissez pour s&eacute;lectionner du texte et ensuite appuyez sur le bouton droit pour
coller le texte s&eacute;lectionn&eacute;. &Ccedil;a marche entre plusieurs consoles virtuelles.
</LI>
<LI> Copier du texte sous X&nbsp;: cliquez et glissez pour s&eacute;lectionnez le texte
dans un <CODE>xterm</CODE> et cliquez ensuite sur le bouton du milieu (ou les deux
boutons) pour coller.
</LI>
</UL>
</P>

<H2><A NAME="s13">13. Lire des bandes VMS depuis Linux</A></H2>

<P>(Cette section a &eacute;t&eacute; &eacute;crite par Mike Miller)</P>

<H2><A NAME="ss13.1">13.1 Introduction</A>
</H2>


<P>De temps en temps vous pourrez &ecirc;tre amen&eacute; &agrave; lire des bandes enregistr&eacute;es &agrave;
partir d'une machine sous VMS (ou des bandes enregistr&eacute;es pour &ecirc;tre lisibles
sous VMS et les syst&egrave;mes Unix). En g&eacute;n&eacute;ral, c'est assez facile pour les bandes
DECFILES11A.</P>
<P>Bien que l'on puisse lire ceci comme une partie d'un mini-HOWTO Linux, je crois
que les informations ici pr&eacute;sent&eacute;es sont appliquables &agrave; tout syst&egrave;me Unix
-- j'ai fait cela avec Linux et les syst&egrave;mes Unix d'HP, de SUN et de DEC. La
principale d&eacute;pendance &agrave; la plate-forme est le nom des
fichiers p&eacute;riph&eacute;riques qui peuvent varier d'un syst&egrave;me &agrave; l'autre, et les
options de <CODE>mt</CODE> pour sp&eacute;cifier le nom du p&eacute;riph&eacute;rique (par exemple, <CODE>mt
-f</CODE> avec Linux et <CODE>mt -t</CODE> sur HPUX 9).</P>
<P>Avertissement&nbsp;: j'ai seulement essay&eacute; cela avec des lecteurs de bande Exabyte
8&nbsp;mm SCSI. Si vous avez lu d'autres formats (vous avez encore des lecteurs
9&nbsp;pistes qui tra&icirc;nent quelque part&nbsp;?), faites-le moi savoir et je les 
ajouterai.  </P>

<H2><A NAME="ss13.2">13.2 Les bases</A>
</H2>


<P>Pour lire une bande qui a &eacute;t&eacute; &eacute;crite avec la commande <CODE>copy</CODE> de VMS
(ou une commande compatible) tout ce que vous devez savoir est que, pour
chaque fichier effectif, il y aura trois fichiers de donn&eacute;es sur la bande&nbsp;: une
ent&ecirc;te, les donn&eacute;es et une terminaison. L'ent&ecirc;te et la terminaison 
sont int&eacute;ressantes car elles contiennent des informations sur le fichier tel
qu'il &eacute;tait sous VMS. Le fichier de donn&eacute;es est... le fichier de donn&eacute;es.
Chacun de ces fichiers peut &ecirc;tre extrait de la bande avec la commande dd. La
bande peut &ecirc;tre positionn&eacute;e en utilisant la commande <CODE>mt</CODE>.</P>
<P>Prenons un exemple. J'ai une bande VMS. Les deux premiers de ses fichiers
&eacute;taient appel&eacute;s <CODE>ce66-2.evt</CODE> et <CODE>ce66-3.evt</CODE> sur le syst&egrave;me VMS. Le label
de la bande est c66a2.</P>
<P>Si j'ex&eacute;cute les commandes suivantes</P>
<P>
<HR>
<PRE>
$ dd if=$TAPE bs=16k of=ent&ecirc;te1
$ dd if=$TAPE bs=16k of=donn&eacute;e1
$ dd if=$TAPE bs=16k of=terminaison1
$ dd if=$TAPE bs=16k of=ent&ecirc;te2
$ dd if=$TAPE bs=16k of=donn&eacute;e2
$ dd if=$TAPE bs=16k of=terminaison2
</PRE>
<HR>
</P>
<P>je me retrouve avec six fichiers&nbsp;: <CODE>ent&ecirc;te1</CODE>, <CODE>donn&eacute;e1</CODE>,
<CODE>terminaison1</CODE>, <CODE>ent&ecirc;te2</CODE>, <CODE>donn&eacute;e2</CODE> et <CODE>terminaison2</CODE>. La syntaxe
ici est <CODE>if="fichier d'entr&eacute;e"</CODE>, <CODE>bs="taille des blocs"</CODE> et 
<CODE>of="fichier de sortie"</CODE>. TAPE doit &ecirc;tre une variable d'environnement
contenant le nom du p&eacute;riph&eacute;rique de votre lecteur de bande --- par exemple 
/dev/nts0 si vous utilisez le premier disque SCSI sous Linux. </P>
<P>Si vous aviez voulu r&eacute;cup&eacute;rer le second fichier, mais pas le premier, sous son
non d'origine, vous n'auriez pas eu &agrave; vous pr&eacute;occuper de l'ent&ecirc;te&nbsp;: </P>
<P>
<HR>
<PRE>
$ mt -f $TAPE fsf 4
$ dd if=$TAPE bs=16k of=ce66-2.evt
$ mt -f $TAPE fsf 1
</PRE>
<HR>
</P>
<P>Notez le 4. Il permet de sauter trois fichiers pour le premier fichier et un
pour l'ent&ecirc;te du deuxi&egrave;me. Le second <CODE>mt</CODE> saute la seconde terminaison et
positionne la bande au d&eacute;but du prochain fichier&nbsp;: la troisi&egrave;me ent&ecirc;te. Vous
pouvez aussi utilisez <CODE>mt</CODE> pour sauter des fichiers en arri&egrave;re (<CODE>bsf</CODE>),
rembobiner (<CODE>rewind</CODE>) ou d&eacute;charger la bande (<CODE>offline</CODE>, <CODE>rewoffl</CODE>).</P>

<H2><A NAME="ss13.3">13.3 Quelques d&eacute;tails</A>
</H2>


<P>Les fichiers d'ent&ecirc;tes et de terminaisons contiennent des donn&eacute;es ASCII en
majuscules utilis&eacute;es par VMS pour stocker des informations sur le fichier
comme par exemple la taille des blocs. Ils contiennent aussi le nom du
fichier, ce qui peut &ecirc;tre utile si vous voulez faire des scripts qui lisent
automatiquement des fichiers ou recherchent un fichier particulier. La premi&egrave;re
ent&ecirc;te de la bande est un peu diff&eacute;rente des suivantes.</P>
<P>L'en-t&ecirc;te du premier fichier de la bande (comme par exemple dans l'exemple
ci-dessus) d&eacute;bute par la cha&icirc;ne «&nbsp;VOL1&nbsp;». Suit le nom de volume.
Dans notre exemple, le fichier <CODE>ent&ecirc;te1</CODE> commence par 
«&nbsp;VOL1C66A2&nbsp;». Vient ensuite une s&eacute;rie d'espace termin&eacute;e par un
chiffre. Apr&egrave;s, on trouve la cha&icirc;ne «&nbsp;HDR1&nbsp;» qui indique que l'on a
&agrave; faire &agrave; un fichier d'ent&ecirc;te. Les caract&egrave;res qui suivent 
imm&eacute;diatement la cha&icirc;ne «&nbsp;HDR1&nbsp;» forment le nom du fichier VMS.
Dans l'exemple, cette cha&icirc;ne est «&nbsp;HDR1CE66-2.EVT&nbsp;». Le prochain
champ est le nom du volume.  </P>
<P>Le champs initial des autres fichiers (c'est-&agrave;-dire tous sauf le premier de la
bande) est quelque peu diff&eacute;rent. 
«&nbsp;VOL1&nbsp;» n'est pas pr&eacute;sent. Le reste est identique.
Un autre champ utile est le septi&egrave;me. Il se termine par
«&nbsp;DECFILES11A&nbsp;». C'est un 
signe de conformit&eacute; au standard DEC Files11A. </P>
<P>
<BLOCKQUOTE><CODE>
<PRE>
Champ                Ent&ecirc;te initiale                  Ent&ecirc;tes suivantes
1                    VOL1 + nom du volume             HDR1 + nom du fichier 
2                    HDR1 + nom du fichier            Nom du volume
3                    Nom du volume                    ...
4                    ...                              ...
5                    ...                              ...
6                    ...                              DECFILES11A
7                    DECFILES11A
</PRE>
</CODE></BLOCKQUOTE>
</P>
<P>Pour une documentation compl&egrave;te sur le format de l'ent&ecirc;te et de la terminaison,
voyez la documentation DEC FILES11 (sur le mur gris/orange --- demandez &agrave; 
votre communaut&eacute; VMS locale :-).</P>

<H2><A NAME="ss13.4">13.4 Commentaires sur la taille des blocks</A>
</H2>


<P>Dans l'exemple, j'ai utilis&eacute; une taille de bloc de 16 ko. Sur un syst&egrave;me Unix,
il n'y a pas de taille de bloc associ&eacute;e &agrave; un fichier sur un disque alors que,
sous VMS, chaque fichier &agrave; une taille de bloc sp&eacute;cifique. Cela veut dire que la
taille du bloc importe peu sous linux... sauf que cela  rend la lecture des
bandes plus compliqu&eacute;e. Si vous avez des difficult&eacute;s pour trouver la taille du
bloc et pour lire une bande, vous pouvez essayer de r&eacute;gler la taille de bloc
mat&eacute;rielle de votre lecteur de bande en utilisant <CODE>mt -f $TAPE setblk 0</CODE>. La
syntaxe exacte de l'option setblk (et sa disponibilit&eacute;) d&eacute;pend de la version de
<CODE>mt</CODE>, de l'interface mat&eacute;rielle de votre lecteur de bande et de votre
environnement Unix.</P>
<P>(Merci &agrave; 
<A HREF="skulski@nsrlc6.nsrl.rochester.edu">Wojtek Skulski</A> pour avoir signal&eacute; l'option setblk.)</P>

<H2><A NAME="s14">14. La fin</A></H2>



<H2><A NAME="ss14.1">14.1 Copyright</A>
</H2>


<P>Sauf indication contraire, les droits d'auteur des HOWTO Linux sont
d&eacute;tenus par leurs auteurs respectifs. Les HOWTO Linux peuvent &ecirc;tre
reproduits et distribu&eacute;s, en totalit&eacute; ou en partie, sur tout m&eacute;dia
physique ou &eacute;lectronique dans la mesure o&ugrave; ce copyright est pr&eacute;serv&eacute;
dans chaque copie. La distribution commerciale en est autoris&eacute;e et
encourag&eacute;e. L'auteur appr&eacute;cierait toutefois qu'on lui notifie
individuellement ce genre de distribution.</P>
<P>Le pr&eacute;sent copyright doit couvrir toute traduction, compilation et
autre travail d&eacute;riv&eacute; des HOWTO Linux. C'est-&agrave;-dire qu'il est interdit
d'imposer des restrictions de diffusion allant au del&agrave; du pr&eacute;sent
copyright &agrave; des ouvrages inspir&eacute;s, ou incorporant des passages, de
HOWTO Linux. Sous certaines conditions, des exceptions &agrave; ces r&egrave;gles
seront tol&eacute;r&eacute;es&nbsp;: contactez le coordinateur des HOWTO &agrave; l'adresse
donn&eacute;e ci-dessous.  </P>
<P>Pour r&eacute;sumer, nous souhaitons une diffusion aussi large que possible
de ces informations. N&eacute;anmoins, nous entendons garder la propri&eacute;t&eacute;
intellectuelle (copyright) des HOWTO, et appr&eacute;cierions d'&ecirc;tre inform&eacute;s
de leur redistribution.</P>
<P>Pour toute question plus g&eacute;n&eacute;rale, merci de contacter le coordinateur
des HOWTO, Guylhem Aznar, &agrave; l'adresse &eacute;lectronique 
<A HREF="mailto:linux-howto@sunsite.unc.edu">linux-howto@sunsite.unc.edu</A> par email. </P>

<H2><A NAME="ss14.2">14.2 Avertissement</A>
</H2>


<P>Ce travail a &eacute;t&eacute; &eacute;crit d'apr&egrave;s l'exp&eacute;rience que nous avons eue au <I>Settore
di Geofisica of Bologna University</I> (Italie), ou un VAX 4000 a &eacute;t&eacute; remplac&eacute; par
un Pentium tournant sous Linux. La plupart de mes coll&egrave;gues sont des
utilisateurs de VMS, et certains d'entre eux l'ont abandonn&eacute; pour Linux.</P>
<P>Le <I>HOWTO Comment migrer de VMS &agrave; Linux</I> a &eacute;t&eacute; &eacute;crit par 
<A HREF="mailto:guido@ibogeo.df.unibo.it">Guido Gonzato</A> et 
<A HREF="mailto:miller5@uiuc.edu">Mike Miller</A> qui a &eacute;crit la partie sur
la lecture des bandes VMS. Merci beaucoup &agrave; mes coll&egrave;gues et amis qui m'ont aid&eacute;
&agrave; d&eacute;finir les besoins et les habitudes de l'utilisateur lambda de VMS, et 
particuli&egrave;rement au Dr. Warner Marsocchi.</P>
<P>S'il vous pla&icirc;t, aidez moi &agrave; am&eacute;liorer ce HOWTO. Je ne suis pas un expert de
VMS et je n'en serai jamais un. C'est pourquoi vos suggestions et reports de
bogues seront plus que bienvenus.</P>
<P>Amusez-vous bien,</P>
<P>Guido <CODE>=8-)</CODE></P>

</BODY>
</HTML>
doc-linux-fr-html 2013.01-2 / usr / share / doc / HOWTO / fr-html / VMS-to-Linux-HOWTO.html
