diff --git a/awk/base.array.awk b/awk/src/base.array.awk similarity index 100% rename from awk/base.array.awk rename to awk/src/base.array.awk diff --git a/awk/base.awk b/awk/src/base.awk similarity index 100% rename from awk/base.awk rename to awk/src/base.awk diff --git a/awk/base.core.awk b/awk/src/base.core.awk similarity index 100% rename from awk/base.core.awk rename to awk/src/base.core.awk diff --git a/awk/base.date.awk b/awk/src/base.date.awk similarity index 100% rename from awk/base.date.awk rename to awk/src/base.date.awk diff --git a/awk/csv.awk b/awk/src/csv.awk similarity index 100% rename from awk/csv.awk rename to awk/src/csv.awk diff --git a/awk/enc.base64.awk b/awk/src/enc.base64.awk similarity index 100% rename from awk/enc.base64.awk rename to awk/src/enc.base64.awk diff --git a/bash/base.args.sh b/bash/base.args.sh deleted file mode 100644 index 19d037a..0000000 --- a/bash/base.args.sh +++ /dev/null @@ -1,176 +0,0 @@ -# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8 -##@cooked nocomments -module: base.args "Fonctions de base: analyse d'arguments" -require: base.arr - -function: myargs_local "Afficher des commandes pour rendre locales des variables utilisées par myargs() - -Cela permet d'utiliser myargs() à l'intérieur d'une fonction. Par défaut, la génération automatique de l'autocomplete est désactivée." -function myargs_local() { - # par défaut, désactiver génération de autocomplete - echo "local NUCORE_ARGS_HELP_DESC NUCORE_ARGS_HELP_USAGE NUCORE_ARGS_HELP_OPTIONS args" - echo "local NUCORE_ARGS_DISABLE_AC=1" - echo "local NUCORE_ARGS_ONERROR_RETURN=1" -} - -function: myargs: "Débuter la description des arguments reconnus par ce script. - -Arguments -: \$1 est un résumé de l'objet de ce script -: \$2 est le nom du script s'il est différent de \$MYNAME - -Le mode opératoire est généralement le suivant: -~~~ -myargs: -desc \"faire un traitement\" -usage \"MYNAME [options] \" -arg -o:,--output:file output= \"spécifier le fichier destination\" -arg -h:,--host:host hosts+ \"spécifier les hôtes concernés\" -arg -c,--count count=1 -parse \"\$@\"; set -- \"\${args[@]}\" -~~~" -function myargs:() { - NUCORE_ARGS_HELP_DESC= - NUCORE_ARGS_HELP_USAGE= - NUCORE_ARGS_HELP_OPTIONS=() - args=() - function desc() { myargs_desc "$@"; } - function usage() { myargs_usage "$@"; } - function arg() { myargs_add "$@"; } - function parse() { myargs_parse "$@"; } -} - -function: myargs_desc "" -function myargs_desc() { - NUCORE_ARGS_HELP_DESC="$*" -} - -function: myargs_usage "" -function myargs_usage() { - NUCORE_ARGS_HELP_USAGE="$*" -} - -function: myargs_add "Ajouter une définition d'option - -Syntaxes -: arg MODE -: arg [MODE] -OPTIONS ACTION DESC -: arg [MODE] VARIABLE DESC - -MODE peut être l'un des caractères '+', '-', '%' et a un effet sur l'analyse -entière de la ligne de commande -* Les caractères '+' et '-' influent sur la méthode d'analyse. Par défaut, les - options sont valides n'importe où sur la ligne de commande. Avec '+', - l'analyse s'arrête au premier argument qui n'est pas une option. Avec '-', les - options sont valides n'importe ou sur la ligne de commande, mais les arguments - ne sont pas réordonnés, et apparaissent dans l'ordre de leur mention. -* Le caractère '%' demande que toutes les variables mentionnées à partir de ce - moment soient initialisées. Elle sont garanties d'être vides. - -Avec la première syntaxe, on définit précisément l'option. Deux formes sont -supportées. La forme détermine le type d'action -* Avec la forme '-OPT VAR[=VALUE]', OPT est une description d'option, VAR un nom - de variable à mettre à jour, et VALUE une valeur éventuelle pour les options - sans argument. Si plusieurs options sont mentionnées, séparées par des - virgules, alors tous les options partagent les mêmes paramètres. - - OPT peut être de la forme '-o' ou '--longopt' pour des options sans arguments. - Dans ce cas, VAR obtient le nombre de fois que l'option est mentionnée (vide - pour aucune mention, '1' pour une seule mention, etc.), sauf si on utilise la - forme VAR=VALUE, auquel cas la variable obtient la valeur VALUE, et le nombre - d'occurences de l'option n'est pas compté. - - Pour faciliter la lecture: - * '--longopt .' est équivalent à '--longopt longopt' - * '--longopt: .' est équivalent à '--longopt: longopt=' - - Avec les formes '-o:' et '--longopt:', l'option prend un argument obligatoire. - Avec les formes '-o::' et '--longopt::', l'option prend un argument facultatif - (dans ce cas, la valeur de l'option sur la ligne de commande doit - obligatoirement être collée à l'option.) - - Si ces options sont mentionnées plusieurs fois sur la ligne de commande, alors - la variable de destination est un tableau qui contient toutes les valeurs. Le - traitement de la valeur d'une variable dépend de la forme utilisée. - * Avec une option sans argument, le comportement est celui décrit ci-dessus. - * Avec une option qui prend des arguments, la forme '-o: VAR' considère que - VAR est un tableau qui contiendra toutes les valeurs mentionnées dans les - options. Avec la forme '-o: VAR=', la variable n'est pas un tableau et - contient toujours la dernière valeur spécifiée. -* Dans la forme 'opt \$cmd', la commande cmd est executée avec eval *dès* que - l'option est rencontrée. La variable option_ contient l'option, e.g. '-o' ou - '--longopt'. Le cas échéant, la variable value_ contient la valeur de - l'option. La fonction 'set@ NAME' met à jour la variable NAME, soit en lui - donnant la valeur \$value_, soit en l'incrémentant, suivant le type d'option. - La fonction 'inc@ NAME' incrémente la variable NAME, 'res@ NAME [VALUE]' - initialise la variable à la valeur VALUE, 'add@ NAME [VALUE]' ajoute VALUE à - la fin du tableau NAME. Par défaut, VALUE vaut \$value_ - -Avec la deuxième syntaxe, l'option est déterminée sur la base du nom de la -variable. -* Une variable de la forme 'sansarg' est pour une option simple qui ne prend pas - d'argument -* Une variable de la forme 'avecarg=[default-value]' est pour une option qui - prend un argument. -L'option générée est une option longue. En l'occurence, les options générées -sont respectivement '--sansarg' et '--avecarg:' -Les variables et les options sont toujours en minuscule. Pour les variables, le -caractère '-' est remplacé par '_'. Si une option contient une lettre en -majuscule, l'option courte correspondante à cette lettre sera aussi reconnue. - -" -function myargs_add() { - # description des options - array_add args "${@:1:2}" - # puis construire la description de l'option pour l'aide - local -a os; local o odesc - array_split os "$1" , - for o in "${os[@]}"; do - o="${o%%:*}" - [ -n "$odesc" ] && odesc="$odesc, " - odesc="$odesc$o" - done - for o in "${os[@]}"; do - if [[ "$o" == *:* ]]; then - if [ "${2#\$}" != "$2" ]; then - o=ARG - else - o="${2%%=*}" - o="${o^^}" - fi - [ -n "$odesc" ] && odesc="$odesc " - odesc="$odesc$o" - fi - break - done - array_add NUCORE_ARGS_HELP_OPTIONS "$odesc" - [ -n "$3" ] && array_add NUCORE_ARGS_HELP_OPTIONS "$3" -} - -function: myargs_show_help "" -function myargs_show_help() { - local help="$MYNAME" - [ -n "$NUCORE_ARGS_HELP_DESC" ] && help="$help: $NUCORE_ARGS_HELP_DESC" - [ -n "$NUCORE_ARGS_HELP_USAGE" ] && help="$help - -USAGE - $NUCORE_ARGS_HELP_USAGE" - [ ${#NUCORE_ARGS_HELP_OPTIONS[*]} -gt 0 ] && help="$help - -OPTIONS" - echo "$help" - for help in "${NUCORE_ARGS_HELP_OPTIONS[@]}"; do - echo "$help" - done -} - -function: myargs_parse "" -function myargs_parse() { - [ -z "$NUCORE_NO_DISABLE_SET_X" ] && [[ $- == *x* ]] && { set +x; local NUCORE_ARGS_SET_X=1; } - local r=0 - if ! parse_opts "${PRETTYOPTS[@]}" "${args[@]}" @ args -- "$@"; then - edie "$args" - r=$? - fi - [ -n "$NUCORE_ARGS_SET_X" ] && set -x; return $r -} diff --git a/bash/nucore.sh b/bash/nucore.sh deleted file mode 120000 index b22bb26..0000000 --- a/bash/nucore.sh +++ /dev/null @@ -1 +0,0 @@ -../load.sh \ No newline at end of file diff --git a/bash/src/base.args.sh b/bash/src/base.args.sh new file mode 100644 index 0000000..93ae671 --- /dev/null +++ b/bash/src/base.args.sh @@ -0,0 +1,382 @@ +# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8 +##@cooked nocomments +module: base.args "Fonctions de base: analyse d'arguments" +require: base.arr + +function: local_args "Afficher des commandes pour rendre locales des variables utilisées par parse_args() + +Cela permet d'utiliser parse_args() à l'intérieur d'une fonction." +function local_args() { + echo "local args" + echo "local NUCORE_ARGS_ONERROR_RETURN=1" +} + +function: parse_args "Analyser les arguments de la ligne de commande à partir des définitions du tableau args + +Cette fonction s'utilise ainsi: +~~~"' +args=( + [gendesc] + [usage] + [+|-] + -o,--longopt action [optdesc] + -a:,--mandarg: action [optdesc] + -b::,--optarg:: action [optdesc] +) +parse_args "$@"; set -- "${args[@]}" +~~~'" + +au retour de la fonction, args contient les arguments qui n'ont pas été traités +automatiquement. + +l'option --help est automatiquement gérée. les descriptions sont utilisées pour +l'affichage de l'aide. + +gendesc +: description de l'objet du script ou de la fonction. cette valeur est + facultative + +usage +: description des arguments du script, sans le nom du script. par exemple la + valeur '[options] FILE' générera le texte d'aide suivant: + ~~~ + USAGE + \$MYNAME [options] FILE + ~~~ + ++|- +: méthode d'analyse des arguments. + * Par défaut, les options sont valides n'importe où sur la ligne de commande. + * Avec '+', l'analyse s'arrête au premier argument qui n'est pas une option. + * Avec '-', les options sont valides n'importe ou sur la ligne de commande, + mais les arguments ne sont pas réordonnés, et apparaissent dans l'ordre de + leur mention. IMPORTANT: dans ce cas, aucun argument ni option n'est traité, + c'est à la charge de l'utilisateur. Au retour de la fonction, args contient + l'ensemble des arguments tels qu'analysés par getopt + +-o, --longopt +: option sans argument + +-a:, --mandarg +: option avec argument obligatoire + +-b::, --optarg:: +: option avec argument facultatif + +action +: action à effectuer si cette option est utilisée. plusieurs syntaxes sont valides: + * 'NAME' met à jour la variable en fonction du type d'argument: l'incrémenter + pour une option sans argument, lui donner la valeur spécifiée pour une + option avec argument, ajouter la valeur spécifiée au tableau si l'option est + spécifiée plusieurs fois. + la valeur spéciale '.' calcule une valeur de NAME en fonction du nom de + l'option la plus longue. par exemple, les deux définitions suivantes sont + équivalentes: + ~~~ + -o,--short,--very-long . + -o,--short,--very-long very_long + ~~~ + * 'NAME=VALUE' pour une option sans argument, forcer la valeur spécifiée; pour + une option avec argument, prendre la valeur spécifiée comme valeur par + défaut si la valeur de l'option est vide + * '$CMD' CMD est évalué avec eval *dès* que l'option est rencontrée. + les valeurs suivantes sont initialisées: + * option_ est l'option utilisée, e.g --long-opt + * value_ est la valeur de l'option + les fonctions suivantes sont définies: + * 'inc@ NAME' incrémente la variable NAME -- c'est le comportement de set@ si + l'option est sans argument + * 'res@ NAME VALUE' initialise la variable NAME avec la valeur de l'option (ou + VALUE si la valeur de l'option est vide) -- c'est le comportement de set@ + si l'option prend un argument + * 'add@ NAME VALUE' ajoute la valeur de l'option (ou VALUE si la valeur de + l'option est vide) au tableau NAME. + * 'set@ NAME' met à jour la variable NAME en fonction de la définition de + l'option (avec ou sans argument, ajout ou non à un tableau) + +optdesc +: description de l'option. cette valeur est facultative" +function parse_args() { + local NUCORE_NO_DISABLE_SET_X=1 #XXX + [ -z "$NUCORE_NO_DISABLE_SET_X" ] && [[ $- == *x* ]] && { set +x; local NUCORE_ARGS_SET_X=1; } + local r=0 + + # distinguer les descriptions des définition d'arguments + local NUCORE_ARGS_USAGE NUCORE_ARGS_DESC + local -a NUCORE_ARGS_DEFS NUCORE_ARGS_ARGS + NUCORE_ARGS_ARGS=("$@") + set -- "${args[@]}" + [ "${1#-}" == "$1" ] && { NUCORE_ARGS_DESC="$1"; shift; } + [ "${1#-}" == "$1" ] && { NUCORE_ARGS_USAGE="$1"; shift; } + if [ "$1" != "+" -a "${1#-}" == "$1" ]; then + eerror "Invalid args definition: third arg must be an option" + r=1 + else + NUCORE_ARGS_DEFS=("$@") + __parse_args || r=1 + fi + [ -n "$NUCORE_ARGS_SET_X" ] && set -x; return $r +} +function __parse_args() { + local __die='[ -n "$NUCORE_ARGS_ONERROR_RETURN" ] && return 1 || die' + ## tout d'abord, construire la liste des options + local popt sopts lopts autohelp=1 + local -a defs + set -- "${NUCORE_ARGS_DEFS[@]}" + while [ $# -gt 0 ]; do + case "$1" in + +) popt="$1"; shift; continue;; + -) popt="$1"; shift; continue;; + -*) IFS=, read -a defs <<<"$1"; shift;; + *) eerror "Invalid arg definition: expected option, got '$1'"; eval "$__die";; + esac + # est-ce que l'option prend un argument? + local def witharg= + for def in "${defs[@]}"; do + if [ "${def%::}" != "$def" ]; then + [ "$witharg" != : ] && witharg=:: + elif [ "${def%:}" != "$def" ]; then + witharg=: + fi + done + # définitions sopts et lopts + for def in "${defs[@]}"; do + def="${def%::}"; def="${def%:}" + if [[ "$def" == --* ]]; then + # --longopt + def="${def#--}" + lopts="$lopts${lopts:+,}$def$witharg" + elif [[ "$def" == -* ]] && [ ${#def} -eq 2 ]; then + # -o + def="${def#-}" + sopts="$sopts$def$witharg" + else + # -longopt ou longopt + def="${def#-}" + lopts="$lopts${lopts:+,}$def$witharg" + fi + [ "$def" == help ] && autohelp= + done + # sauter l'action + shift + # sauter la description le cas échéant + [ "${1#-}" == "$1" ] && shift + done + [ -n "$autohelp" ] && lopts="$lopts${lopts:+,}help" + sopts="$popt$sopts" + local -a getopt_args + getopt_args=(-n "$MYNAME" ${sopts:+-o "$sopts"} ${lopts:+-l "$lopts"} -- "${NUCORE_ARGS_ARGS[@]}") + + ## puis analyser et normaliser les arguments + if args="$(getopt -q "${getopt_args[@]}")"; then + eval "set -- $args" + else + # relancer pour avoir le message d'erreur + LANG=C getopt "${getopt_args[@]}" 2>&1 1>/dev/null + eval "$__die" + fi + + ## puis traiter les options + local defname defvalue autoadd option_ name_ value_ + function inc@() { + if [ -n "$2" ]; then + # forcer une valeur + eval "$1=\"\$2\"" + else + # incrémenter + eval "[ -n \"\$$1\" ] || let $1=0" + eval "let $1=$1+1" + fi + } + function res@() { + local value_="${value_:-$2}" + eval "$1=\"\$value_\"" + } + function add@() { + local value_="${value_:-$2}" + eval "$1+=(\"\$value_\")" + } + function set@() { + if [ -n "$witharg" ]; then + if [ -n "$autoadd" ]; then + if is_array "$1"; then + add@ "$@" + elif ! is_defined "$1"; then + # première occurrence: variable + res@ "$@" + else + # deuxième occurence: tableau + [ -z "${!1}" ] && eval "$1=()" + add@ "$@" + fi + else + res@ "$@" + fi + else + inc@ "$@" + fi + } + function showhelp@() { + local help="$MYNAME" + if [ -n "$NUCORE_ARGS_DESC" ]; then + help="$help: $NUCORE_ARGS_DESC" + fi + help="$help + +USAGE + $MYNAME" + if [ -n "$NUCORE_ARGS_USAGE" ]; then + help="$help $NUCORE_ARGS_USAGE" + else + help="$help [options]" + fi + help="$help + +OPTIONS" + set -- "${NUCORE_ARGS_DEFS[@]}" + while [ $# -gt 0 ]; do + case "$1" in + +) shift; continue;; + -) shift; continue;; + -*) IFS=, read -a defs <<<"$1"; shift;; + esac + # est-ce que l'option prend un argument? + witharg= + for def in "${defs[@]}"; do + if [ "${def%::}" != "$def" ]; then + [ "$witharg" != : ] && witharg=:: + elif [ "${def%:}" != "$def" ]; then + witharg=: + fi + done + # description de l'option + local first=1 + for def in "${defs[@]}"; do + def="${def%::}"; def="${def%:}" + if [[ "$def" == --* ]]; then + : # --longopt + elif [[ "$def" == -* ]] && [ ${#def} -eq 2 ]; then + : # -o + else + # -longopt ou longopt + def="--${def#-}" + fi + if [ -n "$first" ]; then + first= + help="$help + " + else + help="$help, " + fi + help="$help$def" + done + [ -n "$witharg" ] && help="$help VALUE" + # sauter l'action + shift + # prendre la description le cas échéant + if [ "${1#-}" == "$1" ]; then + help="$help + $1" + shift + fi + done + uecho "$help" + exit 0 + } + if [ "$popt" != + ]; then + while [ $# -gt 0 ]; do + if [ "$1" == -- ]; then + shift + break + fi + [[ "$1" == -* ]] || break + option_="$1"; shift + __parse_opt "$option_" + if [ -n "$witharg" ]; then + # l'option prend un argument + value_="$1"; shift + else + # l'option ne prend pas d'argument + value_= + fi + eval "$action" + done + fi + unset -f inc@ res@ add@ set@ showhelp@ + args=("$@") +} +function __parse_opt() { + # $1 est l'option spécifiée + local option_="$1" + set -- "${NUCORE_ARGS_DEFS[@]}" + while [ $# -gt 0 ]; do + case "$1" in + +) shift; continue;; + -) shift; continue;; + -*) IFS=, read -a defs <<<"$1"; shift;; + esac + # est-ce que l'option prend un argument? + witharg= + for def in "${defs[@]}"; do + if [ "${def%::}" != "$def" ]; then + [ "$witharg" != : ] && witharg=:: + elif [ "${def%:}" != "$def" ]; then + witharg=: + fi + done + # nom le plus long + defname= + local found= + for def in "${defs[@]}"; do + def="${def%::}"; def="${def%:}" + [ "$def" == "$option_" ] && found=1 + if [[ "$def" == --* ]]; then + # --longopt + def="${def#--}" + [ ${#def} -gt ${#defname} ] && defname="$def" + elif [[ "$def" == -* ]] && [ ${#def} -eq 2 ]; then + # -o + def="${def#-}" + [ ${#def} -gt ${#defname} ] && defname="$def" + else + # -longopt ou longopt + def="${def#-}" + [ ${#def} -gt ${#defname} ] && defname="$def" + fi + done + defname="${defname//-/_}" + # analyser l'action + if [ "${1#\$}" != "$1" ]; then + name_="$defname" + defvalue= + autoadd= + action="${1#\$}" + else + if [ "$1" == . ]; then + name_="$defname" + defvalue= + autoadd=1 + elif [[ "$1" == *=* ]]; then + name_="${1%%=*}" + defvalue="${1#*=}" + autoadd= + else + name_="$1" + defvalue= + autoadd=1 + fi + action="$(qvals set@ "$name_" "$defvalue")" + fi + shift + # sauter la description le cas échéant + [ "${1#-}" == "$1" ] && shift + + [ -n "$found" ] && return 0 + done + # ici, l'option n'a pas été trouvée, on ne devrait pas arriver ici + if [ "$option_" == --help -a -n "$autohelp" ]; then + action="showhelp@" + return 0 + fi + eerror "Unexpected option '$option_'"; eval "$__die" +} diff --git a/bash/base.arr.sh b/bash/src/base.arr.sh similarity index 100% rename from bash/base.arr.sh rename to bash/src/base.arr.sh diff --git a/bash/base.core.sh b/bash/src/base.core.sh similarity index 100% rename from bash/base.core.sh rename to bash/src/base.core.sh diff --git a/bash/base.eval.sh b/bash/src/base.eval.sh similarity index 100% rename from bash/base.eval.sh rename to bash/src/base.eval.sh diff --git a/bash/base.init.sh b/bash/src/base.init.sh similarity index 100% rename from bash/base.init.sh rename to bash/src/base.init.sh diff --git a/bash/base.io.sh b/bash/src/base.io.sh similarity index 100% rename from bash/base.io.sh rename to bash/src/base.io.sh diff --git a/bash/base.path.sh b/bash/src/base.path.sh similarity index 100% rename from bash/base.path.sh rename to bash/src/base.path.sh diff --git a/bash/base.sh b/bash/src/base.sh similarity index 100% rename from bash/base.sh rename to bash/src/base.sh diff --git a/bash/base.split.sh b/bash/src/base.split.sh similarity index 100% rename from bash/base.split.sh rename to bash/src/base.split.sh diff --git a/bash/base.str.sh b/bash/src/base.str.sh similarity index 100% rename from bash/base.str.sh rename to bash/src/base.str.sh diff --git a/bash/git.sh b/bash/src/git.sh similarity index 100% rename from bash/git.sh rename to bash/src/git.sh diff --git a/bash/src/nucore.sh b/bash/src/nucore.sh new file mode 120000 index 0000000..562af8d --- /dev/null +++ b/bash/src/nucore.sh @@ -0,0 +1 @@ +../../load.sh \ No newline at end of file diff --git a/bash/pretty.sh b/bash/src/pretty.sh similarity index 100% rename from bash/pretty.sh rename to bash/src/pretty.sh diff --git a/bash/sysinfos.sh b/bash/src/sysinfos.sh similarity index 100% rename from bash/sysinfos.sh rename to bash/src/sysinfos.sh diff --git a/bash/tests/test-args.sh b/bash/tests/test-args.sh new file mode 100755 index 0000000..414d05c --- /dev/null +++ b/bash/tests/test-args.sh @@ -0,0 +1,48 @@ +#!/bin/bash +# -*- coding: utf-8 mode: sh -*- vim:sw=4:sts=4:et:ai:si:sta:fenc=utf-8 +source "$(dirname -- "$0")/../src/nucore.sh" || exit 1 + +count= +fixed= +mopt= +dmopt= +oopt= +doopt= +unset a1 +a2=() +a3= +a4=x +args=( + "tester la gestion des arguments" + -o,--eopt count "incrémenter count" + -f,--fixed fixed=42 "spécifier fixed" + -a:,--mopt mopt "spécifier mopt" + -A:,--dmopt dmopt=default "spécifier dmopt" + -b::,--oopt oopt "spécifier oopt" + -B::,--doopt doopt=default "spécifier doopt" + -n,--autoinc . "incrémenter autoinc" + -v:,--autoval . "spécifier autoval" + -x: a1 "autoadd a1 qui n'est pas défini" + -y: a2 "autoadd a2 qui est défini à ()" + -z: a3 "autoadd a3 qui est défini à vide" + -t: a4 "autoadd a4 qui est défini à une valeur non vide" + -s '$echo "sans_arg option=$option_, name=$name_, value=$value_"' + -S:: '$echo "avec_arg option=$option_, name=$name_, value=$value_"' +) +parse_args "$@"; set -- "${args[@]}" + +echo "\ +args=($*) +count=$count +fixed=$fixed +mopt=$mopt +dmopt=$dmopt +oopt=$oopt +doopt=$doopt +autoinc=$autoinc +autoval=$autoval +a1=(${a1[*]}) #${#a1[*]} +a2=(${a2[*]}) #${#a2[*]} +a3=(${a3[*]}) #${#a3[*]} +a4=(${a4[*]}) #${#a4[*]} +" diff --git a/load.sh b/load.sh index 0d68741..e7a1b9d 100644 --- a/load.sh +++ b/load.sh @@ -44,9 +44,9 @@ if [ "$NUCOREDIR" = "@@""dest""@@" ]; then NUCORE_SOURCED=1 NUCOREDIR="$(dirname -- "$NUCOREDIR")" elif [ -f "$NUCOREDIR" -a "$(basename -- "$NUCOREDIR")" == nucore.sh ]; then - # Fichier sourcé depuis nucore/bash + # Fichier sourcé depuis nucore/bash/src NUCORE_SOURCED=1 - NUCOREDIR="$(dirname -- "$NUCOREDIR")/.." + NUCOREDIR="$(dirname -- "$NUCOREDIR")/../.." else # Fichier non sourcé. Tout exprimer par rapport au script courant NUCORE_SOURCED= @@ -62,7 +62,7 @@ elif [ "${BASH_SOURCE[0]}" = /etc/nucore.sh ]; then NUCORE_SOURCED=1 fi NUCOREDIR="$(cd "$NUCOREDIR" 2>/dev/null; pwd)" -NUCOREDIRS=("$NUCOREDIR/bash") +NUCOREDIRS=("$NUCOREDIR/bash/src") # marqueur pour vérifier que nucore a réellement été chargé. il faut avoir $NUCOREINIT == $NUCOREDIR # utilisé par le module base qui doit pouvoir être inclus indépendamment @@ -149,8 +149,8 @@ function require:() { } ## Autres modules -[ -d "$NUCOREDIR/awk" ] && inspath "$NUCOREDIR/awk" AWKPATH; export AWKPATH -[ -d "$NUCOREDIR/python3" ] && inspath "$NUCOREDIR/python3" PYTHONPATH; export PYTHONPATH +[ -d "$NUCOREDIR/awk/src" ] && inspath "$NUCOREDIR/awk/src" AWKPATH; export AWKPATH +[ -d "$NUCOREDIR/python3/src" ] && inspath "$NUCOREDIR/python3/src" PYTHONPATH; export PYTHONPATH ## Auto import DEFAULTS nucore__define_functions