Guide to the DEC Text Processing Utility

Document revision date: 19 July 1999

Guide to the DEC Text Processing Utility

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");

DIGITAL 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

**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

**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

Contents

Index

privacy and legal statement

6018PRO_007.HTML