INABA Hitoshi > Char-INFORMIXV6ALS-0.83 > Einformixv6als

Download:
Char/INFORMIXV6ALS/Char-INFORMIXV6ALS-0.83.tar.gz

Dependencies

Annotate this POD

View/Report Bugs
Module Version: 0.83   Source   Latest Release: Char-INFORMIXV6ALS-0.95

NAME ^

Einformixv6als - Run-time routines for INFORMIXV6ALS.pm

SYNOPSIS ^

  use Einformixv6als;

    Einformixv6als::split(...);
    Einformixv6als::tr(...);
    Einformixv6als::chop(...);
    Einformixv6als::index(...);
    Einformixv6als::rindex(...);
    Einformixv6als::lc(...);
    Einformixv6als::lc_;
    Einformixv6als::lcfirst(...);
    Einformixv6als::lcfirst_;
    Einformixv6als::uc(...);
    Einformixv6als::uc_;
    Einformixv6als::ucfirst(...);
    Einformixv6als::ucfirst_;
    Einformixv6als::fc(...);
    Einformixv6als::fc_;
    Einformixv6als::ignorecase(...);
    Einformixv6als::capture(...);
    Einformixv6als::chr(...);
    Einformixv6als::chr_;
    Einformixv6als::X ...;
    Einformixv6als::X_;
    Einformixv6als::glob(...);
    Einformixv6als::glob_;
    Einformixv6als::lstat(...);
    Einformixv6als::lstat_;
    Einformixv6als::opendir(...);
    Einformixv6als::stat(...);
    Einformixv6als::stat_;
    Einformixv6als::unlink(...);
    Einformixv6als::chdir(...);
    Einformixv6als::do(...);
    Einformixv6als::require(...);
    Einformixv6als::telldir(...);

  # "no Einformixv6als;" not supported

ABSTRACT ^

This module is a run-time routines of the INFORMIXV6ALS.pm. Because the INFORMIXV6ALS.pm automatically uses this module, you need not use directly.

BUGS AND LIMITATIONS ^

I have tested and verified this software using the best of my ability. However, a software containing much regular expression is bound to contain some bugs. Thus, if you happen to find a bug that's in INFORMIXV6ALS software and not your own program, you can try to reduce it to a minimal test case and then report it to the following author's address. If you have an idea that could make this a more useful tool, please let everyone share it.

HISTORY ^

This Einformixv6als module first appeared in ActivePerl Build 522 Built under MSWin32 Compiled at Nov 2 1999 09:52:28

AUTHOR ^

INABA Hitoshi <ina@cpan.org>

This project was originated by INABA Hitoshi. For any questions, use <ina@cpan.org> so we can share this file.

LICENSE AND COPYRIGHT ^

This module is free software; you can redistribute it and/or modify it under the same terms as Perl itself. See perlartistic.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

EXAMPLES ^

Split string
  @split = Einformixv6als::split(/pattern/,$string,$limit);
  @split = Einformixv6als::split(/pattern/,$string);
  @split = Einformixv6als::split(/pattern/);
  @split = Einformixv6als::split('',$string,$limit);
  @split = Einformixv6als::split('',$string);
  @split = Einformixv6als::split('');
  @split = Einformixv6als::split();
  @split = Einformixv6als::split;

  This function scans a string given by $string for separators, and splits the
  string into a list of substring, returning the resulting list value in list
  context or the count of substring in scalar context. Scalar context also causes
  split to write its result to @_, but this usage is deprecated. The separators
  are determined by repeated pattern matching, using the regular expression given
  in /pattern/, so the separators may be of any size and need not be the same
  string on every match. (The separators are not ordinarily returned; exceptions
  are discussed later in this section.) If the /pattern/ doesn't match the string
  at all, Einformixv6als::split returns the original string as a single substring, If it
  matches once, you get two substrings, and so on. You may supply regular
  expression modifiers to the /pattern/, like /pattern/i, /pattern/x, etc. The
  //m modifier is assumed when you split on the pattern /^/.

  If $limit is specified and positive, the function splits into no more than that
  many fields (though it may split into fewer if it runs out of separators). If
  $limit is negative, it is treated as if an arbitrarily large $limit has been
  specified If $limit is omitted or zero, trailing null fields are stripped from
  the result (which potential users of pop would do wel to remember). If $string
  is omitted, the function splits the $_ string. If /pattern/ is also omitted or
  is the literal space, " ", the function split on whitespace, /\s+/, after
  skipping any leading whitespace.

  A /pattern/ of /^/ is secretly treated if it it were /^/m, since it isn't much
  use otherwise.

  String of any length can be split:

  @chars  = Einformixv6als::split(//,  $word);
  @fields = Einformixv6als::split(/:/, $line);
  @words  = Einformixv6als::split(" ", $paragraph);
  @lines  = Einformixv6als::split(/^/, $buffer);

  A pattern capable of matching either the null string or something longer than
  the null string (for instance, a pattern consisting of any single character
  modified by a * or ?) will split the value of $string into separate characters
  wherever it matches the null string between characters; nonnull matches will
  skip over the matched separator characters in the usual fashion. (In other words,
  a pattern won't match in one spot more than once, even if it matched with a zero
  width.) For example:

  print join(":" => Einformixv6als::split(/ */, "hi there"));

  produces the output "h:i:t:h:e:r:e". The space disappers because it matches
  as part of the separator. As a trivial case, the null pattern // simply splits
  into separate characters, and spaces do not disappear. (For normal pattern
  matches, a // pattern would repeat the last successfully matched pattern, but
  Einformixv6als::split's pattern is exempt from that wrinkle.)

  The $limit parameter splits only part of a string:

  my ($login, $passwd, $remainder) = Einformixv6als::split(/:/, $_, 3);

  We encourage you to split to lists of names like this to make your code
  self-documenting. (For purposes of error checking, note that $remainder would
  be undefined if there were fewer than three fields.) When assigning to a list,
  if $limit is omitted, Perl supplies a $limit one larger than the number of
  variables in the list, to avoid unneccessary work. For the split above, $limit
  would have been 4 by default, and $remainder would have received only the third
  field, not all the rest of the fields. In time-critical applications, it behooves
  you not to split into more fields than you really need. (The trouble with
  powerful languages it that they let you be powerfully stupid at times.)

  We said earlier that the separators are not returned, but if the /pattern/
  contains parentheses, then the substring matched by each pair of parentheses is
  included in the resulting list, interspersed with the fields that are ordinarily
  returned. Here's a simple example:

  Einformixv6als::split(/([-,])/, "1-10,20");

  which produces the list value:

  (1, "-", 10, ",", 20)

  With more parentheses, a field is returned for each pair, even if some pairs
  don't match, in which case undefined values are returned in those positions. So
  if you say:

  Einformixv6als::split(/(-)|(,)/, "1-10,20");

  you get the value:

  (1, "-", undef, 10, undef, ",", 20)

  The /pattern/ argument may be replaced with an expression to specify patterns
  that vary at runtime. As with ordinary patterns, to do run-time compilation only
  once, use /$variable/o.

  As a special case, if the expression is a single space (" "), the function
  splits on whitespace just as Einformixv6als::split with no arguments does. Thus,
  Einformixv6als::split(" ") can be used to emulate awk's default behavior. In contrast,
  Einformixv6als::split(/ /) will give you as many null initial fields as there are
  leading spaces. (Other than this special case, if you supply a string instead
  of a regular expression, it'll be interpreted as a regular expression anyway.)
  You can use this property to remove leading and trailing whitespace from a
  string and to collapse intervaning stretches of whitespace into a single
  space:

  $string = join(" ", Einformixv6als::split(" ", $string));

  The following example splits an RFC822 message header into a hash containing
  $head{'Date'}, $head{'Subject'}, and so on. It uses the trick of assigning a
  list of pairs to a hash, because separators altinate with separated fields, It
  users parentheses to return part of each separator as part of the returned list
  value. Since the split pattern is guaranteed to return things in pairs by virtue
  of containing one set of parentheses, the hash assignment is guaranteed to
  receive a list consisting of key/value pairs, where each key is the name of a
  header field. (Unfortunately, this technique loses information for multiple lines
  with the same key field, such as Received-By lines. Ah well)

  $header =~ s/\n\s+/ /g; # Merge continuation lines.
  %head = ("FRONTSTUFF", Einformixv6als::split(/^(\S*?):\s*/m, $header));

  The following example processes the entries in a Unix passwd(5) file. You could
  leave out the chomp, in which case $shell would have a newline on the end of it.

  open(PASSWD, "/etc/passwd");
  while (<PASSWD>) {
      chomp; # remove trailing newline.
      ($login, $passwd, $uid, $gid, $gcos, $home, $shell) =
          Einformixv6als::split(/:/);
      ...
  }

  Here's how process each word of each line of each file of input to create a
  word-frequency hash.

  while (<>) {
      for my $word (Einformixv6als::split()) {
          $count{$word}++;
      }
  }

  The inverse of Einformixv6als::split is join, except that join can only join with the
  same separator between all fields. To break apart a string with fixed-position
  fields, use unpack.
Transliteration
  $tr = Einformixv6als::tr($variable,$bind_operator,$searchlist,$replacementlist,$modifier);
  $tr = Einformixv6als::tr($variable,$bind_operator,$searchlist,$replacementlist);

  This is the transliteration (sometimes erroneously called translation) operator,
  which is like the y/// operator in the Unix sed program, only better, in
  everybody's humble opinion.

  This function scans a INFORMIX V6 ALS string character by character and replaces all
  occurrences of the characters found in $searchlist with the corresponding character
  in $replacementlist. It returns the number of characters replaced or deleted.
  If no INFORMIX V6 ALS string is specified via =~ operator, the $_ variable is translated.
  $modifier are:

  ---------------------------------------------------------------------------
  Modifier   Meaning
  ---------------------------------------------------------------------------
  c          Complement $searchlist.
  d          Delete found but unreplaced characters.
  s          Squash duplicate replaced characters.
  r          Return transliteration and leave the original string untouched.
  ---------------------------------------------------------------------------

  To use with a read-only value without raising an exception, use the /r modifier.

  print Einformixv6als::tr('bookkeeper','=~','boep','peob','r'); # prints 'peekkoobor'
Chop string
  $chop = Einformixv6als::chop(@list);
  $chop = Einformixv6als::chop();
  $chop = Einformixv6als::chop;

  This fubction chops off the last character of a string variable and returns the
  character chopped. The Einformixv6als::chop function is used primary to remove the newline
  from the end of an input recoed, and it is more efficient than using a
  substitution. If that's all you're doing, then it would be safer to use chomp,
  since Einformixv6als::chop always shortens the string no matter what's there, and chomp
  is more selective. If no argument is given, the function chops the $_ variable.

  You cannot Einformixv6als::chop a literal, only a variable. If you Einformixv6als::chop a list of
  variables, each string in the list is chopped:

  @lines = `cat myfile`;
  Einformixv6als::chop(@lines);

  You can Einformixv6als::chop anything that is an lvalue, including an assignment:

  Einformixv6als::chop($cwd = `pwd`);
  Einformixv6als::chop($answer = <STDIN>);

  This is different from:

  $answer = Einformixv6als::chop($tmp = <STDIN>); # WRONG

  which puts a newline into $answer because Einformixv6als::chop returns the character
  chopped, not the remaining string (which is in $tmp). One way to get the result
  intended here is with substr:

  $answer = substr <STDIN>, 0, -1;

  But this is more commonly written as:

  Einformixv6als::chop($answer = <STDIN>);

  In the most general case, Einformixv6als::chop can be expressed using substr:

  $last_code = Einformixv6als::chop($var);
  $last_code = substr($var, -1, 1, ""); # same thing

  Once you understand this equivalence, you can use it to do bigger chops. To
  Einformixv6als::chop more than one character, use substr as an lvalue, assigning a null
  string. The following removes the last five characters of $caravan:

  substr($caravan, -5) = '';

  The negative subscript causes substr to count from the end of the string instead
  of the beginning. To save the removed characters, you could use the four-argument
  form of substr, creating something of a quintuple Einformixv6als::chop;

  $tail = substr($caravan, -5, 5, '');

  This is all dangerous business dealing with characters instead of graphemes. Perl
  doesn't really have a grapheme mode, so you have to deal with them yourself.
Index string
  $byte_pos = Einformixv6als::index($string,$substr,$byte_offset);
  $byte_pos = Einformixv6als::index($string,$substr);

  This function searches for one string within another. It returns the byte position
  of the first occurrence of $substring in $string. The $byte_offset, if specified,
  says how many bytes from the start to skip before beginning to look. Positions are
  based at 0. If the substring is not found, the function returns one less than the
  base, ordinarily -1. To work your way through a string, you might say:

  $byte_pos = -1;
  while (($byte_pos = Einformixv6als::index($string, $lookfor, $byte_pos)) > -1) {
      print "Found at $byte_pos\n";
      $byte_pos++;
  }
Reverse index string
  $byte_pos = Einformixv6als::rindex($string,$substr,$byte_offset);
  $byte_pos = Einformixv6als::rindex($string,$substr);

  This function works just like Einformixv6als::index except that it returns the byte
  position of the last occurrence of $substring in $string (a reverse Einformixv6als::index).
  The function returns -1 if $substring is not found. $byte_offset, if specified,
  is the rightmost byte position that may be returned. To work your way through a
  string backward, say:

  $byte_pos = length($string);
  while (($byte_pos = INFORMIXV6ALS::rindex($string, $lookfor, $byte_pos)) >= 0) {
      print "Found at $byte_pos\n";
      $byte_pos--;
  }
Lower case string
  $lc = Einformixv6als::lc($string);
  $lc = Einformixv6als::lc_;

  This function returns a lowercased version of INFORMIX V6 ALS $string (or $_, if
  $string is omitted). This is the internal function implementing the \L escape
  in double-quoted strings.

  You can use the Einformixv6als::fc function for case-insensitive comparisons via INFORMIXV6ALS
  software.
Lower case first character of string
  $lcfirst = Einformixv6als::lcfirst($string);
  $lcfirst = Einformixv6als::lcfirst_;

  This function returns a version of INFORMIX V6 ALS $string with the first character
  lowercased (or $_, if $string is omitted). This is the internal function
  implementing the \l escape in double-quoted strings.
Upper case string
  $uc = Einformixv6als::uc($string);
  $uc = Einformixv6als::uc_;

  This function returns an uppercased version of INFORMIX V6 ALS $string (or $_, if
  $string is omitted). This is the internal function implementing the \U escape
  in interpolated strings. For titlecase, use Einformixv6als::ucfirst instead.

  You can use the Einformixv6als::fc function for case-insensitive comparisons via INFORMIXV6ALS
  software.
Upper case first character of string
  $ucfirst = Einformixv6als::ucfirst($string);
  $ucfirst = Einformixv6als::ucfirst_;

  This function returns a version of INFORMIX V6 ALS $string with the first character
  titlecased and other characters left alone (or $_, if $string is omitted).
  Titlecase is "Camel" for an initial capital that has (or expects to have)
  lowercase characters following it, not uppercase ones. Exsamples are the first
  letter of a sentence, of a person's name, of a newspaper headline, or of most
  words in a title. Characters with no titlecase mapping return the uppercase
  mapping instead. This is the internal function implementing the \u escape in
  double-quoted strings.

  To capitalize a string by mapping its first character to titlecase and the rest
  to lowercase, use:

  $titlecase = Einformixv6als::ucfirst(substr($word,0,1)) . Einformixv6als::lc(substr($word,1));

  or

  $string =~ s/(\w)(\w*)/\u$1\L$2/g;

  Do not use:

  $do_not_use = Einformixv6als::ucfirst(Einformixv6als::lc($word));

  or "\u\L$word", because that can produce a different and incorrect answer with
  certain characters. The titlecase of something that's been lowercased doesn't
  always produce the same thing titlecasing the original produces.

  Because titlecasing only makes sense at the start of a string that's followed
  by lowercase characters, we can't think of any reason you might want to titlecase
  every character in a string.

  See also P.287 A Case of Mistaken Identity
  in Chapter 6: Unicode
  of ISBN 978-0-596-00492-7 Programming Perl 4th Edition.
Fold case string
  P.860 fc
  in Chapter 27: Functions
  of ISBN 978-0-596-00492-7 Programming Perl 4th Edition.

  $fc = Einformixv6als::fc($string);
  $fc = Einformixv6als::fc_;

  New to INFORMIXV6ALS software, this function returns the full Unicode-like casefold of
  INFORMIX V6 ALS $string (or $_, if omitted). This is the internal function implementing
  the \F escape in double-quoted strings.

  Just as title-case is based on uppercase but different, foldcase is based on
  lowercase but different. In ASCII there is a one-to-one mapping between only
  two cases, but in other encoding there is a one-to-many mapping and between three
  cases. Because that's too many combinations to check manually each time, a fourth
  casemap called foldcase was invented as a common intermediary for the other three.
  It is not a case itself, but it is a casemap.

  To compare whether two strings are the same without regard to case, do this:

  Einformixv6als::fc($a) eq Einformixv6als::fc($b)

  The reliable way to compare string case-insensitively was with the /i pattern
  modifier, because INFORMIXV6ALS software has always used casefolding semantics for
  case-insensitive pattern matches. Knowing this, you can emulate equality
  comparisons like this:

  sub fc_eq ($$) {
      my($a,$b) = @_;
      return $a =~ /\A\Q$b\E\z/i;
  }
Make ignore case string
  @ignorecase = Einformixv6als::ignorecase(@string);

  This function is internal use to m/ /i, s/ / /i, split / /i and qr/ /i.
Make capture number
  $capturenumber = Einformixv6als::capture($string);

  This function is internal use to m/ /, s/ / /, split / / and qr/ /.
Make character
  $chr = Einformixv6als::chr($code);
  $chr = Einformixv6als::chr_;

  This function returns a programmer-visible character, character represented by
  that $code in the character set. For example, Einformixv6als::chr(65) is "A" in either
  ASCII or INFORMIX V6 ALS, not Unicode. For the reverse of Einformixv6als::chr, use INFORMIXV6ALS::ord.
File test function Einformixv6als::X
  The following all functions function when the pathname ends with chr(0x5C) on
  MSWin32.

  A file test function is a unary function that takes one argument, either a
  filename or a filehandle, and tests the associated file to see whether something
  is true about it. If the argument is omitted, it tests $_. Unless otherwise
  documented, it returns 1 for true and "" for false, or the undefined value if
  the file doesn't exist or is otherwise inaccessible. Currently implemented file
  test functions are listed in:

  ------------------------------------------------------------------------------
  Function and Prototype     Meaning
  ------------------------------------------------------------------------------
  Einformixv6als::r(*), Einformixv6als::r_()   File is readable by effective uid/gid.
  Einformixv6als::w(*), Einformixv6als::w_()   File is writable by effective uid/gid.
  Einformixv6als::x(*), Einformixv6als::x_()   File is executable by effective uid/gid.
  Einformixv6als::o(*), Einformixv6als::o_()   File is owned by effective uid.
  Einformixv6als::R(*), Einformixv6als::R_()   File is readable by real uid/gid.
  Einformixv6als::W(*), Einformixv6als::W_()   File is writable by real uid/gid.
  Einformixv6als::X(*), Einformixv6als::X_()   File is executable by real uid/gid.
  Einformixv6als::O(*), Einformixv6als::O_()   File is owned by real uid.
  Einformixv6als::e(*), Einformixv6als::e_()   File exists.
  Einformixv6als::z(*), Einformixv6als::z_()   File has zero size.
  Einformixv6als::f(*), Einformixv6als::f_()   File is a plain file.
  Einformixv6als::d(*), Einformixv6als::d_()   File is a directory.
  Einformixv6als::l(*), Einformixv6als::l_()   File is a symbolic link.
  Einformixv6als::p(*), Einformixv6als::p_()   File is a named pipe (FIFO).
  Einformixv6als::S(*), Einformixv6als::S_()   File is a socket.
  Einformixv6als::b(*), Einformixv6als::b_()   File is a block special file.
  Einformixv6als::c(*), Einformixv6als::c_()   File is a character special file.
  Einformixv6als::u(*), Einformixv6als::u_()   File has setuid bit set.
  Einformixv6als::g(*), Einformixv6als::g_()   File has setgid bit set.
  Einformixv6als::k(*), Einformixv6als::k_()   File has sticky bit set.
  ------------------------------------------------------------------------------

  The Einformixv6als::T, Einformixv6als::T_, Einformixv6als::B and Einformixv6als::B_ work as follows. The first block
  or so of the file is examined for strange chatracters such as
  [\000-\007\013\016-\032\034-\037\377] (that don't look like INFORMIX V6 ALS). If more
  than 10% of the bytes appear to be strange, it's a *maybe* binary file;
  otherwise, it's a *maybe* text file. Also, any file containing ASCII NUL(\0) or
  \377 in the first block is considered a binary file. If Einformixv6als::T or Einformixv6als::B is
  used on a filehandle, the current input (standard I/O or "stdio") buffer is
  examined rather than the first block of the file. Both Einformixv6als::T and Einformixv6als::B
  return 1 as true on an empty file, or on a file at EOF (end-of-file) when testing
  a filehandle. Both Einformixv6als::T and Einformixv6als::B doesn't work when given the special
  filehandle consisting of a solitary underline. Because Einformixv6als::T has to read to
  do the test, you don't want to use Einformixv6als::T on special files that might hang or
  give you other kinds or grief. So on most occasions you'll want to test with a
  Einformixv6als::f first, as in:

  next unless Einformixv6als::f($file) && Einformixv6als::T($file);

  ------------------------------------------------------------------------------
  Function and Prototype     Meaning
  ------------------------------------------------------------------------------
  Einformixv6als::T(*), Einformixv6als::T_()   File is a text file.
  Einformixv6als::B(*), Einformixv6als::B_()   File is a binary file (opposite of -T).
  ------------------------------------------------------------------------------

  File ages for Einformixv6als::M, Einformixv6als::M_, Einformixv6als::A, Einformixv6als::A_, Einformixv6als::C, and Einformixv6als::C_
  are returned in days (including fractional days) since the script started running.
  This start time is stored in the special variable $^T ($BASETIME). Thus, if the
  file changed after the script, you would get a negative time. Note that most time
  values (86,399 out of 86,400, on average) are fractional, so testing for equality
  with an integer without using the int function is usually futile. Examples:

  next unless Einformixv6als::M($file) > 0.5;     # files are older than 12 hours
  &newfile if Einformixv6als::M($file) < 0;       # file is newer than process
  &mailwarning if int(Einformixv6als::A_) == 90;  # file ($_) was accessed 90 days ago today

  ------------------------------------------------------------------------------
  Function and Prototype     Meaning
  ------------------------------------------------------------------------------
  Einformixv6als::M(*), Einformixv6als::M_()   Age of file (at startup) in days since modification.
  Einformixv6als::A(*), Einformixv6als::A_()   Age of file (at startup) in days since last access.
  Einformixv6als::C(*), Einformixv6als::C_()   Age of file (at startup) in days since inode change.
  ------------------------------------------------------------------------------

  The Einformixv6als::s, and Einformixv6als::s_ returns file size in bytes if succesful, or undef
  unless successful.

  ------------------------------------------------------------------------------
  Function and Prototype     Meaning
  ------------------------------------------------------------------------------
  Einformixv6als::s(*), Einformixv6als::s_()   File has nonzero size (returns size in bytes).
  ------------------------------------------------------------------------------
Filename expansion (globbing)
  @glob = Einformixv6als::glob($string);
  @glob = Einformixv6als::glob_;

  This function returns the value of $string with filename expansions the way a
  shell would expand them, returning the next successive name on each call.
  If $string is omitted, $_ is globbed instead. This is the internal function
  implementing the <*> operator.
  This function function when the pathname ends with chr(0x5C) on MSWin32.

  For economic reasons, the algorithm matches the command.com or cmd.exe's style
  of expansion, not the UNIX-like shell's. An asterisk ("*") matches any sequence
  of any character (including none). A question mark ("?") matches any one
  character or none. A tilde ("~") expands to a home directory, as in "~/.*rc"
  for all the current user's "rc" files, or "~jane/Mail/*" for all of Jane's mail
  files.

  For example, C<<..\\l*b\\file/*glob.p?>> on MSWin32 or UNIX will work as
  expected (in that it will find something like '..\lib\File/DosGlob.pm' alright).

  Note that all path components are case-insensitive, and that backslashes and
  forward slashes are both accepted, and preserved. You may have to double the
  backslashes if you are putting them in literally, due to double-quotish parsing
  of the pattern by perl.

  The Einformixv6als::glob function grandfathers the use of whitespace to separate multiple
  patterns such as <*.c *.h>. If you want to glob filenames that might contain
  whitespace, you'll have to use extra quotes around the spacy filename to protect
  it. For example, to glob filenames that have an "e" followed by a space followed
  by an "f", use either of:

  @spacies = <"*e f*">;
  @spacies = Einformixv6als::glob('"*e f*"');
  @spacies = Einformixv6als::glob(q("*e f*"));

  If you had to get a variable through, you could do this:

  @spacies = Einformixv6als::glob("'*${var}e f*'");
  @spacies = Einformixv6als::glob(qq("*${var}e f*"));

  Hint: Programmer Efficiency

  "When I'm on Windows, I use split(/\n/,`dir /s /b *.* 2>NUL`) instead of glob('*.*')"
  -- ina
Statistics about link
  @lstat = Einformixv6als::lstat($file);
  @lstat = Einformixv6als::lstat_;

  Like Einformixv6als::stat, returns information on file, except that if file is a symbolic
  link, Einformixv6als::lstat returns information about the link; Einformixv6als::stat returns
  information about the file pointed to by the link. If symbolic links are
  unimplemented on your system, a normal Einformixv6als::stat is done instead. If file is
  omitted, returns information on file given in $_.
  This function function when the filename ends with chr(0x5C) on MSWin32.
Open directory handle
  $rc = Einformixv6als::opendir(DIR,$dir);

  This function opens a directory named $dir for processing by readdir, telldir,
  seekdir, rewinddir, and closedir. The function returns true if successful.
  Directory handles have their own namespace from filehandles.
  This function function when the directory name ends with chr(0x5C) on MSWin32.
Statistics about file
  $stat = Einformixv6als::stat(FILEHANDLE);
  $stat = Einformixv6als::stat(DIRHANDLE);
  $stat = Einformixv6als::stat($expr);
  $stat = Einformixv6als::stat_;
  @stat = Einformixv6als::stat(FILEHANDLE);
  @stat = Einformixv6als::stat(DIRHANDLE);
  @stat = Einformixv6als::stat($expr);
  @stat = Einformixv6als::stat_;

  In scalar context, this function returns a Boolean value that indicates whether
  the call succeeded. In list context, it returns a 13-element list giving the
  statistics for a file, either the file opened via FILEHANDLE or DIRHANDLE, or
  named by $expr. It's typically used as followes:

  ($dev,$ino,$mode,$nlink,$uid,$gid,$rdev,$size,
      $atime,$mtime,$ctime,$blksize,$blocks) = Einformixv6als::stat($expr);

  Not all fields are supported on all filesystem types; unsupported fields return
  0. Here are the meanings of the fields:

  -------------------------------------------------------------------------
  Index  Field      Meaning
  -------------------------------------------------------------------------
    0    $dev       Device number of filesystem
    1    $ino       Inode number
    2    $mode      File mode (type and permissions)
    3    $nlink     Nunmer of (hard) links to the file
    4    $uid       Numeric user ID of file's owner
    5    $gid       Numeric group ID of file's owner
    6    $rdev      The device identifier (special files only)
    7    $size      Total size of file, in bytes
    8    $atime     Last access time since the epoch
    9    $mtime     Last modification time since the epoch
   10    $ctime     Inode change time (not creation time!) since the epoch
   11    $blksize   Preferred blocksize for file system I/O
   12    $blocks    Actual number of blocks allocated
  -------------------------------------------------------------------------

  $dev and $ino, token together, uniquely identify a file on the same system.
  The $blksize and $blocks are likely defined only on BSD-derived filesystems.
  The $blocks field (if defined) is reported in 512-byte blocks. The value of
  $blocks * 512 can differ greatly from $size for files containing unallocated
  blocks, or "hole", which aren't counted in $blocks.

  If Einformixv6als::stat is passed the special filehandle consisting of an underline, no
  actual stat(2) is done, but the current contents of the stat structure from
  the last Einformixv6als::stat, Einformixv6als::lstat, or Einformixv6als::stat-based file test function
  (such as Einformixv6als::r, Einformixv6als::w, and Einformixv6als::x) are returned.

  Because the mode contains both the file type and its permissions, you should
  mask off the file type portion and printf or sprintf using a "%o" if you want
  to see the real permissions:

  $mode = (Einformixv6als::stat($expr))[2];
  printf "Permissions are %04o\n", $mode &07777;

  If $expr is omitted, returns information on file given in $_.
  This function function when the filename ends with chr(0x5C) on MSWin32.
Deletes a list of files.
  $unlink = Einformixv6als::unlink(@list);
  $unlink = Einformixv6als::unlink($file);
  $unlink = Einformixv6als::unlink;

  Delete a list of files. (Under Unix, it will remove a link to a file, but the
  file may still exist if another link references it.) If list is omitted, it
  unlinks the file given in $_. The function returns the number of files
  successfully deleted.
  This function function when the filename ends with chr(0x5C) on MSWin32.
Changes the working directory.
  $chdir = Einformixv6als::chdir($dirname);
  $chdir = Einformixv6als::chdir;

  This function changes the current process's working directory to $dirname, if
  possible. If $dirname is omitted, $ENV{'HOME'} is used if set, and $ENV{'LOGDIR'}
  otherwise; these are usually the process's home directory. The function returns
  true on success, false otherwise (and puts the error code into $!).

  chdir("$prefix/lib") || die "Can't cd to $prefix/lib: $!";

  This function has limitation on the MSWin32. See also BUGS AND LIMITATIONS.
Do file
  $return = Einformixv6als::do($file);

  The do FILE form uses the value of FILE as a filename and executes the contents
  of the file as a Perl script. Its primary use is (or rather was) to include
  subroutines from a Perl subroutine library, so that:

  Einformixv6als::do('stat.pl');

  is rather like: 

  scalar eval `cat stat.pl`;   # `type stat.pl` on Windows

  except that Einformixv6als::do is more efficient, more concise, keeps track of the current
  filename for error messages, searches all the directories listed in the @INC
  array, and updates %INC if the file is found.
  It also differs in that code evaluated with Einformixv6als::do FILE can not see lexicals in
  the enclosing scope, whereas code in eval FILE does. It's the same, however, in
  that it reparses the file every time you call it -- so you might not want to do
  this inside a loop unless the filename itself changes at each loop iteration.

  If Einformixv6als::do can't read the file, it returns undef and sets $! to the error. If 
  Einformixv6als::do can read the file but can't compile it, it returns undef and sets an
  error message in $@. If the file is successfully compiled, do returns the value of
  the last expression evaluated.

  Inclusion of library modules (which have a mandatory .pm suffix) is better done
  with the use and require operators, which also Einformixv6als::do error checking and raise
  an exception if there's a problem. They also offer other benefits: they avoid
  duplicate loading, help with object-oriented programming, and provide hints to the
  compiler on function prototypes.

  But Einformixv6als::do FILE is still useful for such things as reading program configuration
  files. Manual error checking can be done this way:

  # read in config files: system first, then user
  for $file ("/usr/share/proggie/defaults.rc", "$ENV{HOME}/.someprogrc") {
      unless ($return = Einformixv6als::do($file)) {
          warn "couldn't parse $file: $@" if $@;
          warn "couldn't Einformixv6als::do($file): $!" unless defined $return;
          warn "couldn't run $file"            unless $return;
      }
  }

  A long-running daemon could periodically examine the timestamp on its configuration
  file, and if the file has changed since it was last read in, the daemon could use
  Einformixv6als::do to reload that file. This is more tidily accomplished with Einformixv6als::do than
  with Einformixv6als::require.
Require file
  Einformixv6als::require($file);
  Einformixv6als::require();

  This function asserts a dependency of some kind on its argument. If an argument is
  not supplied, $_ is used.

  Einformixv6als::require loads and executes the Perl code found in the separate file whose
  name is given by the $file. This is similar to using a Einformixv6als::do on a file, except
  that Einformixv6als::require checks to see whether the library file has been loaded already
  and raises an exception if any difficulties are encountered. (It can thus be used
  to express file dependencies without worrying about duplicate compilation.) Like
  its cousins Einformixv6als::do, Einformixv6als::require knows how to search the include path stored
  in the @INC array and to update %INC on success.

  The file must return true as the last value to indicate successful execution of any
  initialization code, so it's customary to end such a file with 1 unless you're sure
  it'll return true otherwise.
Current position of the readdir
  $telldir = Einformixv6als::telldir(DIRHANDLE);

  This function returns the current position of the readdir routines on DIRHANDLE.
  This value may be given to seekdir to access a particular location in a directory.
  The function has the same caveats about possible directory compaction as the
  corresponding system library routine. This function might not be implemented
  everywhere that readdir is. Even if it is, no calculation may be done with the
  return value. It's just an opaque value, meaningful only to seekdir.
syntax highlighting: