Récupérer les options et paramètres reçus pour les passer à une autre commande

Version imprimable

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:

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:

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:

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.

28/01/2019, 13h53
Flodelarab

Bonjour :coucou:

Dans ce genre de démarche, il faut faire attention au nombre de fois que sont interprété les double quotes " ".

Je ne connais pas ksh93, mais ne faut-il pas plutôt écrire un truc comme ceci, pour régler le problème ?

Code:

Opts+="-${Opt} \"${OPTARG}\" "
28/01/2019, 14h06
al1_24
J'avais déjà essayé (mais j'ai revérifié par acquit de conscience;)) mais celà ne change rien au comportement de la fonction : les apostrophes sont simplement remplacées par des guillemets et les arguments restent traités mot par mot.:?
```
Opt : -y |""|
Opt : -x |"Deux|
Prm1 = |Mots"|
Prm2 = |-z|
Prm3 = |"Version|
Prm4 = |2"|
```
Merci quand même de t'être intéressé à mon problème.
28/01/2019, 15h02
Flodelarab

Rajoute une couche.

Code:

Opts+="-${Opt} \\\"${OPTARG}\\\" "

Ou plusieurs. Jusqu'à ce que ce satané double quote apparaisse. Puis -1.
28/01/2019, 20h06
al1_24

Le "satané" guillemet apparait bien. Mon problème c'est qu'il n'est pas interprété comme un caractère d'encadrement de chaine.

A force de chercher, j'ai fini par trouver une solution en appelant ma procédure et sa variable contenant options et paramètres à travers la commande eval.

Oui, je sais que eval is evil mais, pour le moment, c'est tout ce que j'ai trouvé.:calim2:

J'ai trouvé !
Je peux me dispenser d'eval en utilisant un tableau passé par référence à la fonction.

Je donne la solution si cela peut aider quelqu'un d'autre ;)

La fonction

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
function ExtraitOpts2 {
  if (( $# > 2 ))
  then
    nameref Opts=$1
    typeset Options="$2"
    shift 2
    typeset Opt
    integer Idx=0
    while getopts ":${Options}" Opt "$@"
    do
      Opts[ $(( ++Idx )) ]="-${Opt}"
      if [[ ${Options} == *${Opt}:* ]]  # Option avec argument
      then
        Opts[ $(( ++Idx )) ]="${OPTARG}"
      fi
    done
    shift $(( OPTIND - 1 ))
    while (( $# ))
    do
      Opts[ $(( ++Idx )) ]="${1}"
      shift
    done
  fi
}

Son utilisation

Code:

1
2
3
typeset -a Tableau
ExtraitOpts2 Tableau 'w:x:y:z' -y '' -x "Deux Mots" -w '"' -z "Version 2" '' '"' "'"
Procedure "${Tableau[@]}"

Le résultat

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