naked indicator, name, namedactual, namedactuallist, namevalue, newargument, newsvn, nlformat, noncomma, noncommachars, noncommasemi, nonquote, nref, nrefind, Null string, numexpr, numlit
Introduced in the 1977 ANSI M[UMPS] language standard.
The naked indicator is an internal variable in a M[UMPS] system. The value of this variable may be either undefined or defined. When this variable has a defined value, a naked reference will build a reference to a global variable, based on the value of the naked indicator, and the information in the naked reference.
Initially, the naked indicator is undefined.
The naked indicator is defined after each reference to a subscripted global variable and becomes undefined after each reference to an unsubscripted global variable.
A naked reference may redefine the value of the naked indicator.
| Naked indicator Before evaluation |
Reference | Actual reference | Naked indicator After evaluation |
|---|---|---|---|
| undefined | ^(123) | error | undefined |
| undefined | ^ABC | ^ABC | undefined |
| undefined | ^A(1,2) | ^A(1,2) | ^A(1, |
| ^A(1, | ^(123) | ^A(1,123) | ^A(1, |
| ^A(1, | ^(4,5,6) | ^A(1,4,5,6) | ^A(1,4,5, |
| ^A(1, | ^BCD(1) | ^BCD(1) | ^BCD( |
| ^BCD( | ^KLM | ^KLM | undefined |
Introduced in the 1977 ANSI M[UMPS] language standard.
This metalanguage symbol represents the sequence of characters that establishes the name of an entity. Note that the sequence of characters that are described by the metalanguage symbol name does not include the prefixed characters for the names of certain special entities (^ for routines and global variables, $ for intrinsic functions and special variables, $$ for extrinsic functions and extrinsic variables or ^$ for structured system variables).
A name can start with either an alphabetic character or a percent sign (%); any further characters should be alphabetic characters or digits.
While the definition of name allows for any alphabetic characters, the portability section prohibits the use of lower case characters in names.
Only the first 8 characters in a name are interpreted by a M[UMPS] system.
Tricky detail about the term "name": when used colloquially, the prefix characters (^, $, etcetera) are usually included, when used as a metalanguage symbol, these characters are not included. I.e. these prefix characters do not count when determining the length of the name.
Modification in the 1995 ANSI M[UMPS] language standard.
A new metalanguage symbol is defined (ident) which represents "any character that may be used in a name". This addition allows for the inclusion of non-ASCII alphabetic characters in names.
A name can start with either an ident character or a percent sign (%); any further characters should be ident characters or digits.
Modifications in a future ANSI M[UMPS] language standard.
The characters that are eligible to be used in portable names are no longer restricted to upper case only. A M[UMPS] system is guaranteed to interpret the first 31 characters of a name. Implementations may allow for even longer names to be unique.
In addition, characters beyond the implementation's maximum limit for the length of a name are no longer ignored: an error (M56) will occur when too many characters are used in a name.
Approved for inclusion in a future ANSI M[UMPS] language standard.
This metalanguage symbol represents a value in a parameter of a method of an object. Such value can be passed either "by value" or "by reference".
Approved for inclusion in a future ANSI M[UMPS] language standard.
This metalanguage symbol represents the list of parameters that may be passed to a method of an object. Parameters in this list (enclosed in parameters, separated by commas) may be either "values" (passed "by value" or "by reference) or "named values" (passed as a keyword = value combination). Simple "values" as well as "named values" may be passed "by value" as well as "by reference".
Introduced in the 1990 ANSI M[UMPS] language standard.
This metalanguage symbol represents a value that meets the syntax of the name of a variable (local or global). A namevalue can not evaluate to a naked reference.
Modified in the 1995 ANSI M[UMPS] language standard.
This metalanguage symbol represents a value that meets the syntax of the name of a variable (local variable, global variable or structured system variable). A namevalue can not evaluate to a naked reference.
Introduced in the 1990 ANSI M[UMPS] language standard.
This metalanguage symbol represents an occurrence of an argument of the NEW command. Examples of valid arguments for the NEW command appear in an earlier section. The argument of the NEW command is either a name of a variable or a list of names of variables (separated by commas) enclosed in parentheses, or an indirection operator (@) followed by an expression that evaluates to a list (separated by commas) of such arguments.
Addition in the 1995 ANSI M[UMPS] language standard:
The intrinsic special variables $ESTACK and $ETRAP may occur as arguments of the NEW command.
Approved for addition in a future ANSI M[UMPS] language standard:The intrinsic special variable $TEST may occur as an argument of the NEW command.
Introduced in the 1995 ANSI M[UMPS] language standard.
This metalanguage symbol represents an occurrence of an intrinsic
special variable as an argument of the NEW command.
Currently, the intrinsic special variables $ESTACK and
$ETRAP may occur as arguments of the NEW command.
Additions in a future ANSI M[UMPS] language standard:
The intrinsic special variable $TEST may occur as an argument of the NEW command.
The intrinsic special variable $REFERENCE may occur as an argument of the NEW command.
Approved for inclusion in a future ANSI M[UMPS] language standard.
This metalanguage symbol represents a format item that causes a line-feed in a READ or WRITE command. Such a format is written as an exclamation mark.
Introduced in the 1995 ANSI M[UMPS] language standard.
This metalanguage symbol represents any character (from the 94 printable ASCII characters) that is not the comma character ($CHAR(44) or ",").
Introduced in the 1995 M[UMPS] Windowing Application Programmer's Interface.
This metalanguage symbol represents a sequence of zero or more characters, excluding the comma.
Approved for inclusion in a future ANSI M[UMPS] language standard.
This metalanguage symbol represents any character (from the 94 printable ASCII characters) that is not the comma character ($CHAR(44) or ",") or the semi-colon character ($CHAR(59) or ";").
Introduced in the 1977 ANSI M[UMPS] language standard.
This metalanguage symbol represents any character (from the 94 printable ASCII characters) that is not the quote character ($CHAR(34) or """").
Introduced in the 1977 ANSI M[UMPS] language standard.
This metalanguage symbol represents a reference to a name, in the context of the LOCK command. A reference to a name, in this context, may be the name of any subscripted or unsubscripted local or global variable, specified either "directly" or "indirectly", but not a naked reference.
Addition in the 1995 ANSI M[UMPS] language standard:
There may be an evnvironment specification in a name reference.
Approved for addition in a future ANSI M[UMPS] language standard:There may be a "subscript indirection" in a name reference.
Approved for inclusion in a future ANSI M[UMPS] language standard.
This metalanguage symbol represents a reference to a name, in a form that makes an indirect reference to that name.
This term is not one that is formally in any M[UMPS] standard, but it is one that gives rise to a lot of confusion. To many people this term identifies a string that contains no characters, i.e. a string for which $LENGTH(string) equals 0 (zero). To many other people this term identifies a string that contains one character, namely the ASCII character that is called NULL (internal code 0, or $CHAR(0)).
As a result, many people prefer to avoid using the ambiguous term null string and use the term empty string to denote the string of length 0, and the term NULL character for the string of length 1.
Note that in C and Unix (TM), the length of a string containing one NULL character equals 0, whereas in M[UMPS] $LENGTH($CHAR(0))=1.
Introduced in the 1977 ANSI M[UMPS] language standard.
This metalanguage symbol represents the numeric interpretation of an expression. In order to produce the numeric interpretation of an expression, first the expression is evaluated, and then reduced to its canonical numeric representation.
The reduction to a canonic numerical representation involves (colloquially) the removal of any redundant leading and trailing zeroes, the conversion of exponentionential notation to "mantissa only" notation, and the reduction of any leading plus (+) and minus (-) signs to at most one leading minus sign.
| String value | Numeric interpretation |
|---|---|
| 123.456 | 123.456 |
| "5 apples" | 5 |
| "+---+--+---+++-5.2300" | -5.23 |
| 123.45E6 | 123450000 |
Introduced in the 1977 ANSI M[UMPS] language standard.
This metalanguage symbol represents a numeric literal string. A numeric
literal string consists of a mantissa (see metalanguage symbol
mant),
and optionally an exponent (see metalanguage symbol
exp.
A numlit is not necessarily a canonic representation of a number.
Valid numeric literals are:
0
123
00000
00123
.00000
.10100
.12345
1.23E+20
1.23E-5
1.23E-005
12E3
but not:
0.
1.
123e-4
12.3E4.5
The ANSI standard guarantees 9 digits of precision, and a numeric range from -1*10**25 through -1*10**-25, then 0, then +1*10**-25 through +1*10**25.
Modification in the 1984 ANSI M[UMPS] language standard.
The ANSI standard guarantees 12 digits of precision, and a numeric range from -1*10**25 through -1*10**-25, then 0, then +1*10**-25 through +1*10**25.
Modification in the 1995 ANSI M[UMPS] language standard.
The ANSI standard guarantees 15 digits of precision, a computational accuracy of 1 in 10**12 for the operators +, -, *, #, / and \, a computational accuracy of 1 in 10**9 for the operator **, and a numeric range from -1*10**25 through -1*10**-25, then 0, then +1*10**-25 through +1*10**25.
This document is © Ed de Moel, 1995-2005.
It is part of a book by Ed de Moel that is published
under the title "M[UMPS] by Example" (ISBN 0-918118-42-5).
Printed copies of the book are no longer available.
This document describes the various metalanguage terms starting with the letter "N" that are used throughout the M[UMPS] standards, as well as some other terms that may not be obvious to all readers of the M[UMPS] language standards.
The information in this document is NOT authoritative
and subject to be modified at any moment.
Please consult the appropriate (draft) language standard for an
authoritative definition.
In this document, information is included that will
appear in
future standards.
The MDC cannot guarantee that these 'next'
standards will indeed appear.