Como posso obter com segurança a versão do ksh?

Como posso obter com segurança a versão do ksh de um script ksh?

Eu vi as seguintes soluções :

1. ksh --version
2. echo ${.sh.version}
3. echo $KSH_VERSION

E, dadas as circunstâncias corretas, cada uma delas funciona corretamente. No entanto, eu me preocupo com o caso não perfeito.

Especificamente, existem várias máquinas com as quais trabalho que possuem versões mais antigas do ksh que, para meus propósitos, estão com uma falta grave de funcionalidade. De qualquer forma, o motivo pelo qual desejo verificar a versão (programaticamente) é ver se a versão ksh é uma das versões menos capazes; e, se assim for, quero executar um ramo com código menos impressionante.

No entanto, nas máquinas problemáticas, a inaptidão do shell se estende à verificação da versão ...

• Se eu tentar ksh --version, ele não imprime nada e abre uma nova instância do ksh!

• Se eu tentar echo ${.sh.version}, kshtrata isso como um erro de sintaxe que não pode ser descartado 2> /dev/null.

  $ echo ${.sh.version} 2> /dev/null  
  ksh: ${.sh.version}: bad substitution

• É claro que echo $KSH_VERSIONparece funcionar bem - quero dizer, não falhará - embora nessas máquinas esteja em branco. Além disso, eu vi em algum lugar que KSH_VERSIONé definido apenas por pdksh.

Questões:

• Como posso verificar com segurança a versão do kshprogramaticamente? Para meus propósitos aqui, eu realmente não me importo com o número da versão real, apenas se é uma versão desatualizada do ksh.
• É $KSH_VERSIONbom o suficiente? Quero dizer, se estiver em branco, então é kshnecessariamente uma versão desatualizada? Esse outro fórum estava correto e pode não ser definido mesmo para versões mais recentes ksh?
• Não há como verificar isso?

Eu acho que .sh.versionexiste desde a primeira versão do ATT ksh 93. Não está disponível em pdksh ou mksh. Desde a${.sh.version} existe um erro de sintaxe em shells diferentes de ksh93, envolva o teste em um subshell e proteja-o eval.

_sh_version=$(eval 'echo "${.sh.version}"' 2>/dev/null) 2>/dev/null
case $_sh_version in
  '') echo "This isn't ATT ksh93";;
  …
esac

KSH_VERSION começou no clone ksh de domínio público (pdksh) e foi adicionado ao shell Korn real há relativamente pouco tempo, em 2008, com o ksh93t.

Em vez de testar o número de uma versão, você deve testar o recurso específico que está causando sofrimento. A maioria dos recursos pode ser testada, tentando alguma construção em um subshell e veja se ele desencadeia um erro.

KSH_VERSIONnão foi implementado ksh93antes da versão 93t. Ele será definido em mksh, pdksh, lksh. Então, para verificar a versão doksh , podemos tentar estas etapas:

• Verificando KSH_VERSIONpara detectar mksh,pdksh ,lksh
• Se o primeiro passo falhar, tente um recurso diferente entre ksh93e ksh88/86( deixe David Korn nos mostrar ).

Com isso em mente, irei com:

case "$KSH_VERSION" in
  (*MIRBSD*|*PD*|*LEGACY*) printf '%s\n' "$KSH_VERSION" ;;
  (*) [ -z "$ERRNO" ] && printf '%s\n' "${.sh.version}" || echo ksh88/86 ;;
esac

Para kshlançamentos "reais" (ou seja, baseados na AT&T), eu uso este comando:

strings /bin/ksh | grep Version | tail -2 

Aqui estão várias saídas que recebo:

Ksh original:

@(#)Version M-11/16/88i

dtksh;

@(#)Version 12/28/93
Version not defined

Ksh93 moderno:

@(#)$Id: Version AJM 93u+ 2012-08-01 $

Para pdksh/ msh kshclones e kshversões modernas da AT&T também, aqui está algo que funciona:

$ mksh -c 'echo $KSH_VERSION'
@(#)MIRBSD KSH R50 2015/04/19

Editar:

Eu esqueci que você estava perguntando sobre fazer isso de dentro de um script, não conhecendo o caminho para o binário ksh testado.

Supondo que você realmente queira a versão kshusada, e não os recursos suportados, aqui está uma maneira de fazê-lo usando apenas o stringscomando que deve funcionar pelo menos no Linux e Solaris:

echo $(for i in $(find /proc/$$ ! -type d ! -name "pagemap" | 
  grep -v "/path/" | grep -v "/fd/" ) ; do
  strings $i | egrep "([V]ersion|[K]SH_VERSION).*[0-9]" | sort -u
done 2>/dev/null)

Observe que esse método não é confiável, pois /procpode não ser montado, e certamente existem outros pontos fracos. Não foi testado em outros sistemas operacionais Unix.

Enquanto escrevia um script ksh, notei que a -aopção do whencecomando interno do ksh parece não ser suportada em versões mais antigas do ksh. E isso parece ser verdade em todos os sistemas que verifiquei, incluindo Solaris, AIX, HP-UX e Linux.

Então, aqui está a solução como uma função ksh:

is_modern_ksh() {
  if whence -a whence > /dev/null 2>&1 ; then
    return 0 #success -> true
  fi
  #Else the call to `whence` failed because `-a` is not supported
  return 1 #failure -> false
}

E aqui está como usá-lo:

if is_modern_ksh ; then
  echo "You're using a MODERN version of ksh. :)"
else
  echo "You're using an OLD version of ksh. :("
fi

CTRL+ ALT+V

ou

ESC, CTRL+V

Em geral, eles se mostraram muito confiáveis ​​na determinação interativa da versão do KSH que você está usando, no entanto, a criação de scripts para eles se mostrou mais difícil.

Eu acho que o problema fundamental com o uso de $ {. Sh.version} é que o ksh88 para, com um código de saída diferente de zero.

Portanto, minha solução é colocar o código que faz referência a $ {. Sh.version} em um sub-shell e, em seguida, testar se o sub-shell sai diferente de zero e possui um código no sub-shell que funcionará nas versões do o ksh em que a referência a $ {. sh.version} funciona. Embrulhando-o em uma função que é chamada por outra função que reverte o código de retorno, para que a chamada final seja verificada como verdadeira.

function is_oldksh
{
    (test -n ${.sh.version}) 2>/dev/null
}

function oldkshtest
{

    is_oldksh || return 0 && return 1
}

oldkshtest && echo "old ksh" || echo "new ksh"

Eu executei isso no AIX e Oracle Enterprise Linux 5 e 6, com ksh88, ksh93 e pdksh.

Pete

O seguinte parece funcionar razoavelmente bem para todos os shells que testei, incluindo o antigo ksh88e e uma gama quase completa de clones Ksh comuns (embora apenas uma versão de cada), embora ainda não testei um shell Bourne original real ( e isso pode exigir a adaptação da testexpressão para versões mais antigas ....

Termo aditivo:

Agora também testei com sucesso isso com o Heirloom Bourne Shell, embora com um programa externo (e mais moderno) test.

is_attksh()
{
    # ksh93
    _sh_version=$(eval 'echo "${.sh.version}"' 2>/dev/null)
    # pdksh only
    _opt_login=$(set -o | grep login)

    test -n "${_sh_version}" -o \( -z "${_opt_login}" -a -n "${_}" -a -n "${ERRNO}" -a -n "${FCEDIT}" -a -n "${PS3}" \)
}
is_attksh && echo "AT&T Ksh${_sh_version:+: }${_sh_version:- (probably ksh88 or ksh86)}" || echo "not real ksh"

is_zsh()
{
    test -n "${ZSH_VERSION}"
}
is_zsh && echo "Zsh: ${ZSH_VERSION}" || echo "not zsh"