Document revision date: 30 March 2001

## Guide to the DEC Text Processing Utility

Previous | Contents | Index

## 4.4 Identifiers

In DECTPU, identifiers are used to name programs, procedures, keywords, and variables. An identifier is a combination of alphabetic characters, digits, dollar signs, and underscores, and it must conform to the following restrictions:

- An identifier cannot contain any spaces or symbols except the dollar sign and the underscore.
- Identifiers cannot be more than 132 characters long.

DECTPU identifiers for built-in procedures, constants, keywords, and global variables are reserved words.

You can create your own identifiers to name programs, procedures, constants, and variables. Any symbol that is neither declared nor used as the target of an assignment statement is assumed to be an undefined procedure.

## 4.5 Variables

Variables are names given to DECTPU storage locations that hold values. A variable name can be any valid DECTPU identifier that is not a DECTPU reserved word or the name of a DECTPU procedure. You assign a value to a variable by using a valid identifier as the left-hand side of an assignment statement. Following is an example of a variable assignment:

    new_buffer := CREATE_BUFFER ("new_buffer_name");

Compaq suggests that you establish some convention for naming variables so that you can distinguish your variables from the variables in the section file that you are using.

DECTPU allows two kinds of variables: global and local. Global variables are in effect throughout a DECTPU environment. Local variables are evaluated only within the procedure or unbound code in which they are declared. A variable is implicitly global unless you use the LOCAL declaration. You can also declare global variables with the VARIABLE declaration.

Example 4-1 shows a global variable declaration and a procedure that contains a local variable declaration.

Example 4-1 Global and Local Variable Declarations

    VARIABLE user_tab_char;

    ! Tab key procedure.  Always inserts a tab, even if current mode
    ! is overstrike.

    PROCEDURE user_tab

    LOCAL this_mode;          ! Local variable for current mode

    this_mode := GET_INFO (CURRENT_BUFFER, "mode"); ! Save current mode
    SET (INSERT, CURRENT_BUFFER);                  ! Set mode to insert
    user_tab_char := ASCII (9);                    ! Define the tab char
    COPY_TEXT (user_tab_char);                     ! Insert tab
    SET (this_mode, CURRENT_BUFFER);               ! Reset original mode

    ENDPROCEDURE;

The global variable user_tab_char is assigned a value when the procedure user_tab is executing. Since the variable is a global variable, it could have been assigned a value outside the procedure user_tab.

The local variable this_mode has the value established in the procedure user_tab only when this procedure is executing. You can have a variable also named this_mode in another procedure. The two variables are not the same and may have different values. You can also have a global variable named this_mode. However, using this_mode as a global variable when you are also using it as a local variable is likely to confuse people who read your code. DECTPU will return an informational message during compilation if a local variable has the same name as a global variable.

## 4.6 Constants

DECTPU has three types of constants:

- Integers
- Strings
- Keywords

Integer constants can be any integer value that is valid in DECTPU. See the DEC Text Processing Utility Reference Manual for more information on the integer data type.

String constants can be one character or a combination of characters delimited by apostrophes or quotation marks. See the DEC Text Processing Utility Reference Manual for a complete description of how to quote strings in DECTPU.

Keywords are reserved words that have special meaning to the DECTPU compiler. See Chapter 3 for a complete description of keywords.

With the CONSTANT declaration, you can associate a name with a constant expression. User-defined constants can be locally or globally defined.

A local constant is a constant declared within a procedure declaration. The scope of the constant is limited to the procedure in which it is defined.

A global constant is a constant declared outside a procedure. Once a global constant has been defined, it is set for the life of the DECTPU session. You can reassign to a constant the same value it was assigned previously, but you cannot redefine a constant during a DECTPU session.

See Section 4.9.5.3 for a complete description of the CONSTANT declaration.

Example 4-2 shows a global constant declaration and a procedure that contains a local constant declaration.

Example 4-2 Global and Local Constant Declarations

    ! Define some global constants.
    CONSTANT
       user_bell := BELL,
       user_hello := "Hello",
       user_ten := 10;

    ! Hello world procedure.

    PROCEDURE user_hello_world
    CONSTANT
       world := "world";
    MESSAGE (user_hello + " " + world);   ! Display "Hello world"
                                          ! in message area
    ENDPROCEDURE;

## 4.7 Operators

DECTPU uses symbols and characters as language operators. There are five types of operators:

- Arithmetic
- String
- Relational
- Pattern
- Logical

Table 4-5 lists the symbols and language elements that DECTPU uses as operators.

Table 4-5 DECTPU Operators
Type | Symbol | Description
--- | --- | ---
Arithmetic | + | Addition, unary plus
| -- | Subtraction, unary minus
| * | Multiplication
| / | Division
String | + | String concatenation
| - | String reduction
| * | String replication
Relational | <> | Not equal to
| = | Equal to
| < | Less than
| <= | Less than or equal to
| > | Greater than
| >= | Greater than or equal to
Pattern | | | Pattern alternation
| @ | Partial pattern assignment
| + | Pattern concatenation
| & | Pattern linkage
Logical | AND | Boolean AND
| NOT | Boolean NOT
| OR | Boolean OR
| XOR | Boolean exclusive OR

You can use the + operator to concatenate strings. You can also use the relational operators to compare a string with a string, a marker with a marker, or a range with a range.

The precedence of the operators in an expression determines the order in which the operands are evaluated. Table 4-6 lists the order of precedence for DECTPU operators. Operators of equal precedence are listed on the same line.

Table 4-6 Operator Precedence
Operator | Precedence
--- | ---
unary +,unary -- | Highest
NOT |
*, /, AND |
@, &, +, --, |, OR, XOR |
=, <>, <, <=, >, >= |
:= | Lowest

Expressions enclosed in parentheses are evaluated first. You must use parentheses for correct evaluation of an expression that combines relational operators.

You can use parentheses in an expression to force a particular order for combining operands. For example:

    Expression            Result

    8 * 5 / 2 - 4           16
    8 * 5 / (2 - 4)        -20

## 4.8 Expressions

An expression can be a constant, a variable, a procedure, or a combination of these separated by operators. You can use expressions in a DECTPU procedure where an identifier or constant is required. Expressions are frequently used within DECTPU conditional language statements.

The data types of all elements of a DECTPU expression must be the same. The following are exceptions to this rule:

- You can mix keywords, strings, and pattern variables in expressions used to create patterns.
- You can mix data types when using the not equal (<>) and equal (=) relational operators.
- You can mix strings and integers when doing string replication.

Except for these cases, DECTPU does not perform implicit type conversions to allow for the mixing of data types within an expression. If you mix data types, DECTPU issues an error message.

In the following example, the elements (J > 4) and (my_string = "this is my string") each evaluate to an integer type (odd integers are true; even integers are false) so that they can be used following the DECTPU IF statement:

    IF (J > 4) AND (my_string = "this is my string")
    THEN
       .
       .
       .

With the exception of patterns and the relational operators, the result of an expression is the same data type as the elements that make up the expression.

The following example shows a pattern expression that uses a string data type on the right-hand side of the expression. The LINE_BEGIN and REMAIN pattern keywords are used with the string constant "the" to create a pattern data type that is stored in the variable pat1:

    pat1 := LINE_BEGIN + "the" + REMAIN;

Whenever possible, the DECTPU compiler evaluates constant expressions at compile time. DECTPU built-in procedures that can return a constant value given constant input are evaluated at compile time.

In the following example, the variable fubar has a single string assigned to it:

    fubar := ASCII (27) + "[0m";

Note Do not assume that the DECTPU compiler automatically evaluates an expression in left-to-right order.

To avoid the need to rewrite code, you should write as if this compiler optimization were already implemented. If you need the compiler to evaluate an expression in a particular order, you should force the compiler to evaluate each operand in order before using the expression. To do so, use each operand in an assignment statement before using it in an expression. For example, suppose you want to use ROUTINE_1 and ROUTINE_2 in an expression. Suppose, too, that ROUTINE_1 must be evaluated first because it prompts for user input. To get this result, you could use the following code:

    PARTIAL_1 := ROUTINE_1;
    PARTIAL_2 := ROUTINE_2;

You could then use a statement in which the order of evaluation was important, such as the following:

    IF PARTIAL_1 OR PARTIAL_2
       .
       .
       .

There are four types of DECTPU expressions:

- Arithmetic
- Relational
- Pattern
- Boolean

The following sections discuss each of these expression types.

### 4.8.1 Arithmetic Expressions

You can use any of the arithmetic operators (+, --, *, / ) with integer data types to form arithmetic expressions. DECTPU performs only integer arithmetic. The following are examples of valid DECTPU expressions:

    12 + 4             ! adds two integers

    "abc" + "def"      ! concatenates two strings

The following is not a valid DECTPU expression because it mixes data types:

    "abc" + 12         ! you cannot mix data types

When performing integer division, DECTPU truncates the remainder; it does not round. The following examples show the results of division operations:

    Expression         Result

     39 / 10              3
    -39 / 10             -3

### 4.8.2 Relational Expressions

A relational expression tests the relationship between items of the same data type and returns an integer result. If the relationship is true, the result is integer 1; if the relationship is false, the result is integer 0.

Use the following relational operators with any of the DECTPU data types:

- Not equal operator (<>)
- Equal operator (=)

For example, the following code fragment tests whether string1 starts with a letter that occurs later in the alphabet than the starting letter of string2:

    string1 := "gastropod";
    string2 := "arachnid";
    IF string1 > string2
    THEN
        MESSAGE ("Out of alphabetical order ");
    ENDIF;

Use the following relational operators for comparisons of integers, strings, or markers:

- Greater than operator (>)
- Less than operator (<)
- Greater than or equal to operator (>=)
- Less than or equal to operator (<=)

When used with markers, these operators test whether one marker is closer to (or farther from) the top of the buffer than another marker. (If markers are in different buffers, they will return as false.) For example, the procedure in Example 4-3 uses relational operators to determine which half of the buffer the cursor is located in.

Example 4-3 Procedure That Uses Relational Operators on Markers

    PROCEDURE which_half

    LOCAL  number_lines,
           saved_mark;

    saved_mark := MARK (FREE_CURSOR);
    POSITION (BEGINNING_OF (CURRENT_BUFFER));
    number_lines := GET_INFO (current_buffer, "record_count");
    IF number_lines = 0
    THEN
        MESSAGE ("The current buffer is empty");
    ELSE
        MOVE_VERTICAL (number_lines/2);
          IF MARK (FREE_CURSOR) = saved_mark
          THEN
              MESSAGE ("You are at the middle of the buffer");
          ELSE
              IF MARK (FREE_CURSOR) < saved_mark
              THEN
                MESSAGE ("You are in the second half of the buffer");
              ELSE
                MESSAGE ("You are in the first half of the buffer");
              ENDIF;
          ENDIF;
    ENDIF;

    ENDPROCEDURE;

### 4.8.3 Pattern Expressions

A pattern expression consists of the pattern operators (+, &, |, @) combined with string constants, string variables, pattern variables, pattern procedures, pattern keywords, or parentheses. The following are valid pattern expressions:

    pat1 := LINE_BEGIN + SPAN ("0123456789") + ANY ("abc");

    pat2 := LINE_END + ("end"|"begin");

    pat3 := SCAN (';"!') + (NOTANY ("'") & LINE_END);

See Chapter 3 for more information on pattern expressions.

### 4.8.4 Boolean Expressions

DECTPU performs bitwise logical operations on Boolean expressions. This means that the logical operation is performed on the individual bits of the operands to produce the individual bits of the result. In the following example, the value of user_variable is set to 3.

    user_variable := 3 AND 7;

As another example, if user_var were %X7777 (30583), then you would use the following statement to set user_var to %x0077 (119):

    user_var := user_var AND %XFF

A true value in DECTPU is any odd integer; a false value is any even integer. Use the logical operators (AND, NOT, OR, XOR) to combine one or more expressions. DECTPU evaluates Boolean expressions enclosed in parentheses before other elements. The following example shows the use of parentheses to ensure that the Boolean expression is evaluated correctly:

    IF (X = 12) AND (y <> 40)
    THEN
      .
      .
      .
    ENDIF;

## 4.9 Reserved Words

Reserved words are words that are defined by DECTPU and that have a special meaning for the compiler.

DECTPU reserved words can be divided into the following categories:

- Keywords
- Built-in procedure names
- Predefined constants
- Declarations and statements

The following sections describe the categories of reserved words.

### 4.9.1 Keywords

Keywords are a DECTPU data type. They are reserved words that have special meaning to the compiler. You can redefine DECTPU keywords only in local declarations (local constants, local variables, and parameters in a parameter list). If you give a local constant, local variable, or parameter the same name as that of a keyword, the compiler issues a message notifying you that the local declaration or parameter temporarily supersedes the keyword. In such a circumstance, the keyword is said to be occluded. See Chapter 3 and the DEC Text Processing Utility Reference Manual for more information on keywords.

### 4.9.2 Built-In Procedure Names

The DECTPU language has many built-in procedures that perform functions such as screen management, key definition, text manipulation, and program execution. You can redefine DECTPU built-in procedures only in local declarations (local constants, local variables, and parameters in a parameter list). If you give a local constant, local variable, or parameter the same name as that of a built-in procedure, the compiler issues a message notifying you that the local declaration or parameter temporarily supersedes the built-in. In such a circumstance, the built-in is said to be occluded. See the DEC Text Processing Utility Reference Manual for a complete description of the DECTPU built-in procedures.

### 4.9.3 Predefined Constants

The following is a list of predefined global constants that DECTPU sets up. You cannot redefine these constants.

- FALSE
- TPU$K_ALT_MODIFIED
- TPU$K_CTRL_MODIFIED
- TPU$K_HELP_MODIFIED
- TPU$K_MESSAGE_FACILITY
- TPU$K_MESSAGE_ID
- TPU$K_MESSAGE_SEVERITY
- TPU$K_MESSAGE_TEXT
- TPU$K_SEARCH_CASE
- TPU$K_SEARCH_DIACRITICAL
- TPU$K_SHIFT_MODIFIED
- TPU$K_UNSPECIFIED
- TRUE

Previous | Next | Contents | Index

| privacy and legal statement |
6018PRO_007.HTML