freem/doc/freem.texi - diff

Return to freem.texi CVS log

Up to [Coherent Logic Development] / freem / doc

Diff for /freem/doc/freem.texi between versions 1.6 and 1.49

-version 1.6, 2025/03/15 03:19:34
+version 1.49, 2025/05/05 13:15:53
  Line 4
  @settitle The FreeM Manual
  @copying
- This manual is for FreeM, (version 0.62.1), which is a free and open-source implementation of the M programming language.
+ This manual is for FreeM, (version 0.64.0-rc1), which is a free software implementation of the M programming language.
+ Print-optimized versions of this book are typeset in @emph{Computer Modern} by the author using the @emph{GNU Texinfo} tools.
  Copyright @copyright{} 2014-2025 Coherent Logic Development LLC
- Line 18  Permission is granted to copy, distribut
+ Line 19  Permission is granted to copy, distribut
  @title The FreeM Manual
  @subtitle @sc{The Official Manual of FreeM}
- @subtitle Version 0.62.1
+ @subtitle Version 0.64.0-rc1
  @c@vskip 10pt
  @c@center @image{freem-logo-sm,,,,.png}
  @author Serena Willis
- Line 42  This is the official manual for the Free
+ Line 43  This is the official manual for the Free
  @menu
  * Introduction::                        About the FreeM Project, its history, and its goals.
+ * Document Conventions::                Conventions used in this manual.
+ * A Note on Standards::                 FreeM positioning regarding the M Development Committee.
  * FreeM Invocation::                    How to invoke FreeM from the command line.
- * The FreeM Daemon::                    Managing shared resources in the FreeM environment.
+ * The FreeM Environment Daemon::        Managing shared resources in the FreeM environment.
  * The FreeM Direct-Mode Environment::   Executing M programs interactively.
+ * Debugging::                           The program development cycle of FreeM.
  * Directives::                          Per-Routine Language Directives.
  * Intrinsic Special Variables::         Intrinsic Special Variables.
- Line 73  This is the official manual for the Free
+ Line 77  This is the official manual for the Free
  * Global Aliasing::                     Defining alternate names for globals.
  * Global Mappings::                     Mapping global names to non-default namespaces.
- * Transaction Processing::              Transactions in FreeM.
  * Asynchronous Event Handling::         Handling asynchronous events in FreeM.
  * Global Triggers::                     Responding to global accesses in M code.
  * Synchronous Event Handling::          Synchronous events in FreeM.
- Line 92  This is the official manual for the Free
+ Line 95  This is the official manual for the Free
  * Interrupt Handling::                  How FreeM handles interrupts.
  * Error Processing::                    How to handle errors in M program code.
  * FreeM Error Codes::                   Explanations of each FreeM error code.
- * Debugging::                           The program development cycle of FreeM.
  * System Configuration::                Configuring your FreeM installation.
  * Accessing FreeM from C Programs::     How to use the mlib interface.
- Line 110  This is the official manual for the Free
+ Line 112  This is the official manual for the Free
  @node Introduction
  @unnumbered Introduction
+ FreeM started its life as @emph{FreeMUMPS}, written for MS-DOS and ported to SCO UNIX by a mysterious individual going by the name of "Shalom ha-Ashkenaz". It was released to MUG Deutschland in 1998. In 1999, Ronald L. Fox ported FreeM to the Red Hat Linux 5 distribution of the GNU/Linux operating system. Thereafter, maintenance was taken over by the Generic Universal M Project, which changed its name first to Public Standard MUMPS and then by popular request to FreeM.
- FreeM started its life as @emph{FreeMUMPS}, written for MS-DOS and ported to SCO UNIX by a mysterious individual going by the name of "Shalom ha-Ashkenaz". It was released to MUG Deutschland in 1998. In 1999, Ronald L. Fox ported FreeM to the Red Hat Linux 5 of the GNU/Linux operating system. Thereafter, maintenance was taken over by the Generic Universal M Project, which changed its name first to Public Standard MUMPS and then by popular request to FreeM.
  When GT.M was open-sourced in late 1999, FreeM and GUMP were essentially abandoned. L.D. Landis, the owner of the original GUMP SourceForge project, and one of FreeM's significant contributors, passed maintenance of FreeM and ownership of its SourceForge project to Serena Willis in 2014. At this point, FreeM would not compile or run on modern Linux systems, so steps were taken to remedy the most pressing issues in the codebase. Limitations on the terminal size (previously hard-coded to 80x25) were lifted, and new @code{$VIEW} functions were added to retrieve the terminal size information. @code{$X} and @code{$Y} intrinsic special variables were updated to support arbitrary terminal sizes, and FreeM was once again able to build and run.
- In February of 2020, work began in earnest to build a development and support infrastructure for FreeM and begin the careful process of refining it into a more stable and robust product.
+ In February of 2020, work began in earnest to build a development and support infrastructure for FreeM and begin the careful process of refining it into a more stable and robust application.
+ For more information on FreeM history, see @code{@emph{$PREFIX}/share/freem/doc/freem_history.*} (distributed in PostScript, PDF, and plain text formats).
  @section Production Readiness
- Line 226  Serena Willis (Current Maintainer and Pr
+ Line 229  Serena Willis (Current Maintainer and Pr
  Steve Zeck (Code)
  @end itemize
+ @node Document Conventions
+ @chapter Document Conventions
+ @cindex document conventions
+ @cindex conventions
+ @section Formatting Conventions
+ This manual uses the following formatting conventions:
+ @itemize
+ @item Code examples, filesystem paths, and commands are presented in @code{monospace}
+ @item Placeholders where the reader is expected to supply a replacement value are presented in @code{@emph{monospace italics}}, and depending on context, may be surrounded by angle brackets
+ @item New terminology is introduced in @emph{proportional italics}
+ @end itemize
+ @section Definitions
+ FreeM uses abbreviations for common language elements:
+ @table @asis
+ @item @emph{$PREFIX}
+ Refers to the base filesystem location within which FreeM is installed. For most distribution methods of FreeM, @emph{$PREFIX} represents either @code{/} or @code{/usr/local}.
+ @item @emph{dlabel}
+ Refers to a label in an M routine, beginning in the first column of the line. Can be a @emph{name} or an @emph{intlit}.
+ @item @emph{entryref}
+ Refers to an M routine entry point, denoted in the format @code{@emph{dlabel} [+@emph{intexpr}][^@emph{routine}]}.
+ @item @emph{expr}
+ Refers to any expression. Often presented in the format @emph{expr V <type>}, where @emph{V} means @emph{giving}; e.g., @emph{expr V lvn} means @emph{expression giving local variable name}.
+ @item @emph{glvn}
+ Refers to the name of an M global, local, or structured system variable.
+ @item @emph{gvn}
+ Refers to the name of an M global variable.
+ @item @emph{intexpr}
+ Refers to an integer expression.
+ @item @emph{intlit}
+ Refers to an integer literal.
+ @item @emph{ISV}, @emph{isv}
+ Refers to an M intrinsic special variable; @code{$JOB} and @code{$IO} are examples of ISVs.
+ @item @emph{L}
+ Indicates a @emph{list} of the following item, e.g., @emph{L gvn} means @emph{list of global variable names}.
+ @item @emph{lvn}
+ Refers to the name of an M local variable.
+ @item @emph{postcondition}
+ A @emph{tvexpr} immediately following a command verb affecting that command's execution.
+ @item @emph{strlit}
+ Refers to an M string literal.
+ @item @emph{ssvn}
+ Refers to the name of an M structured system variable.
+ @item @emph{tvexpr}
+ Refers to a truth-valued expression, i.e., an expression interpreted as a truth value.
+ @end table
+ @node A Note on Standards
+ @chapter A Note on Standards
+ @cindex MDC
+ @cindex M Development Committee
+ @cindex ANSI X11.1
+ @cindex standards, ANSI
+ @cindex standards, MDC
+ FreeM attempts to implement as many features as possible from the M Development Committee's unpublished @emph{Millennium Draft Standard}, as well as its predecessors.
+ The maintainer of FreeM (who is also the author of this book) is largely in favor of standardization efforts, and hopes that the MDC will resume activities, and will happily participate if it does so in an open, public, transparent, and democratic manner. Until then, however, FreeM will attempt to improve the M language, in cooperation with other free software M implementers where possible. Any breaking changes introduced in future MDC releases of the @emph{Standard} (such as the rumored @emph{M5}) which prove incompatible with FreeM will be handled via the @code{$DIALECT} special variable (to be changed to @code{$ZDIALECT} in a coming release).
+ The conformance document required per the @emph{Standard} should be installed as a @code{man} page on any computer system where FreeM is made available. Simply type @code{man freem_conformance} to access.
  @node FreeM Invocation
  @chapter FreeM Invocation
  @cindex invocation, command-line
- Line 236  Steve Zeck (Code)
+ Line 305  Steve Zeck (Code)
  $ @command{./freem} [@emph{OPTIONS}...] [[-r <entryref>] | [--routine=<entryref>]]
  @end example
- When FreeM loads, it searches the @code{SYSTEM} namespace for the @code{^%SYSINIT} routine, and begins executing it.
+ When FreeM loads, it searches the @code{SYSTEM} namespace for the @code{%SYSINIT} routine, and begins executing it.
+ When @code{-r} or @code{--routine} are passed on the command line, FreeM will load and run the specified routine after running @code{%SYSINIT}. Beginning with FreeM 0.1.7, routines invoked in this manner are no longer required to perform their own namespace setup with @code{VIEW} commands.
+ @section %SYSINIT Routine
+ The @code{%SYSINIT} routine runs every time a FreeM interpreter process starts. This routine defines some useful constants, enables handling of @code{TRIGGER} events, and handles the execution of code passed via the @code{-x|--execute} or routines passed via @code{-r|--routine}.
- When @code{-r} or @code{--routine} are passed on the command line, FreeM will load and run the specified routine instead of @code{^%SYSINIT}. Beginning with FreeM 0.1.7, routines invoked in this manner are no longer required to perform their own namespace setup with @code{VIEW} commands.
+ Do not modify the supplied @code{%SYSINIT} routine to add site-specific startup items. Instead, create a @code{LCLINIT} routine in the @code{USER} namespace of one or more environments. @code{%SYSINIT} will automatically run @code{LCLINIT} each time it starts.
  @section Command-Line Options
+ @cindex options, command-line
  @table @asis
  @item @option{-d}, @option{--daemon}
- Starts the FreeM daemon, exactly one of which must be running at all times in order for FreeM interpreter and fmadm processes to function.
+ Starts the FreeM environment daemon, exactly one of which must be running at all times in order for FreeM interpreter and fmadm processes to function.
  @item @option{-e}, @option{--environment}
  Selects the environment to be used. If no environment is specified, @code{DEFAULT} is used.
  @item @option{-k}, @option{--nofork}
- When used with @option{-d} or @option{--daemon}, causes the FreeM daemon to run instead in the foreground. Useful for debugging.
+ When used with @option{-d} or @option{--daemon}, causes the FreeM environment daemon to run instead in the foreground. Useful for debugging.
- @item @option{-p}, @option{--pidfile}
- When used with @option{-d} or @option{--daemon}, sets the file in which the PID of the running daemon is stored.
  @item @option{-S}, @option{--shmsize}
  When used with @option{-d} or @option{--daemon}, specifies the number of bytes of shared memory FreeM will allocate for the @code{LOCK} table, job table, and IPC table. This will determine the maximum number of concurrent FreeM processes and @code{LOCK}s available in this environment.
- Line 272  Causes your UNIX environment variables t
+ Line 345  Causes your UNIX environment variables t
  Allows your M routines to be used as UNIX filters.
  @item @option{-n @emph{<namespace-name>}}, @option{--namespace=@emph{<namespace-name>}}
- Selects the FreeM namespace to be entered on startup. Must be defined in @file{/etc/freem.conf}.
+ Selects the FreeM namespace to be entered on startup. Must be defined in @file{/etc/<environment>/freem.conf}.
  @item @option{-r @emph{<entryref>}}, @option{--routine=@emph{<entryref>}}
- Causes @code{<entryref>} to be executed at load, instead of @code{^%SYSINIT}.
+ Causes @code{<entryref>} to be executed at load, instead of @code{%SYSINIT}.
  @item @option{--standard=@emph{<standard>}}
  Sets the default FreeM dialect to use for new routine buffers.
- Line 305  Please note that FreeM is not entirely s
+ Line 378  Please note that FreeM is not entirely s
  Displays FreeM version information.
  @item @option{-x @emph{<mcode>}}, @option{--execute=@emph{<mcode>}}
- Executes M code @code{<mcode>} at startup instead of the startup routine.
+ Executes M code @code{<mcode>} at startup.
  @end table
- Line 333  You will also need to set the script's p
+ Line 406  You will also need to set the script's p
  $ chmod +x @emph{myscript.m}
  @end example
- @node The FreeM Daemon
+ @node The FreeM Environment Daemon
- @chapter The FreeM Daemon
+ @chapter The FreeM Environment Daemon
  @cindex daemon, freem
- The FreeM daemon manages shared resources for a given FreeM environment. These include the lock table, job table, inter-process communication, and concurrency control for transaction processing. Unlike some M implementations, the FreeM daemon does @emph{not} function as a write daemon for global storage.
+ The FreeM environment daemon manages shared resources for a given FreeM environment. These include the lock table, job table, inter-process communication, and concurrency control for transaction processing. Unlike some M implementations, the FreeM environment daemon does @emph{not} function as a write daemon for global storage.
- One daemon process is required per FreeM environment, and can be started as follows:
+ One daemon process is required per FreeM environment, and can be started in the following ways, in order of preference:
  @example
- $ freem --daemon [--nofork] [--environment=<environment-name>] [--user=<username>] \
+ $ sudo fmadm start environment [-e=<environment-name>]
-         [--group=<group-name>] [--pidfile=<pid-file>] [--shmsize=<bytes>]
+ @end example
+ @example
+ $ freem --daemon [--nofork] [--environment=<environment-name>] [--shmsize=<bytes>]
  @end example
  If the daemon is started with @option{--nofork}, it will run in the foreground and its output will be reflected on the terminal. Otherwise, the daemon will run as a child process in the background and immediately return terminal control to the shell. The latter option is recommended in most cases.
  The @option{--environment} option will start the daemon for the specified @emph{environment-name}. The default environment, if unspecified, is called @code{DEFAULT}. If using an environment other than @code{DEFAULT}, interpreter processes that wish to also connect to the same environment must also use the @option{--environment} option when starting, and @code{libfreem} clients must also pass the environment name as the first argument to the @code{freem_init()} function. Environments allow you to run multiple, isolated instances of FreeM on the same machine, whose globals and routines are distinct and unique.
- The @option{--user} and @option{--group} options are only valid when the FreeM daemon is started by the superuser, and will cause the daemon to reduce its runtime privileges to those of the specified user and group, and run as that user and/or group. We recommend creating a @code{freem} user and group and running the FreeM daemon with @code{--user=freem --group=freem}.
- The @option{--pidfile} option specifies the file in which the FreeM daemon will store its own PID. If running as the superuser, the FreeM daemon will store the PID file in @code{/var/run/freem.pid}. Otherwise, the PID file will be stored as @code{.freem.pid} in the home directory of the user account which owns the FreeM daemon process.
  The @option{--shmsize} option specifies the size in bytes of the FreeM shared memory segment. The default is 4194304 bytes. Increasing the size of the FreeM shared memory segment will, at the cost of increased memory usage, increase the number of concurrent jobs and lock table entries available to the environment; decreasing the size of the segment will have the expected opposite effect. Note that you must also pass @option{--shmsize} with the same number of bytes to any interpreter process to be used with an environment whose daemon uses a non-default shared memory segment size.
  Attempting to start a FreeM interpreter process without a daemon running with the same environment name will result in an error.
- Line 369  Attempting to start a FreeM interpreter
+ Line 441  Attempting to start a FreeM interpreter
  The FreeM direct-mode environment is the mode entered when FreeM is invoked without the use of @option{-r @emph{<entryref>}} or @option{--routine=@emph{<entryref>}}:
  @example
- Coherent Logic Development FreeM version 0.62.1 (x86_64-pc-linux-gnu)
+ Coherent Logic Development FreeM version 0.64.0-rc1 (x86_64-pc-linux-gnu)
  Copyright (C) 2014, 2020, 2021 Coherent Logic Development LLC
  USER>
  @end example
- The prompt (@code{USER>}) indicates the currently-active namespace. If any uncommitted direct-mode transactions have been started, the prompt will change to reflect the current value of @code{@ref{$TLEVEL}}:
+ The prompt (@code{DEFAULT.USER>}) displays the current environment and namespace, @code{DEFAULT} and @code{USER}, respsectively. If any uncommitted direct-mode transactions have been started, the prompt will change to reflect the current value of @code{@ref{$TLEVEL}}:
  @example
- TL1:USER>
+ TL1:DEFAULT.USER>
  @end example
  In the above example, @code{TL1} indicates that @code{@ref{$TLEVEL}} is currently @emph{1}.
- Line 397  Accesses FreeM online help. Requires GNU
+ Line 469  Accesses FreeM online help. Requires GNU
  Writes a list of @emph{event classes} and their @code{ABLOCK} counts:
  @example
- USER> events
+ DEFAULT.USER> events
  Event Class          Processing Mode ABLOCK Count
  -----------          --------------- ------------
- Line 417  TRIGGER              Disabled        0
+ Line 489  TRIGGER              Disabled        0
  @item @command{trantab}
  Displays information about any uncommitted transactions currently in-flight for this process.
+ @anchor{glstat}
+ @item @command{trantab}
+ Displays statistics about globals that have been opened in the current FreeM process.
  @anchor{jobtab}
  @item @command{jobtab}
  Displays a summary of the FreeM job table.
- Line 429  Displays a list of @code{LOCK}s held in
+ Line 505  Displays a list of @code{LOCK}s held in
  @item @command{rbuf}
  Lists the status of all FreeM routine buffers.
- @anchor{dbstats}
- @item @command{dbstats}
- Shows statistics for the BerkeleyDB global handler.
  @anchor{wh}
  @item @command{wh}
  Forces an immediate flush of this process's @code{readline} history buffer to disk.
- Line 457  Allows you to recall command number @emp
+ Line 529  Allows you to recall command number @emp
  Launches a subshell within the FreeM direct mode, allowing the user to run operating system commands.
  @example
- USER> !!
+ DEFAULT.USER> !!
  Type Ctrl-D to exit from the shell
  $ uname -a
  Linux hesperos 4.19.0-17-amd64 #1 SMP Debian 4.19.194-3 (2021-07-18) x86_64 GNU/Linux
  $ exit
- USER>
+ DEFAULT.USER>
  @end example
  @item @command{!@emph{<external-command>}}
- Invokes a shell to run @emph{<external-command>} from within FreeM. This temporarily disables @command{SIGALRM} handling in FreeM, which may interrupt the use of event-driven M programming commands including @command{ESTART} and @command{ESTOP}.
+ Invokes a shell to run @emph{<external-command>} from within FreeM. This temporarily disables @command{SIGALRM} handling in FreeM, which may interrupt the use of event-driven M programming commands including @command{ASTART} and @command{ASTOP}.
  If the @command{>} character is supplied immediately preceding @emph{<external-command>}, FreeM will append the contents of an M local or global variable referenced in @code{^$JOB($JOB,"PIPE_GLVN")} to the standard input stream of @emph{<external-command>}.
- Line 482  The data value in the unsubscripted M lo
+ Line 554  The data value in the unsubscripted M lo
  If you issue a @code{@ref{HALT}} command at the direct-mode prompt, you will exit out of FreeM. However, if you issue a @code{@ref{HALT}} command when @code{@ref{$TLEVEL}} is greater than zero, you will be given the opportunity to commit or rollback any pending transactions:
  @example
- USER> TSTART
+ DEFAULT.USER> TSTART
- TL1:USER> SET ^MYGLOBAL=1
+ TL1:DEFAULT.USER> SET ^MYGLOBAL=1
- TL1:USER> HALT
+ TL1:DEFAULT.USER> HALT
  UNCOMMITTED TRANSACTIONS EXIST:
- Line 510  In the above example, the user selected
+ Line 582  In the above example, the user selected
  FreeM direct mode allows you to enter M expressions directly from the direct-mode prompt, as long as they begin with a number:
  @example
- USER> S DENOM=10
+ DEFAULT.USER> S DENOM=10
- USER> 100/DENOM
+ DEFAULT.USER> 100/DENOM
- USER>
+ DEFAULT.USER>
  @end example
  Such expressions will be immediately evaluated, and the result printed on @code{@ref{$IO}}.
+ @node Debugging
+ @chapter Debugging
+ @cindex debugging
+ @section Debugging Synopsis
+ FreeM includes an interactive debugger, entered using the @code{BREAK "DEBUG"} command. The debugger is also entered if @code{Ctrl-C} is pressed, @code{Ctrl-C} handling is enabled, and you are in direct mode.
+ If you would like to enter the debugger automatically each time an error is encountered, add the following to your @code{LCLINIT} routine:
+ @example
+ S $ETR="B ""DEBUG"""
+ @end example
+ @section Debugging Commands
+ The debugger uses its own unique command language, where M commands are unavailable. Commands are as follows:
+ @table @asis
+ @item @code{exit}, @code{quit}
+ Exits the debugger and returns to direct mode or normal program execution.
+ @item @code{e} @emph{glvn}, @code{examine} @emph{glvn}
+ Prints the value of @emph{glvn} to the terminal.
+ @item @code{t}, @code{trace}
+ Toggles @emph{trace mode} on and off. When trace mode is on, FreeM will display information about each @code{DO} or @code{GOTO} command encountered, including the routine which invoked the branch, which type of branch was invoked, and the target of the branch.
+ @item @code{s}, @code{step}
+ Single-steps through FreeM code command-by-command.
+ @item @code{n}, @code{next}
+ Single-steps through FreeM code line-by-line.
+ @item @code{c}, @code{cont}, @code{continue}
+ Resumes normal program execution, disabling single-step mode.
+ @item @code{bt}, @code{backtrace}
+ Produces a stack trace.
+ @item @code{h}, @code{halt}
+ Halts the process being debugged and returns control to the operating system.
+ @item @code{w [[+|-|?]@emph{<glvn>}]}, @code{watch [[+|-|?]@emph{<glvn>}]}
+ With no arguments, toggles watchpoints on and off. With @code{+}, adds @emph{<glvn>} to the watchlist. With @code{-}, removes @emph{<glvn>} from the watchlist. With @code{?}, queries the watch status of @emph{<glvn>}.
+ @end table
  @node Directives
  @chapter Directives
  @cindex directives
- Line 591  Please note that FreeM is not entirely s
+ Line 700  Please note that FreeM is not entirely s
  * $SYSTEM::                  MDC system ID of FreeM.
  * $TEST::                    Truth value of last conditional expression or result of certain @code{LOCK} operations.
  * $TLEVEL::                  Current level of transaction nesting.
- * $WITH::                    Current variable prefix set by @code{WITH} command.
+ * $WITH::                    Current variable prefix set by @code{ZWITH} command.
  * $X::                       Current horizontal screen position.
  * $Y::                       Current vertical screen position.
  * $ZA::                      Current position of file on @code{$IO}.
- Line 657  Please note that FreeM is not entirely s
+ Line 766  Please note that FreeM is not entirely s
  Returns a comma-delimited list of error conditions currently present, and is writable. An empty @code{$ECODE} indicates no errors.
+ Writing a value in the format @code{,<error-code>,} into @code{$ECODE} will raise that error condition.
  @node $ESTACK
  @section $ESTACK
  @cindex $ESTACK
- Line 785  uncommitted transactions exist.
+ Line 896  uncommitted transactions exist.
  @cindex $WITH
  @cindex intrinsic special variables, $WITH
- Returns the variable prefix set by the @code{@ref{WITH}} command.
+ Returns the variable prefix set by the @code{@ref{ZWITH}} command.
  @node $X
  @section $X
- Line 1081  SET M=$EXTRACT(NAME,1,5)
+ Line 1192  SET M=$EXTRACT(NAME,1,5)
  It is also possible to use @code{$EXTRACT} on the left-hand side of a @code{SET} assignment in order to modify a substring:
  @example
- USER> SET FOO="ABCDEFG"
+ DEFAULT.USER> SET FOO="ABCDEFG"
- USER> SET $EXTRACT(FOO,1,3)="XYZ"
+ DEFAULT.USER> SET $EXTRACT(FOO,1,3)="XYZ"
- USER> WRITE FOO
+ DEFAULT.USER> WRITE FOO
  XYZDEFG
  @end example
- Line 1114  Formats a number according to a particul
+ Line 1225  Formats a number according to a particul
  The first argument is the number to format.
- The second argument is the series of formatting codes.
+ The second argument is the series of formatting codes:
+ @table @asis
+ @item 'P' or 'p'
+ Will display negative numbers within parentheses instead of showing a minus sign.
+ @item , (comma)
+ Will add commas as thousands separators.
+ @item +
+ Will include a plus sign for positive numbers. Not compatible with 'P' or 'p'.
+ @item -
+ Will remove the minus sign from negative numbers. Not compatible with 'p' or 'P'.
+ @item 't' or 'T'
+ Will place the sign after the number instead of before the number.
+ @end table
+ The optional third argument is a number indicating how many digits to which the fractional part of the number will be zero-padded.
  @node $GET()
  @section $GET
- Line 1139  The first argument is a string represent
+ Line 1265  The first argument is a string represent
  The second argument is a string representing a valid FreeM class.
  @example
- USER> N STR=$$^%STRING
+ DEFAULT.USER> N STR=$$^%STRING
- USER> W $INSTANCEOF("STR","^%STRING")
+ DEFAULT.USER> W $INSTANCEOF("STR","^%STRING")
  @end example
- Line 1188  The optional second argument indicates t
+ Line 1312  The optional second argument indicates t
  @cindex $NEXT
  @cindex intrinsic functions, $NEXT
+ Deprecated. Use @code{$ORDER} instead.
  @node $ORDER()
  @section $ORDER
  @cindex $ORDER
  @cindex intrinsic functions, $ORDER
+ Returns the previous subscript or next subscript in a local, global, or a subset of structured system variables.
+ The first argument is the subscripted local, global, or SSVN.
+ The optional second argument can be @code{1} to retrieve the next subscript, or @code{-1} to return the previous.
  @node $PIECE()
  @section $PIECE
  @cindex $PIECE
- Line 1215  The optional fourth argument is the fina
+ Line 1347  The optional fourth argument is the fina
  Can be used on the left-hand side of an expression in order to @code{@ref{SET}} a value into a @code{d}-delimited piece of @code{s}, as in:
  @example
- ; ^jpw="this^is^a^piece"
+ ; ^snw="this^is^a^piece"
- SET $PIECE(^jpw,"^",2)="isn't" ; => "this^isn't^a^piece"
+ SET $PIECE(^snw,"^",2)="isn't" ; => "this^isn't^a^piece"
  @end example
  @node $QLENGTH()
- Line 1248  Returns the number of subscripts in @emp
+ Line 1380  Returns the number of subscripts in @emp
  @code{$QSUBSCRIPT(@emph{expr V glvn},@emph{expr V n})}
  @end example
- Returns the @emph{n}th subscript of @emph{glvn}.
+ In the RHS form, returns the @emph{n}th subscript of @emph{glvn}.
  @emph{Example}
- Line 1256  Returns the @emph{n}th subscript of @emp
+ Line 1388  Returns the @emph{n}th subscript of @emp
  @code{SET SUB=$QSUBSCRIPT("^GBL(1,2,3)",2) ; => 2}
  @end example
+ @emph{Syntax}
+ @example
+ @code{SET $QSUBSCRIPT(@emph{expr V glvn},@emph{expr V n})=@emph{expr} ; => ^GBL(1,4,3)}
+ @end example
+ In the LHS form, sets the @emph{n}th subscript of @emph{glvn} to @emph{expr}.
  @node $QUERY()
  @section $QUERY
  @cindex $QUERY
- Line 1273  Returns the next subscripted reference i
+ Line 1413  Returns the next subscripted reference i
  We will assume the following data structure exists:
  @example
- ^jpw(1)=1
+ ^snw(1)=1
- ^jpw(1,2)="foo"
+ ^snw(1,2)="foo"
- ^jpw(2)=3
+ ^snw(2)=3
- ^jpw(3)=""
+ ^snw(3)=""
  @end example
- The following code will retrieve the next subscripted name after @code{^jpw(1)}:
+ The following code will retrieve the next subscripted name after @code{^snw(1)}:
  @example
- @code{SET NEXTNAM=$QUERY(^jpw(1)) ; => ^jpw(1,2)}
+ @code{SET NEXTNAM=$QUERY(^snw(1)) ; => ^snw(1,2)}
  @end example
  @node $RANDOM()
- Line 1379  Returns a line of code from a routine.
+ Line 1519  Returns a line of code from a routine.
  @cindex $TRANSLATE
  @cindex intrinsic functions, $TRANSLATE
+ Replaces characters in a string.
+ The first argument is a string expression representing the text to be changed.
+ The second argument is a list of characters to replace.
+ The third argument is a list of characters to use as the replacements for the characters in the second argument.
+ @emph{Example}
+ @example
+  DEFAULT.USER> W $TRANSLATE("twig","wt","rb")
+  brig
+ @end example
  @node $TYPE()
  @section $TYPE
  @cindex $TYPE
- Line 1452  Always @emph{true}
+ Line 1607  Always @emph{true}
  @cindex intrinsic functions, $ZCALL
  @cindex intrinsic functions, implementation-specific
+ Purpose unknown.
  @node $ZCRC()
  @section $ZCRC
  @cindex $ZCRC
- Line 1472  Returns a checksum of @code{arg1}.
+ Line 1629  Returns a checksum of @code{arg1}.
  @cindex intrinsic functions, $ZDATA
  @cindex intrinsic functions, implementation-specific
+ Purpose unknown.
  @node $ZDATE()
  @section $ZDATE
  @cindex $ZDATE
- Line 1496  The optional @emph{<format-string>} foll
+ Line 1655  The optional @emph{<format-string>} foll
  @cindex intrinsic functions, $ZEDIT
  @cindex intrinsic functions, implementation-specific
+ Purpose unknown.
  @node $ZHOROLOG()
  @section $ZHOROLOG
  @cindex $ZHOROLOG
- Line 1520  $ZHOROLOG(@emph{<date-value>},@emph{<for
+ Line 1681  $ZHOROLOG(@emph{<date-value>},@emph{<for
  @cindex intrinsic functions, $ZKEY
  @cindex intrinsic functions, implementation-specific
+ Purpose unknown.
  @node $ZLENGTH()
  @section $ZLENGTH
  @cindex $ZLENGTH
  @cindex intrinsic functions, $ZLENGTH
  @cindex intrinsic functions, implementation-specific
+ Purpose unknown.
  @node $ZLSD()
  @section $ZLSD
  @cindex $ZLSD
- Line 1554  Returns the Levenshtein distance between
+ Line 1719  Returns the Levenshtein distance between
  @cindex intrinsic functions, $ZNAME
  @cindex intrinsic functions, implementation-specific
+ Purpose unknown.
  @node $ZNEXT()
  @section $ZNEXT
  @cindex $ZNEXT
  @cindex intrinsic functions, $ZNEXT
  @cindex intrinsic functions, implementation-specific
+ Purpose unknown.
  @node $ZORDER()
  @section $ZORDER
  @cindex $ZORDER
  @cindex intrinsic functions, $ZORDER
  @cindex intrinsic functions, implementation-specific
+ Purpose unknown.
  @node $ZPIECE()
  @section $ZPIECE
  @cindex $ZPIECE
  @cindex intrinsic functions, $ZPIECE
  @cindex intrinsic functions, implementation-specific
+ Purpose unknown.
  @node $ZPREVIOUS()
  @section $ZPREVIOUS
  @cindex $ZPREVIOUS
  @cindex intrinsic functions, $ZPREVIOUS
  @cindex intrinsic functions, implementation-specific
+ Purpose unknown.
  @node $ZREPLACE()
  @section $ZREPLACE
  @cindex $ZREPLACE
- Line 1749  $$<objectName>.EXTRACT(<start>,<end>)
+ Line 1924  $$<objectName>.EXTRACT(<start>,<end>)
  @node $$FIND
  @section $$FIND
+ Finds the character immediately following the first occurence of a substring within a string.
+ The first argument is the substring to be located.
+ The second argument is the position within the string at which to begin searching.
+ See @ref{$FIND()}.
  @node $$FNUMBER
  @section $$FNUMBER
+ Formats a number according to a set of formatting codes.
+ The argument is a series of formatting codes. See @ref{$FNUMBER()} for details.
  @node $$JUSTIFY
  @section $$JUSTIFY
+ Right-justifies a string based on a specified fixed length.
+ The first argument is the character length of the output.
+ The second argument controls the number of fractional digits to be included in the output, and defaults to the number of digits specified in the first argument.
+ See @ref{$JUSTIFY()} for details.
  @node $$LENGTH
  @section $$LENGTH
+ Returns the length of the string.
  @node $$PIECECOUNT
  @section $$PIECECOUNT
+ Returns the number of items in a list delimited by the character specified in the argument.
  @node $$PIECE
  @section $$PIECE
+ @emph{Syntax}
+ @code{$PIECE(@emph{d}[,@emph{n}[,@emph{end}]])}
+ Accesses the @code{n}th through @code{end} @code{d}-delimited pieces of the string.
+ The first argument is the delimiter to be used.
+ The optional second argument is the first @code{d}-delimited piece to access, and defaults to @code{1}.
+ The optional third argument is the final @code{d}-delimited piece to access, and defaults to the value of the third argument (@code{n}).
  @node $$REPLACE
  @section $$REPLACE
+ @emph{Syntax}
+ @code{myString.$$REPLACE(@emph{arg1},@emph{arg2})}
+ Replaces all instances of @code{arg2} with @code{arg3} in @code{myString}.
  @node $$REVERSE
  @section $$REVERSE
+ Returns the reverse of the string.
  @node $$TOLOWER
  @section $$TOLOWER
+ Returns an all-lowercase version of the string.
  @node $$TOUPPER
  @section $$TOUPPER
+ Returns an all-uppercase version of the string.
  @node $$TRANSLATE
  @section $$TRANSLATE
+ Identical to @ref{$TRANSLATE()}, except that the arguments are shifted left by one, and the input string is implicit (the object).
  @node Commands
  @chapter Commands
  @cindex commands
- Line 1788  $$<objectName>.EXTRACT(<start>,<end>)
+ Line 2013  $$<objectName>.EXTRACT(<start>,<end>)
  * !::                                   Run an external program or command.
  * !!::                                  Launch a subshell from FreeM direct mode.
  * ABLOCK::                              Increment the block counter for one or more event classes.
- * ASSERT::                              Raise error when a conditional expression evaluates @emph{false}.
  * ASTART::                              Enable asynchronous event handling for one or more event classes.
  * ASTOP::                               Disable asynchronous event handling for one or more event classes.
  * AUNBLOCK::                            Decrement the block counter for one or more event classes.
  * BREAK::                               Interrupt a running routine to allow interactive debugging.
  * CLOSE::                               Close an input/output device.
- * CONST::                               Define a constant that cannot be altered after initial definition.
  * DO::                                  Transfer program control to one or more subroutines or introduces a new execution level.
  * ELSE::                                Execute the remainder of a line if @code{@ref{$TEST}} evaluates @emph{false}.
  * FOR::                                 Repeat execution of a line or block of code.
- Line 1807  $$<objectName>.EXTRACT(<start>,<end>)
+ Line 2030  $$<objectName>.EXTRACT(<start>,<end>)
  * KSUBSCRIPTS::                         Kill only the descendant subscripts of a local, global, global, or structured system variable.
  * KVALUE::                              Kill only the value of a local, global, or structured system variable.
  * LOCK::                                Control advisory locking for concurrency control.
- * MAP::                                 Map a global name to a non-default namespace.
  * MERGE::                               Merge contents of one local, global, or structured system variable into another.
  * NEW::                                 Introduce a new scope for a specified local variable or intrinsic special variable or instantiate an object.
  * OPEN::                                Open a sequential or socket input/output device.
- Line 1816  $$<objectName>.EXTRACT(<start>,<end>)
+ Line 2038  $$<objectName>.EXTRACT(<start>,<end>)
  * SET::                                 Set the value of a local variable, global, intrinsic special variable, or structured system variable.
  * TCOMMIT::                             Commit a transaction.
  * THEN::                                Preserve @code{@ref{$TEST}} until the end of the current line.
- * THROW::                               Programmatically raise an error condition.
  * TROLLBACK::                           Roll back all pending transactions.
  * TSTART::                              Introduce a new transaction processing level.
- * UNMAP::                               Remove a mapping of a global to a non-default namespace.
  * USE::                                 Set the currently-active input/output device.
  * VIEW::                                Modify FreeM internal parameters.
- * WATCH::                               Enable or disable watchpoints, or set or clear watchpoints on specified globals, locals, or structured system variables.
- * WITH::                                Set prefix for future variable references.
  * WRITE::                               Write output to current input/output device.
  * XECUTE::                              Interpret string as M code.
- * ZALLOCATE::                           Alternative to @code{LOCK}.
+ * ZASSERT::                             Raise error when a conditional expression evaluates @emph{false}.
- * ZBREAK::                              Unknown.
+ * ZBREAK::                              Enable/disable ZBREAK mode.
- * ZDEALLOCATE::                         Alternative to @code{LOCK}.
+ * ZCONST::                              Define a constant that cannot be altered after initial definition.
- * ZGO::                                 Unknown.
+ * ZGOTO::                               @code{GOTO} with @code{BREAK} control.
- * ZHALT::                               Unknown.
+ * ZHALT::                               Exit FreeM job with return value.
  * ZINSERT::                             Insert code into routine buffer.
- * ZJOB::                                Unknown.
+ * ZJOB::                                Invoke job, ignoring any timeouts.
  * ZLOAD::                               Load routine into routine buffer.
+ * ZMAP::                                Map a global name to a non-default namespace.
  * ZNEW::                                Unknown.
  * ZPRINT::                              Print contents of routine buffer.
- * ZQUIT::                               Unknown.
+ * ZQUIT::                               Quit multiple stack levels at once.
  * ZREMOVE::                             Remove code from routine buffer.
  * ZSAVE::                               Save routine buffer to disk.
+ * ZTHROW::                              Programmatically raise an error condition.
  * ZTRAP::                               Unknown.
+ * ZUNMAP::                              Remove a mapping of a global to a non-default namespace.
+ * ZWATCH::                              Enable or disable watchpoints, or set or clear watchpoints on specified globals, locals, or structured system variables.
+ * ZWITH::                               Set prefix for future variable references.
  * ZWRITE::                              Write local variable, global, or structured system variable to @code{@ref{$IO}}.
  @end menu
- Line 1861  Executes FreeM code @emph{expr V mcode}.
+ Line 2084  Executes FreeM code @emph{expr V mcode}.
  @emph{Example (Using Variable)}
  @example
- USER> SET FOO="WRITE ""HELLO WORLD"",!"
+ DEFAULT.USER> SET FOO="WRITE ""HELLO WORLD"",!"
- USER> @@FOO
+ DEFAULT.USER> @@FOO
  HELLO WORLD
- USER>
+ DEFAULT.USER>
  @end example
  @emph{Example (Using String Literal)}
  @example
- USER> @@"WRITE ""HELLO WORLD"",!"
+ DEFAULT.USER> @@"WRITE ""HELLO WORLD"",!"
  HELLO WORLD
- USER>
+ DEFAULT.USER>
  @end example
  @emph{Example (Using Indirection)}
  @example
- USER> SET FOO="BAR"
+ DEFAULT.USER> SET FOO="BAR"
- USER> SET BAR="WRITE ""HELLO WORLD"",!"
+ DEFAULT.USER> SET BAR="WRITE ""HELLO WORLD"",!"
- USER> @@@@FOO
+ DEFAULT.USER> @@@@FOO
  HELLO WORLD
- USER>
+ DEFAULT.USER>
  @end example
- Line 1921  If the @command{>} character is supplied
+ Line 2144  If the @command{>} character is supplied
  Launches a subshell within the FreeM direct mode, allowing the user to run operating system commands.
  @example
- USER> !!
+ DEFAULT.USER> !!
  Type Ctrl-D to exit from the shell
  $ uname -a
  Linux hesperos 4.19.0-17-amd64 #1 SMP Debian 4.19.194-3 (2021-07-18) x86_64 GNU/Linux
  $ exit
- USER>
+ DEFAULT.USER>
  @end example
- Line 1961  In its inclusive form, @code{ABLOCK} inc
+ Line 2184  In its inclusive form, @code{ABLOCK} inc
  In its exclusive form, @code{ABLOCK} increments the block counters for all event classes @emph{except for} those named in the list, provided the optional @emph{postcondition} is either @emph{true} or omitted.
- @node ASSERT
- @section ASSERT
- @cindex ASSERT
- @cindex commands, ASSERT
- @cindex commands, debugging
- @cindex commands, implementation-specific
- @cindex commands, non-standard
- @emph{FreeM Extension}
- Triggers error @code{ASSERT} if the supplied truth-valued expression @emph{tvexpr} is @emph{false} (@emph{1} is @emph{true}, and @emph{0} is @emph{false}), and that the optional @emph{postcondition} evaluates to @emph{true} or is omitted.
- The @code{ASSERT} error is catchable whether using standard-style, FreeM-style, or DSM 2.0-style error processing.
- @emph{Syntax}
- @example
-  ASSERT@emph{:postcondition} @emph{<tvexpr>}
- @end example
- @emph{Example}
- @example
- USER> SET DEBUG=1
- USER> ASSERT:DEBUG 1=1
- USER> ASSERT:DEBUG 1=0
- >> Error ZASSERT:  programmer assertion failed in SYSTEM::^%SYSINIT  [$STACK = 0]
- >> ASSERT:DEBUG 1=0
-                    ^
- @end example
  @node ASTART
  @section ASTART
- Line 2100  In its argumentless form, @code{BREAK} s
+ Line 2288  In its argumentless form, @code{BREAK} s
  @emph{FreeM Extension}
- In its single-argument form, @code{BREAK} sets @emph{Ctrl-C} handling and error handling characteristics, provided the optional @emph{postcondition} is @emph{true} or omitted.
+ In its single-argument form, @code{BREAK} enters the interactive debugger or sets @emph{Ctrl-C} handling and error handling characteristics, provided the optional @emph{postcondition} is @emph{true} or omitted.
  The following table enumerates the possible values of @emph{breakflag}
  @table @code
+ @item "DEBUG"
+ Enters the interactive debugger
  @item 0
  Disables @emph{Ctrl-C} handling
  @item -2
- Line 2135  In its argumentless form, @code{CLOSE} c
+ Line 2325  In its argumentless form, @code{CLOSE} c
  In its single-argument form, @code{CLOSE} closes the I/O device associated with channel @emph{channel}, provided that @emph{channel} represents a currently-open device, and the optional @emph{postcondition} is @emph{true} or omitted.
- @node CONST
- @section CONST
- @cindex CONST
- @cindex commands, CONST
- @cindex commands, non-standard
- @emph{FreeM Extension}
- Defines a local @emph{constant}, or variable that cannot be altered after its initial definition, provided the optional @emph{postcondition} is @emph{true} or omitted.
- Constants must only be locals, and globals are not supported.
- @emph{Syntax}
- @example
- @code{CONST@emph{:postcondition} @emph{mref1}=@emph{initial-value1},...,@emph{mrefN}=@emph{initial-valueN}}
- @end example
  @node DO
  @section DO
  @cindex DO
- Line 2165  In its inclusive form, transfers program
+ Line 2338  In its inclusive form, transfers program
  DO[@emph{:postcondition}] @emph{entryref}[@emph{:postcondition}[,...]]
  @end example
+ @cartouche
+ @quotation
+ @emph{Non-Standard Behavior}
+ FreeM allows @code{DO} @emph{entryref}s to follow the format of @code{+@emph{intexpr}}. In this case, the value of @emph{intexpr} will be interpreted as an offset from the first line of the current routine.
+ @end quotation
+ @end cartouche
  In its argumentless form, transfers control to the following block of code where the line level is one greater than the level at which @code{DO} was encountered, provided the optional @emph{postcondition} evaluates to @emph{true} or is omitted.
  @emph{Syntax}
- Line 2190  ELSE[@emph{:postcondition}]
+ Line 2371  ELSE[@emph{:postcondition}]
  @quotation
  @emph{Non-Standard Behavior}
- FreeM allows a @emph{postcondition} on @code{ELSE}. While explicitly forbidden in the @emph{standard}--and for good reason--it was decided that FreeM should allow postconditions everywhere, both for the sake of foolish consistency (the likes of which Emerson warned against), and for the benefit of entrants to a hypothetical future obfuscated M contest, and those with a Machiavellian predisposition to wicked perversions and undue cleverness.
+ FreeM allows a @emph{postcondition} on @code{ELSE}. While explicitly forbidden in the @emph{Standard}, it was decided that FreeM should allow postconditions everywhere, both for the sake of foolish consistency (the likes of which Emerson warned against), and for the benefit of entrants to a hypothetical future obfuscated M contest, and those with a Machiavellian predisposition to wicked perversions and undue cleverness.
- Using postconditions on @code{ELSE} should be strictly avoided in production code, as they have no practical use, and may contribute to technical debt, hardening of the arteries, hobgoblins, a small mind, a surfeit of logic, climate change, Daily WTF rants, or meltdown of global financial markets.
+ Using postconditions on @code{ELSE} should be strictly avoided in production code, as they have no practical use, and may contribute to technical debt, hardening of the arteries, hobgoblins, a small mind, a surfeit of logic, climate change, @emph{Daily WTF} rants, or the meltdown of global financial markets.
  @end quotation
  @end cartouche
- Line 2232  FOR[@emph{:postcondition}] @emph{glvn}=@
+ Line 2413  FOR[@emph{:postcondition}] @emph{glvn}=@
  @emph{Example}
  @example
- USER> FOR I=1:1:10 WRITE I,!
+ DEFAULT.USER> FOR I=1:1:10 WRITE I,!
- Line 2245  USER> FOR I=1:1:10 WRITE I,!
+ Line 2426  USER> FOR I=1:1:10 WRITE I,!
- USER> FOR I=2:2:10 WRITE I,!
+ DEFAULT.USER> FOR I=2:2:10 WRITE I,!
- Line 2265  FOR[@emph{:postcondition}] @emph{glvn}=@
+ Line 2446  FOR[@emph{:postcondition}] @emph{glvn}=@
  @emph{Example}
  @example
- USER> FOR I=60,"FOO",-3,"George",1450,$HOROLOG WRITE I,!
+ DEFAULT.USER> FOR I=60,"FOO",-3,"George",1450,$HOROLOG WRITE I,!
  FOO
- Line 2288  Transfers program execution to another l
+ Line 2469  Transfers program execution to another l
  GOTO[@emph{:postcondition}] @emph{entryref}
  @end example
+ @cartouche
+ @quotation
+ @emph{Non-Standard Behavior}
+ FreeM allows @code{GOTO} @emph{entryref}s to follow the format of @code{+@emph{intexpr}}. In this case, the value of @emph{intexpr} will be interpreted as an offset from the first line of the current routine.
+ @end quotation
+ @end cartouche
  @node HALT
  @section HALT
  @cindex HALT
- Line 2336  IF[@emph{:postcondition}] @emph{tvexpr}[
+ Line 2526  IF[@emph{:postcondition}] @emph{tvexpr}[
  In its argumentless form, allows the remainder of the line of code following @code{IF} to execute only if @code{$TEST} evaluates to @emph{1}, provided the optional @emph{postcondition} evaluates to @emph{true} or is omitted.
  @emph{Syntax}
  @example
- IF[@emph{:postcondition}]
+ IF[@emph{:postcondition}]  @emph{command...}
  @end example
+ @cartouche
+ @quotation
+ @emph{Style Recommendation}
+ In the interest of readability and maintainability, we recommend avoiding the argumentless form of @code{IF} in new code. It is an obsolete relic of an era when routine sizes were severely limited, and can be difficult to spot, as the use of whitespace (@code{IF  @emph{command}}) makes the intent of its use non-obvious at a glance. It is also far too easy to inadvertently delete the extra space, leading to program errors easily avoided otherwise.
+ We recommend explicitly checking the value of @code{$TEST} instead, as in @code{IF $TEST @emph{command}} or @code{@emph{command}:$TEST ...}, as this makes the intent immediately clear both to M newcomers and seasoned experts, and sacrifices nothing of value, even on the oldest computer systems where FreeM can be used today.
+ @end quotation
+ @end cartouche
  @node JOB
  @section JOB
  @cindex JOB
- Line 2399  In the above @emph{inclusive} form, @cod
+ Line 2600  In the above @emph{inclusive} form, @cod
  @cartouche
  @quotation
  @emph{Note}
- The below @emph{argumentless} and @emph{exclusive} forms of @code{KSUBSCRIPTS} are not implemented in FreeM, as of version 0.3.3, but are planned for a future release.
+ The below @emph{argumentless} and @emph{exclusive} forms of @code{KSUBSCRIPTS} are not implemented in FreeM, as of version 0.64.0-rc1, but are planned for a future release.
  @end quotation
  @end cartouche
- Line 2434  In the above @emph{inclusive} form, @cod
+ Line 2635  In the above @emph{inclusive} form, @cod
  @cartouche
  @quotation
  @emph{Note}
- The below @emph{argumentless} and @emph{exclusive} forms of @code{KVALUE} are not implemented in FreeM, as of version 0.62.1, but are planned for a future release.
+ The below @emph{argumentless} and @emph{exclusive} forms of @code{KVALUE} are not implemented in FreeM, as of version 0.64.0-rc1, but are planned for a future release.
  @end quotation
  @end cartouche
- Line 2475  LOCK[@emph{:postcondition}] [+|-]@emph{n
+ Line 2676  LOCK[@emph{:postcondition}] [+|-]@emph{n
  @emph{Example}
- This example will increment the lock counter for @code{^JPW} and decrement the lock counter for @code{^MJR}.
+ This example will increment the lock counter for @code{^SNW} and decrement the lock counter for @code{^MJR}.
  @example
- LOCK +^JPW,-^MJR
+ LOCK +^SNW,-^MJR
  @end example
  In its non-incremental form, @code{LOCK} releases all @code{LOCK}s held by the current process, and then attempts to acquire a lock on each @emph{name}, provided the optional @emph{postcondition} evaluates to @emph{true} or is omitted. If @emph{timeout} is supplied, FreeM will attempt to lock @emph{name} for no more than @emph{timeout} seconds.
- Line 2490  If @code{LOCK} succeeds within @emph{tim
+ Line 2691  If @code{LOCK} succeeds within @emph{tim
  LOCK[@emph{:postcondition}] @emph{name}[:@emph{timeout}][,...@emph{name}[:@emph{timeout}]]
  @end example
- @node MAP
- @section MAP
- @cindex MAP
- @cindex commands, MAP
- @cindex commands, implementation-specific
- @cindex commands, non-standard
- Maps global name @code{gvn} to be mapped to the non-default namespace @emph{expr V namespace}, provided the optional @emph{postcondition} evaluates to @emph{true} or is omitted.
- @emph{Syntax}
- @example
- MAP[@emph{:postcondition}] GLOBAL @emph{gvn}=@emph{expr V namespace}
- @end example
  @node MERGE
  @section MERGE
  @cindex MERGE
- Line 2551  NEW@emph{:postcondition} @emph{name}=@em
+ Line 2737  NEW@emph{:postcondition} @emph{name}=@em
  In its initializing form, @code{NEW} stacks variable @emph{name} and sets its value to @emph{expr}, provided the optional @emph{postcondition} evaluates to @emph{true} or is omitted. When the current stack frame is exited, the previous value is restored.
+ @emph{Syntax}
+ @example
+ NEW@emph{:postcondition} @emph{name}=$%@emph{^CLASS}(@emph{initializer-list})
+ @end example
+ In its object-oriented form, @code{NEW} creates an instance of class @emph{^CLASS} in local variable @emph{name} and calls the constructor of @emph{^CLASS}, passing @emph{initializer-list} as its argument(s).
  @node OPEN
  @section OPEN
  @cindex OPEN
- Line 2747  Saves the value of @code{$TEST} until th
+ Line 2940  Saves the value of @code{$TEST} until th
  IF 1 THEN  WRITE "HELLO!",!
  @end example
- @node THROW
- @section THROW
- @cindex THROW
- @cindex commands, THROW
- @cindex commands, non-standard
- @emph{FreeM Extension}
- Raises an error condition as long as the optional @emph{postcondition} is @emph{true} or omitted.
- @emph{Syntax}
- @example
- @code{THROW@emph{:postcondition} @emph{expr V error-code}}
- @end example
- @emph{Example}
- @example
- @code{THROW "M102"}
- @end example
  @node TROLLBACK
  @section TROLLBACK
  @cindex TROLLBACK
- Line 2832  If you are using more than one transacti
+ Line 3004  If you are using more than one transacti
  TSTART (FOO,BAR):(SERIAL,TRANSACTIONID="FOO")
  @end example
- @node UNMAP
- @section UNMAP
- @cindex UNMAP
- @cindex commands, UNMAP
- @cindex commands, implementation-specific
- @cindex commands, non-standard
- Removes any mapping connecting @emph{gvn} to a non-default namespace, provided the optional @emph{postcondition} evaluates to @emph{true} or is omitted.
- @emph{Syntax}
- @example
- UNMAP GLOBAL @emph{gvn}
- @end example
  @node USE
  @section USE
- Line 2914  Closes all global data files open in the
+ Line 3072  Closes all global data files open in the
  VIEW 21
  @end example
- @item @code{29} - Symbol Table Copy
- Copies the primary symbol table's contents to the alternate symbol table. Takes no arguments.
- @emph{Syntax}
- @example
- VIEW 29
- @end example
  @item @code{52} - Set G0 Input Translation Table for @code{$IO}
  @emph{Syntax}
- Line 3070  If @emph{tvexpr} evaluates to @emph{true
+ Line 3220  If @emph{tvexpr} evaluates to @emph{true
  VIEW 83:@emph{tvexpr}
  @end example
- @item @code{87} - Date Type Definition
- We believe this defines date formats for @code{$ZDATE}, but we have not yet figured out how it works.
- @emph{Syntax}
- @example
- ; Syntax unknown
- @end example
- @item @code{88} - Time Type Definition
- We believe this defines time formats for @code{$ZTIME}, but we have not yet figured out how it works.
- @emph{Syntax}
- @example
- ; Syntax unknown
- @end example
- @item @code{91} - Set Default Expression for Missing @code{QUIT} Expression
- Sets the default expression to be printed when a @code{QUIT} is encountered where a @code{QUIT} argument would be expected, but was not provided. We're not entirely sure what this does.
- @emph{Syntax}
- @example
- ; Syntax unknown
- @end example
  @item @code{92} - Set Type Mismatch Error Flag on @code{EUR2DEM}
  If @emph{tvexpr} evaluates to @emph{true}, a type mismatch error will be thrown in @code{EUR2DEM} currency conversions in certain situations that we do not yet understand.
- Line 3182  VIEW 133:@emph{tvexpr}
+ Line 3308  VIEW 133:@emph{tvexpr}
  @end table
- @node WATCH
- @section WATCH
- @cindex WATCH
+ @node WRITE
- @cindex commands, WATCH
+ @section WRITE
+ @cindex WRITE
+ @cindex commands, WRITE
+ @node XECUTE
+ @section XECUTE
+ @cindex XECUTE
+ @cindex commands, XECUTE
+ @node ZASSERT
+ @section ZASSERT
+ @cindex ZASSERT
+ @cindex commands, ZASSERT
  @cindex commands, debugging
  @cindex commands, implementation-specific
  @cindex commands, non-standard
  @emph{FreeM Extension}
- Sets a watchpoint on a global, local, or SSVN node.
+ Triggers error @code{ZASSERT} if the supplied truth-valued expression @emph{tvexpr} is @emph{false} (@emph{1} is @emph{true}, and @emph{0} is @emph{false}), and that the optional @emph{postcondition} evaluates to @emph{true} or is omitted.
- @emph{Syntax}
+ The @code{ZASSERT} error is catchable whether using standard-style, FreeM-style, or DSM 2.0-style error processing.
- In its @emph{argumentless} form, @code{WATCH} toggles watchpoints on and off, provided the optional @emph{postcondition} is @emph{true} or omitted.
+ @emph{Syntax}
  @example
- WATCH[@emph{:postcondition}]
+  ZASSERT@emph{:postcondition} @emph{<tvexpr>}
  @end example
- In its @emph{inclusive} form, @code{WATCH} adds, removes, or examines watchpoints, provided the optional @emph{postcondition} is @emph{true} or omitted.
+ @emph{Example}
- A @code{+} adds a new watchpoint to the following variable.
- A @code{-} removes an existing watchpoint for the following variable.
- A @code{?} examines the status of a watchpoint for the following variable.
  @example
- WATCH[@emph{:postcondition}] [+|-|?]@emph{var1}...,[+|-|?]@emph{varN}
+ DEFAULT.USER> SET DEBUG=1
- @end example
- The following example demonstrates turning watchpoint processing on and adding a watchpoint for global variable @code{^jpw(1)}. It then changes the value of @code{^jpw(1)}.
+ DEFAULT.USER> ZASSERT:DEBUG 1=1
- @example
- USER> WATCH
- Watchpoints enabled.
- USER> WATCH +^JPW(1)
- Added '^JPW("1")' to the watchlist.
- USER> SET ^JPW(1)="new value"
- >> WATCHPOINT:  ^JPW("1") => 'new value' (changed 1 times)
- @end example
+ DEFAULT.USER> ZASSERT:DEBUG 1=0
- The following example will remove that watchpoint:
- @example
- USER> WATCH -^JPW(1)
- Removed '^JPW("1")' from the watchlist.
- USER> WATCH ?^JPW(1)
- '^JPW("1")' is not being watched.
+ >> Error ZASSERT:  programmer assertion failed in SYSTEM::^%SYSINIT  [$STACK = 0]
+ >> ZASSERT:DEBUG 1=0
+                    ^
  @end example
- @node WITH
+ @node ZBREAK
- @section WITH
+ @section ZBREAK
- @cindex WITH
+ @cindex ZBREAK
- @cindex commands, WITH
+ @cindex commands, ZBREAK
+ @cindex commands, debugging
+ @cindex commands, implementation-specific
  @cindex commands, non-standard
  @emph{FreeM Extension}
- Sets a prefix to be applied to all subsequent local variable or constant references.
+ Sets or clears the @code{ZBREAK} flag@footnote{NOTE: FreeM team needs to investigate how @code{zbreakon} and @code{zbflag} affect program execution.}, based on the result of evaluating @emph{tvexpr}.
  @emph{Syntax}
  @example
- @code{WITH@emph{:postcondition} @emph{var-prefix}}
+ ZBREAK @emph{tvexpr}
  @end example
- In the above single-argument form, sets the @code{$WITH} prefix to @emph{var-prefix}, provided that the optional @emph{postcondition} is either @emph{true} or omitted.
+ @node ZCONST
+ @section ZCONST
- The @emph{var-prefix} argument may be a string literal or any valid FreeM expression.
+ @cindex ZCONST
+ @cindex commands, ZCONST
- @example
+ @cindex commands, non-standard
- @code{WITH@emph{:postcondition}}
+ @emph{FreeM Extension}
- @end example
- In the above argumentless form, clears the @code{$WITH} prefix, provided the optional @emph{postcondition} is either @emph{true} or omitted. Equivalent to @code{WITH ""}.
+ Defines a local @emph{constant}, or variable that cannot be altered after its initial definition, provided the optional @emph{postcondition} is @emph{true} or omitted.
+ Constants must only be locals, and globals are not supported.
- @node WRITE
+ @emph{Syntax}
- @section WRITE
- @cindex WRITE
- @cindex commands, WRITE
- @node XECUTE
+ @example
- @section XECUTE
+ @code{ZCONST@emph{:postcondition} @emph{mref1}=@emph{initial-value1},...,@emph{mrefN}=@emph{initial-valueN}}
- @cindex XECUTE
+ @end example
- @cindex commands, XECUTE
- @node ZALLOCATE
+ @node ZGOTO
- @section ZALLOCATE
+ @section ZGOTO
- @cindex ZALLOCATE
+ @cindex ZGOTO
- @cindex commands, ZALLOCATE
+ @cindex commands, ZGOTO
  @cindex commands, implementation-specific
  @cindex commands, non-standard
  @emph{FreeM Extension}
- @node ZBREAK
+ In its argumented form, enables @code{BREAK} mode and branches unconditionally to @emph{entryref}.
- @section ZBREAK
- @cindex ZBREAK
- @cindex commands, ZBREAK
- @cindex commands, debugging
- @cindex commands, implementation-specific
- @cindex commands, non-standard
- @emph{FreeM Extension}
- @node ZDEALLOCATE
+ @emph{Syntax}
- @section ZDEALLOCATE
- @cindex ZDEALLOCATE
- @cindex commands, ZDEALLOCATE
- @cindex commands, implementation-specific
- @cindex commands, non-standard
- @emph{FreeM Extension}
- @node ZGO
+ @example
- @section ZGO
+ ZGOTO @emph{entryref}
- @cindex ZGO
+ @end example
- @cindex commands, ZGO
- @cindex commands, implementation-specific
+ In its argumented form, resumes execution after a @code{BREAK}.
- @cindex commands, non-standard
- @emph{FreeM Extension}
+ @emph{Syntax}
+ @example
+ ZGOTO
+ @end example
  @node ZHALT
  @section ZHALT
- Line 3321  In the above argumentless form, clears t
+ Line 3422  In the above argumentless form, clears t
  @cindex commands, non-standard
  @emph{FreeM Extension}
+ In its single-argumented form, @code{ZHALT} command is used to exit the FreeM process with a specific return value @emph{intexpr}.
+ @emph{Syntax}
+ @example
+ ZHALT @emph{intexpr}
+ @end example
+ In its argumentless form, @code{ZHALT} is synonymous with @code{HALT}.
+ @emph{Syntax}
+ @example
+ ZHALT
+ @end example
  @node ZINSERT
  @section ZINSERT
  @cindex ZINSERT
- Line 3357  Loads routine @emph{<routine-name>} into
+ Line 3474  Loads routine @emph{<routine-name>} into
  ZLOAD@emph{:postcondition} @emph{<routine-name>}
  @end example
+ @node ZMAP
+ @section ZMAP
+ @cindex ZMAP
+ @cindex commands, ZMAP
+ @cindex commands, implementation-specific
+ @cindex commands, non-standard
+ Maps global name @code{gvn} to be mapped to the non-default namespace @emph{expr V namespace}, provided the optional @emph{postcondition} evaluates to @emph{true} or is omitted.
+ @emph{Syntax}
+ @example
+ ZMAP[@emph{:postcondition}] GLOBAL @emph{gvn}=@emph{expr V namespace}
+ @end example
  @node ZNEW
  @section ZNEW
  @cindex ZNEW
- Line 3415  In its argumentless form, quits from @co
+ Line 3548  In its argumentless form, quits from @co
  @cindex commands, non-standard
  @emph{FreeM Extension}
+ @node ZTHROW
+ @section ZTHROW
+ @cindex ZTHROW
+ @cindex commands, ZTHROW
+ @cindex commands, non-standard
+ @emph{FreeM Extension}
+ Raises an error condition as long as the optional @emph{postcondition} is @emph{true} or omitted.
+ @emph{Syntax}
+ @example
+ @code{ZTHROW@emph{:postcondition} @emph{expr V error-code}}
+ @end example
+ @emph{Example}
+ @example
+ @code{ZTHROW "M102"}
+ @end example
  @node ZTRAP
  @section ZTRAP
  @cindex ZTRAP
- Line 3424  In its argumentless form, quits from @co
+ Line 3579  In its argumentless form, quits from @co
  @cindex commands, non-standard
  @emph{FreeM Extension}
+ @node ZUNMAP
+ @section ZUNMAP
+ @cindex ZUNMAP
+ @cindex commands, ZUNMAP
+ @cindex commands, implementation-specific
+ @cindex commands, non-standard
+ Removes any mapping connecting @emph{gvn} to a non-default namespace, provided the optional @emph{postcondition} evaluates to @emph{true} or is omitted.
+ @emph{Syntax}
+ @example
+ ZUNMAP GLOBAL @emph{gvn}
+ @end example
+ @node ZWATCH
+ @section ZWATCH
+ @cindex ZWATCH
+ @cindex commands, ZWATCH
+ @cindex commands, debugging
+ @cindex commands, implementation-specific
+ @cindex commands, non-standard
+ @emph{FreeM Extension}
+ Sets a watchpoint on a global, local, or SSVN node.
+ @emph{Syntax}
+ In its @emph{argumentless} form, @code{ZWATCH} toggles watchpoints on and off, provided the optional @emph{postcondition} is @emph{true} or omitted.
+ @example
+ ZWATCH[@emph{:postcondition}]
+ @end example
+ In its @emph{inclusive} form, @code{ZWATCH} adds, removes, or examines watchpoints, provided the optional @emph{postcondition} is @emph{true} or omitted.
+ A @code{+} adds a new watchpoint to the following variable.
+ A @code{-} removes an existing watchpoint for the following variable.
+ A @code{?} examines the status of a watchpoint for the following variable.
+ @example
+ ZWATCH[@emph{:postcondition}] [+|-|?]@emph{var1}...,[+|-|?]@emph{varN}
+ @end example
+ The following example demonstrates turning watchpoint processing on and adding a watchpoint for global variable @code{^snw(1)}. It then changes the value of @code{^snw(1)}.
+ @example
+ DEFAULT.USER> ZWATCH
+ Watchpoints enabled.
+ DEFAULT.USER> ZWATCH +^SNW(1)
+ Added '^SNW("1")' to the watchlist.
+ DEFAULT.USER> SET ^SNW(1)="new value"
+ >> WATCHPOINT:  ^SNW("1") => 'new value' (changed 1 times)
+ @end example
+ The following example will remove that watchpoint:
+ @example
+ DEFAULT.USER> ZWATCH -^SNW(1)
+ Removed '^SNW("1")' from the watchlist.
+ DEFAULT.USER> ZWATCH ?^SNW(1)
+ '^SNW("1")' is not being watched.
+ @end example
+ @node ZWITH
+ @section ZWITH
+ @cindex ZWITH
+ @cindex commands, ZWITH
+ @cindex commands, non-standard
+ @emph{FreeM Extension}
+ NOTE: This command may be deprecated and removed in future FreeM releases.
+ Sets a prefix to be applied to all subsequent local variable or constant references.
+ @emph{Syntax}
+ @example
+ @code{ZWITH@emph{:postcondition} @emph{var-prefix}}
+ @end example
+ In the above single-argument form, sets the @code{$WITH} prefix to @emph{var-prefix}, provided that the optional @emph{postcondition} is either @emph{true} or omitted.
+ The @emph{var-prefix} argument may be a string literal or any valid FreeM expression.
+ @example
+ @code{ZWITH@emph{:postcondition}}
+ @end example
+ In the above argumentless form, clears the @code{$WITH} prefix, provided the optional @emph{postcondition} is either @emph{true} or omitted. Equivalent to @code{ZWITH ""}.
  @node ZWRITE
  @section ZWRITE
  @cindex ZWRITE
- Line 3793  Returns or sets the maximum number of ch
+ Line 4059  Returns or sets the maximum number of ch
  Returns or sets the maximum number of characters of a single global subscript, from 1-255.
  @item @code{SINGLE_USER} +R +U -D
- If set to @code{1}, FreeM will skip all file locking operations on globals, as well as the @code{LOCK} and @code{ZALLOCATE} tables. If set to @code{0}, FreeM will enforce file locking on both.
+ If set to @code{1}, FreeM will skip all file locking operations on globals. If set to @code{0}, FreeM will enforce file locking on both.
- Setting @code{SINGLE_USER} to @code{1} will improve FreeM performance, but you must @emph{ONLY} use this on systems where you are absolutely sure that only one FreeM process will run at any given time, as running multiple instances of FreeM concurrently when any of them are set to @code{SINGLE_USER} mode @emph{will} cause global data and @code{LOCK}/@code{ZALLOCATE} table corruption!
+ Setting @code{SINGLE_USER} to @code{1} will improve FreeM performance, but you must @emph{ONLY} use this on systems where you are absolutely sure that only one FreeM process will run at any given time, as running multiple instances of FreeM concurrently when any of them are set to @code{SINGLE_USER} mode @emph{will} cause global data corruption.
  @item @code{CHARACTER} +R -U -D
  Returns the character set of the job.
- Line 3806  Returns or sets the current working dire
+ Line 4072  Returns or sets the current working dire
  @item @code{OPEN} +R -U -D
  The @code{^$JOB($JOB,"OPEN",<channel>} subscripts list the open I/O channels in the specified job.
- @item @code{ENGINES} +R -U -D
- Returns or sets the storage engines for various FreeM subsystems.
- The following table lists the types of storage engines that can be defined.
- @table @asis
- @item @code{GLOBAL} +R +U -D
- Returns or sets the global handler for a particular FreeM namespace:
- The following code would set the global handler for the @code{SYSTEM} namespace to @code{BERKELEYDB}:
- @code{SET ^$JOB($JOB,"ENGINES","GLOBAL","SYSTEM")="BERKELEYDB"}
- @item @code{LOCAL} +R -U -D
- Returns the local handler for a particular FreeM namespace. Always @code{BUILTIN} in the current FreeM release.
- @end table
  @item @code{BERKELEYDB,FLUSH_THRESHOLD} +R +U -D
  Returns or sets the number of write operations that will be cached in the BerkeleyDB global handler prior to flushing BerkeleyDB's cache to disk.
- Line 4114  Forces a number to positive, whether pos
+ Line 4361  Forces a number to positive, whether pos
  @section Unary -
  @cindex operators, unary -
+ Forces a number to negative, whether positive or negative. Also forces numeric coercion of strings.
  @node +
  @section + (Add)
  @cindex operators, +
+ @emph{Syntax}
+ @example
+ S X=1+2 ; => 3
+ @end example
+ Adds numbers together.
  @node +=
  @section += (Add/Assign)
  @cindex operators, +=
+ @emph{Syntax}
+ @example
+ S X=5
+ S X+=3 ; => 8
+ @end example
+ Increments the variable on the LHS by the value on the RHS.
  @node ++
  @section ++ (Postfix Increment)
  @cindex operators, ++
+ Increments a variable by 1.
  @node -
  @section - (Subtract)
  @cindex operators, -
+ Subtracts one number from another.
  @node -=
  @section -= (Subtract/Assign)
  @cindex operators, -=
+ @emph{Syntax}
+ @example
+ S X=5
+ S X-=3 ; => 2
+ @end example
+ Decrements the variable on the LHS by the value on the RHS.
  @node --
  @section -- (Postfix Decrement)
  @cindex operators, --
+ Decrements the variable by one.
  @node *
  @section * (Multiply)
  @cindex operators, *
+ Multiplies one number by another.
  @node *=
  @section *= (Multiply/Assign)
  @cindex operators, *=
  @node /
  @section / (Divide)
  @cindex operators, /
- Line 4309  An @code{INTEGER} is an interpretation o
+ Line 4594  An @code{INTEGER} is an interpretation o
  @cindex data types, REAL
  @cindex types, REAL
+ A @code{REAL} is a numeric interpretation of data including a fractional part.
  @node STRING
  @section STRING
  @cindex data types, STRING
  @cindex types, STRING
+ The @code{STRING} is the fundamental FreeM data type. Other types are inferred from the context of their usage.
+ @subsection String Rules
+ The following rules apply to all FreeM strings:
+ @itemize
+ @item Must not exceed 255 characters
+ @item Must not contain @code{$C(0)}, @code{$C(201)}, or @code{$C(202)}
+ @end itemize
+ @subsection String Quoting Rules
+ Strings in FreeM must be surrounded in double quotes:
+ @example
+ SET MYSTRING="This is a string literal"
+ @end example
+ If you want to include double quotes inside of a string, simply double them:
+ @example
+ SET MYSTRING="This is a ""string literal"" with embedded double quotes"
+ @end example
  @node Custom Types (Classes)
  @section Custom Types (Classes)
  @cindex data types, custom
  @cindex types, custom
  @cindex classes
- See @ref{Classes}.
+ See @ref{Object-Oriented Programming}.
  @node Globals
  @chapter Globals
- Line 4328  See @ref{Classes}.
+ Line 4640  See @ref{Classes}.
  @cindex variables, global
  @cindex data
+ @menu
+ * Globals Overview::            Basics of FreeM persistent storage.
+ * Creating Globals::            How to create globals.
+ * Removing Globals::            How to remove globals.
+ * Global Storage::              How globals are stored.
+ @end menu
+ @node Globals Overview
+ @section Globals Overview
+ FreeM supports typical M globals, which are often described as persistent, hierachical sparse arrays. Globals make it relatively simple to include persistent data in an application without requiring the developer to use an external database management system, and offer syntax and semantics so similar to M local variables and structured system variables that moving from one to the other is seamless.
+ Each global comprises three elements:
+ @itemize @bullet
+ @item
+ An alphabetic name beginning with a caret (@code{^}) or a caret and a percent sign (@code{^%})
+ @item
+ Optionally, one or more comma-delimited subscripts, enclosed in parentheses
+ @item
+ A value of up to 255 characters in length
+ @end itemize
+ A leading percent sign in the global name will force the named global into the @code{SYSTEM} namespace of the current FreeM environment.
+ @node Creating Globals
+ @section Creating Globals
+ @cindex globals, creating
+ To create a global, you can use the @code{SET} command:
+ @example
+ SET ^MYGLOBAL("foo","bar")="this is the data value"
+ @end example
+ @node Removing Globals
+ @section Removing Globals
+ @cindex globals, removing
+ To remove an entire global, you can use the @code{KILL} command with the unsubscripted name of the global:
+ @example
+ KILL ^MYGLOBAL
+ @end example
+ If you only want to remove part of a global, i.e., beginning at a certain subscript level, use the @code{KILL} command with a subscripted name:
+ @example
+ KILL ^MYGLOBAL("foo")
+ @end example
+ This will remove only the @code{"foo"} subscript and all of its children.
+ If you only want to remove the data value at a specific subscript level, leaving the subscript itself intact, use @code{KVALUE}:
+ @example
+ KVALUE ^MYGLOBAL("foo")
+ @end example
+ @node Global Storage
+ @section Global Storage
+ @cindex globals, storage
+ FreeM globals are stored in @code{$PREFIX/var/freem/@emph{<environment-name>}/@emph{<namespace-name>}/globals} in a binary format.
+ Global files have a header of the following format:
+ @verbatim
+ typedef struct global_header {
+     char magic[5]; /* FRMGL */
+     int format_version;
+     char host_triplet[40];
+     char host_id[256];
+     unsigned long block_size;
+     unsigned long last_transaction_id;
+     long created;
+     long last_backup;
+ } global_header;
+ @end verbatim
  @node Concurrency Control
  @chapter Concurrency Control
  @cindex concurrency control
  @cindex locking
  @cindex transaction processing
+ @menu
+ * Concurrency Control Overview::                Basics of concurrency control.
+ * Advisory Locks::                              Coordinating access voluntarily.
+ * Transaction Processing::                      Ensuring logical consistency.
+ @end menu
+ @node Concurrency Control Overview
+ @section Concurrency Control Overview
+ Multitasking, multi-user FreeM applications must concern themselves with conscientious management of concurrent access to globals in order to maintain logical consistency and prevent concurrent reads and writes from conflicting with each other.
+ In FreeM, there are two mechanisms provided for managing concurrent global access: @emph{advisory locks}, and @emph{transaction processing}.
+ Advisory locks allow applications to voluntarily coordinate concurrent access to globals with the @code{LOCK} command, and require each application to check the @code{LOCK} status prior to accessing a global.
+ Transaction processing allows applications to delineate sets of global operations (sets, kills, etc.) as being part of a transaction, in which no operations are performed against the globals contained within the transaction until the transaction is committed. In addition, processes other than the one running the transaction will be forced to wait to access globals for either the duration of the commit phase (@emph{batch mode}), or for the entire duration of the transaction (@emph{serial mode}).
+ @node Advisory Locks
+ @section Advisory Locks
+ @node Transaction Processing
+ @section Transaction Processing
+ @cindex transaction processing
+ FreeM implements a significant subset of the transaction processing features from @emph{ANSI X11.1-1995}. This allows a series of global operations to be conducted all at once, either in batch mode (where concurrent operation is not interrupted until the last possible moment), or in serial mode (where writes are guaranteed to be atomic, consistent, isolated, and durable).
+ @subsection Theory of Operation
+ FreeM uses a pessimistic concurrency control mechanism for @code{SERIAL} transactions, meaning that any @code{TSTART} command that includes the @code{SERIAL} transaction parameter will cause the process to acquire the transaction processing mutex, which prevents any process but the one holding the mutex from performing any data access (read or write) until either @code{TCOMMIT} or @code{TROLLBACK} is called, either committing or rolling back the transaction, respectively.
+ Any transaction in between its @code{TSTART} and @code{TCOMMIT}/@code{TROLLBACK} is said to be @emph{in-flight}. During the in-flight stage, pending global operations are held only in memory and after-image journals.
+ FreeM maintains a list of all globals affected during a transaction in-flight. When a @code{TCOMMIT} is reached, FreeM will generate a @emph{checkpoint} of each global data file to be changed by the transaction. These checkpoints allow all FreeM globals to be restored to their pre-transaction state if a @code{TCOMMIT} should fail part of the way through its operation.
+ Checkpoints can have one of two modes:
+ @table @asis
+ @item @code{CP_REMOVE}
+ Used for globals that did not exist prior to the beginning of this transaction. Simply marks the entire global data file for deletion in case of @code{TCOMMIT} failure.
+ @item @code{CP_RESTORE}
+ Used for globals that @emph{did} exist prior to the beginning of this transaction. In this case, the entire global data file is copied to a new file with a @code{.chk} extension. In cases of @code{TCOMMIT} failure, @code{CP_RESTORE} checkpoint files will be restored over the partially-modified live data file.
+ @end table
+ The below example shows a few global operations and checkpoints for a transaction in-flight using the @code{trantab} direct-mode command:
+ @verbatim
+ TL1:DEFAULT.USER> trantab
+  $TLEVEL 1*
+   Operations for Transaction ID: 6ea14aad-b8f1-47f9-9f52-4f513f892bc0 [RESTARTABLE SERIAL]
+    OP. NO.   ACTION         KEY/DATA
+    -------   ------         --------
+        SET            ^FOO=3
+        KILL           ^FOO
+        SET            ^snw=10
+        SET            ^BRANDNEW=6
+   Global checkpoints:
+    GLOBAL                        MODE                FILES
+    ------                        ----                -----
+    ^BRANDNEW                     CP_REMOVE           IN:   /usr/local/var/freem/USER/globals/^BRANDNEW
+    ^snw                          CP_RESTORE          IN:   /usr/local/var/freem/USER/globals/^snw
+                                                      OUT:  /usr/local/var/freem/USER/globals/^snw.23390.1.chk
+    ^FOO                          CP_RESTORE          IN:   /usr/local/var/freem/USER/globals/^FOO
+                                                      OUT:  /usr/local/var/freem/USER/globals/^FOO.23390.1.chk
+ @end verbatim
+ In the above example, @code{IN} files are the live data file that will be overwritten or removed, and @code{OUT} files are the checkpoints themselves. Note that @code{OUT} files are only used for @code{CP_RESTORE} checkpoints.
+ @subsection Using Transaction Processing
+ To use transactions in FreeM, you need to be familiar with three commands:
+ @itemize @bullet
+ @item
+ @code{TSTART}
+ @item
+ @code{TCOMMIT}
+ @item
+ @code{TROLLBACK}
+ @end itemize
+ With transaction processing, global variable operations occurring between @code{TSTART} and @code{TCOMMIT} commands will be contained within the transaction.
+ The atomicity, consistency, isolation, and durability facets of FreeM transaction hinge on the transaction mode.
+ @subsubsection BATCH Transactions
+ @code{BATCH} transactions offer higher performance, and allow other applications aside from the one doing the transaction to continue normal operations until the transaction is committed with @code{TCOMMIT}. In batch mode, other processes are only locked out of normal operation during the commit phase of the transaction.
+ The effect of this is that the operations within the batch transaction will not be interleaved with global writes from other applications, but the entire lifetime of the transaction is not guaranteed to be serialized with respect to the transaction processing activities of other running applications in the environment.
+ @subsubsection SERIAL Transactions
+ @code{SERIAL} transactions offer full ACID compliance at the expense of multiprocessing performance. In serial mode, a @code{TSTART} blocks all activity from all other FreeM processes in the environment, and this blocking effect is not released until the transaction is committed with @code{TCOMMIT} or rolled back with @code{TROLLBACK} (or due to abnormal conditions in the environment that preclude the successful completion of the transaction).
  @node Local Variables
  @chapter Local Variables
  @cindex variables, local
  @cindex local variables
+ @menu
+ * Local Variables Overview::            The basics of locals.
+ * Creating Local Variables::            Creating locals with SET.
+ * Removing Local Variables::            Removing locals with KILL.
+ @end menu
+ @node Local Variables Overview
+ @section Local Variables Overview
+ FreeM @emph{local variables} have the same data structure as global variables, but are scoped to a single FreeM process, and stored in memory.
+ Each local comprises three elements:
+ @itemize @bullet
+ @item
+ An alphabetic name beginning with a letter or a percent sign (@code{%})
+ @item
+ Optionally, one or more comma-delimited subscripts, enclosed in parentheses
+ @item
+ A value of up to 255 characters in length
+ @end itemize
+ @node Creating Local Variables
+ @section Creating Local Variables
+ @cindex local variables, creating
+ To create a local variable, use the @code{SET} command:
+ @example
+ SET MYLOCAL("foo","bar")="this is the data value"
+ @end example
+ @node Removing Local Variables
+ @section Removing Local Variables
+ @cindex local variables, removing
+ To remove an entire local variable, you can use the @code{KILL} command with the unsubscripted name of the variable:
+ @example
+ KILL MYLOCAL
+ @end example
+ If you only want to remove part of a local variable, i.e., beginning at a certain subscript level, use the @code{KILL} command with a subscripted name:
+ @example
+ KILL MYLOCAL("foo")
+ @end example
+ This will remove only the @code{"foo"} subscript and all of its children.
+ If you only want to remove the data value at a specific subscript level, leaving the subscript itself intact, use @code{KVALUE}:
+ @example
+ KVALUE MYLOCAL("foo")
+ @end example
  @node Scoping
  @chapter Scoping
  @cindex scoping
+ By default, FreeM local variables and their values are scoped to the entire process, meaning that any function or subroutine can access and modify their values. This can lead to pernicious bugs.
+ M provides the @code{NEW} command to work around these issues. When @code{NEW} is called with a local variable as its argument, FreeM will scope the variable to the process stack frame in which the @code{NEW} command occured. When exiting the stack frame (i.e. with the @code{QUIT} command), FreeM will restore the variable to its value prior to being @code{NEW}ed.
+ @emph{Example}
+ @example
+ MYRTN ;
+   S J=1 ; set local variable J to 1
+   W J,! ; this will output "1"
+   D X   ; execute subroutine X
+   W J,! ; this will output "1", as the value of J was restored
+   Q
+   ;;
+ X ;
+   N J   ; stack J
+   S J=6 ; set its value to 6
+   W J,! ; this will output "6"
+   Q     ; quit from the subroutine, destroying its stack frame
+   ;;
+ @end example
+ @section Scoping Considerations for $TEST
+ In M, the truth value of comparisons, logic operations, and certain forms of @code{LOCK} is stored in the @code{$TEST} intrinsic special variable, which follows the same rules as any M local variable.
+ This is probably the most significant design flaw of the language, as the side effects of logic on @code{$TEST} lead to incredibly difficult bugs. However, M allows @code{$TEST} to be @code{NEW}ed, and FreeM provides the @code{THEN} command@footnote{From MDC Type A extension X11/1998-31} to help in the case of conditionals. @code{THEN} stacks @code{$TEST} to the end of the line.
+ When writing new M code in FreeM, we strongly suggest using @code{THEN} as follows:
+ @example
+ MYRTN ;
+   IF MYVAR=1 THEN DO SUBRT
+ @end example
+ This is instead of the traditional form:
+ @example
+ MYRTN ;
+   IF MYVAR=1 DO SUBR
+ @end example
+ @cartouche
+ @quotation
+ @emph{Style Recommendation}
+ Note that @code{THEN} is not in any currently published version of the @emph{Standard}, but is part of MDC Type A extension X11/1998-31. However, we recommend using @code{THEN} instead of favoring portability, as there is no defensible reason for this incredibly simple feature @emph{not} to be ubiquitous.
+ If you use other M implementations, you should bug the implementers to implement @code{THEN}, as it at least partially mitigates an inexcusable flaw in the design of M.
+ @end quotation
+ @end cartouche
  @node Decision Constructs
  @chapter Decision Constructs
  @cindex decision constructs
- Line 4386  See @ref{Classes}.
+ Line 4988  See @ref{Classes}.
  @cindex programming, object-oriented
  @menu
- * Classes::             The basis of object-oriented programming.
+ * Classes::                             The organizing concept of object-oriented programming.
+ * Inheritance::                         Making one class derive from another.
+ * Methods::                             Attach code to classes.
+ * Public and Private Variables::        Determining accessibility.
+ * Instantiating Objects::               Creating instances of classes.
  @end menu
  @node Classes
  @section Classes
+ @subsection Class Overview
- @menu
+ A @emph{class} is the primary organizing concept of FreeM support for object-oriented programming, and in FreeM, is simply an M routine with a few special properties:
- * Inheritance::         Basing one class upon another.
- * Methods::             Attaching code to a class.
+ @example
- * Public Variables::    Variables visible outside of a class.
+ MYCLASS(THIS,INIT):OBJECT ; Constructor for MYCLASS, inherits OBJECT
- * Private Variables::   Variables only visible within a class.
+   ; two private variables
- @end menu
+   S THIS("NUMERATOR"):PRIVATE=$P(INIT,"/",1)
+   S THIS("DENOMINATOR"):PRIVATE=$P(INIT,"/",2)
+   Q
+   ;
+ DESTROY(THIS) ; This is the destructor
+   Q
+ @end example
+ The above example demonstrates general class syntax.
+ @subsection Constructors
+ A @emph{constructor} is an M entry point that is called when a new instance of a class is created.
+ A constructor must be the first entry point in a class routine, its tag must match the class/routine name, and it must take two arguments, @code{THIS} and @code{INIT}.
+ @code{THIS} represents the instance of the object being accessed, and @code{INIT} represents an initializer that can be used to assign an initial value to the object when instantiating the class.
+ A constructor looks like this:
+ @example
+ %FRACTION(THIS,INIT):OBJECT ;
+    S THIS("NUMERATOR"):PRIVATE=$P(INIT,"/",1)
+    S THIS("DENOMINATOR"):PRIVATE=$P(INIT,"/",2)
+    Q
+ @end example
+ @emph{Syntax}
+ @example
+ @emph{<class-name>}(THIS,INIT)[:@emph{<superclass>}]
+ @end example
+ In the above example, @emph{<superclass>} represents the name of a class from which this class should inherit. In this case, the @code{FRACTION} class inherits from the @code{OBJECT} class. Note that this is not strictly necessary in this case, as all classes in FreeM automatically inherit from @code{OBJECT}.
+ @subsection Destructors
+ A @code{destructor} is called when you @code{KILL} an instance variable. Its tag must be @code{DESTROY}, and it must take one argument (@code{THIS}).
+ The destructor should be used to clean up any resources used by class methods.
+ A destructor looks like this:
+ @example
+ DESTROY(THIS) ;
+   ; free any resources that should be freed at the end of the object's lifetime
+   Q
+ @end example
  @node Inheritance
- @subsection Inheritance
+ @section Inheritance
+ Every class you create will automatically inherit the methods and functionality of the @code{OBJECT} class, supplied with FreeM.
+ When attempting to call a method, FreeM will first search the class routine for a matching entry point, and then follow the inheritance chain upwards until a matching entry point is found. If the final class in the chain does not have a matching entry point, FreeM will try to find a matching entry point in the @code{OBJECT} class.
+ Inheritance is achieved by specifying the name of the superclass in the constructor:
+ @example
+ CLASS(THIS,INIT):SUPERCLASS
+ @end example
+ @subsection Runtime Polymorphism
+ You can achieve runtime polymorphism by subclassing, and defining methods in the subclass that match the names of existing methods in the superclass. Following FreeM inheritance rules, the overridden method in the subclass will be called, and the method in the superclass will not.
+ Note that the overridden method in the subclass can take a different set or number of arguments than the @emph{formallist} of the superclass method would specify.
  @node Methods
- @subsection Methods
+ @section Methods
+ Class methods are defined as tags with @emph{formallist}s in a class routine, and per the typical FreeM object pattern, must take at least one argument, being @code{THIS} (representing a reference to the object instance being accessed).
+ The following class (@code{MYCLASS}) has a constructor, a destructor, and a method called @code{MYMETHOD}:
+ @example
+ %MYCLASS(THIS,INIT) ;
+   Q THIS
+ DESTROY(THIS) ;
+   Q
+ MYMETHOD(THIS) ;
+   Q "VALUE"
+ @end example
+ The dot operator is used to invoke class methods:
+ @example
+ DEFAULT.USER> N MYOBJ=$#^%MYCLASS("")
+ DEFAULT.USER> W MYOBJ.MYMETHOD()
+ VALUE
+ @end example
+ @node Public and Private Variables
+ @section Public and Private Variables
+ FreeM supports private fields with the @code{:PRIVATE} specifier in the @code{SET} command, enforcing classical object-oriented data encapsulation. The @code{:PUBLIC} specifier is provided for completeness, and is the default.
+ The below constructor for a @code{FRACTION} class defines two private fields:
+ @example
+ %FRACTION(THIS,INIT):OBJECT ;
+    S THIS("NUMERATOR"):PRIVATE=$P(INIT,"/",1)
+    S THIS("DENOMINATOR"):PRIVATE=$P(INIT,"/",2)
+    Q
+ @end example
+ Either of the following commands will create a public field:
+ @example
+   S THIS("VARNAM")="Initial Value"
+   S THIS("VARNAM"):PUBLIC="Initial Value"
+ @end example
+ Attempting to access private fields from outside of the class will raise error condition @code{ZOBJFLDACCV}.
+ @node Instantiating Objects
+ @section Instantiating Objects
- @node Public Variables
+ To instantiate an object (i.e., create an object from a certain class), you will use the @code{NEW} command as follows:
- @subsection Public Variables
+ @example
+ NEW MYSTR=$#^%STRING("myString")
+ @end example
+ This will create a local variable called MYSTR of type STRING, and initialize it with the value myString.
+ @subsection Determining Object Class
+ To determine the class of any FreeM local variable, you will use the @code{$$TYPE()} method:
+ @example
+ USER> W MYSTR.$$TYPE()
+ ^%STRING
+ @end example
- @node Private Variables
+ The @code{$$TYPE()} method is a member of the @code{OBJECT} class.
- @subsection Private Variables
  @node Libraries
  @chapter Libraries
- Line 4477  You may also use an expression that reso
+ Line 5204  You may also use an expression that reso
    WRITE ^|NS|VA(200,0),!
  @end example
- @section File Path Extended Global References
- @cindex extended global references, file path
- If a namespace is configured to use the @code{BUILTIN} global handler, FreeM supports accessing a global data file by way of its filesystem path.
- The following file path extended global reference will write the value of @code{^VA(200,0)}, assuming the @code{^VA} data file exists at path @code{/home/jpw/^VA}:
- @example
-   WRITE ^/home/jpw/VA(200,0),!
- @end example
  @node Global Aliasing
  @chapter Global Aliasing
  @cindex aliasing, global
- Line 4529  To remove the above mapping, any of the
+ Line 5244  To remove the above mapping, any of the
    KILL ^$SYSTEM("MAPPINGS","GLOBAL","^FOO")
  @end example
- @node Transaction Processing
- @chapter Transaction Processing
- @cindex transaction processing
- FreeM implements a significant subset of the transaction processing features from @emph{ANSI X11.1-1995}. This allows a series of global operations to be conducted all at once, either in batch mode (where concurrency is not disturbed), or in serial mode (where writes are guaranteed to be atomic, consistent, isolated, and durable).
- @section Theory of Operation
- FreeM uses a pessimistic concurrency control mechanism for @code{SERIAL} transactions, meaning that any @code{TSTART} command that includes the @code{SERIAL} transaction parameter will cause the process to acquire the transaction processing mutex, which prevents any process but the one holding the mutex from performing any data access (read or write) until either @code{TCOMMIT} or @code{TROLLBACK} is called, either committing or rolling back the transaction, respectively.
- Any transaction in between its @code{TSTART} and @code{TCOMMIT}/@code{TROLLBACK} is said to be @emph{in-flight}. During the in-flight stage, pending global operations are held only in memory and after-image journals.
- FreeM maintains a list of all globals affected during a transaction in-flight. When a @code{TCOMMIT} is reached, FreeM will generate a @emph{checkpoint} of each global data file to be changed by the transaction. These checkpoints allow all FreeM globals to be restored to their pre-transaction state if a @code{TCOMMIT} should fail part of the way through its operation.
- Checkpoints can have one of two modes:
- @table @asis
- @item @code{CP_REMOVE}
- Used for globals that did not exist prior to the beginning of this transaction. Simply marks the entire global data file for deletion in case of @code{TCOMMIT} failure.
- @item @code{CP_RESTORE}
- Used for globals that @emph{did} exist prior to the beginning of this transaction. In this case, the entire global data file is copied to a new file with a @code{.chk} extension. In cases of @code{TCOMMIT} failure, @code{CP_RESTORE} checkpoint files will be restored over the partially-modified live data file.
- @end table
- The below example shows a few global operations and checkpoints for a transaction in-flight using the @code{trantab} direct-mode command:
- @verbatim
- TL1:USER> trantab
-  $TLEVEL 1*
-   Operations for Transaction ID: 6ea14aad-b8f1-47f9-9f52-4f513f892bc0 [RESTARTABLE SERIAL]
-    OP. NO.   ACTION         KEY/DATA
-    -------   ------         --------
-        SET            ^FOO=3
-        KILL           ^FOO
-        SET            ^jpw=10
-        SET            ^BRANDNEW=6
-   Global checkpoints:
-    GLOBAL                        MODE                FILES
-    ------                        ----                -----
-    ^BRANDNEW                     CP_REMOVE           IN:   /usr/local/var/freem/USER/globals/^BRANDNEW
-    ^jpw                          CP_RESTORE          IN:   /usr/local/var/freem/USER/globals/^jpw
-                                                      OUT:  /usr/local/var/freem/USER/globals/^jpw.23390.1.chk
-    ^FOO                          CP_RESTORE          IN:   /usr/local/var/freem/USER/globals/^FOO
-                                                      OUT:  /usr/local/var/freem/USER/globals/^FOO.23390.1.chk
- @end verbatim
- In the above example, @code{IN} files are the live data file that will be overwritten or removed, and @code{OUT} files are the checkpoints themselves. Note that @code{OUT} files are only used for @code{CP_RESTORE} checkpoints.
  @node Asynchronous Event Handling
- Line 4794  You can also set up a trigger that appli
+ Line 5457  You can also set up a trigger that appli
  This routine is the implementation of the @code{$ZCOLUMNS} intrinsic special variable.
- @section ^%SYSINIT
+ @section %SYSINIT
- @cindex ^%SYSINIT
+ @cindex %SYSINIT
- @cindex system library routines, ^%SYSINIT
+ @cindex system library routines, %SYSINIT
  This routine is the default startup routine for FreeM running in direct mode.
- Line 4818  This routine is the implementation of th
+ Line 5481  This routine is the implementation of th
  @chapter Interrupt Handling
  @cindex interrupt handling
- When FreeM receives the @code{SIGINT} signal, either by pressing @code{Ctrl-C} during program execution, or by external signal from the operating system, the FreeM daemon, or another external process, one of two things can happen, depending on the state of the @code{$ZI} special variable:
+ When FreeM receives the @code{SIGINT} signal, either by pressing @code{Ctrl-C} during program execution, or by external signal from the operating system, the FreeM environment daemon, or another external process, one of two things can happen, depending on the state of the @code{$ZI} special variable:
  @table @asis
  @item @code{$ZI} evaluates @emph{true}
- Line 5061  Raised when you attempt to use multiple
+ Line 5724  Raised when you attempt to use multiple
  Raised when attempts are made to set @code{$ECODE} to an invalid error code value. Obsolete and replaced by standard error code @code{M101}.
  @item @code{ZASSERT} - @emph{programmer assertion failed}
- Raised when an @code{ASSERT} expression's result is not true.
+ Raised when an @code{ZASSERT} expression's result is not true.
  @item @code{ZUSERERR} - @emph{user-defined error}
  Raised when program code calls @code{THROW} with an error code argument for which the first character is @code{U}, or when @code{$ECODE} is set to an error code for which the first character is @code{U}.
- Line 5071  Custom error messages for @code{ZUSERERR
+ Line 5734  Custom error messages for @code{ZUSERERR
  For example:
  @example
- USER> S ^$JOB($JOB,"USER_ERRORS","UBLACKHOLE")="black hole encountered"
+ DEFAULT.USER> S ^$JOB($JOB,"USER_ERRORS","UBLACKHOLE")="black hole encountered"
- USER> THROW UBLACKHOLE
+ DEFAULT.USER> THROW UBLACKHOLE
  >> Error UBLACKHOLE:  black hole encountered in SYSTEM::^%SYSINIT  [$STACK = 0]
- Line 5246  Raised when an attempt is made to use a
+ Line 5909  Raised when an attempt is made to use a
  @end table
- @node Debugging
- @chapter Debugging
- @cindex debugging
  @node System Configuration
  @chapter System Configuration
- Line 5257  Raised when an attempt is made to use a
+ Line 5917  Raised when an attempt is made to use a
  @section Installing FreeM
  @cindex installation
- @section Build Configuration
+ @subsection Installation Methods
- @cindex build configuration
- When configuring FreeM with the supplied @code{configure} script, there are some FreeM-specific options that may be used to compile in optional features, or exclude default ones:
+ FreeM allows the following installation methods:
  @table @asis
+ @item Binary Repository
+ On recent versions the Ubuntu and Debian distributions of GNU/Linux, we provide package repositories from which FreeM may easily be installed. See the @emph{FreeM Wiki} for more information, and @emph{https://packages.coherent-logic.com} for instructions.
- @item @code{--enable-mwapigtk} (EXPERIMENTAL)
+ If available, this is the simplest method of installing FreeM.
- Enables experimental support for the M Windowing API using the GTK3 libraries. Requires that you have GTK 3 libraries, their headers, and their dependencies installed on your system.
+ @item Binary Packages
+ We provide binary packages of FreeM for @emph{dpkg} and @emph{rpm}-based distributions of GNU/Linux, and @emph{pkgadd} packages for Solaris 8-10. If you cannot use repositories, this is the easiest option.
+ See @emph{https://freem.coherent-logic.com/binaries.cfm} for downloads and instructions.
+ @item Source Archive
+ If you prefer installing from source, we recommend that you download the latest @emph{.tar.gz} file from @emph{https://freem.coherent-logic.com/downloads.cfm}, and follow these steps:
+ @example
+ $ gunzip freem-@emph{<version>}.tar.gz
+ $ tar xf freem-@emph{<version>}.tar
+ $ cd freem
+ $ ./configure # see the Build Configuration section for optional flags
+ $ make
+ $ sudo make install
+ @end example
- Please consult your operating system's documentation for the correct commands to install the required libraries.
+ Once this process has been completed, you may proceed to @emph{Initial Configuration}.
- @emph{Example}
+ Installation from source archive is the most challenging but flexible supported option for advanced users.
+ @item CVS Repository
+ If you wish to try the bleeding-edge development version of FreeM, you may do so by following these steps:
- @example
+ @verbatim
- $ ./configure --enable-mwapigtk
+ $ cvs -d :pserver:anonymous@cvs.coherent-logic.com:/home/cvsroot co freem
+ $ cd freem
+ $ ./autogen.sh
+ $ ./configure # see the Build Configuration section for optional flags
  $ make
  $ sudo make install
- @end example
+ @end verbatim
- @item @code{--enable-berkeleydb} (EXPERIMENTAL)
+ Once this process has been completed, you may proceed to @emph{Initial Configuration}.
- Enables experimental support for using the BerkeleyDB database as a global handler for FreeM global namespaces. Requires that you have the @code{libdb} library, headers, and dependencies installed on your system.
- Please consult your operating system's documentation for the correct commands to install the required libraries.
+ This installation method is by far the most complicated, and is intended only for those who wish to contribute to FreeM development. It is not intended for end users, and no technical support will be provided.
- @emph{Example}
+ See the @emph{Contributor Guide} on the @emph{FreeM Wiki} for more information.
+ @end table
+ @subsection Build Configuration
+ @cindex build configuration
- @example
+ When configuring FreeM with the supplied @code{configure} script, there are some FreeM-specific options that may be used to compile in optional features, or exclude default ones:
- $ ./configure --enable-berkeleydb
- $ make
- $ sudo make install
- @end example
+ @table @asis
- @item @code{--without-readline}
+ @item @code{--enable-mwapi} (EXPERIMENTAL)
- Builds FreeM without GNU @code{readline} support, even if @code{readline} is installed on your system.
+ Enables experimental support for the M Windowing API (ANSI @emph{X11.6-1995}) using the OSF/Motif widget toolkit. Requires that you have the @code{X11}, @code{Xt}, @code{ICE}, and @code{Xm} libraries, as well as all of their C header files.
- Please note that building FreeM without GNU @code{readline} will also exclude REPL functionality and all direct-mode utility commands, i.e. @code{events}, @code{tdump}, @code{shmstat}, and @code{shmpages}.
+ Please consult your operating system's documentation for the correct commands to install the required libraries.
  @emph{Example}
  @example
- $ ./configure --without-readline
+ $ ./configure --enable-mwapi
  $ make
  $ sudo make install
  @end example
  @end table
+ @subsection Initial Configuration
+ Once FreeM is installed, you will need to configure it:
+ @enumerate
+ @item Create a user and group, each named @emph{freem}, under which FreeM will run
+ @item Add any user accounts that will need to run FreeM to the @emph{freem} group
+ @item Have all users added in step 2 sign out and sign in for the new group membership to take effect
+ @item Run @code{fmadm configure} with superuser privileges to create the @code{DEFAULT} environment with @code{SYSTEM} and @code{USER} namespaces and default after-image journal settings, and populate the bundled vendor routines
+ @item Run @code{fmadm start environment} with superuser privileges to start the @code{DEFAULT} environment
+ @item Make sure the environment is ready by running @code{fmadm status environment} with superuser privileges
+ @end enumerate
+ @subsubsection Creating Additional Environments
+ To create additional environments, do the following steps:
+ @enumerate
+ @item Create a new user and group for the environment @emph{(optional)}
+ @item Run @code{fmadm configure -e=@emph{<environment>} -u=@emph{<username>} -g=@emph{<groupname>} [-E=@emph{true|false}]} @emph{(the @code{-E} flag enables or disables the environment)}
+ @item Run @code{fmadm start environment -e=@emph{<environment>}} to start the environment
+ @item Run @code{fmadm status environment} to make sure the environment is healthy
+ @end enumerate
+ @subsubsection Additional Customization
+ See the FreeM @emph{environment catalog} at @code{@emph{$PREFIX}/etc/freem/env.conf}, and the @emph{fmadm}(1) @code{man} page for more information.
+ @emph{$PREFIX} represents the root location of your FreeM installation. This can be @code{/usr/local}, @code{/}, or others, depending on how FreeM was built and installed.
  @node Accessing FreeM from C Programs
  @chapter Accessing FreeM from C Programs
- Line 5798  The FreeM @code{LOCK} table.
+ Line 6503  The FreeM @code{LOCK} table.
  Supported actions are @code{list} and @code{remove}.
- @item zallocate
- The FreeM @code{ZALLOCATE} table.
- No actions yet implemented.
  @item journal
  FreeM after-image journaling.
- Line 6024  Module headers should adhere to the foll
+ Line 6724  Module headers should adhere to the foll
   *    binding library
   *
   *
-  *   Author: Serena Willis <jpw@coherent-logic.com>
+  *   Author: Serena Willis <snw@coherent-logic.com>
   *    Copyright (C) 1998 MUG Deutschland
   *    Copyright (C) <Year> Coherent Logic Development LLC
   *

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>