{

local type var i func funcs method size proto methods reftypes

[[ ${*: -1} =~ ${__BUILTIN__[vartype]} ]] || error.fatal "'${*: -1}' erro de sintaxe"

# Extrai tipo e comprimento.

type=${BASH_REMATCH[1]}

size=${BASH_REMATCH[3]}

# Analisa sintaxe.

[[ -v __SOURCE_TYPES__[$type] ]] || error.fatal "'$type' tipo desconhecido"

# Tipos definidos

reftypes=${__REF_TYPES__[@]}' '${!__SOURCE_TYPES__[@]}

# Lista os identificadores.

for var in ${*:1:${#*}-1}; do

# Verifica identificador da variável.

[[ $var =~ ${__BUILTIN__[varname]} ]] || error.fatal "'$var' não é um identificador válido"

[[ -v __OBJ_INIT__[$var] ]] && error.fatal "'$var' o objeto já foi inicializado"

methods=()

for ((i=0; i < ${size:-1}; i++)); do

# Extrai as funções vinculadas ao tipo.

IFS='|' read _ funcs _ <<< ${__SOURCE_TYPES__[$type]}

for func in $funcs; do

# Define o nome do método com base no comprimento do tipo.

# Caso o tipo seja um array anexa o indíce do elemento ao

# identificador do método.

#

# Exemplo:

#

# var -> varname.method

# array -> varname[n].method

#

method=${var}${size:+[$i]}.${func#*.}

# Se há conflitos entre métodos implementados.

[[ $(type -t $method) == function ]] && error.fatal "conflito de método: '$method' o método já foi implementado"

# Verifica o protótipo da função para determinar o método de immplementação.

# Se o primeiro argumento da função for um tipo definido a implementação é realizada por 'referência',

# ou seja, a função irá receber o identificador do objeto implementado, caso contrário a função recebe

# o valor armazenado.

[[ $(declare -fp $func 2>/dev/null) =~ ${__GETOPT__[parse]}(${reftypes// /|})(\[[^]]*\])?: ]] &&

proto='%s(){ %s "%s" "$@"; return $?; }' || # referência

proto='%s(){ %s "${%s}" "$@"; return $?; }' # valor

# Implementa o método

printf -v proto "$proto" $method $func ${var}${size:+[$i]}

eval "$proto" 2>/dev/null || error.fatal "'$method' não foi possível implementar o método"

# Anexa o novo método.

methods+=($method)

# Define a função como somente-leitura protegendo o método

# implementado de uma chamada inválida.

readonly -f $func

done

done

# Funções (builtin)

#

# As funções builtin são implementas por todos os tipos (type_t) recebendo seu

# identificador literal (sem vetores).

for func in ${__BUILTIN_METHODS__[@]}; do

method=${var}.${func#.*}

[[ $(declare -fp $func 2>/dev/null) =~ ${__GETOPT__[parse]}(${reftypes// /|})(\[[^]]*\])?: ]] &&

proto='%s(){ %s "%s" "$@"; return $?; }' ||

proto='%s(){ %s "${%s}" "$@"; return $?; }'

printf -v proto "$proto" $method $func $var

eval "$proto" 2>/dev/null || error.fatal "'$method' não foi possível implementar o método"

methods+=($method)

readonly -f $func

done

# Registra a variável e define os seus atributos:

#

# * tipo

# * comprimento

# * métodos implementados

#

__OBJ_INIT__[$var]="$type|${size:-0}|${methods[*]}"

done

return $?

{

getopt.parse -1 "typename:str:$1" "func:function:$2" ... "${@:3}"

local type srctypes src

type=$1

# Carrega os tipos já inicializados

srctypes=${!__SOURCE_TYPES__[@]}

# Verifica conflitos.

if [[ $type == @(${srctypes// /|}) ]]; then

IFS='|' read src _ <<< ${__SOURCE_TYPES__[$type]}

error.fatalf "conflito de tipos\n\ntipo: $type\n\nsource: ${BASH_SOURCE[-2]}\nsource: $src\n"

fi

# Registra/atualiza tipos suportados.

__SOURCE_TYPES__[$type]=${BASH_SOURCE[-1]}'|'${@:2}

__ALL_TYPE_NAMES__=${!__BUILTIN_TYPES__[@]}' '${!__SOURCE_TYPES__[@]}

return $?

{

getopt.parse -1 "obj:var:$1" ... "${@:2}"

local __funcs__ __var__

for __var__ in $@; do

# Remove objeto da memória.

IFS='|' read _ _ __funcs__ _ <<< ${__OBJ_INIT__[$__var__]}

unset -f $__funcs__

unset $__var__ \

__OBJ_INIT__[$__var__] \

__SOURCE_TYPES__[$__var__]

done 2>/dev/null || error.fatal "'$__var__' não foi possível deletar o objeto"

return $?

{

getopt.parse 1 "obj:var:$1" "${@:2}"

local -i __len__

local -n __ref__=$1

[[ $1 =~ ${__BUILTIN__[vector]} ]] &&

__len__=${#__ref__} ||

__len__=${#__ref__[@]}

echo $__len__

return $?

{

getopt.parse 1 "expr:str:$1" "${@:2}"

local type

for type in bool uint int float char str; do

[[ $1 =~ ${__BUILTIN_TYPES__[$type]} ]] && break

done

echo "$type"

return $?

{

getopt.parse 1 "obj:var:$1" "${@:2}"

local type

IFS='|' read type _ <<< ${__OBJ_INIT__[${1%[*}]}

echo "$type"

return $?

{

getopt.parse 1 "obj:var:$1" "${@:2}"

local -i size

IFS='|' read _ size _ <<< ${__OBJ_INIT__[${1%[*}]}

echo "$size"

return $?

{

getopt.parse 2 "cond:str:$1" "error:str:$2" "${@:3}"

[ $1 ] 2>/dev/null || error.fatal "$2"

return $?

{

getopt.parse 3 "cond:str:$1" "true:str:$2" "false:str:$3" "${@:4}"

[ $1 ] 2>/dev/null && echo "$2" || echo "$3"

return $?

{

getopt.parse 2 "type:str:+:$1" "prompt:str:$2" "${@:3}"

[[ $1 != @(bool|str|char|int|uint|float) ]] && error.fatal "'$1' tipo básico desconhecido"

local val

read -rp "$2" val

[[ $val =~ ${__BUILTIN_TYPES__[$1]} ]] && echo "$val"

return $?

{

getopt.parse 2 "expr:str:$1" "substr:str:$2" "${@:3}"

[[ $1 == *$2* ]]

return $?

{

getopt.parse 2 "iterable:array:$1" "cond:str:$2" "${@:3}"

local -n __ref__=$1

local __iter__ __ret__

for __iter__ in "${__ref__[@]}"; do

[ ${2//$\?/$__iter__} ]

__ret__+="$?|"

done 2>/dev/null

return $((${__ret__%|}))

{

getopt.parse 2 "iterable:array:$1" "cond:str:$2" "${@:3}"

local -n __ref__=$1

local __iter__

for __iter__ in "${__ref__[@]}"; do

[ ${2//$\?/$__iter__} ] && break

done 2>/dev/null

return $?

{

getopt.parse 1 "num:int:$1" "${@:2}"

local i bit

for ((i=${1#-}; i > 0; i >>= 1)); do bit=$((i&1))$bit; done

echo ${1//[^-]/}${bit:-0}

return $?

{

getopt.parse 2 "obj1:var:$1" "obj2:var:$2" "${@:3}"

local -n __ref1__=$1 __ref2__=$2

local __tmp__=$__ref1__

__ref1__=$__ref2__

__ref2__=$__tmp__

return $?

{

getopt.parse 1 "iterable:array:$1" "${@:2}"

local -n __ref__=$1

local __val__

printf -v __val__ '+%d' "${__ref__[@]}" 2>/dev/null

echo $((__val__))

return $?

{

getopt.parse 2 "iterable:array:$1" "func:function:$2" "${@:3}"

local -n __ref__=$1

local __iter__

for __iter__ in "${__ref__[@]}"; do

$2 "$__iter__" && echo "$__iter__"

done

return $?

{

getopt.parse 1 "code:uint:$1" "${@:2}"

printf \\$(printf '%03o' $1)'\n'

return $?

{

getopt.parse 1 "ch:char:$1" "${@:2}"

printf '%d\n' "'$1"

return $?

{

getopt.parse 1 "num:int:$1" "${@:2}"

printf '0x%x\n' $1

return $?

{

getopt.parse 1 "num:int:$1" "${@:2}"

printf '0%o\n' $1

return $?

{

getopt.parse 1 "hex:str:$1" "${@:2}"

printf '%d\n' $1

return $?

{

getopt.parse 1 "bin:str:$1" "${@:2}"

echo $((2#$1))

return $?

{

getopt.parse 1 "oct:str:$1" "${@:2}"

echo $((8#$1))

return $?

{

getopt.parse 3 "start:int:$1" "stop:int:$2" "max:int:$3" "${@:4}"

local i op

[[ $3 -lt 0 ]] && op='>=' || op='<='

for ((i=$1; i $op $2; i=i+$3)); do echo $i; done

return $?

{

getopt.parse 1 "obj:var:$1" "${@:2}"

[[ -v __OBJ_INIT__[${1:--}] ]]

return $?

{

getopt.parse -1 "iterable:array:$1" "func:function:$2" "args:str:$3" ... "${@:4}"

local -n __ref__=$1

local __iter__

for __iter__ in "${__ref__[@]}"; do

$2 "$__iter__" "${@:3}"

done

return $?

{

getopt.parse 2 "obj:var:$1" "expr:str:$2" "${@:3}"

mapfile -t $1 <<< "$2"

return $?

{

getopt.parse 2 "iterable:array:$1" "start:int:$2" "${@:3}"

local -n __ref__=$1

local __iter__ __i__=$2

for __iter__ in "${__ref__[@]}"; do

echo "$((__i__++)) $__iter__"

done

return $?

{

getopt.parse 0 "$@"

local obj type objs

for obj in ${!__OBJ_INIT__[@]}; do

IFS='|' read type _ <<< ${__OBJ_INIT__[$obj]}

objs+=($obj:$type)

done

printf '%s\n' "${objs[@]}"

return $?

{

getopt.parse 1 "iterable:array:$1" "${@:2}"

local -n __ref__=$1

local __iter__ __min__

__min__=${__ref__[0]}

for __iter__ in "${__ref__[@]}"; do

[[ $__iter__ < $__min__ ]] && __min__=$__iter__

done

echo "$__min__"

return $?

{

getopt.parse 1 "iterable:array:$1" "${@:2}"

local -n __ref__=$1

local __iter__ __max__

__max__=${__ref__[0]}

for __iter__ in "${__ref__[@]}"; do

[[ $__iter__ > $__max__ ]] && __max__=$__iter__

done

echo "$__max__"

return $?

{

getopt.parse 1 "iterable:array:$1" "${@:2}"

local -n __ref__=$1

echo ${#__ref__[@]}

return $?

{

getopt.parse 1 "iterable:array:$1" "${@:2}"

local -n __ref__=$1

printf '%s\n' "${__ref__[@]}" | tac

return $?

{

getopt.parse 1 "iterable:array:$1" "${@:2}"

local -n __ref__=$1

printf '%s\n' "${__ref__[@]}" | sort -du

return $?

{

getopt.parse 1 "iterable:array:$1" "${@:2}"

local -n __ref__=$1

local __opt__ __re__

__re__='^(\s*[+-]?[0-9]+(.[0-9]+)?\s*)+$'

[[ ${__ref__[@]} =~ $__re__ ]] && __opt__=n

printf '%s\n' "${__ref__[@]}" | sort -${__opt__:-d}

return $?

{

getopt.parse 1 "obj:var:$1" "${@:2}"

[[ -z ${!1} ]]

return $?