# Ceci est un commentaire
# --------------------------- Menu principal ------------------------------

# vérifie si on fait tourner csh 5.16 ou au-dessus. $_version contient la
# version courante, et la commande return finit un fichier script.

if $_version < 516
 echo "Désolé, version 5.16 de csh requise";return 0
endif



cls  # efface l'écran

# La commande echo est utilisée pour imprimer des lignes à l'écran. Notez qu'une
# apostrophe à la fin n'est pas nécesaire.

echo "Voici un script d'exemple pour csh. Il contient quelques alias assez utiles
echo "que vous pourriez vouloir garder de façon permanente, mais son but
echo "principal est d'être utilisé comme tutorial. Regardez-le et modifiez-le.
echo



# Toutes les commandes csh acceptent les codes de contrôle dans leur ligne de
# commande , ex. ^A est la même chose que CTRL-A, qui est le code ASCII 1. Ceci
# peut être utilisé pour générer des séquences d'échappement.

echo -n ^[[30m^[[41m                    # inverse vidéo, par de retour charriot
echo -n @center( " C H O I X " 76 ) # affichage centré
echo    ^[[0m
echo
echo "[1] Nombres premiers
echo "[2] Afficheur de textes 'More'
echo "[3] Jeu de labyrinthe
echo "[4] Jeu de tours de Hanoi
echo "[5] Système de contrôle Backup/Version
echo "[6] Alias utiles
echo "[7] Mansplit, explose votre csh.doc



# La commande input lit une ligne sur la console et la stoque dans la variable
# indiquée.


echo -n "> "
input choice

goto Start$choice   # Saute aux étiquettes Start1 ou Start2 et ainsi de suite





# ------------------------- Nombres premier -----------------------------
# L'intéressant au sujet de ce rpogramme est l'utilisation de la commande
# fornum et les trucs utilisés pour générer les tableaux. L'information si
# 93 est premier ou non est stoquée dans la variable $prime93.

label Start1    # point d'entrée... on arrive ici après le goto

set max 100     # le nombre le plus haut testé s'il est premier
echo "Calcul des nombres premiers depuis 1 à "$max
fornum i 2 $max "set prime$i 1

# Voici un bloc de contrôle. Tout va être concaténé en une ligne en interne,
# séparés par un point-virgule. Ainsi les guillemets finals sont obligatoires
# et les commentaires sont interdits.
fornum i 2 $max {
 exec "set bool $prime"$i
 if $bool
  echo -n $i^i
  fornum -s j $i $max $i "set prime$j 0"
 endif
}
echo

return 0




# ------------------------------ More -------------------------------
# Ce script fait à peu près ce que fait le programme 'more'. I est supposé
# démontrer les commandes d'entrées/sorties de fichiers et les fonctions
# de gestion des fichiers.

label Start2

# L'écran d'aide de 'more', défini comme un alias
alias morehelp {
 echo "  espace    page suivante"
 echo "  entrée    ligne suivante"
 echo "  backspace page précédente"
 echo "  <         haut du fichier"
 echo "  >         bas du fichier"
 echo "  ESC, q    quitter"
 echo "  h         aide"
}

echo "Voici une approche simple de la programation d'un afficheur de textes"
echo "en script csh. Fonctions:"
echo
morehelp
echo

echo -n "Entrez le nom du fichier de texte à afficher:"
input text
#set text test
if -nf $text;echo "Fichier non trouvé";return 20;endif

# Ceci lit le fichier en mémoire. Chaque ligne sera un 'mot', même si elle
# contient des espaces. Pour le définition du mot, référez-vous à csh.doc.
readfile file $text
# Chaque utilisation de $file génèrera à partir de maintenant une ENORME
# ligne de commande
set pos    1
set page   @rpn( @winrows( ) 1 - )
set lines  @flines( file )
set bottom @rpn( $lines $page - 1 + )


label Disp

cls
set screen @subfile( file $pos $page )   # stoque l'écran entier dans $screen
writefile screen
                                           # calcule & affiche le pourcentage
set perc @rpn( $pos $page + 1 - 100 \* $lines / 100 MIN )
echo -n ^[[3m^[[30m^[[41m "-- More -- ("$perc"%)"^[[0m ""


input -r c    # saisit une simple pression de touche sans attendre le retour
set c x$c     # charriot. empêche '<' d'être mal interprété dans 'if'

if $c = x" ";if $pos = $bottom;unset file;return 0;endif;endif
if $c = x" ";inc pos $page;if $pos > $bottom;set pos $bottom;endif;endif
if $c = x^m ;inc pos   1  ;if $pos > $bottom;set pos $bottom;endif;endif
if $c = x^h ;dec pos $page;if $pos < 1;set pos 1;endif;endif
if $c = x"<";set pos 1;endif
if $c = x">";set pos $bottom;endif
if $c = xq  ;unset file;return 0;endif
if $c = x^[ ;unset file;return 0;endif
if $c = xh  ;cls;morehelp;echo "Appuyez sur une touche";input -r a;endif
#if $c = x/  ;set char xf;endif
#if $c = xf
# echo -n "Cherche la chaîne: ";input str;search -fq $text $str | input found;
# set found @subwords( $found 2 1000 );set c xn
#endif
#if $c = xn
# set hop 0
# foreach i ( $found ) "if $i > $pos;if $hop = 0;set hop $i;endif;endif
# if $hop;set pos $hop;endif
#endif

goto Disp





# ---------------------------- Labyrinthe -------------------------------
# J'ai toujours voulu faire un jeu d'action avec un script :-)
# Le labyrithe est stoqué en une seule chaîne, avec chaque ligne un mot.
# Modifiez-le librement, La taille est détectée automatiquement. N'utilisez
# pas la répétition de touches automatique en jouant, ça peut produire des
# problèmes avec la console.

label Start3

set lab      "#########################"
set lab $lab "#   #     #   #     #   #"
set lab $lab "# # # ### ### ### # ### #"
set lab $lab "# #   # #   #     # #   #"
set lab $lab "# ##### ### ### ### # ###"
set lab $lab "#   #   #   #   # #     #"
set lab $lab "### # ### ### # # ##### #"
set lab $lab "#       #     #   #      "
set lab $lab "#########################"

cls
writefile lab
echo -n ^j"8=up 2=down 4=left 6=right "^j^[[2A
set x 2
set y 2
set wid @strlen( @word( $lab 1 ) )
set up  @words( $lab )
echo -n ^[[$up\A^[[B^[[C.^[[D
alias test "%a%b set xx @rpn( $x $a + );set yy @rpn( $y $b + );\
 set f @strmid( @word( $lab $yy ) $xx 1 )


date -s

label Loop

input -r c
if $c = 8;test 0 -1;if -n $f = "#";echo -n " "^H^[[A.^H;dec y;endif;endif
if $c = 2;test 0  1;if -n $f = "#";echo -n " "^H^[[B.^H;inc y;endif;endif
if $c = 6;test  1 0;if -n $f = "#";echo -n " "^H^[[C.^H;inc x;endif;endif
if $c = 4;test -1 0;if -n $f = "#";echo -n " "^H^[[D.^H;dec x;endif;endif
if $x >= $wid;cls;echo Félicitations, échappé en `date -r` secondes.;return 0;endif
goto Loop

return 0



# ------------------------------ Tours de hanoi -----------------------------
# Ce jeu a été optimisé pour la vitesse, et est ainsi peu agréable à regarder

label Start4

set height 7 # mettez-la à un nombre impair inférieur à 7

set h2 $height;inc h2
cls
unset t
set t1 "9"; set t2 "9"; set t3 "9"   # Les trois tours
fornum -s i $h2 2 -1 "set t1 $i$t1
set done $t1

#prépare l'affichage
set im "x";set h @rpn( $height 2 \* 1 + )
fornum -s i 1 $h 2 "set im $im @center( @strleft( XXXXXXXXXXXXXXX $i ) $h )
fornum i $height 10 "set im $im \"               \"

cls
echo
echo " T O U R S  D E  H A N O I
echo "---------------------------
echo
echo "Ce jeu n'est pas très confortable, mais il fonctionne bien. Vous devez
echo "déplacer une pile de disques depuis la première de trois bases vers la
echo "troisième sans jamais mettre un disque plus large sur un plus petit. Pour
echo "déplacer un disque au sommet de la pile 1 vers la pile 3, pressez d'abord
echo "'1' puis '3'. Quand c'est fait, le temps que ça vous a pris est affiché,
echo "et vous devez presser CTRL-C pour finir le jeu. Vous ne verrez aucune
echo "sortie à part les piles lorsque le jeu fonctionne.
echo
echo "PS: Signalez-moi si vous faîtes moins de 60 secondes pour une partie :-)
echo
echo "Pressez une touche lorsque vous êtes prêt...

input -r x
date -s
cls

#Affichage de la pile
fornum  i 2 $h2 "echo \" \" @word( $im $i )
echo

set m1 1;set m2 17;set m3 33

forever {
 label Disp
 input -r x;input -r y
 exec "set src $t"$x";set dst $t"$y";set rt1 $m"$x";set rt2 $m"$y
 strleft move $src 1
 if a$move""a >= a$dst""b
  echo -n ^g
 else
  strlen up1 $src; strlen up2 $dst; inc up2
  echo -n \233$up1""A\233$rt1""C"                "^m\233$up1""B\
\233$up2""A\233$rt2""C @word( $im $move ) ^m\233$up2""B
  set t$y $move$dst
  strmid t$x $src 2
 endif
 if $t3 = $done;echo ^j^j;date -r;endif
}

return 0




# ---------------------- contrôle Backup/Version -------------------------------
# Maintenant, voici un script que vous voudrez utiliser régulièrement.
# il fait un backup d'un jeu de fichiers vers un répertoire différent,
# gardant n'importe quel nombre de vielles versions. Extrayez ce script et
# appelez-le depuis votre .login ou chaque fois que vous lancez votre système
# de développement C. En fixant un délai de zéro vous êtes sûr que chaque fois
# qu'il s'exécute, un backup est fait.

label Start5

set versions 3         # Nombre maximum de versions d'un fichier conservées
set delay    1         # Nombre minimum de jours entre les backups
set dest     bak       # Le sous-répertoire de destination du backup
set pattern  "*.c *.h" # Le motif des fichiers à sauvegarder
set exlude   "x.c y.c" # Les fichiers à NE PAST recopier


#----- mise en place de l'environement -----
if -nd $dest
 echo -n "Répertoire "$dest" non présent... le créer? o/n: ";input x
 if $x = o;mkdir $dest;else;echo "Stoppé...";return 0;endif
endif

if -f $dest/timestamp
 set last @age( $dest/timestamp )
 if $last < $delay
  echo "Aucun backup effectué... le dernier backup date d'il y a "$last" jour(s)."
  return 0
 endif
else
 echo >$dest/timestamp
endif


#----- détermine les fichiers altérés ----
echo "Vérification des fichiers...."
exec set all $pattern              # l'expansion des motifs se fait ici

set cp ""                          # Les fichiers à copier
foreach i ( $all ) "if -nt $i $dest/$i;set cp $cp $i;endif

exec set exclude $exclude          # L'expansion des motifs se fait ici
set cp @without( $cp , $exclude )

if $cp = "";echo "Fini.";touch $dest/timestamp;return 0;endif
echo "Les fichiers à copier:"
echo $cp
# Sortez le commentaire sur la ligne suivante si vous voulez un test de sûreté...
# set cp @confirm( Backup $cp )
if $cp = "";echo "Fini.";touch $dest/timestamp;return 0;endif


#------ Faire le backup -------
alias name "%a set n $dest/$i;if $a;set n $n.$a;endif

foreach i ( $cp ) {
 set v $versions;dec v
 name $v;dec v
 if -f $n;rm $n;endif
 fornum -s j $v 0 -1 "set hi $n;name $j;if -f $n;mv $n $hi;endif"
 cp $i $dest
}

touch $dest/timestamp
echo "Fini."

return 0





# ---------------------- Les alias utiles -------------------------------
# Lisez les commentaires de chaque alias pour choisir ceux que vous préférez
# Copiez-les dans votre login.

label Start6

# d'abord quelques alias utiles pour dir
alias  d   "*a dir @pickopts( $a ) -ze \"%6s %-.12n%m\" @pickargs( $a )
alias  lst "*a ls -t $a"    # trie par date d'accès
alias  lsl "*a ls -l $a"    # trie suiavnt la longueur
alias  move "cp -m

# sc cherche les *.c, même 'sc -c main()' marche
alias  sc "%a search @pickopts( $a ) *.c @pickargs( $a )

# edf edite une fonction dans CygnusEd si le nom commence en première colonne:
alias  edf {
%func
 set b ""
 search -afl *.c $func | inp b
 if $b
  split b file line
  lced $file
  waitforport rexx_ced
  inc line 1
  rxsend rexx_ced "jump to file "$file "jumpto "$line" 0"
 else
  echo Pas trouvé.
 endif
}

# ces alias suppriment l'expansion des motifs pour certaines commandes
alias  zoo     "*a Zoo $a
alias  lharc   "*a Lharc $a
alias  lz      "*a Lz $a
alias  newlist "*a Newlist $a
alias  eval    "*a Eval $a


# Celui-ci affichera toutes les images, les plus récentes d'abord
alias  newpix  "ls -nt | forline i STDIN \"ShowIFF $i

# si vous voulez lancer des commandes internes csh en arrière plan, utilisez rs
alias  rs      "rback csh -c

# certains alias pour compatibilité avec UNIX

# ceci crée une commande chmod qui attend les bits d'abord et les fichiers après
alias ias chmod "%a protect @subwords( $a 2 9999 ) @first( $a )

# la même chose avec grep:
alias ias grep "%a search @subwords( $a 2 9999 ) @first( $a )

set stk ""
# pushd met le répertoire courant sur une pile
alias  pushd "%a set stk $_cwd @subwords( $stk 1 10 );\\cd $a;e $stk

# popd  l'en retire
alias  popd  "\\cd @first( $stk );set stk @subwords( $stk 2 10 );e $stk

echo "Les alias utiles sont définis. Lisez ce fichier script pour connaître
echo "leurs noms et ce qu'ils font.

return 0





# ----------------------- Mansplit.sh - explose votre csh.doc ------------------
# Explose votre csh.doc en petits fichiers, un par entrée dans le manuel. Donc
# les programmes de manuel externes peuvent marcher avec, ce qui est souvent
# plus rapide que la méthode propre de csh.

label Start7

echo Patience...
set dest ram:cshdoc/           # mettez votre répertoire de destinaton ici
if -nd ram:cshdoc;mkdir ram:cshdoc;endif   # ...et ici
set mode skip
forline i csh:csh.doc {
 if $mode = write
  if @strleft( $i^a 1 ) < " "
   echo >>$dest$file $i
  else
   set mode skip
  endif
 endif
 if $mode = skip
  if "    " = @strleft( $i 4 )
   set mode write
   set a @index( $i "(" )
   if $a > 0;dec a 1;strleft i $i $a;endif
   set file $i
   echo >$dest$file $i
   echo $file
  endif
 endif
}
echo "csh.doc explosé et écrit dans "$dest

return 0