[BACK]Return to freem.texi CVS log [TXT] [DIR] Up to [Coherent Logic Development] / freem / doc

Diff for /freem/doc/freem.texi between versions 1.29 and 1.38

version 1.29, 2025/04/18 22:02:33 version 1.38, 2025/05/02 20:01:12
Line 4 Line 4
 @settitle The FreeM Manual  @settitle The FreeM Manual
   
 @copying  @copying
 This manual is for FreeM, (version 0.64.0-rc0), 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@footnote{FreeM subscribes to the software licensing philosophy described in @emph{Free Software, Free Society:
   Selected Essays of Richard M. Stallman}.} implementation of the M programming language.
   
   
 Copyright @copyright{} 2014-2025 Coherent Logic Development LLC  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  @title The FreeM Manual
 @subtitle @sc{The Official Manual of FreeM}  @subtitle @sc{The Official Manual of FreeM}
 @subtitle Version 0.64.0-rc0  @subtitle Version 0.64.0-rc1
 @c@vskip 10pt  @c@vskip 10pt
 @c@center @image{freem-logo-sm,,,,.png}  @c@center @image{freem-logo-sm,,,,.png}
 @author Serena Willis  @author Serena Willis
Line 42  This is the official manual for the Free Line 43  This is the official manual for the Free
   
 @menu  @menu
 * Introduction::                        About the FreeM Project, its history, and its goals.  * Introduction::                        About the FreeM Project, its history, and its goals.
   * Document Conventions::                Conventions used in this manual.
 * FreeM Invocation::                    How to invoke FreeM from the command line.  * FreeM Invocation::                    How to invoke FreeM from the command line.
 * The FreeM Environment 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.  * The FreeM Direct-Mode Environment::   Executing M programs interactively.
   * Debugging::                           The program development cycle of FreeM.
   
 * Directives::                          Per-Routine Language Directives.  * Directives::                          Per-Routine Language Directives.
 * Intrinsic Special Variables::         Intrinsic Special Variables.  * Intrinsic Special Variables::         Intrinsic Special Variables.
Line 73  This is the official manual for the Free Line 76  This is the official manual for the Free
 * Global Aliasing::                     Defining alternate names for globals.  * Global Aliasing::                     Defining alternate names for globals.
 * Global Mappings::                     Mapping global names to non-default namespaces.  * Global Mappings::                     Mapping global names to non-default namespaces.
   
 * Transaction Processing::              Transactions in FreeM.  
 * Asynchronous Event Handling::         Handling asynchronous events in FreeM.  * Asynchronous Event Handling::         Handling asynchronous events in FreeM.
 * Global Triggers::                     Responding to global accesses in M code.  * Global Triggers::                     Responding to global accesses in M code.
 * Synchronous Event Handling::          Synchronous events in FreeM.  * Synchronous Event Handling::          Synchronous events in FreeM.
Line 92  This is the official manual for the Free Line 94  This is the official manual for the Free
 * Interrupt Handling::                  How FreeM handles interrupts.  * Interrupt Handling::                  How FreeM handles interrupts.
 * Error Processing::                    How to handle errors in M program code.  * Error Processing::                    How to handle errors in M program code.
 * FreeM Error Codes::                   Explanations of each FreeM error code.  * FreeM Error Codes::                   Explanations of each FreeM error code.
 * Debugging::                           The program development cycle of FreeM.  
   
 * System Configuration::                Configuring your FreeM installation.  * System Configuration::                Configuring your FreeM installation.
 * Accessing FreeM from C Programs::     How to use the mlib interface.  * Accessing FreeM from C Programs::     How to use the mlib interface.
Line 110  This is the official manual for the Free Line 111  This is the official manual for the Free
 @node Introduction  @node Introduction
 @unnumbered 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 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 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.
   
 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.  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.
   
 @section Production Readiness  @section Production Readiness
   
Line 225  Serena Willis (Current Maintainer and Pr Line 226  Serena Willis (Current Maintainer and Pr
 Steve Zeck (Code)  Steve Zeck (Code)
   
 @end itemize  @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{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.
   @end table
   
 @node FreeM Invocation  @node FreeM Invocation
 @chapter FreeM Invocation  @chapter FreeM Invocation
 @cindex invocation, command-line  @cindex invocation, command-line
Line 241  When @code{-r} or @code{--routine} are p Line 292  When @code{-r} or @code{--routine} are p
   
 @section %SYSINIT Routine  @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}.  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}.
   
 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.  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.
   
Line 371  Attempting to start a FreeM interpreter Line 422  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>}}:  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  @example
 Coherent Logic Development FreeM version 0.64.0-rc0 (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  Copyright (C) 2014, 2020, 2021 Coherent Logic Development LLC
   
   
Line 523  DEFAULT.USER> Line 574  DEFAULT.USER>
   
 Such expressions will be immediately evaluated, and the result printed on @code{@ref{$IO}}.  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  @node Directives
 @chapter Directives  @chapter Directives
 @cindex directives  @cindex directives
Line 2216  In its argumentless form, @code{BREAK} s Line 2304  In its argumentless form, @code{BREAK} s
   
 @emph{FreeM Extension}  @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}  The following table enumerates the possible values of @emph{breakflag}
   
 @table @code  @table @code
   @item "DEBUG"
   Enters the interactive debugger
 @item 0  @item 0
 Disables @emph{Ctrl-C} handling  Disables @emph{Ctrl-C} handling
 @item -2  @item -2
Line 2281  In its inclusive form, transfers program Line 2371  In its inclusive form, transfers program
 DO[@emph{:postcondition}] @emph{entryref}[@emph{:postcondition}[,...]]  DO[@emph{:postcondition}] @emph{entryref}[@emph{:postcondition}[,...]]
 @end example  @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.  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}  @emph{Syntax}
Line 2308  ELSE[@emph{:postcondition}] Line 2406  ELSE[@emph{:postcondition}]
   
 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}--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.
   
 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 quotation
 @end cartouche  @end cartouche
   
Line 2404  Transfers program execution to another l Line 2502  Transfers program execution to another l
 GOTO[@emph{:postcondition}] @emph{entryref}  GOTO[@emph{:postcondition}] @emph{entryref}
 @end example  @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  @node HALT
 @section HALT  @section HALT
 @cindex HALT  @cindex HALT
Line 2515  In the above @emph{inclusive} form, @cod Line 2622  In the above @emph{inclusive} form, @cod
 @cartouche  @cartouche
 @quotation  @quotation
 @emph{Note}  @emph{Note}
 The below @emph{argumentless} and @emph{exclusive} forms of @code{KSUBSCRIPTS} are not implemented in FreeM, as of version 0.64.0-rc0, 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 quotation
 @end cartouche  @end cartouche
   
Line 2550  In the above @emph{inclusive} form, @cod Line 2657  In the above @emph{inclusive} form, @cod
 @cartouche  @cartouche
 @quotation  @quotation
 @emph{Note}  @emph{Note}
 The below @emph{argumentless} and @emph{exclusive} forms of @code{KVALUE} are not implemented in FreeM, as of version 0.64.0-rc0, 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 quotation
 @end cartouche  @end cartouche
   
Line 4412  A @code{REAL} is a numeric interpretatio Line 4519  A @code{REAL} is a numeric interpretatio
 @cindex data types, STRING  @cindex data types, STRING
 @cindex types, STRING  @cindex types, STRING
   
 A @code{STRING} is any data in FreeM.  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)  @node Custom Types (Classes)
 @section Custom Types (Classes)  @section Custom Types (Classes)
Line 4428  See @ref{Classes}. Line 4558  See @ref{Classes}.
 @cindex variables, global  @cindex variables, global
 @cindex data  @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  @node Concurrency Control
 @chapter Concurrency Control  @chapter Concurrency Control
 @cindex concurrency control  @cindex concurrency control
 @cindex locking  @cindex locking
 @cindex transaction processing  @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 concurrency is not disturbed), 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
      -------   ------         --------
      1         SET            ^FOO=3
      2         KILL           ^FOO
      3         SET            ^snw=10
      4         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  @node Local Variables
 @chapter Local Variables  @chapter Local Variables
 @cindex variables, local  @cindex variables, local
 @cindex local variables  @cindex local variables
   
   @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  @node Scoping
 @chapter Scoping  @chapter Scoping
 @cindex 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.
   
 @node Decision Constructs  @node Decision Constructs
 @chapter Decision Constructs  @chapter Decision Constructs
 @cindex decision constructs  @cindex decision constructs
Line 4490  See @ref{Classes}. Line 4855  See @ref{Classes}.
 * Inheritance::                     Basing one class upon another.  * Inheritance::                     Basing one class upon another.
 * Methods::                         Attaching code to a class.  * Methods::                         Attaching code to a class.
 * Public and Private Variables::    Managing class member access.  * Public and Private Variables::    Managing class member access.
   * Instantiating Objects::           Creating instances of classes.
   * Determining Object Class::        Getting object information at runtime.
 @end menu  @end menu
   
 @node Classes  @node Classes
 @section Classes  @section Classes
   
   @menu
   * Class Overview::                  Class basics.
   * Constructors::                    Managing object creation.
   * Destructors::                     Cleaning up.
   * Runtime Polymorphism::            Selecting methods at runtime.
   @end menu
   
   @node Class Overview
   @subsection Class Overview
   
 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:  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:
   
 @example  @example
Line 4584  MYMETHOD(THIS) ; Line 4961  MYMETHOD(THIS) ;
   Q "VALUE"    Q "VALUE"
 @end example  @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   @node Public and Private Variables 
 @section 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.  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:  The below constructor for a @code{FRACTION} class defines two private fields:
   
Line 4607  Either of the following commands will cr Line 4992  Either of the following commands will cr
   
 Attempting to access private fields from outside of the class will raise error condition @code{ZOBJFLDACCV}.   Attempting to access private fields from outside of the class will raise error condition @code{ZOBJFLDACCV}. 
   
   @node Instantiating Objects
   @section Instantiating Objects
   
   To instantiate an object (i.e., create an object from a certain class), you will use the @code{NEW} command as follows:
   
   @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. 
   
   @node Determining Object Class
   @section 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
   
   The @code{$$TYPE()} method is a member of the @code{OBJECT} class. 
   
 @node Libraries  @node Libraries
 @chapter Libraries  @chapter Libraries
 @cindex libraries  @cindex libraries
Line 4713  To remove the above mapping, any of the Line 5121  To remove the above mapping, any of the
   KILL ^$SYSTEM("MAPPINGS","GLOBAL","^FOO")    KILL ^$SYSTEM("MAPPINGS","GLOBAL","^FOO")
 @end example  @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:DEFAULT.USER> trantab  
  $TLEVEL 1*  
   Operations for Transaction ID: 6ea14aad-b8f1-47f9-9f52-4f513f892bc0 [RESTARTABLE SERIAL]  
   
    OP. NO.   ACTION         KEY/DATA  
    -------   ------         --------  
    1         SET            ^FOO=3  
    2         KILL           ^FOO  
    3         SET            ^snw=10  
    4         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.  
   
   
 @node Asynchronous Event Handling  @node Asynchronous Event Handling
Line 5430  Raised when an attempt is made to use a Line 5786  Raised when an attempt is made to use a
   
 @end table  @end table
   
 @node Debugging  
 @chapter Debugging  
 @cindex debugging  
   
 @node System Configuration  @node System Configuration
 @chapter System Configuration  @chapter System Configuration
Line 5441  Raised when an attempt is made to use a Line 5794  Raised when an attempt is made to use a
 @section Installing FreeM  @section Installing FreeM
 @cindex installation  @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  @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  $ make
 $ sudo make install  $ 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}  @emph{Example}
   
 @example  @example
 $ ./configure --without-readline  $ ./configure --enable-mwapi
 $ make  $ make
 $ sudo make install  $ sudo make install
 @end example  @end example
   
   
 @end table  @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  @node Accessing FreeM from C Programs
 @chapter Accessing FreeM from C Programs  @chapter Accessing FreeM from C Programs
   
Removed from v.1.29  
changed lines
  Added in v.1.38

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