For other uses of the word MUMPS, see Mumps (disambiguation).

MUMPS (Massachusetts General Hospital Utility Multi-Programming System), or alternatively M, is a programming language created in the late 1960s, originally for use in the healthcare industry. It was designed to make writing database-driven applications easy while simultaneously making efficient use of computing resources. It was adopted as the language-of-choice for many healthcare and financial information systems/databases (especially ones developed in the 1970s and early 1980s) and continues to be used by many of the same clients today. It is currently used by the world\'s largest electronic health record systems as well as by multiple banking networks and online trading/investment services.

Because it predates C and most other popular languages in current usage, it has very different syntax and terminology. It offers a number of features unavailable in other languages, including some rarely used programming and database concepts.

Major users of MUMPS applications

Health Care Industry

Companies currently using MUMPS include AmeriPath (now part of Quest Diagnostics), Care Centric, Team Health, Epic Systems Corporation, EMIS, Partners HealthCare, Meditech, and GE Healthcare (formerly IDX Systems and Centricity). Many reference laboratories, such as Quest Diagnostics and Dynacare, use MUMPS software either written by Antrim Corporation, or based on Antrim code. Sunquest, and its subsidiary Antrim, were purchased by Misys in 2001.SEC Info: Misys Purchase of Sunquest

Veterans Administration and Department of Defense

The Veterans Administration (now called the United States Department of Veterans Affairs) officially adopted MUMPS as the programming language to be used while implementing an integrated laboratory / pharmacy / patient admission, tracking and discharge system in the early 1980s. The original version, the Decentralized Hospital Computer Program (DHCP) was delivered early and under budget. Before implementing DHCP, the VA also wrote an intermediate layer in MUMPS, FileMan, to function as a database management system. Today, DHCP is known as Veterans Health Information Systems and Technology Architecture (VistA).

The VA hired SAIC to do two pilot projects, converting the MUMPS code into a Java/web based solution, but the project was mismanaged and was cancelled. One of the pilots was completed, converting the MUMPS code to functionally equivalent Java while web-enabling it, including FileMan. This pilot is open source and can be acquired from the VA.

Nearly the entire VA hospital system in the United States and the Indian Health Service, as well as major parts of the Department of Defense CHCS hospital system all run systems using MUMPS databases for clinical data tracking.

They now use the continuously updated Intersystems Cache version of MUMPS.

Other industries

MUMPS gained an early following in the financial sector, and MUMPS applications are in use at many banks and credit unions. It is used by Ameritrade, the largest online trading service in the US with over 12 billion transactions per day, as well as by the Bank of England and Barclays Bank, among others.Welcome to M21 -- the database for the 21st Century.

As of 2005 most use of M is either in the form of GT.M or InterSystems Caché. The latter is being aggressively marketed by InterSystems and has had success in penetrating new markets, such as telecommunications, in addition to existing markets.

History

MUMPS was developed by Neil Pappalardo and colleagues in Dr Octo Barnett\'s animal lab at Massachusetts General Hospital (MGH) in Boston during 1966 and 1967. The original MUMPS system was, like Unix a few years later, built on a spare DEC PDP-7.

Octo Barnett and Neil Pappalardo were also involved with MGH\'s planning for a Hospital Information System, obtained a reverse-compatible PDP-9, and began using MUMPS in the admissions cycle and laboratory test reporting. MUMPS was then an interpreted language and incorporated a hierarchical database file system to standardize interaction with the data. Some aspects of MUMPS can be traced from Rand Corporation\'s JOSS through BBN\'s TELCOMP and STRINGCOMP. The MUMPS team deliberately chose to include portability between machines as a design goal. Another feature, not widely supported for machines of the era, in operating systems or in hardware, was multitasking, which was also built into the language itself.

The portability was soon useful as MUMPS was shortly adapted to a DEC PDP-15 where it lived for some time. MUMPS was developed with the support of a government research grant, and so MUMPS was released to the public domain (no longer a requirement for grants), and was soon ported to a number of other systems including the popular DEC PDP-8, the Data General Nova and the DEC PDP-11. Word about MUMPS spread mostly through the medical community, and by the early 1970s was in widespread use, often being locally modified for their own needs.

By the early 1970s, there were many and varied implementations of MUMPS on a range of hardware platforms. The most widespread was DEC\'s MUMPS-11 on the PDP-11, and Meditech\'s MIIS. In 1972, many MUMPS users attended a conference which standardized the now fractured language, and created the MUMPS Users Group and MUMPS Development Committee (MDC) to do so. These efforts proved successful; a standard was complete by 1974, and was approved, on September 15, 1977, as ANSI standard, X11.1-1977. At about the same time DEC launched DSM-11 (Digital Standard MUMPS) for the PDP-11. This quickly dominated the market, and became the reference implementation of the time.

During the early 1980s several vendors brought MUMPS-based platforms that met the ANSI standard to market. The most significant were Digital Equipment Corporation with DSM (Digital Standard MUMPS), and InterSystems with their ISM (InterSystems M) on VMS and UNIX, and M/11+ on the PDP-11 platform. Other companies who developed important MUMPS implementations were:

Greystone Technology Corporation with a compiled version called GT.M,

DataTree Inc. with an Intel PC based product called DTM,

Micronetics Design Corporation with a product line called MSM for UNIX and Intel PC platforms (later ported to IBM\'s VM operating system), and

M-Global with MGM, a Mac OS based product.

M-Global MUMPS was the first commercial MUMPS for the PC and the only Mac implementation. DSM-11 was superseded by VAX/DSM for the VAX/VMS platform, and that was ported to the Alpha in two variants: DSM for OpenVMS, and as DSM for Ultrix.

This period also saw considerable MDC activity. The second revision of the ANSI standard for MUMPS (X11.1-1984) was approved on November 15, 1984. On November 11, 1990 the third revision of the ANSI standard (X11.1-1990) was approved. In 1992 the same standard was also adopted as ISO standard 11756-1992. Use of M as an alternative name for the language was approved around the same time. On December 8, 1995 the fourth revision of the standard (X11.1-1995) was approved by ANSI, and by ISO in 1999 as ISO 11756-1999. The MDC finalized a further revision to the standard in 1998 but this has not been presented to ANSI for approval. On 6 January 2005, ISO re-affirmed its MUMPS-related standards: ISO/IEC 11756:1999, language standard, ISO/IEC 15851:1999, Open MUMPS Interconnect and ISO/IEC 15852:1999, MUMPS Windowing Application Programmers Interface.

By 2000, the middleware vendor InterSystems had become the dominant player in the MUMPS market with the purchase of several other vendors. Initially they acquired DataTree Inc. in the early 1990s. And, on December 30, 1995, Intersystems acquired the DSM product line from DEC [1]. InterSystems consolidated these products into a single product line, branding them, on several hardware platforms, as OpenM. In 1997, InterSystems essentially completed this consolidation by launching a unified successor named Caché. This was based on their ISM product, but with influences from the other implementations. Micronetics Design Corporation assets were also acquired by InterSystems on June 21, 1998. Intersystems remains today (2007) the dominant MUMPS vendor, selling Caché to MUMPS developers who write applications for a variety of operating systems.

Greystone Technology Corporation\'s GT.M implementation was sold to Sanchez Computer Associates Inc. (now part of Fidelity National Financial Inc.) in the mid 1990s. On November 7, 2000 Sanchez made GT.M for Linux available under the GPL license and on October 28, 2005 GT.M for OpenVMS and Tru64 UNIX were also made available under the GPL license. GT.M continues to be available on other UNIX platforms under a traditional license.

The newest implementation of MUMPS, released in April 2002, is an MSM derivative called M21 from the Real Software Company of Rugby, UK.

There are also several open source implementations of MUMPS, including some research projects. The most notable of these is Professor Kevin O\'Kane\'s (and students\') project, now at the University of Northern Iowa.

One of the original creators of the MUMPS language, Neil Pappalardo, early founded a company called Meditech. They extended and built on the MUMPS language, naming the new language MIIS (and later, MAGIC). Unlike Intersystems, Meditech no longer sells middleware, so MIIS and MAGIC are only used internally at Meditech.

Overview

MUMPS is a language intended for and designed to build database applications. Secondary language features were included to help programmers make applications using minimal computing resources. The original implementations were interpreted, though modern implementations may be fully or partially compiled.

The most outstanding, and unusual, design feature of MUMPS is that database interaction is transparently built into the language. The MUMPS language assumes the presence of a MUMPS hierarchical database, which is implicitly "opened" for every application. All variable names prefixed with the caret character ("^") use permanent (instead of RAM) storage, will maintain their values after the application ends, and will be visible to (and modifiable by) other running applications. Variables using permanent storage are called Globals in MUMPS, not to be confused with the C term for unscoped variables.

Additionally, all variables (both RAM and disk-based) are hierarchical. They can all have child nodes (called subscripts in MUMPS terminology). Thus, the variable \'Car\' can have subscripts "Door", "Steering Wheel" and "Engine", each of which can contain a value and have subscripts of their own. Thus, you could say

 SET ^Car("Door","Color")="BLUE" 

to modify a nested child node of ^Car. In MUMPS terminology, "Color" is the 2nd subscript of the variable ^Car (both the names of the child-nodes and the child-nodes themselves are called subscripts). Hierarchical variables are similar to objects with properties in Object Oriented languages. Additionally, all subscripts of variables are automatically kept in sorted order. Numeric subscripts (including floating-point numbers) are stored from lowest to highest. All non-numeric subscripts are stored in alphabetical order following the numbers. In MUMPS terminology, this is canonical order. By using only non-negative integer subscripts, the MUMPS programmer can emulate the Arrays data type from other languages. Although MUMPS does not natively offer a full set of DBMS features, several DBMS systems have been built on top of it that provide application developers with flat-file, relational and network database features.

As a secondary language feature, you can abbreviate nearly all commands and native functions to a single character to save space; this was a common feature of languages designed in this period (eg, early BASICs). Additionally, there are built-in operators which treat a delimited string (eg, comma-separated values) as an array. Early MUMPS programmers would often store a structure of related information as a delimited string, parsing it after it was read in; this saved disk access time and offered considerable speed advantages on some hardware.

MUMPS has no data types. Numbers can be treated as strings of digits, or strings can be treated as numbers by numeric operators (coerced, in MUMPS terminology). Coercion can have some odd side effects, however. For example, when a string is coerced, the parser turns as much of the string (starting from the left) into a number as it can, then discards the rest (as in PHP). Thus the statement IF 20<"30 DUCKS" is evaluated as TRUE in MUMPS.

Other features of the language are intended to help MUMPS applications interact with each other in a multi-user environment. Database locks, process identifiers, and atomicity of database update transactions are all required of standard MUMPS implementations.

In contrast to languages in the C or Wirth traditions, some space characters between MUMPS statements are significant. A single space separates a command from its argument, and a space, or newline, separates each argument from the next MUMPS token. Commands which take no arguments (eg, ELSE) require two following spaces. The concept is that one space separates the command from the (nonexistent) argument, the next separates the "argument" from the next command. Newlines are also significant; an IF, ELSE or FOR command processes (or skips) everything else til the end-of-line. To make those statements control multiple lines, you must use the DO command to create a code block.

"Hello, World!" in MUMPS

A simple Hello world program in MUMPS might be:

 hello() 
        write "Hello, World!",!
        quit

and would be run from the MUMPS command line with the command \'do ^hello()\'. Since MUMPS allows commands to be strung together on the same line, and since commands can be abbreviated to a single letter, this routine could be even more compact:

 hello() w "Hello, World!",! q

The \',!\' after the text generates a newline. The \'quit\' is not strictly necessary at the end of a function like this, but is good programming practice in case other functions are added below \'hello()\' later.

MUMPS language syntax

The M syntax allows multiple commands to appear on a line, grouped into procedures (subroutines) in a fashion similar to most structured programming systems.

In MUMPS syntax, some spaces are significant; they are not merely whitespace. There are contexts in which a pair of spaces has a different syntactic significance than a single space. However, extra spaces (in this context not syntactically significant) may always be added between commands for clarity, up to the line length limit in an implementation. Lines are syntactically significant, and carriage returns and linefeeds are not treated as white space; they are statement/function terminators. There is no requirement to put semicolons at the end of commands, and lines may be explicitly continued when needed.

Procedures - MUMPS routines

A typical M procedure (a "routine" in MUMPS terminology) is analogous to a source file in C (with respect to namespace scope and variable lifetime, for instance) and consists of lines of MUMPS code. Line / statement labels can be used to create memory resident subroutines within the routine\'s scope by simply prefixing the line with a label. The same subroutine can be used from outside the parent routine\'s scope by referencing the Label and routine name separated by an \'up-arrow\' character (actually the caret, as in SUBRTN^ABC).

Calling the procedure/routine at the beginning of the line uses the routine name which starts with the caret (e.g. ^ABC as DO ^ABC). Within the routine ^ABC, labels are defined by starting a line with a label instead of a space or tab. One may reference the labeled line within the parent routine as DO SUBX, or outside as DO SUBX^ABC. It may or may not have a variable number of arguments and may return a value as a function.

Variables and datatypes

The chief difference between MUMPS and other programming languages is that MUMPS does not require declaration of variables by datatype (or to declare them at all!). They are all, in effect, strings. Numbers may be represented as strings. Variable use in a numeric context (eg, addition, subtraction) invokes a well-defined conversion in case the string is not a canonical number, such as "123 Main Street".

MUMPS inherently includes a complete and powerful set of string manipulation commands.

MUMPS includes sparse array management rountines for "memory variables". Those arrays are process-connected and disappear with the termination of the process in which they were created. Disk resident (ie, database) sparse variables (called "global variables" in MUMPS terminology) incur very little space penalty when written to disk, and are automatically stored in hierarchical structures on disk. Most implementations are careful to use highly optimized disk routines to reduce the time/space cost of disk references.

In a MUMPS context, \'sparse arrays\' are those with \'missing\' elements; there is no requirement for sequential nodes to exist — A(1), A(99) and A(100) may be used without defining, allocating space for, or using any space for, nodes 2 through 98. Indeed, one can use fractional numbers ( A(1.2), A(3.3), etc) where the numbers have some meaning external to the program. The access function $ORDER ( A(1.2) ) returns the next defined key or subscript value, 3.3 in this example, so the program can readily manage the data. This implements an automatic sort feature, inherent in the standard language, with very little processing cost.

This feature is often used in global index functions where the sort key is used as a global subscript, eg, (^INDEX (lastname, firstname, SSNumber)=... ).

SET A="abc"

creates the variable A and sets its value to the string, abc. An array with the same name is distinct in the namespace --

SET A(1,2)="def"

Subscripts may be string valued as well as integer or numeric-valued (eg, A(1.2)).

SET A("first_name")="Bob"
SET A("last_name")="Dobbs"

which makes the variable names useful data stores independently of the variable contents.

MUMPS\' memory resident (ie, local) variables work in a similar fashion as in other programming languages; when the program (or routine) exits, variable values are discarded.

Global variables - the database

MUMPS\' concept of globals is particularly practical. Globals are variables which are automatically and transparently stored on disk and persist beyond program, routine, or process completion. Globals are used exactly like ordinary variables, but with the caret character prefixed to the variable name. Modifying the earlier example as follows

SET ^A("first_name")="Bob"
SET ^A("last_name")="Dobbs"

results in creation of a new disk record, which is immediately inserted within the file structure of the disk. It is persistent, just as a file persists in most operating systems. Globals are stored in highly structured data files by MUMPS, and accessed only as MUMPS globals. MUMPS has a long history of efficient, stable, theoretically-sound cached, journaled, and balanced B-tree key/value disk storage, including sophisticated transaction control for multiple file transaction \'commit\' and \'roll-back\' at the language/operating system level. Huge databases in the real world commonly grow randomly rather than in a preset sequence, and the MUMPS system handles each with carefully optimized internal algorithms invisible to the MUMPS programmer, thus saving considerable time and coding effort. Missing information, common in real world database situations, does not inherently cause trouble (eg, errors, exceptions, abends, ...).

For all of these reasons, one of the most common MUMPS applications is database management. MUMPS can easily provide the classic ACID properties on top of any standard MUMPS implementation. FileMan is an example. Intersystems\' Caché implementation allows dual views of selected data structures—as MUMPS globals, or as SQL data—and has SQL built in (called M/SQL). The MUMPS view allows programmers rather more control of the data, as there is no requirement to fit the data into the assumed rows and columns of relational SQL.

Multi-user, multi-tasking, multi-processor

MUMPS allowed multi-user operation at a time when memory was measured in kilobytes, and processor time was both scarce and slow, but processors themselves were even more so. MUMPS implementations include full support for multi-tasking, multi-user, multi-machine programming even when the host operating system itself does not.

To demonstrate the ease of network operations, consider:

SET ^|"DENVER"|A("first_name")="Bob"
SET ^|"DENVER"|A("last_name")="Dobbs"

which gives A a value as before, but this time on the remote machine "DENVER". MUMPS programs are accordingly nearly trivial to distribute over multiple machines. This ease of network operation made it easy to expose the same sorts of distributed operation in SQL (and other) layers with ease. It\'s not uncommon for MUMPS systems to have better (faster and more easily used and managed) networked SQL support than dedicated SQL systems.

Another use of MUMPS in more recent times has been to create object databases. Intersystems\' Cache implementation, for instance, includes such features natively.

MUMPS can easily generate HTML or XML pages as well, and can be called via the CGI interface to serve web pages directly from the database. It can also be used as a backend for web applications using Ajax background communication.

MUMPS also reads delimited datasets easily, such as the .csv (comma-separated values) files commonly used as an interchange format (eg, in exports from spreadsheets).

Summary of key language features

The following incomplete and informal sketch seeks to give programmers familiar with other languages a feeling for what MUMPS is like. Neither the language description, nor the descriptions of each feature, are complete and many significant features have been omitted for brevity. These notes reflect the language circa 1994. ANSI X11.1-1995 gives a complete, formal description of the language; an annotated version of this standard is available online.

Data types: There is one universal datatype, automatically interpreted/converted to string, integer, or floating-point number as context requires. It is somewhat like the "variant" type found in Visual BASIC 6.0 and earlier.

Booleans: In IF statements, and other conditional statements, any nonzero value is treated as True. a yields 1 if a is less than b, 0 otherwise.

Declarations: None. All variables are dynamically created on first reference.

Lines: are important syntactic entities, unlike their status in languages patterned on C or Pascal. Multiple statements per line are allowed and are common. The scope of IF and FOR is "the remainder of current line."

Case sensitivity: Commands and intrinsic functions are case-insensitive. In contrast, variable names and labels are case-sensitive. There is no special meaning for upper vs. lower-case and few widely followed conventions. The percent sign (%) is legal as first character of variables and labels.

Postconditionals: SET:N<10 A="FOO" sets A to "FOO" if N is less than 10; DO:N>100 PRINTERR, performs PRINTERR if N is greater than 100. This construct provides a conditional whose scope is less than a full line.

Abbreviation: You can abbreviate nearly all commands and native functions to a single character.

Reserved words: None. Since MUMPS interprets source code by context, there is no need for reserved words. You may use the names of language commands as variables. There has been no obfuscated MUMPS contest as in C, despite the potential of examples such as the following, perfectly legal, MUMPS code:

GREPTHIS()
       NEW SET,NEW,THEN,IF,KILL,QUIT SET IF="KILL",SET="11",KILL="l1",QUIT="RETURN",THEN="KILL"
       IF IF=THEN DO THEN
       QUIT:$QUIT QUIT QUIT ; (quit)
THEN  IF IF,SET&KILL SET SET=SET+KILL QUIT

       for i=10000:1:12345 set sqtable(i)=i*i
       set address("Smith","Daniel")="dpbsmith@world.std.com"

       SET X="dpbsmith@world.std.com" 

       Set stuff(6)="xyz",stuff(10)=26,stuff(15)=""  

       Set i="" For  Set i=$O(stuff(i)) Quit:i=""  Write !,i,?10,stuff(i)

  hellohtml()  
        ; This redirects all output to a file, here an html file.
        SET dev="www/HelloWorld.htm" 
        OPEN dev         
        USE dev 
        DO html 
        CLOSE dev
        QUIT
        ;
  html  W !,""  
        DO head,body 
        W "",! 
        Q
        ;
  head  ; similar javascript and style subroutines could be added.
        W !,""  
        DO javascript,style 
        W "",! 
        Q
        ;      
  body  W !,""  
        DO H1 
        W !,"",! 
        Q
        ;
  H1    W !,"
"
        W "Hello World from MUMPS via HTML !"
        W "
",! 
        QUIT
        ;
  javascript   ...  you get the picture   
        QUIT
        ;
  style    ...   QUIT

%DTC
%DTC ; SF/XAK - DATE/TIME OPERATIONS ;1/16/92  11:36 AM
     ;;19.0;VA FileMan;;Jul 14, 1992
     D    I \'X1!\'X2 S X="" Q
     S X=X1 D H S X1=%H,X=X2,X2=%Y+1 D H S X=X1-%H,%Y=%Y+1&X2
     K %H,X1,X2 Q
     ;
C    S X=X1 Q:\'X  D H S %H=%H+X2 D YMD S:$P(X1,".",2) X=X_"."_$P(X1,".",2) K X1,X2 Q
S    S %=%#60/100+(%#3600\60)/100+(%\3600)/100 Q
     ;
H    I X<1410000 S %H=0,%Y=-1 Q
     S %Y=$E(X,1,3),%M=$E(X,4,5),%D=$E(X,6,7)
     S %T=$E(X_0,9,10)*60+$E(X_"000",11,12)*60+$E(X_"00000",13,14)
TOH  S %H=%M>2&\'(%Y#4)+$P("^31^59^90^120^151^181^212^243^273^304^334","^",%M)+%D
     S %=\'%M!\'%D,%Y=%Y-141,%H=%H+(%Y*365)+(%Y\4)-(%Y>59)+%,%Y=$S(%:-1,1:%H+4#7)
     K %M,%D,% Q
     ;
DOW  D H S Y=%Y K %H,%Y Q
DW   D H S Y=%Y,X=$P("SUN^MON^TUES^WEDNES^THURS^FRI^SATUR","^",Y+1)_"DAY"
     S:Y<0 X="" Q
7    S %=%H>21608+%H-.1,%Y=%\365.25+141,%=%#365.25\1
     S %D=%+306#(%Y#4=0+365)#153#61#31+1,%M=%-%D\29+1
     S X=%Y_"00"+%M_"00"+%D Q
     ;
YX   D YMD S Y=X_% G DD^%DT
YMD  D 7 S %=$P(%H,",",2) D S K %D,%M,%Y Q
T    F %=1:1 S Y=$E(X,%) Q:"+-"[Y  G 1^%DT:$E("TODAY",%)\'=Y
     S X=$E(X,%+1,99) G PM:Y="" I +X\'=X D DMW S X=%
     G:\'X 1^%DT
PM   S @("%H=$H"_Y_X) D TT G 1^%DT:%I(3)\'?3N,D^%DT
N    F %=2:1 S Y=$E(X,%) Q:"+-"[Y  G 1^%DT:$E("NOW",%)\'=Y
     I Y="" S %H=$H G RT
     S X=$E(X,%+1,99)
     I X?1.N1"H" S X=X*3600,%H=$H,@("X=$P(%H,"","",2)"_Y_X),%=$S(X<0:-1,1:0)+(X\86400),X=X#86400,%H=$P(%H,",")+%_","_X G RT
     D DMW G 1^%DT:\'% S @("%H=$H"_Y_%),%H=%H_","_$P($H,",",2)
RT   D TT S %=$P(%H,",",2) D S S %=X_% I %DT\'["S" S %=+$E(%,1,12)
     Q:\'$D(%(0))  S Y=% G E^%DT
PF   S %H=$H D YMD S %(9)=X,X=%DT["F"*2-1 I @("%I(1)*100+%I(2)"_$E("> <",X+2)_"$E(%(9),4,7)") S %I(3)=%I(3)+X
     Q
TT   D 7 S %I(1)=%M,%I(2)=%D,%I(3)=%Y K %M,%D,%Y Q
NOW  S %H=$H,%H=$S($P(%H,",",2):%H,1:%H-1)
     D TT S %=$P(%H,",",2) D S S %=X_$S(%:%,1:.24) Q
DMW  S %=$S(X?1.N1"D":+X,X?1.N1"W":X*7,X?1.N1"M":X*30,+X=X:X,1:0)
     Q
COMMA     ;
     S %D=X<0 S:%D X=-X S %=$S($D(X2):+X2,1:2),X=$J(X,1,%),%=$L(X)-3-$E(23456789,%),%L=$S($D(X3):X3,1:12)
     F %=%:-3 Q:$E(X,%)=""  S X=$E(X,1,%)_","_$E(X,%+1,99)
     S:$D(X2) X=$E("$",X2["$")_X S X=$J($E("(",%D)_X_$E(" )",%D+1),%L) K %,%D,%L
     Q
HELP S DDH=$S($D(DDH):DDH,1:0),A1="Examples of Valid Dates:" D %
     S A1="  JAN 20 1957 or 20 JAN 57 or 1/20/57"_$S(%DT\'["N":" or 012057",1:"") D %
     S A1="  T   (for TODAY),  T+1 (for TOMORROW),  T+2,  T+7,  etc." D %
     S A1="  T-1 (for YESTERDAY),  T-3W (for 3 WEEKS AGO), etc." D %
     S A1="If the year is omitted, the computer "_$S(%DT["P":"assumes a date in the PAST.",1:"uses the CURRENT YEAR.") D %
     I %DT\'["X" S A1="You may omit the precise day, as:  JAN, 1957" D %
     I %DT\'["T",%DT\'["R" G 0
     S A1="If the date is omitted, the current date is assumed." D %
     S A1="Follow the date with a time, such as JAN 20@10, T@10AM, 10:30, etc." D %
     S A1="You may enter a time, such as NOON, MIDNIGHT or NOW." D %
     I %DT["S" S A1="Seconds may be entered as 10:30:30 or 103030AM." D %
     I %DT["R" S A1="Time is REQUIRED in this response." D %
0    Q:\'$D(%DT(0))
     S A1=" " D % S A1="Enter a date which is "_$S(%DT(0)["-":"less",1:"greater")_" than or equal to " D %
     S Y=$S(%DT(0)["-":$P(%DT(0),"-",2),1:%DT(0)) D DD^%DT:Y\'["NOW"
     I \'$D(DDS) W Y,"." K A1 Q
     S DDH(DDH,"T")=DDH(DDH,"T")_Y_"." K A1 Q
     ;
%    I \'$D(DDS) W !,"     ",A1 Q
     S DDH=DDH+1,DDH(DDH,"T")="     "_A1 Q