☜	Definitions Draft MDC Standard					☞

4. Definitions

For the purposes of this standard, the following definitions apply.

[ A, B, C, D, E, F, G, H, I, J, L, M, N, O, P, R, S, T, U, V, W ]

4.1 argument (of a command): M[UMPS] command words are verbs. Their arguments are the objects on which they act.

4.2 array: M[UMPS] arrays, unlike those of most other computer languages, are trees of unlimited depth and breadth. Every node may optionally contain a value and may also have zero or more descendant nodes. The name of a subscripted variable refers to the root, and the nth subscript refers to a node on the nth level. Arrays vary in size as their nodes are set and killed. See also scalar, subscript.

4.3 atom: a singular, most-basic element of a construction. For example, some atoms in an expression are names of variables and functions, numbers, and string literals.

4.4 block: one or more lines of code within a routine that execute in line as a unit. The argumentless Do command introduces a block, and each of its lines begins with one or more periods. Blocks may be nested. See also level.

4.5 call by name: a calling program names an actual parameter and passes its value to an object’s service. Limited to a single value, that is, the value of a scalar variable or of one node in an array. See also call by reference, call by value.

4.6 call by reference: a calling program passes to a subroutine or function a reference to its actual parameter. If the called subroutine, function, or object’s service changes the value of its formal parameter, the change affects the actual parameter as well. Limited to unsubscripted names of local variables, either scalar or array. See also call by name, call by value.

4.7 call by value: a calling program passes the value of its actual parameter to a subroutine, function, or object’s service. Limited to a single value, that is, the value of a scalar variable or of one node in an array. See also call by name, call by reference.

4.8 call: a procedural process of transferring execution control to a callee by a caller.

4.9 callee: the recipient of a call.

4.10 caller: the originator of a call.

4.11 character: (1) a member of a set of elements used for the organization, control, or representation of data. (2) a character is a simple or composite graphic symbol belonging to a conventional set of symbols. There are alphabetic characters, numerical characters (arabic and roman), diacritic characters (for example ^ ° ̀  ́ ), punctuation characters (for example . , ; : ! ?), and specific other characters (for example § $ % & { #). The following synonyms should be avoided: graphic symbol, phonetic symbol, sign, mark, note, cipher, whether or not these are used in conjunction with terms like phonetic and graphic..

4.12 combining character: a member of an identified subset of the coded character set of ISO/IEC 10646 intended for combination with the preceding non-combining graphic character, or with a sequence of combining characters preceded by a non-combining character (see also composite sequence). NOTE - ISO/IEC 10646 specifies several subset collections which include combining characters.

4.13 command: a command word (a verb), an optional conditional expression, and zero or more arguments. Commands initiate all actions in M[UMPS].

4.14 composite sequence: a sequence of graphic characters consisting of a non-combining character followed by one or more combining characters (see also combining characters). NOTES - 1) A graphic symbol for a composite sequence generally consists of the combination of the graphic symbols of each character in the sequence. 2) A composite sequence is not a character and therefore is not a member of the repertoire any character set.

4.15 computationally equivalent: the result of a procedure is the same as if the code provided were executed by a M[UMPS] program without error. However, there is no implication that executing the code provided is the method by which the result is achieved.

4.16 concatenation: the act or result of joining two strings together to make one string.

4.17 conditional expression: guards a command (sometimes an argument of a command). Only if the expression’s value is true does the command execute (or the argument). See also truthvalue.

4.18 contains: a relational operator that tests whether one string is a substring of another.

4.19 data-cell: in the formal model of M[UMPS] execution. It contains the value and subscripts (if any) of a variable, but not the name of the variable. Any number of variable names may point to a data-cell due to parameters passed by reference. See also name-table, value-table.

4.20 default property: the default state of an object; a property to which an OREF evaluates if used in a property reference that doesn’t name a specific property. See also default state, OREF, property.

4.21 default state: the state that is assumed when no state has been explicitly specified.

4.22 descriptor: uniquely defines an element. It comprises various characteristics of the element that distinguish the element from all other similar elements.

4.23 device-dependent: that which depends on the device in question.

4.24 diacritic: character which is not a letter of the latin alphabet and which is placed over, under, or through a letter or combination of letters indicating a semantic or phonetic value different from that given the unmarked or otherwise marked letter. A letter with a diacritic is a composite character. NOTE - The points of german “Umlaut”-character should be regarded as diacritic. [also called a diacritical mark]

4.25 diacritic mark: an attribute of a character, written either above or below that character, applied to denote a phonetically or linguistically different letter.

4.26 digit: a graphic character used to represent the numeric value, or part thereof, of a number. Examples: decimal digits, hexadecimal digits.

4.27 empty: an entity that contains nothing. For example, an empty string contains no characters; it exists but has zero length. See also null string, NULL character.

4.28 environment: a set of distinct names. For example, in one global variable environment all global variables have distinct names. Similar to a directory in many operating systems.

4.29 evaluate: to derive a value.

4.30 execute: to perform the operations specified by the commands of the language.

4.31 “executing” a namevalue: a namevalue is “executed” when it is used in an indirect reference (i.e., @Ref) or subscripted indirectness (i.e., @Ref@(3)).

4.32 extract: to retrieve part of a value, typically contiguous characters from a string.

4.33 extrinsic: a function or variable defined and created by M[UMPS] code, distinct from the primitive functions or special variables of the language. See also intrinsic.

4.34 follow: to come after according to some ordering sequence. See also sorts after.

4.35 function: a value-producing subroutine whose value is determined by its parameters. Intrinsic functions are defined elements of the language, while extrinsic functions are programmed in M[UMPS].

4.36 global variable: a scalar or array variable that is public, available to more than one job, and persistent, outliving the job. See also local variable.

4.37 GMT: Greenwich Mean Time.

4.38 graphic: a visible character (as opposed to most control characters).

4.39 graphic character: a character, other than a control function, that has a visual representation normally handwritten, printed, or displayed.

4.40 hidden: unseen. The New command hides local variables. Also pertains to unseen elements invoked to define the operation of some commands and functions.

4.41 intrinsic: a primitive function or variable defined by the language standard as opposed to one defined by M[UMPS] code. See also extrinsic.

4.42 job: a single operating system process running an M[UMPS] program.

4.43 label: identifies a line of code.

4.44 letter: (1) a letter (or alphabetic character) is a character that is an individual unspecific basic unit of an alphabet, irrespective of the shape and any graphical realization on a medium. In some alphabets, a letter can be specified as a small letter or capital letter. (2) a graphic character used for writing natural language, normally representing a sound of the language.

4.45 level: the depth of nesting of a block of code lines. The first line of a routine is usually at level 1 and successively nested blocks are at levels 2, 3, . . . Formally, the level of a line is one plus li. Visually, li periods follow the label (if any) and precede the body of the line. See also block.

4.46 library: a collection of library elements, with unique names, which are referenced using a single library name. A library is defined as being either mandatory or optional.

4.47 library element: an individual function that is separately defined and accessible from an M[UMPS] process using the library reference syntax.

4.48 ligature: (1) a composite character joining two or more letters. There are ligatures that are conventionalized units of national variants of alphabets, and ligatures that are caused by the font used in a document. Maybe the first ones should be named ligature characters, the last ones ligature font elements. [Language dependent. Only ligature characters are taken into consideration] (2) two or more letters written together. The resulting symbol is in some cases considered equivalent with the originating letters, in some cases it is considered a separate entity.

4.49 local variable: a scalar or array variable that is private to one job, not available to other jobs, and disappears when the job terminates. See also global variable.

4.50 lock: to claim or obtain exclusive access to a resource.

4.51 M[UMPS] Standard Library: all libraries and library elements defined within the M[UMPS] Standard, whether mandatory or optional.

4.52 mapping: the logical association or substitution of one element for another.

4.53 map: the act of mapping.

4.54 metalanguage: underlined terms used in the formal description of the M[UMPS] language.

4.55 method: a service that represents the behavior that may be requested of an object. See also object, property, service.

4.56 modulo: an arithmetic operator that produces the remainder after division of one operand by another. There are many interpretations of how this operation is performed in the general computing field. M[UMPS] explicitly defines the result of this computation.

4.57 multidimensional: used in reference to arrays to indicate that the array can have more than one dimension.

4.58 MVAL: the type of any data value that may be represented as a string of variable length. Arithmetic operations interpret strings as numbers, and logical operations further interpret the numbers as true or false. See also OREF, truthvalue, type.

4.59 naked: a shorthand reference to one level of the tree forming a global array variable. The full reference is defined dynamically.

4.60 name-table: in the formal model of M[UMPS] execution, a set of variable names and their pointers to data-cells.

4.61 negative: a numeric value less than zero. Zero is neither negative nor positive.

4.62 node: one element of the tree forming an array. It may have a value and it may have descendants.

4.63 NULL character: the character that is internally coded as code number 0 (zero). A string may contain any number of occurrences of this character (up to the maximum string length). A string consisting of one NULL character has a length of 1 (one).

4.64 null string: 1) a string consisting of 1 (one) NULL character; 2) a string consisting of 0 (zero) characters.

4.65 object: an identifiable, encapsulated software entity whose state and behavior can only be observed or changed by use of its services. An object is considered as a whole in relation to other entities, and is identified by a value of data type OREF. See also OREF, service.

4.66 ordering: bringing strings of characters into a well-defined sequence using a string comparison specification.

4.67 OREF: an object reference. A value of data type OREF is a reference to an object that uniquely identifies that object. OREFs have no literal representation. Under most circumstances, values of data type OREF are coerced into values of type MVAL based on the value of the default property of the object identified by the value of data type OREF. See also default property, object, type.

4.68 own: to have exclusive access to a resource. In M[UMPS] this pertains to devices and locks.

4.69 parameter: a qualifier of a command that modifies its behavior (for example by imposing a time out), or augments its argument (for example by setting characteristics of a device). Some parameters are expressions, and some have the form keyword=value. See also argument.

4.70 parameter (of a function, subroutine, or object’s service): The calling program provides actual parameters. In a called function or subroutine formal parameters relate by position to the caller’s actual arguments. In a called object’s service formal parameters can relate by position or name to the caller’s actual arguments. See also call by name, call by reference, call by value, parameter passing.

4.71 parameter passing: this alliterative phrase refers to the association of actual parameters with formal parameters when calling a subroutine, function, or object’s service.

4.72 partition: the random access memory in which a job runs.

4.73 piece: a part of a string, a sub-string delimited by chosen characters.

4.74 pointer: indirection allows one M[UMPS] variable to refer, or point to, another variable or the argument of a command.

4.75 portable: M[UMPS] code that conforms to the portability section of the standard.

4.76 positive: a numeric value greater than zero. Zero is neither negative nor positive.

4.77 post-conditional: see conditional expression.

4.78 primitives: the basic elements of the language.

4.79 process-stack: in the formal model of M[UMPS] execution, a push-down stack that controls the execution flow and scope of variables.

4.80 property: a service that represents the external view of some of an object’s data. An object may have a default property. See also default property, method, object, service.

4.81 relational: pertaining to operators that compare the values of their operands.

4.82 scalar: single-valued, without descendants. See also array.

4.83 scope (of a command): the range of other commands affected by the command, as in loop control, block structure, and conditional execution.

4.84 scope (of a local variable): the range of commands for which the variable is visible, from its creation to its deletion, or from its appearance in a New command to the end of the subroutine, function, or block. Scope is not textual, but dynamic, controlled by the flow of execution.

4.85 service: a body of code associated with objects. Services are the only mechanism through which the state of an object may be altered. An object’s services include methods and properties. See also method, object, property.

4.86 sorts after: to come after according to an ordering sequence that is based on a collating algorithm. See also follows.

4.87 subscript: an expression whose value specifies one node of an array. Its value may be an integer, a floating point number, or any string. Subscripts are sparse, that is, only those that have been defined appear in the array. See also array, scalar.

4.88 trails: “A trails B” means that (" "_A) ]] (" "_B) in the appropriate collation sequence; if not specified, it refers to the sequence used for local variables.

4.89 truthvalue: the value of an expression considered as a logical value. When considered as a numeric value, non-zero is true, and zero is false.

4.90 tuple: a sequence of a predetermined number of descriptors (usually a name and a series of subscripts) that identifies a member of a set.

4.91 type: M[UMPS] recognizes only two data types, the reference to an object, or OREF, and the string of variable length, or MVAL. See also MVAL, OREF.

4.92 UCT: Universal Coordinated Time.

4.93 unbound: in the formal model of M[UMPS] execution, the disassociation of a variable’s name from its value.

4.94 undefined: pertaining to a variable that is not visible to a command.

4.95 unsubscripted: see scalar.

4.96 value-denoting: representing or having a value.

4.97 value-table: in the formal model of M[UMPS] execution, a set of data-cells.

4.98 variable: M[UMPS] variables may be local or global, scalar or array.

4.99 write-once: a property of an ssvn descriptive of the ability of a M[UMPS] routine to assign a value to it if and only if it does not currently have a $Data value of 1 or 11.

Copyright © Standard Documents; 1977-2024 MUMPS Development Committee;
Copyright © Examples: 1995-2024 Ed de Moel;
Copyright © Annotations: 2003-2008 Jacquard Systems Research
Copyright © Annotations: 2008-2024 Ed de Moel.

Some specifications are "approved for inclusion in a future standard". Note that the MUMPS Development Committee cannot guarantee that such future standards will indeed be published.

This page most recently updated on 16-Nov-2023, 17:33:38.

For comments, contact Ed de Moel (demoel@jacquardsystems.com)