Bernd Eggink

Variablen editieren (2)

Funktionen: Zur Unterscheidung von Variablen wird vor jedem Funktionsnamen eine der Optionen -f, -F oder -p angegeben. Die Funktion braucht noch nicht zu existieren; ggf. wird eine leere Funktion generiert. Die Optionen entsprechen verschiedenen Bearbeitungsmodi:

-f name: Rein temporäres Ändern. Sinnvoll, um auf die Schnelle kleine Funktionen zu erzeugen und zu testen, aber nur unter der bash. Diese kann eine intern gespeicherte Funktion als Text reproduzieren, sodass zum Editieren eine temporäre Hilfsdatei ausreicht. Der Text unterliegt einer bash-eigenen Formatierung, die man nicht unbedingt schön finden muss. Die Funktionsdefinition steht in derselben Datei wie eventuelle Variablenbesetzungen.
Im Gegensatz zur bash kann die Kornshell den Text einer Funktion nur ausgeben, wenn die zugehörige Quelldatei existiert. Ist die Datei nicht mehr verfügbar, lässt sich die Funktion zwar noch aufrufen, aber nicht mehr editieren. Die Verwendung einer temporären Datei hat also bei der ksh keinen Sinn. Deshalb wirkt bei der ksh-Version von vared die Option -f wie -F (s.u.).
-F name: Editieren mithilfe einer permanenten Datei. Sinnvoll, wenn man eine Funktion in mehreren Sitzungen bearbeiten will. Statt in einer temporären Datei wird der Text in einem speziellen Verzeichnis unter dem Namen der Funktion abgelegt. Das Verzeichnis lässt sich durch Besetzen der Variablen BASH_VARED_FDIR bzw. KSH_VARED_FDIR vorgeben, voreingestellt sind ~/bash-funcs bzw. ~/ksh-funcs. Die Quelle steht auch nach Ende der Shell noch zur Verfügung, nicht mehr benötigte Dateien müssen vom Benutzer gelöscht werden. Falls man eine anderswo definierte Funktion editiert, gibt es anschließend zwei Quellen - die Originalversion und die von vared erzeugte. Wurde die Originalversion beim Durchlaufen einer profile-Datei definiert, ist sie zwar nach dem Einloggen zunächst aktiv, aber der nächste vared-Aufruf aktiviert die von vared verwaltete Version. In diesem Modus kann man eine Funktion schrittweise ändern, ohne die Originalversion anzurühren. Erst nach ausführlichem Testen überschreibt man dann die alte Version mit der neuen.
-p name oder -p pfad: Direktes Editieren einer Quelle. Ist der Parameter ein einfacher Name, wird die Quelle über den Suchpfad FPATH gesucht. Handelt es sich um einen Pfad (d.h. mindestens ein / ist enthalten), bezeichnet er die Quelldatei. Vorsicht ist geboten, denn im Gegensatz zu (2) wird hier die "offizielle" Version der Funktion verändert.

Bash-Version

# Edit variables interactively (bash version)

# vared {varname | arrayname[index] | -a arrayname | {-f|-F} funcname | -p {funcname|path} }...

shopt -s extglob

#-----------------------------------------------------------------------

function vared  
{ 
    local vared_dcl_ vared_dir_ vared_editfiles_ vared_file_ 
    local vared_found_ vared_funcdir_ vared_funcname_ 
    local vared_i_ vared_indexed_ 
    local -a vared_indices_
    local vared_isfunc_ vared_n_
    local vared_IFS_=$IFS vared_editIFS_
    local vared_defaultFile_=$(mktemp vared.XXXXX)

    trap 'rm -f $vared_defaultFile_' RETURN

    while [[ $1 ]]
    do
        vared_indexed_=
        vared_isfunc_=
        vared_funcname_=

        case $1 in
        (-a)    vared_indexed_=1
                shift
                ;;
        (-f)    vared_isfunc_=1
                shift
                ;;
        (-F)    vared_isfunc_=2
                shift
                ;;
        (-p)    vared_isfunc_=3
                shift
                ;;
        (-h)    cat <<EOF
Usage: ${FUNCNAME[0]} [-h] {name|name[index]|-a name|{-f|-F} name|-p {name|path}}...
     -a: Indexed array 'name' is written in indexed form.
     -f: 'name' is a function name. 
     -F: 'name' is a function name; keep the file /tmp/_vared_/name. 
     -p: Edit existing source.
         If the next parameter is a name, look it up using FPATH.
         Otherwise it must be the path of a function file.
     -h: This help.

An edited file will be sourced.
EOF
                return 0
                ;;
        (*\[*\]|[[:alpha:]]*([[:word:]]))
                :
                ;;
        (*)     printf "+++ not a name: %s\n" "$1" >&2
                shift
                continue
        esac

        # write current settings to tmp file

        if [[ $1 == *\[*\] ]]
        then        
            ### array element

            vared_out_ $1 "${!1}" $'\n' >> $vared_defaultFile_
        elif [[ $vared_isfunc_ ]]
        then
            ### function

            [[ $1 == */* ]] && vared_isfunc_=3

            vared_funcname_=${1##*/}

            case $vared_isfunc_ in
            (1)     # Name supplied, declaration default file

                    if [[ $(declare -F $1) ]]
                    then
                        declare -f $1
                    else
                        printf "function %s\n{\n    :\n}\n" "$vared_funcname_"
                    fi >> $vared_defaultFile_
                    ;;

            (2)     # Name supplied, decl in dedicated tmp file

                    vared_funcdir_=${BASH_VARED_FDIR:-~/bash-funcs}
                    mkdir -p $vared_funcdir_

                    if [[ $(declare -F $1) ]]       # dup!
                    then
                        declare -f $1
                    else
                        printf "function %s\n{\n    :\n}\n" "$vared_funcname_"
                    fi > $vared_funcdir_/$1

                    vared_editfiles_+="$vared_funcdir_/$1" 
                    ;;
    
            (3)     # Path or name supplied
                    
                    if [[ $1 == */* ]]
                    then
                        # path

                        [[ ! -s $1 ]] && printf "function %s\n{\n    :\n}\n" "$vared_funcname_" > $1

                        vared_editfiles_+=" $1"
                    else
                        # name, lookup

                        vared_found_=
                        IFS=:

                        for vared_dir_ in ${FPATH:=$PATH}      # lookup
                        do
                            vared_file_=$vared_dir_/$1

                            if [[ -f $vared_file_ ]]
                            then
                                vared_editfiles_+=" $vared_file_"
                                vared_found_=1
                                break
                            fi
                        done

                        IFS=$' \t\n'

                        [[ ! $vared_found_ ]] &&
                        {
                            printf "+++ unknown function: %s\n" "$1"
                            continue
                        }
                    fi
            esac
        else    
            ### not a function

            vared_dcl_=$(declare -p $1 2>/dev/null)

            case $vared_dcl_ in
            (declare\ -A*)
                ### assoc array

                vared_dcl_=${vared_dcl_#declare -A }
                printf "${vared_dcl_//\'/}\n" >> $vared_defaultFile_
                ;;

            (declare\ -a*)      
                ### indexed array                    

                eval 'vared_n_=${#'$1'[*]}'

                [[ ! $vared_indexed_ ]] && (( vared_n_ )) &&
                {
                    # check for index holes
 
                    eval 'vared_indices_=(${!'$1'[*]})'
                    (( vared_n_ != ${vared_indices_[vared_n_-1]} + 1 )) && vared_indexed_=1
                }
                
                if [[ $vared_indexed_ ]]
                then                    # print indexed
                    vared_dcl_=${vared_dcl_#declare -a }
                    printf "${vared_dcl_//\'/}\n"
                else                    # print normal
                    printf "%s=( " "$1"

                    for (( vared_i_ = 0; vared_i_ < vared_n_; ++vared_i_ ))
                    do
                        eval 'vared_dcl_=${'$1'['$vared_i_']}'
                        vared_out_ '' "$vared_dcl_" ' '
                    done

                     printf ")\n"
                fi >> $vared_defaultFile_
                ;;

            ('')
                ### not set 

                printf "%s=\n" "$1" >> $vared_defaultFile_
                ;;

            (declare\ -?\ *)     
                ### scalar 

                [[ $1 == IFS ]] && vared_editIFS_=1

                vared_out_ $1 "${!1}" $'\n' >> $vared_defaultFile_
                ;;

            (*) 
                ### other

                printf "%s\n" "$vared_dcl_" >> $vared_defaultFile_
                ;;
            esac
        fi

        shift
    done 

    [[ -s $vared_defaultFile_ ]] && vared_editfiles_="$vared_defaultFile_ $vared_editfiles_"

    [[ $vared_editfiles_ ]] && 
    {
        ${EDITOR:-vi} $vared_editfiles_         # edit tmp files

        for vared_file_ in $vared_editfiles_    # source them
        do
            source $vared_file_
        done
    }

    [[ ! $vared_editIFS_ ]] && IFS=$vared_IFS_
    rm -f $vared_defaultFile_
    return 0
}

#-----------------------------------------------------------------------

function vared_out_
{
    local c name=$1 value=$2 out special
    while [[ $value ]]
    do
        c=${value:0:1}

        case $c in
        ($'\a')     out+='\a'
                    special=1
                    ;;
        ($'\b')     out+='\b'
                    special=1
                    ;;
        ($'\f')     out+='\f'
                    special=1
                    ;;
        ($'\n')     out+='\n'
                    special=1
                    ;;
        ($'\r')     out+='\r'
                    special=1
                    ;;
        ($'\t')     out+='\t'
                    special=1
                    ;;
        ($'\v')     out+='\v'
                    special=1
                    ;;
        ($'\\')     out+='\\'
                    special=1
                    ;;
        ($'\'')     out+="\\'"
                    special=1
                    ;;
        (*)         out+=$c
        esac

        value=${value#?}
    done

    if [[ $special ]]
    then
        printf "%s${name:+=}\$'%s'%s" "$name" "$out" "$3"
    else
        printf "%s${name:+=}'%s'%s" "$name" "$out" "$3"
    fi
}

#-----------------------------------------------------------------------

# Completion

complete -v vared

# vim: set filetype=sh

Ksh-Version

# Edit variables interactively (ksh version)

# vared {varname|arrayname[index]|[-a] arrayname|[-f] funcname}...

function vared_usage_
{
    print "Usage: vared [-h] {name|name[index]|-a name|{-f|-F} name|-p {name|path}}..."
    print "     -a: Array 'name' is written in indexed form."
    print "     -f, -F: 'name' is a function name." 
    print "     -p: Edit existing source."
    print "         If the next parameter is a name, look it up using FPATH."
    print "         Otherwise it is must be the path of a function file."
    print "     -h: This help."
}

#-----------------------------------------------------------------------

vared()
{
    typeset vared_dcl_ vared_edit_ vared_funcdir_ 
    typeset vared_i_ vared_indexed_ 
    typeset vared_indices_ vared_isfunc_ vared_n_ 
    typeset vared_tmpfile_=$(mktemp -p ${TMPDIR:-~}/ vared-XXXXX)
    typeset vared_vartype_ 
    typeset -a vared_editfiles_ vared_funcnames_ 

    [[ $1 == -h ]] &&
    {
        vared_usage_
        return
    }

    # functions directory
    
    vared_funcdir_=${KSH_VARED_FDIR:=~/ksh-funcs}

    mkdir -p $vared_funcdir_
    
    # write current settings to tmp file

    > $vared_tmpfile_

    while [[ $1 ]]
    do
        vared_indexed_= 
        vared_isfunc_=

        case $1 in
        (-a)    vared_indexed_=1
                shift
                ;;
        (-f|-F) vared_isfunc_=2
                shift
                ;;
        (-p)    vared_isfunc_=3
                shift
                ;;
        (*\[*\]|[[:alpha:]_]*([[:word:]]))
                :
                ;;
        (*)     print -u2 "+++ not a name: $1"
                shift
                continue
        esac

        typeset -n vared_ref_=$1

        # array element?

        if [[ $1 == *\[*\] ]]
        then        
            ### array element

            print "$1='$vared_ref_'" >> $vared_tmpfile_
            vared_edit_=1
        elif [[ $vared_isfunc_ ]]
        then
            ### function

            case $vared_isfunc_ in
            (2)     # Name supplied, put declaration in special directory

                    vared_dcl_=$(vared_func_ $1)    # get declaration

                    if [[ $vared_dcl_ == "function $1" || $vared_dcl_ == "$1()" ]]
                    then
                        print -u2 "+++ $vared_dcl_: Text not available"
                    else
                        print "$vared_dcl_" > $vared_funcdir_/$1
                        vared_funcnames_+=($vared_funcdir_/$1)
                    fi
                    ;;
            (3)     # Path or name supplied, edit in-place
                    
                    if [[ $1 == */* ]]
                    then
                        # path

                        [[ ! -e $1 ]] &&
                        {
                            echo "+++ file doesn't exist: $1" >&2
                            shift
                            continue
                        }

                        vared_funcnames_+=($1)
                    else
                        # name, look up

                        vared_found_=
                        IFS=:

                        for vared_dir_ in $FPATH      # lookup
                        do
                            vared_file_=$vared_dir_/$1

                            if [[ -f $vared_file_ ]]
                            then
                                vared_funcnames_+=("$vared_file_")
                                vared_found_=1
                                break
                            fi
                        done

                        IFS=$' \t\n'

                        [[ ! $vared_found_ ]] &&
                        {
                            echo "+++ unknown function: $1"
                            continue
                        }
                    fi
                    ;;
            esac
        else
            vared_edit_=1

            # attributed?

            vared_vartype_=$(typeset | grep " $1\$")

            if [[ $vared_vartype_ == *\ array\ * ]] 
            then
                case $vared_vartype_ in

                (indexed\ array\ *)
                    vared_n_=${#vared_ref_[*]}
                    vared_indices_=(${!vared_ref_[*]})

                    (( vared_n_ && vared_n_ != ${vared_indices_[vared_n_ - 1]} + 1 )) && 
                        vared_indexed_=1

                    if [[ ! $vared_indexed_ ]] 
                    then
                        # normal form
                         
                        print -n "typeset -a $1=( "

                        for vared_i_ in ${vared_indices_[*]}
                        do
                            print -n "'${vared_ref_[vared_i_]}' "
                        done

                        print ")"
                    else
                        # indexed form
                        
                        print -n "typeset -a $1=("

                        for vared_i_ in ${!vared_ref_[*]}
                        do
                            print -n " [$vared_i_]='${vared_ref_[vared_i_]}'"
                        done

                        print " )"
                    fi >> $vared_tmpfile_
                    ;;

                (associative\ array\ *)
                    {
                        print "typeset -A $1=("

                        for vared_i_ in ${!vared_ref_[*]}
                        do
                            print "[$vared_i_]='${vared_ref_[$vared_i_]}'"
                        done

                        print ")"
                    } >> $vared_tmpfile_
                    ;;
                esac
            else
                # scalar or unknown
                    
                vared_edit_=1
                {  
                    set | grep "^$1=" || 
                    {
                        if [[ $vared_indexed_ ]] 
                        then
                            print "typeset -a $1=()"
                        else
                            print "$1="
                        fi
                    }
                } >> $vared_tmpfile_
            fi
        fi
        shift
    done 

    [[ $vared_edit_ ]] && vared_editfiles_[0]=$vared_tmpfile_

    vared_editfiles_+=("${vared_funcnames_[@]}")

    (( ${#vared_editfiles_[*]} )) &&
    {
        ${EDITOR:-vi} "${vared_editfiles_[@]}"          # edit

        for vared_i_ in "${vared_editfiles_[@]}"        # source files
        do
            source $vared_i_
        done
    }

    rm $vared_tmpfile_          # remove tmpfile, leave function files
    typeset +n vared_ref_ 
    unset vared_dcl_ vared_edit_ vared_editfiles_ 
    unset vared_funcdir_ vared_funcnames_ 
    unset vared_i_ vared_indexed_ vared_indices_ vared_isfunc_ vared_n_ 
    unset vared_ref_ vared_tmpfile_ vared_vartype_ 
}

#-----------------------------------------------------------------------

function vared_func_
{
    # Print function definition
 
    typeset name=$1
    typeset res=$(typeset +f $name)     # check if defined

    if [[ $res ]]  
    then
        # Function is defined, get its content
 
        typeset -f $name
    else
        # Function not defined, look up via FPATH

        typeset fdir path pdir
        typeset IFS=:

        for fdir in $FPATH
        do
            for pdir in $PATH
            do
                [[ $pdir == $fdir ]] &&
                {
                    [[ -e $fdir/$name ]] &&
                    {
                        # found 

                        cat $fdir/$name                        
                        return
                    }

                    continue 2
                }
            done
        done

        # Not found, create empty function
 
        print "function $name\n{\n    :\n}"
    fi
}