File Coverage

/usr/local/bin/optex

Criterion	Covered	Total	%
statement	173	302	57.2
branch	32	112	28.5
condition	17	45	37.7
subroutine	28	36	77.7
pod			n/a
total	250	495	50.5

#!/usr/bin/env perl

use App::optex;
my $version = $App::optex::VERSION;


=encoding utf8

=head1 NAME

optex - General purpose command option wrapper

=head1 VERSION

Version 1.0601

=head1 SYNOPSIS

B I [ B<-M>I ] ...

or I -> B symlink, or

B I [ -l | -m ] ...

    --link,   --ln  create symlink
    --unlink, --rm  remove symlink
    --ls            list link files
    --rc            list rc files
    --nop, -x       disable option processing
    --[no]module    disable module option on arguments

=cut


use v5.14;
use warnings;

use utf8;
use Encode;
use open IO => ':utf8';

use Pod::Usage;
use Data::Dumper;
$Data::Dumper::Sortkeys = 1;
use Cwd qw(abs_path);
use List::Util qw(uniq max);
use Text::ParseWords qw(shellwords);
use IO::File;
use App::optex::Config;

binmode STDOUT, ":encoding(utf8)";
binmode STDERR, ":encoding(utf8)";

our $rcloader;
our $debug //= $ENV{DEBUG_OPTEX};
our $no_operation;
our $mod_opt = '-M';
our $mod_arg = 1;	# Process -M option in target command
our $exit_code;

my $command_path = $ENV{OPTEX_INVOKED_AS} // $0;
my($cmd_dir, $cmd_name) = ($command_path =~ m{ (.*) / ([^/]+) $ }x) or die;
my($abs_dir, $abs_name) = (abs_path($0)  =~ m{ (.*) / ([^/]+) $ }x) or die;
my $env_MODULE_PATH = sprintf '%s_MODULE_PATH', uc($abs_name);
my $env_ROOT        = sprintf '%s_ROOT',        uc($abs_name);
my $env_BINDIR      = sprintf '%s_BINDIR',      uc($abs_name);
my $env_CONFIG      = sprintf '%s_CONFIG',      uc($abs_name);

my $HOME = $ENV{HOME} or die "No \$HOME.\n";
my $config_dir = $ENV{$env_ROOT} || "${HOME}/.${abs_name}.d";
my $module_dir = $config_dir;
my $bin_dir = $ENV{$env_BINDIR} || "$config_dir/bin";
my $config_file = $ENV{$env_CONFIG} || "$config_dir/config.toml";

##
## decode @ARGV
##
@ARGV = map { utf8::is_utf8($_) ? $_ : decode('utf8', $_) } @ARGV;

##
## load config file
##
my $config = App::optex::Config::load_config($config_file);
my $alias = $config->{alias} //= {};
my $nomodule = $config->{"no-module"} //= [];
my %nomodule = do {
    if (ref $nomodule eq 'ARRAY') {
	map { $_ => 1 } @{$nomodule};
    }
    elsif (ref $nomodule eq 'HASH') {
	%{$nomodule};
    }
    else {
	($nomodule => 1);
    }
};

##
## setup Getopt::EX
##
require Getopt::EX::Loader;
$rcloader = Getopt::EX::Loader->new(
    BASECLASS => [ '', 'App::optex', 'Getopt::EX' ],
    IGNORE_NO_MODULE => 1,
    );

load_rc("$config_dir/default.rc");

##
## setup module search path
##
my @private_mod_path = (
    do {
	if (my $mod_path = $ENV{$env_MODULE_PATH}) {
	    split /:/, $mod_path;
	} else {
	    ();
	}
    },
    $module_dir,
    );

prepend_path(@private_mod_path);

##
## get target command name
##
my $target_name = do {
    if ($cmd_name ne $abs_name) {
	$cmd_name;
    } else {
	self_option(\@ARGV);
	if (@ARGV) {
	    shift @ARGV;
	} else {
	    usage();
	    exit 1;
	}
    }
};

##
## alias
##
my $aliased_name;
if (my $alias = $alias->{$target_name}) {
    my($name, @opts) = do {
	if (ref $alias eq 'ARRAY') {
	    @{$alias};
	} else {
	    shellwords $alias;
	}
    };
    if ($name ne '') {
	$aliased_name = $name;
	unshift @ARGV, @opts;
    }
}

if ($nomodule{$target_name}) {
    $mod_arg = 0;
}

##
## prepare command specific module path
##
my @command_mod_path =
    grep { -d $_ } map { "$_/$target_name" } @private_mod_path;

prepend_path(@command_mod_path, @private_mod_path);

if ($mod_arg and @ARGV > 0 and $ARGV[0] eq $mod_opt) {
    show_modules();
    exit;
}

##
## load command specific rc file
##
unless ($no_operation) {
    load_rc("$config_dir/$target_name.rc");
    $rcloader->configure(PARSE_MODULE_OPT => $mod_arg);
    $rcloader->deal_with(\@ARGV);
}

my $exec_name = $aliased_name || search_path($target_name);
unless (defined $exec_name) {
    warn "$abs_name: $target_name: command not found\n";
    exit 127;
}

warn "$abs_name: exec $exec_name @ARGV\n" if $debug;

##
## execute target command
##
my $status = system $exec_name, @ARGV;

END {
    if (defined $exit_code) {
	$? = $exit_code;
    } elsif (defined $status) {
	$? = $status >> 8;
    }
    close STDERR;
    close STDOUT;
}

######################################################################

sub load_rc {
    my $rc = shift;
    $rcloader->load(FILE => $rc);
    warn "$abs_name: load $rc\n" if $debug;
}

sub search_path {
    my $new = shift;
    return $new if $new =~ m{/} && -x $new;

    # Scan PATH and return the first executable that is not the running
    # optex binary itself (avoid re-entering the wrapper and looping).
    my $self_abs = abs_path("$abs_dir/$abs_name");

    for my $path (split /:+/, $ENV{PATH} // '') {
	my $candidate = "$path/$new";
	-x $candidate or next;
	next if $path eq $cmd_dir and $new eq $cmd_name;

	my $cand_abs = eval { abs_path($candidate) } || $candidate;
	next if $cand_abs eq $self_abs;
	return $candidate;
    }

    return;
}

sub self_option {
    my $argv = shift;

    local $rcloader = Getopt::EX::Loader->new(
	BASECLASS => [ '', 'App::optex', 'Getopt::EX' ],
	);
    $rcloader->load(FILE => "$config_dir/$abs_name.rc");
    $rcloader->deal_with($argv);

    use Getopt::Long qw(GetOptionsFromArray);
    Getopt::Long::Configure(qw"bundling require_order");
    use Getopt::EX::Hashed qw(has); {
	Getopt::EX::Hashed->configure(DEFAULT => [ is => 'ro' ]);
	has debug   => " ! d  " , action => sub { $debug = $_[1] };
	has version => "   v  " ;
	has man     => "   h  " ;
	has link    => "   ln " ;
	has unlink  => "   rm " ;
	has force   => "   f  " ;
	has ls      => "      " ;
	has rc      => "      " ;
	has long    => "   l  " ;
	has path    => "   p  " ;
	has cat     => "   m  " ;
	has M       => "      " ;
	has module  => " !    " , action => sub { $mod_arg = $_[1] };
	has nop     => " ! x  " , action => sub { $no_operation = $_[1] };
	has exit    => " =i   " , action => sub { $exit_code = $_[1] } ;
    }; no Getopt::EX::Hashed;
    my $opt = Getopt::EX::Hashed->new->reset();
    GetOptionsFromArray($argv, $opt->optspec, $rcloader->builtins) or usage();

    if ($opt->man) {
	exec "perldoc $abs_name";
	die "exec: $!";
    }
    elsif ($opt->version) {
	print $version, "\n";
	exit;
    }
    elsif ($opt->link || $opt->unlink) {
	_symlink($argv, $opt);
	exit 0;
    }
    elsif ($opt->ls) {
	_ls($argv, $opt);
	exit 0;
    }
    elsif ($opt->rc) {
	_rc($argv, $opt);
	exit 0;
    }
    elsif ($opt->M) {
	show_modules();
	exit 0;
    }

    return;
}

sub _symlink {
    my($argv, $op) = @_;
    -d $bin_dir or die "Directory $bin_dir does not exist.\n";

    my $script_path = $ENV{OPTEX_SCRIPT_PATH} // $0;
    my @target = @$argv;
    for my $target (@target) {
	my $link = "$bin_dir/$target";
	if ($op->{link}) {
	    -f $link and do { warn "$link already exists.\n"; next };
	    symlink $script_path, $link or die "$link: $!\n";
	    print "$link -> $script_path\n";
	}
	elsif ($op->{unlink}) {
	    -l $link or do { warn "$link is not symlink\n"; next };
	    if ((my $name = readlink $link) ne $script_path ) {
		if (not $op->{force}) {
		    warn
			"$link has unexpected link: -> $name\n" .
			"Use -f option to force unlink.\n" ;
		    next;
		}
	    }
	    unlink $link or die "$link: $!\n";
	    print "$link removed.\n";
	}
    }
}

use Text::VisualWidth::PP 'vwidth';

sub _ls {
    my($argv, $op) = @_;

    use IO::Dir;
    my $dir = IO::Dir->new($bin_dir) or die "$bin_dir: $!\n";
    my @dirent = do {
	sort { $a cmp $b }
	map  { decode 'utf8', $_ }
	grep { not /^\./ }
	$dir->read;
    };
    $dir->close;

    my @aliases = sort keys %{$alias};

    my $max = max map { vwidth $_ } @dirent, @aliases;

    print "[link]\n";
    for my $ent (@dirent) {
	my $path = "$bin_dir/$ent";
	if (-l $path) {
	    print "\t";
	    print $op->{path} ? $path : $ent;
	    if ($op->{long}) {
		print ' ' x ($max - vwidth $ent);
		my $target = do {
	#	    if (my $val = $alias->{$ent}) {
	#		ref($val) eq 'ARRAY' ? join(' ', @$val) : $val;
	#	    } else {
			readlink $path;
	#	    }
		};
		print " -> ", $target;
	    }
	    print "\n";
	}
	warn "$ent: not exist\n" unless -f $path;
    }

    print "[alias]\n";
    for my $key (@aliases) {
	my $val = $alias->{$key};
	my $command = ref($val) eq 'ARRAY' ? join(' ', @$val) : $val;
	print "\t";
	print $key;
	if ($op->{long}) {
	    print ' ' x ($max - vwidth $key);
	    printf " => %s", $command;
	}
	print "\n";
    }
}

sub _rc {
    my($argv, $op) = @_;
    my @command = @$argv;
    my @rc = map { s/(?
    my %rc = map { ($_ => 1) } @rc;
    use IO::Dir;
    my $dir = IO::Dir->new($config_dir) or die "$config_dir: $!\n";
    my @dirent = do {
	grep { %rc == 0 or $rc{$_} }
	grep { /\.rc$/ }
	@rc ? @rc : sort $dir->read
    };
    $dir->close;

    for my $ent (@dirent) {
	my $path = "$config_dir/$ent";
	if ($op->{cat}) {
	    use IO::File;
	    my $fh = IO::File->new($path) or do {
		warn "$path: $!\n";
		next;
	    };
	    while (<$fh>) {
		print "$ent:" if @dirent > 1;
		print;
	    }
	    $fh->close;
	} else {
	    print $op->{long} ? $path : $ent;
	    print "\n";
	}
    }
}

######################################################################

sub usage {
    pod2usage(-verbose => 0,
	      -message => <<"	      EOS" =~ s/^\s+//mgr
	      Use `perldoc $abs_name` for document.
	      Use `$abs_name [command] ${mod_opt}help` for available options.
	      EOS
	);
}

my @ORIG_INC; BEGIN { @ORIG_INC = @INC }
my @mod_path;
sub prepend_path {
    @mod_path = uniq @_;
    @INC = (@mod_path, @ORIG_INC);
}

sub show_modules {
    my $path = @_ ? shift : [
	@mod_path,
	grep { -d } map { "$_/App/optex" } @INC,
	];
    print "MODULES:\n";
    for my $path (@$path) {
	my($name) = $path =~ m:([^/]+)$:;
	my @module = do {
#	    grep { not /\bdefault\.pm$/ }
	    glob "$path/[a-z0-9]*.pm";
	};
	next unless @module;
	print "    $path\n";
	for my $mod (@module) {
	    printf "        ${mod_opt}%s\n", $mod =~ /([^\/]*)\.pm/;
	}
	print "\n";
    }
}

=head1 DESCRIPTION

B is a general purpose command option handling wrapper
utilizing Perl module L.  It enables user to define their
own option aliases for any commands on the system, and provide module
style extensibility.

Target command is given as an argument:

    % optex command

or as a symbolic linked file to B:

    command -> optex

If the configuration file F<~/.optex.d/>IF<.rc> exists, it is
evaluated before execution and command arguments are pre-processed
using it.


=head2 OPTION ALIASES

Think of macOS's C command, which does not have C<-I[TIMESPEC]>
option.  Using B, these can be implemented by preparing
following setting in F<~/.optex.d/date.rc> file.

    option -I        -Idate
    option -Idate    +%F
    option -Iseconds +%FT%T%z
    option -Iminutes +%FT%H:%M%z
    option -Ihours   +%FT%H%z

    option --iso-8601         -I
    option --iso-8601=date    -Idate
    option --iso-8601=seconds -Iseconds
    option --iso-8601=minutes -Iminutes
    option --iso-8601=hours   -Ihours

Then next command will work as expected.

    % optex date -Iseconds

If a symbolic link C<< date -> optex >> is found in command search
path, you can use it just same as standard command, but with
unsupported options.

    % date -Iseconds

Common configuration is stored in F<~/.optex.d/default.rc> file, and
those rules are applied to all commands executed through B.

Actually, C<--iso-8601> option can be defined simpler as this:

    option --iso-8601 -I$

This works fine almost always, but fails with sole C<--iso-8601>
option preceding other option like this:

    % date --iso-8601 -u

=head2 COMMAND ALIASES

B's command alias is no different from the alias function of
shell, but it is effective in that it can be executed as a command
from a tool or script, and can be managed collectively in a
configuration file.

Command aliases can be set in the configuration file
(F<~/.optex.d/config.toml>) like this:

    [alias]
        tc = "optex -Mtextconv"

You can make symbolic link from C to C like this:

    % optex --ln tc

And include F<$HOME/.optex.d/bin> in your C evnironment.

The C module can be used to convert files given as arguments
to plain text.  Defined in this way, Word files can be compared as
follows.

    % tc diff A.docx B.docx

Alias name is used to find rc file and module directory.  In the above
example, F<~/.optex.d/tc.rc> and F<~/.optex.d/tc/> will be referred.

It is also possible to write shell scripts in the config file.  The
following example implements the C-shell C command.

    [alias]
            repeat = [ 'bash', '-c', '''
                while getopts 'c:i:' OPT; do
                    case $OPT in
                        c) count=$OPTARG;;
                        i) sleep=$OPTARG;;
                    esac
                done; shift $((OPTIND - 1))
                case $1 in
                    [0-9]*) count=$1; shift;;
                esac
                while ((count--)); do
                    eval "$*"
                    [ "$sleep" ] && (( count > 0 )) && sleep $sleep
                done
            ''', 'repeat' ]

Read L section.

=head2 MACROS

Complex string can be composed using macro C.  Next example is
an awk script to count vowels in the text, to be declared in file
F<~/.optex.d/awk.rc>.

    define __delete__ /[bcdfgkmnpsrtvwyz]e( |$)/
    define __match__  /ey|y[aeiou]*|[aeiou]+/
    define __count_vowels__ <
    {
        s = tolower($0);
        gsub(__delete__, " ", s);
        for (count=0; match(s, __match__); count++) {
            s=substr(s, RSTART + RLENGTH);
        }
        print count " " $0;
    }
    EOS
    option --vowels __count_vowels__

This can be used like this:

    % awk --vowels /usr/share/dict/words

When setting complex option, C directive is useful.  C
works almost same as C, but effective only within the file
scope, and not available for command line option.

    expand repository	( -name .git -o -name .svn -o -name RCS )
    expand no_dots	! -name .*
    expand no_version	! -name *,v
    expand no_backup	! -name *~
    expand no_image 	! -iname *.jpg  ! -iname *.jpeg \
			! -iname *.gif  ! -iname *.png
    expand no_archive	! -iname *.tar  ! -iname *.tbz  ! -iname *.tgz
    expand no_pdf	! -iname *.pdf

    option --clean \
            repository -prune -o \
            -type f \
            no_dots \
            no_version no_backup \
            no_image \
            no_archive \
            no_pdf

    % find . --clean -print


=head2 MODULES

B also supports module extension.  In the example of C,
module file is found at F<~/.optex.d/date/> directory.  If default
module, F<~/.optex.d/date/default.pm> exists, it is loaded
automatically on every execution.

This is a normal Perl module, so package declaration and the final
true value is necessary.  Between them, you can put any kind of Perl
code.  For example, next program set environment variable C to
C before executing C command.

    package default;
    $ENV{LANG} = 'C';
    1;

    % /bin/date
    2017年 10月22日 日曜日 18時00分00秒 JST

    % date
    Sun Oct 22 18:00:00 JST 2017

Other modules are loaded using C<-M> option.  Unlike other options,
C<-M> have to be placed at the beginning of argument list.  Module
files in F<~/.optex.d/date/> directory are used only for C
command.  If the module is placed on F<~/.optex.d/> directory, it can
be used from all commands.

If you want use C<-Mes> module, make a file F<~/.optex.d/es.pm> with
following content.

    package es;
    $ENV{LANG} = 'es_ES';
    1;

    % date -Mes
    domingo, 22 de octubre de 2017, 18:00:00 JST

When the specified module was not found in library path, B
ignores the option and stops argument processing immediately.  Ignored
options are passed through to the target command.

Module is also used with subroutine call.  Suppose
F<~/.optex.d/env.pm> module look like:

    package env;
    sub setenv {
        while (($a, $b) = splice @_, 0, 2) {
            $ENV{$a} = $b;
        }
    }
    1;

Then it can be used in more generic fashion.  In the next example,
first format is easy to read, but second one is more easy to type
because it does not have special characters to be escaped.

    % date -Menv::setenv(LANG=de_DE) # need shell quote
    % date -Menv::setenv=LANG=de_DE  # alternative format
    So 22 Okt 2017 18:00:00 JST

Option aliases can be also declared in the module, at the end of file,
following special literal C<__DATA__>.  Using this, you can prepare
multiple set of options for different purposes.  Think about generic
B module:

    package i18n;
    1;
    __DATA__
    option --cn -Menv::setenv(LANG=zh_CN) // 中国語 - 簡体字
    option --tw -Menv::setenv(LANG=zh_TW) // 中国語 - 繁体字
    option --us -Menv::setenv(LANG=en_US) // 英語
    option --fr -Menv::setenv(LANG=fr_FR) // フランス語
    option --de -Menv::setenv(LANG=de_DE) // ドイツ語
    option --it -Menv::setenv(LANG=it_IT) // イタリア語
    option --jp -Menv::setenv(LANG=ja_JP) // 日本語
    option --kr -Menv::setenv(LANG=ko_KR) // 韓国語
    option --br -Menv::setenv(LANG=pt_BR) // ポルトガル語 - ブラジル
    option --es -Menv::setenv(LANG=es_ES) // スペイン語
    option --ru -Menv::setenv(LANG=ru_RU) // ロシア語

This can be used like:

    % date -Mi18n --tw
    2017年10月22日 週日 18時00分00秒 JST

You can declare autoload module in your F<~/.optex.d/optex.rc> like:

    autoload -Mi18n --cn --tw --us --fr --de --it --jp --kr --br --es --ru

Then you can use them without module option.  In this case, option
C<--ru> is replaced by C<-Mi18n --ru> automatically.

    % date --ru
    воскресенье, 22 октября 2017 г. 18:00:00 (JST)

Module C is implemented as L and included in
this distribution.  So it can be used as above without additional
installation.

Modules can also define built-in options using C directive in
the C<__DATA__> section.  Built-in options are processed by
L and must be specified before the target command name.
For example:

    optex -Mxform --xform-visible=2 cat file

Here C<--xform-visible> is a built-in option defined in the C
module.

=head1 STANDARD MODULES

Standard modules are installed at C, and they can be
addressed with and without C prefix.

=over 4

=item -MB

Print available option list.  Option name is printed with substitution
form, or help message if defined.  Use B<-x> option to omit help
message.

Option B<--man> or B<-h> will print document if available.  Option
B<-l> will print module path.  Option B<-m> will show the module
itself.  When used after other modules, print information about the
last declared module.  Next command show the document about B
module.

    % optex -Mfirst -Msecond -Mhelp --man

=item -MB

Print debug messages.

=item -MB

Module to manipulate command argument.
See L for detail.

=item -MB

Module to implement command input/output filters.
See L for detail.

=back

=head1 Getopt::EX MODULES

In addition to its own modules, B can also use C
modules.  The standard C modules installed are these.

=over 4

=item -MB (L)

You can display a Greek calendar by doing the following:

    optex -Mi18n cal --gr

=back

=head1 OPTIONS

These options are not effective when B was executed from
symbolic link.

=over 4


=item B<--link>, B<--ln> [ I ]

Create symbolic link in F<~/.optex.d/bin> directory.


=item B<--unlink>, B<--rm> [ B<-f> ] [ I ]

Remove symbolic link in F<~/.optex.d/bin> directory.


=item B<--ls> [ B<-l> ] [ I ]

List symbolic link files in F<~/.optex.d/bin> directory.


=item B<--rc> [ B<-l> ] [ B<-m> ] [ I ]

List rc files in F<~/.optex.d> directory.


=item B<--nop>, B<-x> I

Stop option manipulation.  Use full pathname otherwise.


=item B<-->[B]B

B deals with module option (-M) on target command by default.
However, there is a command which also uses same option for own
purpose.  Option B<--nomodule> disables that behavior.  Other option
interpretation is still effective, and there is no problem using
module option in rc or module files.


=item B<--exit> I

Usually B exits with status of executed command.  This option
override it and force to exit with specified status code.


=back


=head1 CONFIGURATION FILE

When starting up, B reads configuration file
F<~/.optex.d/config.toml> which is supposed to be written in TOML
format.

=head2 PARAMETERS

=over 4

=item B

Set commands for which B does not interpret module option
B<-M>.  If the target command is found in this list, it is executed as
if option B<--no-module> is given to B.

    no-module = [
        "greple",
        "pgrep",
    ]

=item B

Set command aliases.  Example:

    [alias]
        pgrep = [ "greple", "-Mperl", "--code" ]
        hello = "echo -n 'hello world!'"

Command alias can be invoked either from symbolic link and command
argument.

=item B

Load extra TOML fragments before applying the main configuration.
Accepts either a string or an array.  Each entry may be a literal path
or a glob pattern.  Tilde is expanded, and relative paths are resolved
against the file that declared the include.  Includes are processed
depth-first; hashes merge recursively, arrays append, and scalars use
last-in-wins semantics.  The main F is applied last so it
can override included values.

    include = [
        "~/.optex.d/config.d/*.toml",
        "local.toml",
    ]

Include directives can nest; cycles (including self-globs) are detected
and reported as errors.

=back


=head1 FILES AND DIRECTORIES

=over 4


=item F

System module directory.


=item F<~/.optex.d/>

Personal root directory.


=item F<~/.optex.d/config.toml>

Configuration file.


=item F<~/.optex.d/default.rc>

Common startup file.


=item F<~/.optex.d/>IF<.rc>

Startup file for I.


=item F<~/.optex.d/>IF

Module directory for I.


=item F<~/.optex.d/>IF

Default module for I.


=item F<~/.optex.d/bin>

Default directory to store symbolic links.

This is not necessary, but it seems a good idea to make special
directory to contain symbolic links for B, placing it in your
command search path.  Then you can easily add/remove it from the path,
or create/remove symbolic links.

=back


=head1 ENVIRONMENT

=over 4

=item OPTEX_ROOT

Override default root directory F<~/.optex.d>.

=item OPTEX_CONFIG

Override default configuration file F.

=item OPTEX_MODULE_PATH

Set module paths separated by colon (C<:>).  These are inserted before
standard path.

=item OPTEX_BINDIR

Override default symbolic link directory F.

=item OPTEX_SCRIPT_PATH

Specify the path to use when creating symbolic links with C<--ln>.
If not set, C<$0> is used.  This is useful when B is invoked
through a wrapper script (e.g., Homebrew installation) and you want
the symbolic links to point to the wrapper rather than the actual
script.

=item OPTEX_INVOKED_AS

Specify the original command path used to invoke B.  This is
useful when B is invoked through a wrapper script and the
original C<$0> is lost.  When a symbolic link to the wrapper is
executed, the wrapper should set this variable to its own C<$0> so
that B can determine the correct command name.

=back


=head1 SEE ALSO

L, L, L

L

L

=head1 AUTHOR

Kazumasa Utashiro


=head1 LICENSE

You can redistribute it and/or modify it under the same terms
as Perl itself.

Copyright ©︎ 2017-2026 Kazumasa Utashiro


=cut


#  LocalWords:  optex rc iso greple awk pdf LANG ENV Oct JST domingo
#  LocalWords:  setenv autoload PERLLIB BINDIR Utashiro Kazumasa