variabilisation nom de tableau KSH

Recherche :

Mot : Pseudo : Filtrer
Bas de page
Auteur	Sujet : variabilisation nom de tableau KSH

Fred_l

Bonjour,

Est il possible de variabiliser un nom de tableau en KSH ?

Voici mon script :

###############################################
# Initatlisation du tableau 2D #
###############################################
function INIT_TAB
{
# INIT_TAB "T_Param" "Valeur d'initialisation"
# T_Param = PROD[100][20]
# Appel : INIT_TAB MyTable 20 20

# Récupération des infos concernant le tableau
T_Name=`echo "$1" |cut -d"[" -f1`
Lignes=`echo "$1" |cut -d"[" -f2|cut -d"]" -f1`
Colonnes=`echo "$1" |cut -d"[" -f3|cut -d"]" -f1`
# Récupération de la valeur d'initialisation
ValInit=$2

" Variables
local rc=0 # indice Ligne
local lc=0 # indice Colonne
local index # Index de positionnement

while [ $rc -lt $Lignes ]
do
while [ $lc -lt $Colonnes ]
do
# Définition de l'index **************
local colonne=`expr $lc % $Colonnes`
local ligne=`expr $rc % $Lignes`
let "index = $colonne * $Lignes + $ligne"
#******************************
# Insertion en Lx;Cy
# PROD[$index]="$ValInit" # ici ca marche
$T_Name[$index] # Ici non !
# Colonne suivante
let "lc += 1"
done
# Ligne suivante + colonne 0
lc=0
let "rc += 1"
done
}

Merci pour votre aide...

Fred

Publicité

gloo

salut,
j'ai mal a la tete d'essayer de suivre le code...
pourquoi tu fais pas du C plutot que du shell !!??
t as essayer d'utiliser la commande "eval" pour regler ton probleme ?
si j'ai rien a faire au taf demain, je reviendrais y reflechir...

Fred_l

Ok merci

eval '$'{$T_Name[$index]}

Ca à l'air de marcher.... je vais faire plus de tests !!!

Fred_l

OK !

comme ca ca marche :
eval "$T_Name[$index]=$ValInit"

Maintenant le problème est de récupérer cette valeur en 1 et en 2 de l'écrire dans un fichier !

test variable
eval "var=${$T_Name[$index]}"
test fichier
echo ${`eval '$T_Name[$index]'`} >> $FileOut

Ca marche pas !!!!!

Une idée ?

gloo

j'ai du mal a comprendre tes explications...

mais dans la ligne
echo ${`eval '$T_Name[$index]'`} >> $FileOut
il y a une erreur, ca c'est sur : eval '$T_Name[$index]' ca veut rien dire, car on utilise eval pour forcer a executer une commande.
par exemple :
TITI=bonjour
TOTO=TITI
eval echo \$$TOTO
bonjour

Message cité 1 fois

Fred_l

OK pour le fichier ca marche :

eval echo \${$T_Name[$index]} >> $FileOut

reste plus que la même chose pour une variable....
du style :
var = eval \${$T_Name[$index]}

En tout cas merci gloo

Message cité 1 fois

Sve@r

gloo a écrit :

on utilise eval pour forcer a executer une commande.

En fait, eval transforme ses arguments en instruction shell [:aloy]

Message édité par Sve@r le 17-06-2006 à 20:04:42

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.

Fred_l

Je testerais ça au boulot.....

Personnellement je "Débute" en KSH.
C'est pas très riche comme language...
Mais j'ai pas le choix ! Portabilité oblige !

Et dire que j'ai tout le plan de PROD à faire avec une gestion dynamique dans un tableau pour éviter les requête $U qui prennent un temps fou quand il faut contrôler les jobs en " Temps réels" et faire l'analyse syntaxique du plan de prod !!!

Merci en tout cas

Fred

Message cité 1 fois

Sve@r

Fred_l a écrit :

Je testerais ça au boulot.....

Personnellement je "Débute" en KSH.
C'est pas très riche comme language...

Hum... tu fais erreur. Tous les shells possèdent une particularité fabuleuse: ils peuvent déléguer aux programmes externes tout ce qu'ils ne savent pas faire par eux-même.
Ce mécanisme s'obtient en utilisant les backquottes. Cela remplace l'instruction entre backquottes par ce qu'elle affiche normallement à l'écran
ex:

var=`date` => ce qu'affiche la commande "date" ira dans "var"
if test `pwd` = "/" ; then ... => ce qu'affiche "pwd" sera comparé avec "/"

Ca, c'est fantastique. Comme tu as à ta disposition une foule de programmes qui te permettent de traiter des fichiers, comme "grep", "cut", "sed", "tr", "sort", "awk", il te suffit, lorsque t'as un truc un peu chiadé à faire, de déléguer à l'un (ou plusieurs) de ces programmes la tâche en question et à récupérer tranquillement le résultat. Evidemment, ça nécessite de savoir utiliser l'ensemble des commandes citées...
Tuto disponible ici: http://fr.lang.free.fr/cours/Shell_v1.4.pdf

Fred_l a écrit :

Mais j'ai pas le choix ! Portabilité oblige !
Et dire que j'ai tout le plan de PROD à faire avec une gestion dynamique dans un tableau pour éviter les requête $U qui prennent un temps fou quand il faut contrôler les jobs en " Temps réels" et faire l'analyse syntaxique du plan de prod !!!

Puisque tu débutes en shell tu peux aussi te mettre à Python (je suis moi-même en train de l'apprendre). Ca c'est un langage de haut niveau qui est :
1) portable (Python existe pour tous les unix et aussi pour Windows)
2) riche (il contient les notions d'objet, de listes, de dictionnaires et de nombreuses librairies comme l'accès aux BDD, des IHM graphiques, etc...)
Tuto disponible ici: http://www.cifen.ulg.ac.be/inforef/swi/python.htm

---------------
Vous ne pouvez pas apporter la prospérité au pauvre en la retirant au riche.

gloo

Fred_l a écrit :

OK pour le fichier ca marche :

eval echo \${$T_Name[$index]} >> $FileOut

reste plus que la même chose pour une variable....
du style :
var = eval \${$T_Name[$index]}

En tout cas merci gloo

j ai un doute que ta derniere ligne fonctionne, esaye plutot ceci :

var="$( eval echo \${$T_Name[$index]} )"

et evite les espaces de part et d autre du '=' d'affectation

Message édité par gloo le 18-06-2006 à 22:00:39

Publicité

Fred_l

je testerais ça demain !

j'en profiterais pour mettre le code complet si ça intéresse quelqu'un !

Merci !

Fred_l

Ok, la récupérartion marche très bien !!

Merci gloo !

Pour ceux que ça intéresse, voici le code de gestion d etableau en 2D:

Citation :

# Déclaration du tableau

###############################################
# Déclaration du tableau #
###############################################
function DEFINE_TAB
{
# DEFINE_TAB "Nom du tableau" "Nbre Ligne" "Nbre Colonnes" "T_Param"*
# Appel DEFINE_TAB Production 100 20

# T_Param contient le nom du tableau, le nbre de lignes et de colonnes
# exemple: T_Päram --> Production[100][20]

Tab_Name=$1
Lignes=$2
Colonnes=$3
T_Param="$Tab_Name[$Lignes][$Colonnes]"
typeset -R $Tab_Name
}

###############################################
# Initatlisation du tableau #
###############################################
function INIT_TAB
{
# INIT_TAB "T_Param" "Valeur d'initialisation"
# Appel INIT_TAB $T_Param "-------------------------"

# A savoir que la longueur des champs du tableau sont défini par le 1er enregistrement
# Si le 1er = 4 caractères, tout les autres font 4 caractère
# Si la valeur rentrée fait 6 caractères, elle sera tronquée à 4
# Exemple :
# tab[0]=Flag ; tab[1]=Session --> tab[1] --> sion

T_Name=`echo "$1" |cut -d"[" -f1`
Lignes=`echo "$1" |cut -d"[" -f2|cut -d"]" -f1`
Colonnes=`echo "$1" |cut -d"[" -f3|cut -d"]" -f1`
ValInit=$2
local rc=0
local index
local lc=0
while [ $rc -lt $Lignes ]
do
while [ $lc -lt $Colonnes ]
do
local colonne=`expr $lc % $Colonnes`
local ligne=`expr $rc % $Lignes`
let "index = $colonne * $Lignes + $ligne"
eval "$T_Name[$index]=$ValInit"
let "lc += 1"
done
lc=0
let "rc += 1"
done
}

###############################################
# Ajout d'un élément au tableau #
###############################################
###############################################
# Ajout d'un élément au tableau #
###############################################

function ADD
{
# ADD "T_Param" "PosX" "PosY" "Valeur"
# Appel : ADD $T_Param 42 8 test

T_Name=`echo "$1" |cut -d"[" -f1`
Lignes=`echo "$1" |cut -d"[" -f2|cut -d"]" -f1`
Colonnes=`echo "$1" |cut -d"[" -f3|cut -d"]" -f1`

rc=$2
lc=$3
value=$4
local colonne=`expr $lc % $Colonnes`
local ligne=`expr $rc % $Lignes`
let "index = $colonne * $Lignes + $ligne"
eval "$T_Name[$index]=$value"

#
# exemple de récupération de la valeur dans une variable
#
# var="$( eval echo \${$T_Name[$index]} )"
# echo "Var a la valeur: $var"
}

###############################################
# Sauvegarde du tableau dans un fichier #
###############################################
###############################################
# Sauvegarde du tableau dans un fichier #
###############################################
function SAVE_TAB
{
# SAVE_TAB "T_Param" "Fichier"
# Appel: SAVE_TAB $T_Param Out.txt

T_Name=`echo "$1" |cut -d"[" -f1`
Lignes=`echo "$1" |cut -d"[" -f2|cut -d"]" -f1`
Colonnes=`echo "$1" |cut -d"[" -f3|cut -d"]" -f1`

FileOut=$2
rm $FileOut
local rc=0
local index
local lc=0
while [ $rc -lt $Lignes ]
do
while [ $lc -lt $Colonnes ]
do
local colonne=`expr $lc % $Colonnes`
local ligne=`expr $rc % $Lignes`
let "index = $colonne * $Lignes + $ligne"
eval echo \${$T_Name[$index]} >> $FileOut
# echo "L$ligne;C$colonne V=${PROD[$index]}" >> $FileOut
let "lc += 1"
done
lc=0
let "rc += 1"
done

}

###############################################
# Upload du fichier dans le tableau #
###############################################
function UPLOAD_TAB
{
# UPLOAD_TAB "T_Param" "FileIn"
# Appel : UPLOAD_TAB $T_param Out.txt

T_Name=`echo "$1" |cut -d"[" -f1`
Lignes=`echo "$1" |cut -d"[" -f2|cut -d"]" -f1`
Colonnes=`echo "$1" |cut -d"[" -f3|cut -d"]" -f1`

FileIn=$2
local rc=0
local index
local lc=0

cat $FileIn |&
while read -p ligne
do
if [ lc -lt $Colonnes ]
then
local colonne=`expr $lc % $Colonnes`
local lng=`expr $rc % $Lignes`

let "index = $colonne * $Lignes + $lng"
# PROD[$index]="$ligne"
eval "$T_Name[$index]=$ligne"
let "lc += 1"
else
lc=0
let "rc += 1"
local colonne=`expr $lc % $Colonnes`
local lng=`expr $rc % $Lignes`
let "index = $colonne * $Lignes + $lng"
# PROD[$index]="$ligne"
eval "$T_Name[$index]=$ligne"
let "lc += 1"
fi
done
}

###########################################
# MAIN #
###########################################
# Exemple

DEFINE_TAB PROD 100 20

# Récupération des éléments concernant le tableau
# Afin de pouvoir en déclarer un deuxième sans perdre les paramètres
Tab1=`echo "$T_Param" |cut -d"[" -f1`
Tab1_Param=$T_Param

echo "Initialisation du tableau $Tab1"
INIT_TAB $Tab1_Param "-------------------------"
echo "Add elements à $Tab1"
ADD $Tab1_Param 0 0 "Flag"
ADD $Tab1_Param 0 1 "ID_L"
ADD $Tab1_Param 0 2 "Len_L"
ADD $Tab1_Param 0 3 "Val_L"
ADD $Tab1_Param 0 4 "CTRL"
ADD $Tab1_Param 0 5 "Termine"
ADD $Tab1_Param 0 6 "Rang"
ADD $Tab1_Param 0 7 "Node"
ADD $Tab1_Param 0 8 "Session"
ADD $Tab1_Param 0 9 "GO"
ADD $Tab1_Param 0 10 "UG"
ADD $Tab1_Param 0 11 "Wait"
ADD $Tab1_Param 0 12 "Wait1"
ADD $Tab1_Param 0 13 "Wait2"
ADD $Tab1_Param 0 14 "Wait3"
ADD $Tab1_Param 0 15 "Wait4"
ADD $Tab1_Param 0 16 "Wait5"
ADD $Tab1_Param 0 17 "Libelle"
ADD $Tab1_Param 0 18 "Vide"
ADD $Tab1_Param 0 19 "NC"

echo "Sauvegarde du tableau $Tab1"
SAVE_TAB $Tab1_Param f1
chmod +x f1

echo "Upload du tableau $Tab1 depuis le fichier f1"
UPLOAD_TAB $Tab1_Param f1

echo "Ajout de test en position 42 18 dans $Tab1"
ADD $Tab1_Param 42 18 test

echo "Sauvegarde du tableau $Tab1 après modification"
SAVE_TAB $Tab1_Param f

gloo

tu pourrais m'expliquer un peu plus a quoi ca sert ?

Fred_l

A avoir un tableau en 2D et de le gérer facilement !!

Bon je vais encore t'embêter !! Ba oui que veux tu !!

Voilà, il faudrais que je lise une chaîne caractère par caratère et ensuite avoir le code ainsi du caractère !!!

ma chine est du genre :

Fred_l

OUPS !!!!!
y'a eu un bug !!

A avoir un tableau en 2D et de le gérer facilement !!

Bon je vais encore t'embêter !! Ba oui que veux tu !!

Voilà, il faudrais que je lise une chaîne caractère par caratère et ensuite avoir le code ainsi du caractère !!!

ma chaine est du genre :
R=00025+NODE=adhpar+CTRL=O+S=SATPABIS01+W=SATPASTP01+GO+UG=P_ADHPAR

et je veux faire un CRC de celle-ci

Message cité 1 fois

gloo

Fred_l a écrit :

y a une commande pour cela : cksum ou bien sum

exemple

cksum file

ou bien

echo "$MAVariable" | cksum

et en recuperant le resultat

RES=$( echo "$MAVariable" | cksum )"

par contre, fait le man pour verifier lequel est meilleur....
y en a un des 2 qui est plus standard que l'autre .....

Message édité par gloo le 19-06-2006 à 16:43:28

Fred_l

Ouai !!

Citation :

For LANCEMENT in $LANCEMENTS
let "NbreLancement += 1"
# CRC
ADD_TAB $Tab1_Prod_Parm $IDX 0 $(echo $LANCEMENT|cksum)|cut -d" " -f1
# ID_L
ADD_TAB $Tab1_Prod_Parm $IDX 1 $NbreLancement
# LEN_L
ADD_TAB $Tab1_Prod_Parm $IDX 2 $(echo $LANCEMENT|cksum)|cut -d" " -f2
et bla bla bal je continue !

Du coup pas besoin de parcourir la chaîne !!
(Même si c'est déjà fait ! )

Citation :

# Lecture d'une chaîne caratère / caratère

rc=0
let "Length=${#StrIn} +1"
while $rc LSS Length
do
cuttemp=cut -c$rc-$rc
Char="eval echo $StrIn | $cuttemp"
echo $Char
done

Merci gloo !
Qaund tu me demande pour quoi c'est faire, si je te mets le code du plan de production tu vas prendre une crise cardiaque !!!
Une vrai usine à gaz !!
Mais ça marche !!!
Faut dire que je dois tout tester de façon à ce que si il y à unhe bourde la prod ne se plante pas !!!!
C'est aussi la raison du pourquoi passer par un tableau dynamique en 2D ! Optimisation oblige !

@+
Fred

FORUM HardWare.fr

Programmation

Shell/Batch

variabilisation nom de tableau KSH

Sujets relatifs
tableau croisé dynamique	pb recup tableau php en javascript
Actualisation de tableau croisé dynamique sur plage variable	[html] problème de tableau ( débutant )
probleme tableau	Margin d'un tableau ... je pète un plomb
Créer un tableau	Arrière plan de cellule de tableau
comment gerer des div (plutot qu'un tableau) ?	[C] tableau
Plus de sujets relatifs à : variabilisation nom de tableau KSH

Page générée en 0.054 secondes