Téléchargé Ubuntu à partir de l'ISO torrent et de téléchargement, mais ils ne sont pas de la même taille

Terminal de couleurs (et d'autres commandes) sont contrôlés par des configurations dans votre ~/.bashrc fichier. Si vous faites un peu de recherche sur google pour .bashrc configurations, vous pouvez trouver quelques excellentes configurations personnalisées que vous pouvez utiliser. Celui que j'utilise est une combinaison de plusieurs de ceux que j'ai trouvé sur le net ainsi que quelques modifications que j'ai apportées. Voici une capture d'écran (dans cygwin, depuis que je suis actuellement au travail).

Et voici le contenu de mon ~/.bashrc fichier. Si vous regardez sous les pseudonymes, les noms d'alias ls ajoute les couleurs des drapeaux de la commande automatiquement, donc si vous avez juste envie de couleurs pour les ls, alors que la ligne à utiliser.

#-------------------------------------------------------------
# Source des définitions globales (le cas échéant)
#-------------------------------------------------------------


if [ -f /etc/bashrc ]; then
 . /etc/bashrc # --> Lire /etc/bashrc, si elle est présente.
fi


#-------------------------------------------------------------
# Certains paramètres
#-------------------------------------------------------------

ulimit-S -c 0 # Ne voulez pas de les coredumps.
set-o informer
set-o noclobber
set-o ignoreeof
set-o nounset
#set -o xtrace # Utile pour le débogage.

# Activer les options:
shopt -s cdspell
shopt -s cdable_vars
shopt -s checkhash
shopt -s checkwinsize
shopt -s sourcepath
shopt -s no_empty_cmd_completion
shopt -s cmdhist
shopt -s histappend histreedit histverify
shopt -s extglob # Nécessaire pour programmable achèvement.



l'exportation TIMEFORMAT=$'\nreal %3R\tuser %3U\tsys %3S\tpcpu %P\n"
l'exportation HISTTIMEFORMAT="%H:%M > "
l'exportation HISTIGNORE="&:bg:fg:ll:h"
l'exportation HOSTFILE=$HOME/.les hôtes # Mettre la liste des hôtes distants dans ~/.les hôtes ...



#-------------------------------------------------------------
# Salut, motd, etc...
#-------------------------------------------------------------

# Définir des couleurs d'abord:
rouge='\e[0;31m'
ROUGE='\e[1;31m'
bleu='\e[0;34m'
BLEU='\e[1;34m'
cyan='\e[0;36m'
CYAN='\e[1;36m'
NC='\e[0m' # Pas de Couleur
# --> Nice. A le même effet que l'utilisation de "ansi.sys" dans le DOS.


# Regarde mieux sur un terminal avec un fond noir.....
date

fonction _exit() # Fonction à exécuter lors de la sortie de la coquille.
{
 echo-e "${ROUGE}Hasta la vista, baby${NC}"
}
piège _exit SORTIE


#-------------------------------------------------------------
# L'Invite Du Shell
#-------------------------------------------------------------


if [[ "${DISPLAY%%:0*}" != "" ]]; alors 
 HILIT=${rouge} # la machine distante: rapide sera en partie rouge
d'autre
 HILIT=${cyan} # la machine locale: rapide sera en partie cyan
fi

export PS1='\n\[\033[0;31m\]\u\[\033[0;37m\]@\[\033[0;32m\]\h\[\033[0;37m\]:\[\033[0;36m\]\W\[\033[0;32m\]\$ \[\033[0;37m\]' 




#===============================================================
#
# LES ALIAS ET LES FONCTIONS
#
# Sans doute, certaines fonctions définies ici sont assez grandes.
# Si vous voulez faire de ce fichier plus petit, ces fonctions ne peuvent
# convertis en scripts et supprimés à partir d'ici.
#
# De nombreuses fonctions ont été prises (presque) directement à partir de la bash-2.04
# exemples.
#
#===============================================================

#-------------------
# Perso Alias
#-------------------

alias rm='rm -i'
alias cp='cp -i'
alias mv='mv -i'
# -> Empêche accidentellement casser les fichiers.
alias mkdir='mkdir -p'

alias h= "historique"
alias j='emplois -l'
alias qui='type'
alias ..='cd ..'
alias chemin='echo-e ${PATH//:/\\n}'
alias libpath='echo-e ${LD_LIBRARY_PATH//:/\\n}'
alias print='/usr/bin/lp -o nobanner -d $LPDEST'
 # Suppose LPDEST est défini (par défaut de l'imprimante)
alias pjet='enscript -h -G -fCourier9 -d $LPDEST'
 # Pretty-print à l'aide de enscript

alias du='du-kh' # Rend plus lisible de sortie.
alias df='df -kTh'

alias vi='vim' #qui veut utiliser vi sur vim?

alias archive='tar czvf' #je ne me souviens jamais les arguments
alias untarball='tar xzvf'

#-------------------------------------------------------------
# Le " ls " de la famille (cela suppose que vous utilisez un récent GNU ls)
#-------------------------------------------------------------
alias ll="ls -l --groupe-répertoires-première"
alias ls='ls -hF --color' # ajouter des couleurs pour filetype reconnaissance
alias la='ls -Al' # afficher les fichiers cachés
alias lx='ls -lXB' # trier par extension
alias lc='ls -lSr' # trier par taille, du plus dernier
alias lc='ls -ltcr' # trier par et de montrer le changement de temps, la plus récente dernière
alias lu='ls -ltur' # trier et d'afficher les temps d'accès, la plus récente dernière
alias lt='ls -ltr' # trier par date, de la plus récente dernière
alias lm='ls -al |plus d'' # pipe à travers "plus"
alias lr='ls -lR' # recursif ls
alias arbre=arbre -Csu' # nice alternative à la "récursive ls'

# Si votre version de 'ls' n'a pas de soutien-groupe-répertoires-d'abord, essayez ceci:
# fonction ll(){ ls-l "$@"| egrep "^d" ; ls -lXB "$@" 2>&-| \
# egrep -v "^d|total "; }


#-------------------------------------------------------------
# coupe 'moins'
#-------------------------------------------------------------

alias plus='moins'
l'exportation PAGER=moins de
l'exportation LESSCHARSET='latin1'
l'exportation LESSOPEN='|/usr/bin/lesspipe.sh %s 2>&-'
 # Utilisez cette fonction si lesspipe.sh existe
l'exportation MOINS='-i -N-o -z-4 -g -e -M -X -F -R -P%t?f%f \
:stdin .?pb%pb\%:?lbLine %lb:?bbByte %bb:-...'


#-------------------------------------------------------------
# orthographe, les fautes de frappe très personnelle et clavier-dépendant :-)
#-------------------------------------------------------------

alias xs='cd'
alias vf='cd'
alias moer= "plus"
alias moew= "plus"
alias kk= "ll"


#-------------------------------------------------------------
# Un peu plus amusantes
#-------------------------------------------------------------


fonction xtitle() # Ajoute du texte dans le terminal cadre.
{
 case "$TERM" dans
 *durée | rxvt)
 echo-n -e "\033]0;$*\007" ;;
 *) 
;;
esac
}

# alias qui utilisent xtitle
alias top='xtitle Processus sur $HOST && top"
alias marque='xtitle Faire $(basename $PWD) ; faire"
alias ncftp="xtitle ncFTP ; ncftp"

# .. et fonctions
la fonction de l'homme (la)
{
 pour je ; ne
 xtitle L' $(basename $1|tr -d .[:digit:]) manuel
 commande homme -F-a "$i"
fait
}


#-------------------------------------------------------------
# Faire les commandes suivantes exécutées en arrière-plan automatiquement:
#-------------------------------------------------------------

la fonction te() # Wrapper autour de xemacs/gnuserv ...
{
 if [ "$(gnuclient -lot -eval t 2>&-)" == "t" ]; then
 gnuclient -q "$@";
d'autre
 ( xemacs "$@" &);
fi
}

fonction soffice() { commande soffice "$@" & }
la fonction de firefox() { commande firefox "$@" & }
fonction xpdf() { commande xpdf "$@" & }


#-------------------------------------------------------------
# Les fichiers et la chaîne des fonctions liées à:
#-------------------------------------------------------------


# Trouver un fichier avec un motif de nom:
la fonction ff() { trouver . -type f -iname '*'$*'*' -ls ; }

# Trouver un fichier avec le modèle 1 $nom et l'Exécuter 2 $sur elle:
la fonction fe()
{ trouver . -type f -iname '*'${1:-}'*' -exec ${2:-fichier} {} \; ; }

# Recherche d'un motif dans un ensemble de fichiers et de les mettre en évidence:
# (besoin d'une version récente de egrep)
fonction fstr()
{
'OPTIND' =1
 local=""
 local usage="fstr: chaîne de recherche dans les fichiers.
Utilisation: fstr [-i] \"motif\" [\"modèle de nom de fichier\"] "
 alors que getopts :il opter
faire
 case "$opt" dans
 i) cas="-i " ;;
 *) echo "$utilisation"; return;;
esac
fait
 shift $ (( $'OPTIND' - 1 ))
 if [ "$#" -lt 1 ]; then
 echo "$utilisation"
retour;
fi
 trouver . -type f -name "${2:-*}" -print0 | \
 xargs -0 egrep --color=toujours -sn ${case} "$1" 2>&- | plus 

}

fonction cuttail() # couper les n dernières lignes dans le fichier, 10 par défaut
{
nlines=${2:-10}
 sed-n -e :a-e "1,${nlines}!{P;N;D;};N;ba" $1
}

la fonction minuscule() # déplacer les noms de fichiers en minuscules
{
 pour le fichier ; ne
filename=${fichier##*/}
 case "$filename" dans
 */*) dirname==${fichier%/*} ;;
 *) dirname=.;;
esac
 nf=$(echo $filename | tr A-Z a-z)
newname="${dirname}/${nf}"
 if [ "$nf" != "$nomfichier" ]; then
 mv "$fichier", "$newname"
 echo "minuscule: $fichier --> $newname"
d'autre
 echo "minuscule: $fichier pas changé."
fi
fait
}


la fonction swap() # Swap 2 noms de fichiers, si elles existent
{ #(à partir de Uzi est bashrc).
 local TMPFILE=tmp.$$ 

 [ $# -ne 2 ] && echo "swap: 2 arguments nécessaires" && return 1
 [ ! -f $1 ] && echo "swap: $1 n'existe pas" && return 1
 [ ! -e $2 ] && echo "swap: $2 n'existe pas" && return 1

 mv "$1" $TMPFILE 
 mv "$2" "$1"
 mv $TMPFILE "$2"
}

la fonction extract() # Pratique de l'Extrait de Programme.
{
 if [ -f $1 ] ; then
 cas 1 $
 *.le goudron.bz2) tar xvjf $1 ;;
 *.tar.gz) tar xvzf $1 ;;
 *.bz2) bunzip2 $1 ;;
 *.rar unrar x $1 ;;
 *.gz) gunzip $1 ;;
 *.tar, tar xvf $1 ;;
 *.tbz2) tar xvjf $1 ;;
 *.tgz) tar xvzf $1 ;;
 *.zip) décompressez $1 ;;
 *.Z) décompresser $1 ;;
 *.7z) 7z x $1 ;;
 *) echo "'$1' ne peut pas être extraite par de l' >extrait<" ;;
esac
d'autre
 echo "'$1' n'est pas un fichier valide"
fi
}

#-------------------------------------------------------------
# Système/processus et fonctions connexes:
#-------------------------------------------------------------


fonction my_ps() { ps $@ -u $USER -o pid%cpu,%mem,bsdtime,commande ; }
la fonction de pp() { my_ps f | awk '!/awk/ && $0~var et la var=${1:-".*"} ; }


fonction killps() # Tuer par le nom du processus.
{
 local pid pname sig="DURÉE" # par Défaut du signal.
 if [ "$#" -lt 1 ] || [ "$#" -gt 2 ]; then
 echo "Usage: killps [-SIGNAL] modèle"
retour;
fi
 if [ $# = 2 ]; then sig=$1 ; fi
 pour le pid dans $(my_ps| awk '!/awk/ && $0~pat { print $1 }' pat=${!#} ) ; ne
 pname=$(my_ps | awk '$1~var { print $5 }' var=$pid )
 si demander à "Tuer le processus de $pid <$pname> avec un signal de $sig?"
 puis tuer $sig $pid
fi
fait
}

fonction my_ip() # Obtenir des adresses IP.
{
 MY_IP=$(/sbin/ifconfig ppp0 | awk '/inet/ { print $2 } ' | \
sed -e s/addr://)
 MY_ISP=$(/sbin/ifconfig ppp0 | awk '/P-t-P/ { print $3 } ' | \
sed -e s/P-t-P://)
}

fonction ii() # Obtenir de l'hôte actuel infos.
{
 echo-e "\nvous êtes connecté sur ${ROUGE}$HOST"
 echo-e "\nAdditionnal informations:$NC " ; uname-a
 echo-e "\n${ROUGE}les Utilisateurs connectés:$NC " ; w -h
 echo-e "\n${ROUGE}date en cours :$NC " ; la date
 echo-e "\n${ROUGE}Machine à stats :$NC " ; la disponibilité
 echo-e "\n${ROUGE}Mémoire stats :$NC " ; libre
 my_ip 2>&- ;
 echo-e "\n${ROUGE}Adresse IP Locale :$NC" ; echo ${MY_IP:-"Non connecté"}
 echo-e "\n${ROUGE}FAI Adresse :$NC" ; echo ${MY_ISP:-"Non connecté"}
 echo-e "\n${ROUGE}connexions Ouvertes :$NC "; netstat -pan --inet;
echo
}

#-------------------------------------------------------------
# Divers utilitaires:
#-------------------------------------------------------------

la fonction de répétition() # Répéter n fois la commande.
{
 local je max
 max=$1; changement;
 for ((i=1; i <= max ; i++)); do # --> C-syntaxe
 eval "$@";
fait
}


la fonction ask() # Voir "killps" pour l'exemple d'utilisation.
{
 echo-n "$@" '[y/n] ' ; lecture et
 case "$ans" en
 y*|Y*) return 0 ;;
 *) return 1 ;;
esac
}

fonction corename() # Obtenir le nom de l'application qui a créé un fichier mémoire.
{ 
 pour le fichier ; ne
 echo-n $fichier : ; gdb --core=$fichier-batch | head -1
 fait 
}




#=========================================================================
# PROGRAMMABLE ACHÈVEMENT SEULE DEPUIS BASH-2.04
# La plupart sont prises à partir de la bash 2.05 documentation et de Ian McDonald
# 'Bash completion' package (http://www.caliban.org/bash/#completion).
# Vous aurez en effet besoin de bash plus récente que la 3.0 pour certaines fonctionnalités.
#=========================================================================

if [ "${BASH_VERSION%.*}" \< "3.0" ]; alors
 echo "Vous devez mettre à niveau vers la version 3.0 \
pour plein programmable achèvement de fonctionnalités."
de retour
fi

shopt -s extglob # Nécessaire,
#set +o nounset # sinon certains achèvements échouera.

complet -Un nom d'hôte rsh rcp telnet, rlogin r ftp ping disque
terminer l'exportation printenv
complet -Une variable d'exportation local readonly unset
complet -Un permis builtin
complet -Un alias alias unalias
complet -Une fonction
terminer l'utilisateur su courrier doigt

complet -Une rubrique d'aide help # Actuellement, de même que les builtins.
terminer shopt shopt
terminer l'arrêté -P '%' bg
complet -travail-P '%' fg emplois renier

complet -Un répertoire mkdir rmdir
complet -Un annuaire -o cd par défaut

# Compression
complet -f -o par défaut -X '*.+(zip|ZIP)' zip
complet -f -o par défaut -X '!*.+(zip|ZIP) décompresser
complet -f -o par défaut -X '*.+(z|Z) " comprimer
complet -f -o par défaut -X '!*.+(z|Z)' décompresser
complet -f -o par défaut -X '*.+(gz|GZ)' gzip
complet -f -o par défaut -X '!*.+(gz|GZ)' gunzip
complet -f -o par défaut -X '*.+(bz2|BZ2)' bzip2
complet -f -o par défaut -X '!*.+(bz2|BZ2)' bunzip2
complet -f -o par défaut -X '!*.+(zip|ZIP|z|Z|gz|GZ|bz2|BZ2)' extrait


# Documents Postscript,pdf,dvi.....
complet -f -o par défaut -X '!*.+(ps|SP)' gs ghostview ps2pdf ps2ascii
complet -f -o par défaut -X '!*.+(dvi|DVI)' dvips dvipdf xdvi dviselect dvitype
complet -f -o par défaut -X '!*.+(pdf|PDF)' acroread pdf2ps
complet -f -o par défaut -X \
'!*.@(@(?(e)ps|?(E)PS|pdf|PDF)?(.gz|.GZ|.bz2|.BZ2|.Z))' gv ggv
complet -f -o par défaut -X '!*.texte*' makeinfo texi2dvi texi2html texi2pdf
complet -f -o par défaut -X '!*.tex' tex latex slitex
complet -f -o par défaut -X '!*.lyx' lyx
complet -f -o par défaut -X '!*.+(htm*|HTM*)' lynx html2ps
complet -f -o par défaut -X \
'!*.+(doc|DOC|xls|XLS|ppt|PPT|sx?|SX?|csv|CSV|od?|OD?|ott|OTT)' soffice

# Multimédia
complet -f -o par défaut -X \
'!*.+(gif|GIF|jp*g|JP*G|bmp|BMP|xpm|XPM|png|PNG)' xv gimp ee gqview
complet -f -o par défaut -X '!*.+(mp3|MP3)' mpg123 mpg321
complet -f -o par défaut -X '!*.+(ogg|OGG)' ogg123
complet -f -o par défaut -X \
'!*.@(mp[23]|MP[23]|ogg|OGG|wav|WAV|pls|m3u|xm|mod|s[3t]m|elle|mtm|ult|flac)' xmms
complet -f -o par défaut -X \
'!*.@(mp?(e)g|MP?(E)G|wma|avi|AVI|asf|vob|VOB|bin|dat|vcd|\
ps|pse|fli|viv|rm|ram|yuv|mov|MOV|qt|QT|wmv|mp3|MP3|ogg|OGG|\
ogm|OGM|mp4|MP4|wav|WAV|asx|ASX)' xine



complet -f -o par défaut -X '!*.pl' perl perl5


# C'est "universelle" fonction d'achèvement - il fonctionne lorsque les commandes ont
# un soi-disant " longue options de mode , c'est à dire: 'ls --tous" au lieu de "ls -a"
# Les besoins de l'option '-o' option de grep
# (essayez de le commenté de version si non disponible).

# Tout d'abord, retirez '=' à partir de l'achèvement des séparateurs de mots
# (cela permettra achèvements comme 'ls --color=auto' pour fonctionner correctement).

COMP_WORDBREAKS=${COMP_WORDBREAKS/=/}


_get_longopts() 
{ 
 #$1 --help | sed -e '/--/!d' -e 's/.*--\([^[:l'espace:].,]*\).*/--\1/'| \
#grep ^"$2" |sort-u ;
 $1 --help | grep -o -e", --[^[: space:].,]*" | grep -e "$2" |sort-u 
}

_longopts()
{
 local cur
cur=${COMP_WORDS[COMP_CWORD]}

 case "${cur:-*}" dans
 -*) ;;
 *) return ;;
esac

 case "$1" dans
 \~*) eval cmd="$1" ;;
 *) cmd="$1" ;;
esac
 COMPREPLY=( $(_get_longopts ${1} ${cur} ) )
}
complet -o par défaut -F _longopts configurer bash
complet -o par défaut -F _longopts wget id info a2ps ls recode

_tar()
{
 local cur ext regex goudron décompresser

COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}

 # Si nous voulons une option, le retour de la longue possible options.
 case "$cur" en
 -*) COMPREPLY=( $(_get_longopts $1 $cur ) ); return 0;;
esac

 if [ $COMP_CWORD -eq 1 ]; then
 COMPREPLY=( $( compgen -W 'c t x u r d A' -- $cur ) )
 return 0
fi

 case "${COMP_WORDS[1]}" dans
?(-)c*f)
 COMPREPLY=( $( compgen -f $cur ) )
 return 0
;;
+([^Izjy])f)
ext='tar'
regex=$ext
;;
*z*f)
ext='tar.gz'
regex='t\(ar\.\)\(gz\|Z\)'
;;
*[Ijy]*f)
ext='t?(ar.)bz?(2)'
regex='t\(ar\.\)bz2\?'
;;
*)
 COMPREPLY=( $( compgen -f $cur ) )
 return 0
;;

esac

 if [[ "$COMP_LINE" == tar*.$ext' '* ]]; then
 # Complet sur les fichiers dans le fichier tar.
#
 # Obtenir le nom de fichier tar en ligne de commande.
 tar=$( echo "$COMP_LINE" | \
 sed-e 's|^.* \([^ ]*'$regex'\) .*$|\1|' )
 # Concevoir la façon de décompresser et de la liste.
décompresser=t${COMP_WORDS[1]//[^Izjyf]/}

 COMPREPLY=( $( compgen -W "$( echo $( tar $décompresser $tar \
 2>/dev/null ) )" -- "$cur" ) )
 return 0

d'autre
 # Fichier de l'achèvement des travaux sur les dossiers pertinents.
 COMPREPLY=( $( compgen -G $cur\*.$ext ) )

fi

 return 0

}

complet -F _tar -o défaut de goudron

_make()
{
 local mdef makef makef_dir="." makef_inc gcmd proposé cur prev i;
COMPREPLY=();
cur=${COMP_WORDS[COMP_CWORD]};
prev=${COMP_WORDS[COMP_CWORD-1]};
 case "$prev" dans
-*f)
 COMPREPLY=($(compgen -f $cur ));
 return 0
;;
esac;
 case "$cur" en
-*)
 COMPREPLY=($(_get_longopts $1 $cur ));
 return 0
;;
esac;

 # faire lit "GNUmakefile", puis "makefile", puis "Makefile"
 if [ -f ${makef_dir}/GNUmakefile ]; then
makef=${makef_dir}/GNUmakefile
 elif [ -f ${makef_dir}/makefile ]; then
makef=${makef_dir}/makefile
 elif [ -f ${makef_dir}/Makefile ]; then
makef=${makef_dir}/Makefile
d'autre
 makef=${makef_dir}/*.mk # la convention Locale.
fi


 # Avant de nous d'analyse pour les cibles, voir si un nom de Makefile a été
 # spécifiée avec-f ...
 for (( i=0; i < ${#COMP_WORDS[@]}; i++ )); do
 if [[ ${COMP_WORDS[i]} == -f ]]; then
 # eval pour l'expansion du tilde
 eval makef=${COMP_WORDS[i+1]}
pause
fi
fait
 [ ! -f $makef ] && return 0

 # deal avec les Makefiles
 makef_inc=$( grep -E '^-?include' $makef | \
 sed -e "s,^.* ,"$makef_dir"/," )
 pour le fichier dans $makef_inc; ne
 [ -f $fichier ] && makef="$makef $fichier"
fait


 # Si nous avons une partie de mot pour terminer, restreindre les achèvements de
 # matches de ce mot.
 if [ -n "$cur" ]; then gcmd proposé='grep "^$cur"' ; else gcmd proposé=cat ; fi

 COMPREPLY=( $( awk -F':' '/^[a-zA-Z0-9][^$#\/\t=]*:([^=]|$)/ \
 {split($1,A,/ /);for(i in A)print A[i]}' \
 $makef 2>/dev/null | eval $gcmd proposé ))

}

complet -F _make -X '+($*|*.[cho])' faire gmake pmake




_killall()
{
 local cur prev
COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}

 # obtenir une liste de processus (le premier sed évaluation
 # prend soin de permutée processus, la deuxième
 # prend soin d'obtenir le nom de base du processus)
 COMPREPLY=( $( /usr/bin/ps -u $USER -o comm | \
 sed-e '1,1 d' -e 's#[]\[]##g' -e 's#^.*/##'| \
 awk '{if ($0 ~ /^'$cur'/) print $0}' ))

 return 0
}

complet -F _killall killall killps



# Une méta-achèvement de commande de fonction pour les commandes comme sudo(8), qui doivent
# d'abord effectuer sur une commande, puis, selon que la commande est propre
# achèvement définition - actuellement pas assez à toute épreuve,
# mais encore très utile (Par Ian McDonald, modifié par moi).


_meta_comp()
{
 local cur func cline cspec

COMPREPLY=()
cur=${COMP_WORDS[COMP_CWORD]}
cmdline=${COMP_WORDS[@]}
 if [ $COMP_CWORD = 1 ]; then 
 COMPREPLY=( $( compgen -c $cur ) )
d'autre
 cmd=${COMP_WORDS[1]} # la commande Rechercher.
 cspec=$( complet -p ${cmd} ) # Trouver les spec de la commande.

 # COMP_CWORD et COMP_WORDS() ne sont pas en lecture seule,
 # on peut donc les définir avant de passer au large à la régulière
 # routine d'achèvement:
 # Récupère la ligne de commande moins une commande initiale,
 cline="${COMP_LINE#$1 }"
 # split ligne de commande actuelle des jetons dans le tableau,
 COMP_WORDS=( $cline )
 # set jeton actuel numéro 1 de moins que maintenant.
 COMP_CWORD=$(( $COMP_CWORD - 1 ))
 # Si arg est vide, l'ajouter à COMP_WORDS tableau
 # (autrement que l'information sera perdue).
 if [ -z $cur ]; puis COMP_WORDS[COMP_CWORD]="" ; fi

 if [ "${cspec%%-F *}" != "${cspec}" ]; then
 # si -F puis obtenir la fonction:
 func=${cspec#*-F }
 func=${func%% *}
 eval $func $cline # de l'Évaluer.
d'autre
 func=$( echo $cspec | sed -e 's/^complets//' -e 's/[^ ]*$//' )
 COMPREPLY=( $( eval compgen $func $cur ) )
fi

fi

}


complet -o par défaut -F _meta_comp nohup \
eval exec trace de botte strace sotruss gdb
complet -o par défaut -F _meta_comp type de commande que l'homme agréable moment

# Variables Locales:
# mode:script shell
# sh-shell:bash
# End: