Auris Solutions : Cabinet de Conseil en Stratégie Numérique

Programmation comparée MS DOS / Korn Shell (Bourne)

MS DOS ayant depuis longtemps été abandonné par Microsoft, la question d’un shell puissant incluant un vrai langage de programmation normalisé a été résolu par l’éditeur via l’adoption officielle de SFU sur les environnements Windows. Cette adoption pose cependant le problème de la traduction des programmes bat en programme korn shell (version posix dans le cas de SFU). Ce cours est destiné à vous aider dans cette opération (il n’est pas exhaustif, en particulier pour les fonctionnalités du ksh).

 

Types et Variables

MS DOS et les shell de la famille Bourne reconnaissent des variables de type entier et chaîne de caractères.
Bien que limité à ces deux types, la programmation avec ces deux langages est suffisante pour une application à la gestion du système ou à l’exploitation des applications. Des structures plus complexes seraient même contre-productive puisqu’elles induiraient un niveau de complexité inutile en regard des objectifs.
MS DOS


REM DOS utilise la syntaxe suivante pour l’affectation de variables
set MA_VAR=valeur REM l’affichage se fait en utilisant le %
echo %MA_VAR%
c:\> valeurREM par defaut, DOS affiche les commandes passées et leur resultat
REM la commande suivante permet de n’afficher que le résultat
@echo off

REM la commande suivante permet de tout afficher
@echo on

Korn shell


#ksh utilise la syntaxe suivante pour l’affectation de variables
MA_VAR=valeur #si l’on veut que des processus fils utilisent cette variable, il faut l’exporter
export MA_VAR=valeur#l’affichage se fait par print en ajoutant $ devant la variable
print $MA_VAR
> valeur

#il est possible d’utiliser  » pour obtenir la même chose
print « $MA_VAR »
> valeur

#les ‘ empêchent le shell d’interpréter la variable
print ‘$MA_VAR’
> $MA_VAR

#Pour affecter le résultat d’une commande : $( la_commande )
MA_VAR= »$( print OK ) »
print $MA_VAR
> OK

Structure de contrôle

Les structures de controle MSDOS sont très limitées et ont recours au goto vers des étiquettes de programmation.
Le Ksh dispose de toutes les structures de controle : 

  • si alors sinon
  • choix multiple
  • pour
  • tant que
MS DOS


REM le si alors sinon test l’existence d’un fichier
if exist le_fichier.bat goto suite
echo le_fichier.bat n’existe pas
goto fin
:suite
echo le_fichier.bat existe
:fin

Korn shell


#le ksh utilise des conditions de test très complètes
if [ condit_vraie_renvoie_zero ] ; then
print « c’est vrai »
else
print « c’est faux »
fi #présence d’un fichier
if [ -f /ou_ca/le_fichier.log ] ; then
print « /ou_ca/le_fichier.log existe »
else
print « /ou_ca/le_fichier.log n’existe pas »
fi#teste si $VAR=ma_valeur ou $CPT=5 (-o = ou, -a = et)
if [ « $VAR »=ma_valeur -o $CPT -eq 5 ] ; then
print « la condition est vérifiée »
else
print « condition fausse »
fi

#teste si $VAR est non nulle (-n = non nulle, -z = null)
if [ -n « $VAR » ] ; then
print « la condition est vérifiée »
else
print « condition fausse »
fi

#le ksh dispose des choix multiples
case « $MA_VAR » in
valeur1) print ‘$MA_VAR’ a la valeur valeur1
;;
[a-Z]+) print ‘$MA_VAR’ est une chaine de caractères minuscule ou majuscule
;;
A0*) print ‘$MA_VAR’ est une chaîne qui commence par A0
;;
0[Aa]*) print ‘$MA_VAR’ est une chaîne qui commence par 0A ou 0a
;;
*) print « On gere ici les cas non pris en compte avant »
;;
esac


REM structure for
REM dans un pg, on utilise %%var_bcl au lieu de %var_bcl
for %%var_bcl in (*.doc val1 val2) do echo la variable vaut %%var_bcl%
Pour une boucle avec plusieurs actions, cela se complique un peu. Une solution est de passer par un sous programme stocké dans un autre fichier : 

REM pg appelant
for %%var_bcl in (1 2 3) do @souspg.bat %%var_bcl%
REM pg appelé
@echo off
echo debut du sous-programme
echo %1%
echo Fin du sous-programme

ou s’il n’y a pas trop de lignes :

for %%var_bcl in (1 2 3) do (
echo debut
echo %%var_bcl%
echo Fin
)


#structure for avec l’exécution d’une commande ls (liste les fichiers d’un répertoire)
for var_bcl in $(ls *.doc) val1 val2
do
print « Dans la boucle avant d’afficher la variable »
print « $var_bcl »
print « Dans la boucle, apres affichage »
done


REM bouche Repeter Tant Que
set var_bcl=0
:debut_TQ
echo Dans la boucle %var_bcl%
set /A var_bcl= 1 + %var_bcl%
REM LSS=inferieur, GTR=superieur, EQU=egal
if %var_bcl% LSS 10 goto debut_TQ


#boucle while
var_bcl=0
while [ $var_bcl -lt 10 ]
do
print « Dans la boucle $var_bcl »
var_bcl=$(( $var_bcl + 1 ))
done


REM Extraction d’une sous-chaine ayant un délimiteur (ici / )
for /F « tokens=1,2,3 delims=/ » %i in (‘date /t’) do (
echo Le jour est %i
echo Le mois est %j
echo l’annee est %k

)


#extraction avec un awk et l’espace comme separateur
date | awk ‘{print ($1, $2, $3)}’
#extraction avec un awk et ‘:’ comme separateur
date | awk -F ‘:’ ‘{print ($3, $2, $1)}’
#substitution du separateur ‘:’ par _
date | sed ‘s/:/_/g’

Programmation structurée

Il est compliqué de produire un programme MSDOS structuré : il faut utiliser des étiquettes et des goto ce qui génère de désastreux programmes « spaghetti ».
La programmation structurée ne pose aucun problème en ksh.
MS DOS


REM structure de programme avec des goto
set ici=PG1
@echo appel procedure1
goto procedure1
:PG1
set ici=PG2
@echo appel procedure2
goto procedure2
:PG2
@echo fini
goto FIN
:procedure1
@echo procedure1 %ici%
goto %ici%
:procedure2
@echo procedure2 %ici%
goto %ici%
:FIN

Korn shell


procedure1()
{ print « Dans procedure1 »
}
procedure2()
{ print « Dans procedure2 »
print « Les 3 paramètres : $1 / $2 / $3 »
}
print « Appel procedure1 »
procedure1
#procedure avec des parametres
print « Appel procedure2 »
procedure2 « Param1 » « $(ls) » P3
print « Fin »


REM Paramètres d’appel des programmes
@echo Param1 : %1
@echo Param2 : %1
REM shift realise les operations %1=%2, %2=%3, %3=%4, …
shift
@echo Param1 : %1
@echo Param2 : %1
REM les erreurs sont gérables par la variable ERRORLEVEL
if ERRORLEVEL 1 echo « Il y a une erreur 1 »
echo Erreur de code : %ERRORLEVEL%


#ksh a des fonctionnalités equivalentes
print « Param1 : $1 »
print « Param2 : $2 »
shift
print « Param1 : $1 »
print « Param2 : $2 »
#Ceci est également applicable aux paramètres des procédures#on recupère le code de retour d’une commande par $?
ls
if [ $? -gt 0 ] ; print « ls a renvoye une erreur »

Autres commandes

On donne ci-dessous la traduction des commandes courantes.
MS DOS


 

  • Changement de répertoire : cd nom_repertoire
  • creation d’un répertoire : md nom_rep
  • liste des fichiers d’un répertoire : dir *.doc
  • Renommer un fichiers : ren fic_avant fic_apres
  • Copier un fichiers : copy fic_avant fic_apres
  • Effacement d’un fichiers : erase fic
  • Contenu d’un fichier : type fic
  • Contenu d’un fichier page à page : more fic
  • Trier un fichiers : sort fic
  • Appel d’un autre programme : call nom_programme
  • Effacer l’écran : cls
  • Afficher la date ou l’heure : date ou time
  • Chercher un pattern dans un fichier : find « chaine » nom_fichier
Korn shell


 

  • Changement de répertoire : cd nom_repertoire
  • creation d’un répertoire : mkdir nom_rep
  • liste des fichiers d’un répertoire : ls *.doc
  • Renommer un fichiers : mv fic_avant fic_apres
  • Copier un fichier : cp fic_avant fic_apres
  • Contenu d’un fichier page à page : more fic ou pg fic
  • Effacement d’un fichiers : rm fic
  • Contenu d’un fichiers : cat fic
  • Trier un fichiers : sort fic
  • Appel d’un autre programme : nom_programme
  • Effacer l’écran : clear
  • Afficher la date ou l’heure: date
  • Chercher un pattern dans un fichier : grep « expression réguliere » nom_fichier

Aucun commentaire jusqu'à présent.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée.


_____________


Avant d'être uberisé,
apprenez à décoder les

17 règles de l'économie numérique


Catégories

Nous respectons la RGPD