January 7th Wednesday 2009 (一月 七日 水曜日)

   The dattrcol and dathstdt.cgi program were both modified.  This morning I tested them.  The next step is to
write the test reports.

module (name [, ...])

  Creates a module. If there is a table in package.loaded[name], this table is the module. Otherwise, if there
is a global table t with the given name, this table is the module. Otherwise creates a new table t and sets it
as the value of the global name and the value of package.loaded[name]. This function also initializes t._NAME
with the given name, t._M with the module (t itself), and t._PACKAGE with the package name (the full module name
minus last component; see below). Finally, module sets t as the new environment of the current function and the
new value of package.loaded[name], so that require returns t.

  If name is a compound name (that is, one with components separated by dots), module creates (or reuses, if
they already exist) tables for each component. For instance, if name is a.b.c, then module stores the module
table in field c of field b of global a.

  This function may receive optional options after the module name, where each option is a function to be applied
over the module.

require (modname)

  Loads the given module. The function starts by looking into the package.loaded table to determine whether modname
is already loaded. If it is, then require returns the value stored at package.loaded[modname]. Otherwise, it tries
to find a loader for the module.

  To find a loader, first require queries package.preload[modname]. If it has a value, this value (which should be
a function) is the loader. Otherwise require searches for a Lua loader using the path stored in package.path. If that
also fails, it searches for a C loader using the path stored in package.cpath. If that also fails, it tries an all-in-one
loader.

  When loading a C library, require first uses a dynamic link facility to link the application with the library. Then
it tries to find a C function inside this library to be used as the loader. The name of this C function is the string
"luaopen_" concatenated with a copy of the module name where each dot is replaced by an underscore. Moreover, if the
module name has a hyphen, its prefix up to (and including) the first hyphen is removed. For instance, if the module name
is a.v1-b.c, the function name will be luaopen_b_c.

  If require finds neither a Lua library nor a C library for a module, it calls the all-in-one loader. This loader searches
the C path for a library for the root name of the given module. For instance, when requiring a.b.c, it will search for
a C library for a. If found, it looks into it for an open function for the submodule; in our example, that would be luaopen_a_b_c.
With this facility, a package can pack several C submodules into one single library, with each submodule keeping its original
open function.

  Once a loader is found, require calls the loader with a single argument, modname. If the loader returns any value, require
assigns the returned value to package.loaded[modname]. If the loader returns no value and has not assigned any value to package.loaded[modname],
then require assigns true to this entry. In any case, require returns the final value of package.loaded[modname].

  If there is any error loading or running the module, or if it cannot find any loader for the module, then require signals
an error.

package.cpath

  The path used by require to search for a C loader.

  Lua initializes the C path package.cpath in the same way it initializes the Lua path package.path, using the environment variable
LUA_CPATH (plus another default path defined in luaconf.h).

package.loaded

  A table used by require to control which modules are already loaded. When you require a module modname and package.loaded[modname]
is not false, require simply returns the value stored there.

package.loadlib (libname, funcname)

  Dynamically links the host program with the C library libname. Inside this library, looks for a function funcname and returns this
function as a C function. (So, funcname must follow the protocol (see lua_CFunction)).

  This is a low-level function. It completely bypasses the package and module system. Unlike require, it does not perform any path
searching and does not automatically adds extensions. libname must be the complete file name of the C library, including if necessary
a path and extension. funcname must be the exact name exported by the C library (which may depend on the C compiler and linker used).

  This function is not supported by ANSI C. As such, it is only available on some platforms (Windows, Linux, Mac OS X, Solaris, BSD,
plus other Unix systems that support the dlfcn standard).

package.path

  The path used by require to search for a Lua loader.

  At start-up, Lua initializes this variable with the value of the environment variable LUA_PATH or with a default path defined in
luaconf.h, if the environment variable is not defined. Any ";;" in the value of the environment variable is replaced by the default path.

  A path is a sequence of templates separated by semicolons. For each template, require will change each interrogation mark in the template
by filename, which is modname with each dot replaced by a "directory separator" (such as "/" in Unix); then it will try to load the resulting
file name. So, for instance, if the Lua path is

     "./?.lua;./?.lc;/usr/local/?/init.lua"

the search for a Lua loader for module foo will try to load the files ./foo.lua, ./foo.lc, and /usr/local/foo/init.lua, in that order.

package.preload

  A table to store loaders for specific modules (see require).

package.seeall (module)

  Sets a metatable for module with its __index field referring to the global environment, so that this module inherits values from the global
environment. To be used as an option to function module.