The USER data specifications within each USER segment consist of a series of data identifiers and associated operators and operands. These identifiers are the words declared in the structural definition (that is, data and node names). The means of assigning or changing the data associated with these identifiers depend on the data type of the identifiers, as follows.

Addressing Node

<addressing node>

──┬─────┬─<addressing node identifier>─────────────────────────────────┤
  ├─ + ─┤
  └─ ─ ─┘

To delete an addressing node from a user entry, precede the node with a minus sign (–). You can precede a node name by either a plus sign (+) or an empty prefix for documentation purposes; such a node name has no effect.

Bit

<bit>

──┬─────┬─<bit identifier>─────────────────────────────────────────────┤
  ├─ + ─┤
  └─ ─ ─┘

Both +<bit identifier> and <bit identifier> assign the specified bit a value of 1. The–<bit identifier> form assigns the specified bit a value of zero.

Credentials

Credentials are automatically derived from the clear text password by the one-way encryption algorithm used by Windows Networking.

Credentials appear in disk output created with the COPY DISK statement; the disk output can be used as input to MAKEUSER. Since they are derived from the password, they must not be changed before being used for input.

The actual characters used to represent the credentials depend on the VISIBLE compile-time option. For the data to be recognized, the value of the VISIBLE option (SET or RESET) must be the same for the MAKEUSER code file that created the disk file and the MAKEUSER code file reading the disk file.

Field

<field>

──<field identifier>─┬─ = ─┬─<value>───────────────────────────────────┤
                     ├─ + ─┤
                     └─ ─ ─┘

You can assign (=) a field identifier a value, or you can increment (+) or decrement (–) the current value by a value. The resulting value must fit within the field. For assignment to an n -bit field, the high-order 48 – n bits must be 0 in the binary representation of the value.

Word or Real

<word> or <real>

──┬─<word identifier>─┬─┬─ = ─┬─<value>────────────────────────────────┤
  └─<real identifier>─┘ ├─ + ─┤
                        └─ ─ ─┘

You can assign (=) a word identifier or real identifier a value, or you can increment (+) or decrement (–) the current value by a value. A real identifier differs from a word identifier only in that a real identifier appears as a decimal number in LIST output, while a word identifier appears as a hexadecimal number.

Time

<time>

──<time identifier>── = ──<timevalue>──────────────────────────────────┤

You can assign (=) a time identifier a time value that specifies a date and time. The value is stored in a word in TIME(6) format.

Date

<date>

──<date identifier>── = ──<datevalue>──────────────────────────────────┤

You can assign (=) a date identifier a value that specifies a date. The date is stored in Julian format.

Array

<array>

──<array identifier>───────────────────────────────────────────────────►
                                ┌◄──────────── , ────────────┐
►─┬───────────────────────┬─ = ─┴─┬─<value>────────────────┬─┴─┬───────┤
  ├─ [ ── subscript ── ] ─┘       ├─<repeat>── * ──<value>─┤   │
  │                               └─<long string>──────────┘   │
  └─ [ ──<subscript>── ] ─┬─ + ─┬─<value>──────────────────────┘
                          └─ - ─┘

A <long string> is a <string> that is longer than 48 bits. A <subscript> is an integer value.

You can assign (=) an array identifier a value, a repeated value, a long string, or a list of such items. A short string (48 bits or less) is considered a value; it occupies one word that is right-justified, zero-filled, and optionally signed. A long string occupies more than one word of the array; it is left-justified, zero-filled in the last word affected, and cannot be signed. Quoted sequences within a string are concatenated without respect to word boundaries, but separate list items (delimited by commas) start new words.

If the array identifier is subscripted, assignment begins at that element in the array and extends for the length of the assignment list. Otherwise, assignment begins at the first element; remaining elements are zeroed if the array is longer than the list. You can increment (+) or decrement (–) a subscripted array element by a value. The subscript is an integer index into the array. The first word is zero. The bounds of subscripts and assignment lists must fall within the defined array.

String

<string>

──<string identifier>─┬───────────────────────┬─ = ────────────────────►
                      └─ [ ──<subscript>── ] ─┘
  ┌◄────────── , ──────────┐
►─┴─┬────────────────────┬─┴───────────────────────────────────────────┤
    ├─<repeat * integer>─┤
    ├─<repeat * string>──┤
    ├─<string>───────────┤
    └─<integer>──────────┘

You can assign (=) a string identifier a string or integer value or a list of such values. (An integer specifies a single character.) If a character index appears, the assignment begins with that character and extends for the length of the assignment list. Otherwise, the assignment affects the entire defined string—left-justified and zero-filled. Character size must match the string type, although even-length hexadecimal sequences can appear in ASCII or EBCDIC strings.

The subscript is an integer index into the string. The first character is zero. Subscripts and assignment lists are bounds checked and must fall within the defined string.

Name, File Name, and Text

<name>, <file name>, and <text>

──┬─────┬─<identifier>── = ──<item>─┬──────────────────────────────────┤
  ├─ + ─┘                           │
  └─ ─ ──<identifier>───────────────┘

The name, file name, and text identifiers represent typed nodes that contain a single variable-length item. For a name, file name, or text identifier, the item must be a name, file name, or EBCDIC string, respectively. If the operator that precedes the identifier is a plus sign (+) or if there is no operator, the node is created if not already present. If the operator is a minus sign (–), the item is deleted if it is present.

The maximum length of an EBCDIC string is 1524 characters (or 3048 characters if a hexadecimal string is specified).

List

<list>

                                ┌◄────────── , ──────────┐
──┬─────┬─<list identifier>──┬──┴──┬─────┬───<item>──────┴──┬─────────┤
  ├─ + ─┘                    │     ├─ + ─┤                  │
  │                          │     ├─ & ─┤                  │
  │                          │     └─ - ─┘                  │
  │                          │     ┌◄── , ──┐               │
  │                          └─ = ─┴─<item>─┘───────────────┤
  │                                                         │
  └─ - ──<list indentifier>─────────────────────────────────┘

A list identifier is a node that contains a variable number of items. For word lists, name lists, password lists, file name lists, chargecode lists, and accesscode lists the items are words, names, passwords, file names, chargecodes, and accesscodes, respectively. If the list identifier is preceded by nothing or a plus sign (+), the node is created if it is not already present. If the list identifier is preceded by a minus sign (–), the node is deleted if it is present.

The operators following the <list identifier> have the following significance:

Family

<family>

──┬─ ─ ──<target>────────────────────────────────┬─────────────────────┤
  ├─────┬─ <target> = <sub> ─┬─ ONLY ────────────┤
  └─ + ─┘                    └─ OTHERWISE <alt> ─┘

The <target>, <sub>, and <alt> constructs are identifiers. If the operator that precedes the target is an empty prefix or a plus sign (+), the node is created if it is not already present. If the operator is a minus sign (–), the node is deleted if it is present. The name TAPE cannot be specified for <target>, <sub>, or <alt>.

Group

<group>

──┬─────┬─<group id>──<action>─┬───────────────────────────────────────┤
  ├─ + ─┘                      │
  └─ ─ ──<group id>────────────┘

<action>

  ┌◄─────────────────────── , ──────────────────────┐
──┴─┬─ AT ─┬─ <key ID>=<key> ─┬───────────────────┬─┴──────────────────┤
    ├─ + ──┤                  └─ (<fixed items>) ─┤
    ├─ & ──┘                                      │
    └─ - ── <key ID>=<key> ───────────────────────┘

<fixed items>

  ┌◄─────────────┐
──┴─┬─<string>─┬─┴─────────────────────────────────────────────────────┤
    ├─<array>──┤
    ├─<word>───┤
    ├─<real>───┤
    ├─<field>──┤
    ├─<bit>────┤
    └─<time>───┘

The operators following the <action> element have the following significance.

<key ID>

Valid <key ID>=<key> syntax appears in the following diagrams.

When <key ID> is a field identifier, the syntax is as follows:

──<field identifier>── = ──<integer>───────────────────────────────────┤

When <key ID> is a word or real identifier, the syntax is as follows:

──┬─<word identifier>─┬─ = ─┬─<integer>─┬──────────────────────────────┤
  └─<real identifier>─┘     └─<real>────┘

When <key ID> is an array identifier, the syntax is as follows:

                               ┌◄────────────── , ─────────────┐
──<array identifier>── = ── ( ─┴─┬─<integer>─────────────────┬─┴─ ) ───┤
                                 ├─<real>────────────────────┤
                                 ├─<long string>─────────────┤
                                 └─<repeat>── * ─┬─<integer>─┤
                                                 └─<real>────┘

When <key ID> is a string identifier, the syntax is as follows:

──<string identifier>── = ─┬─<string info>─────────────┬───────────────┤
                           │     ┌◄────── , ─────┐     │
                           └─ ( ─┴─<string info>─┴─ ) ─┘

When <key ID> is a time identifier, the syntax is as follows:

──<time identifier>── = ──<timevalue>──────────────────────────────────┤

Time List

<time list>

<time list item>

──<day of week>─┬────────────────────┬─<time>─┬─ ON ──┬────────────────┤
                ├────────────────────┤        └─ OFF ─┘
                └─ ─ ──<day of week>─┘

<day of week>

──┬─ SUNday ────┬──────────────────────────────────────────────────────┤
  ├─ MONday ────┤
  ├─ TUEsday ───┤
  ├─ WEDnesday ─┤
  ├─ THUrsday ──┤
  ├─ FRIday ────┤
  ├─ SATurday ──┤
  └─ SUNday ────┘

<time>

──<hour>── : ──<minute>────────────────────────────────────────────────┤

A time list contains a variable number of ON and OFF time list items with at least one ON and one OFF time list item defined. Assignments, deletions, or additions of time list items that produce time lists containing only ON or only OFF time list items are disallowed and result in errors.

The <time> value specifies an hour and a minute. Both attributes are integers, as follows.

A given time list item occurs only once in a time list and is either ON or OFF, not both.

You can enter time list items in any order using MAKEUSER, but they are stored in the USERDATAFILE in chronological order.

Two ON or OFF time list items separated by a hyphen (-) defines an inclusive range of days or times or both. For example, the following entry specifies that ON times are to begin at 8:00 a.m. every day of the week:

SUN-SAT 08:00 ON

To control how the time list interacts with existing time lists, include operators in the list as follows: