Bonjour,

Je cherche à écrire une fonction générique qui extrait les options et leurs arguments d'une ligne de commande pour pouvoir les passer à une autre commande plus loin dans le programme .
Je rencontre un problème lorsqu'un argument est vide ou contient une espace.
Mon premier réflexe a été d'encadrer l'argument mais je n'obtiens pas le résultat attendu.

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#!/usr/bin/ksh93
 
# La fonction qui affiche les options et paramètres reçus
function ExtraitOpts {
  integer  Version=$1
  typeset  Options="$2"
  if (( $# > 2 ))
  then
    shift 2
    typeset  Opt Opts=""
    while getopts ":${Options}" Opt "$@"
    do
      if [[ ${Options} == *${Opt}:* ]]  # Opion avec argument
      then
        if (( Version == 1 )) || ( [[ -n ${OPTARG} ]] && ! [[ ${OPTARG} =~ [ ] ]] ) # Argument en plusieurs mots ou vide
        then
          Opts+="-${Opt} ${OPTARG} "
        else # Argument en plusieurs mots ou vide
          Opts+="-${Opt} '${OPTARG}' "
        fi
      else
        Opts+="-${Opt} "
      fi
    done
    shift $(( OPTIND - 1 ))
    if (( Version == 1 ))
    then
      print -eR ${Opts} "$@"
    else
      typeset Params=
      if [[ -n ${OPTARG} ]] && ! [[ ${OPTARG} =~ [ ] ]]
      then
        Params+="$1 "
      else # Paramètre en plusieurs mots ou vide
        Params+="'$1' "
      fi
      print -eR ${Opts} ${Params}
    fi
  fi
}
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# La fonction qui attend ces options et paramètres
function Procedure {
  typeset Opt= ArgX= ArgY=
  integer Prm=1
  while getopts ':x:y:z' Opt "$@"
  do
    case  ${Opt}   in
      [xy]  ) echo "Opt : -${Opt} |${OPTARG}|"  ;;
      z     ) echo "Opt : -${Opt}"              ;;
    esac
  done
  shift $(( OPTIND - 1 ))
  while (( $# ))
  do
    echo "Prm$(( Prm++ )) = |$1|"
    shift
  done
  echo
}
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# Quelque lignes de commande pour tester
Variable=$(ExtraitOpts 1 'x:y:z' -x abc -y def -z Version1)
Procedure ${Variable}
 
Variable=$(ExtraitOpts 1 'x:y:z' -x "Deux Mots" -y '' -z "Version 1" '')
Procedure ${Variable}
 
Variable=$(ExtraitOpts 1 'x:y:z' -y '' -x "Deux Mots" -z "Version 1" '')
Procedure ${Variable}
 
Variable=$(ExtraitOpts 2 'x:y:z' -x abc -y def -z Version2)
Procedure ${Variable}
 
Variable=$(ExtraitOpts 2 'x:y:z' -x "Deux Mots" -y '' -z "Version 2")
Procedure ${Variable} 
 
Variable=$(ExtraitOpts 2 'x:y:z' -y '' -x "Deux Mots" -z "Version 2" '')
Procedure ${Variable}
# Le résultat obtenu
Opt : -x |abc|
Opt : -y |def|
Opt : -z
Prm1 = |Version1|

Opt : -x |Deux|
Prm1 = |Mots|
Prm2 = |-y|
Prm3 = |-z|
Prm4 = |Version|
Prm5 = |1|

Opt : -y |-x|
Prm1 = |Deux|
Prm2 = |Mots|
Prm3 = |-z|
Prm4 = |Version|
Prm5 = |1|

Opt : -x |abc|
Opt : -y |def|
Opt : -z
Prm1 = |'Version2'|

Opt : -x |'Deux|
Prm1 = |Mots'|
Prm2 = |-y|
Prm3 = |''|
Prm4 = |-z|
Prm5 = |'Version|
Prm6 = |2'|

Opt : -y |''|
Opt : -x |'Deux|
Prm1 = |Mots'|
Prm2 = |-z|
Prm3 = |'Version|
Prm4 = |2'|
# Le résultat attendu sur la dernière commande
Opt : -y ||
Opt : -x |Deux Mots|
Opt : -z
Prm1 = |Version 2|
La fonction originale est plus complexe et extrait seulement certaines options parmi la liste des options reçues.
Il me reste la possibilité de traiter à chaque fois la ligne de commande en détail et enregistrer chaque argument dans une variable mais j'aurais aimé pouvoir me dispenser de recopier ce bloc de code en plusieurs exemplaires.