Content      ..     17      18      19      20     ..

High Level Assembler for z/OS & z/VM & z/VSE. Language Reference (Version 1 Release 6) - page 19

Table 56. Assembler instructions

Type of Instruction

Instruction

Page No.

Establishing SET symbols

GBLA

“GBLA,

GBLB, and

GBLC

instructions”

on page 345

GBLB

“GBLA,

GBLB, and

GBLC

instructions”

on page 345

GBLC

“GBLA,

GBLB, and

GBLC

instructions”

on page 345

LCLA

“LCLA,

LCLB, and

LCLC

instructions”

on page 347

LCLB

“LCLA,

LCLB, and

LCLC

instructions”

on page 347

LCLC

“LCLA,

LCLB, and

LCLC

instructions”

on page 347

SETA

“SETA

instruction”

on page 355

SETB

“SETB

instruction”

on page 369

SETC

“SETC

instruction”

on page 375

Branching

ACTR

“ACTR

instruction”

on page 400

AGO

“AGO

instruction”

on page 399

AIF

“AIF

instruction”

on page 396

ANOP

“ANOP

instruction”

on page 401

344

HLASM V1R6 Language Reference

Table 56. Assembler instructions (continued)

Type of Instruction

Instruction

Page No.

External Function Calling

SETAF

“SETAF

instruction”

on page 394

SETCF

“SETCF

instruction”

on page 395

Declaring SET symbols

You must declare a global SET symbol before you can use it. The assembler assigns

an initial value to a global SET symbol at its first point of declaration.

Local SET symbols need not be declared explicitly with LCLA, LCLB, or LCLC

statements. The assembler considers any undeclared variable symbol found in the

name field of a SETA, SETB, SETC, SETAF, or SETCF statement to be a local SET

symbol. It is given the initial value specified in the operand field. If the symbol in

the name field is subscripted, it is declared as a subscripted SET symbol.

GBLA, GBLB, and GBLC instructions

Use the GBLA, GBLB, and GBLC instructions to declare the global SETA, SETB,

and SETC symbols you need. The SETA, SETB, and SETC symbols are assigned the

initial values of 0, 0, and null character string.

,

▼

►►

GBLA

variable_symbol

►◄

sequence_symbol

GBLB

GBLC

sequence_symbol

Is a sequence symbol.

variable_symbol

Is a variable symbol, with or without the leading ampersand (&).

These instructions can be used anywhere in the body of a macro definition or in

the open code portion of a source module.

Any variable symbols declared in the operand field have a global scope. They can

be used as SET symbols anywhere after the pertinent GBLA, GBLB, or GBLC

instructions. However, they can be used only within those parts of a program in

which they have been declared as global SET symbols; that is, in any macro

definition and in open code.

The assembler assigns an initial value to the SET symbol only when it processes

the first GBLA, GBLB, or GBLC instruction in which the symbol appears. Later

GBLA, GBLB, or GBLC instructions do not reassign an initial value to the SET

symbol.

Chapter 9. How to write conditional assembly instructions

345

Multiple GBLx statements can declare the same variable symbol so long as only

one declaration for a given symbol is encountered during the expansion of a

macro.

The following rules apply to the global SET variable symbol:

v Within a macro definition, it must not be the same as any symbolic parameter

declared in the prototype statement.

v It must not be the same as any local variable symbol declared within the same

local scope.

v The same variable symbol must not be declared or used as two different types of

global SET symbol; for example, as a SETA or SETB symbol.

v Do not begin a global SET symbol with &SYS, because these characters are used

for system variable symbols.

v If the variable symbol is the same as the character value, the assembler considers

the variable symbol to be an implicitly defined local SETC symbol which is

given a null character string value. For example: &C6

SETC

’&C6’

,

assigns the value ’’ to &C6.

Subscripted global SET symbols

A global subscripted SET symbol is declared by the GBLA, GBLB, or GBLC

instruction.

,

▼

►►

GBLA

variable_symbol(dimension)

►◄

sequence_symbol

GBLB

GBLC

sequence_symbol

Is a sequence symbol.

variable_symbol

Is a variable symbol, with or without the leading ampersand (&).

dimension

Is the dimension of the array. It must be an unsigned, decimal, self-defining

term greater than zero.

Example:

GBLA

&GA(25),&GA1(15)

There is no limit on the maximum subscript allowed, except that each subscripted

variable is allocated storage, so the maximum subscript can be limited by the

amount of storage available. Also, the limit specified in the global declaration

(GBLx) can be exceeded. The dimension shows the number of SET variables

associated with the subscripted SET symbol. The assembler assigns an initial value

to every variable in the array thus declared.

Notes:

1. Global arrays are assigned initial values only by the first global declaration

processed, in which a global subscripted SET symbol appears.

346

HLASM V1R6 Language Reference

2. A subscripted global SET symbol can be used only if the declaration has a

subscript, which represents a dimension; an unsubscripted global SET symbol

can be used only if the declaration had no subscript, except for a number

attribute reference to the name of a dimensioned SET symbol.

Alternative format for GBLx statements

The assembler permits the alternative statement format for GBLx instructions:

Cont.

GBLA

&GLOBAL_SYMBOL_FOR_DC_GEN,

X

&LOOP_CONTRL_A,

X

&VALUE_PASSED_TO_FIDO,

X

&VALUE_RETURNED_FROM_FIDO

LCLA, LCLB, and LCLC instructions

Use the LCLA, LCLB, and LCLC instructions to declare the local SETA, SETB, and

SETC symbols you need. The SETA, SETB, and SETC symbols are assigned the

initial values of 0, 0, and null character string.

,

►►

LCLA

▼

variable_symbol

►◄

sequence_symbol

LCLB

LCLC

sequence_symbol

Is a sequence symbol.

variable_symbol

Is a variable symbol, with or without the leading ampersand (&).

These instructions can be used anywhere in the body of a macro definition or in

the open code portion of a source module.

Any variable symbols declared in the operand field have a local scope. They can

be used as SET symbols anywhere after the pertinent LCLA, LCLB, or LCLC

instructions, but only within the declared local scope. Multiple LCLx statements

can declare the same variable symbol so long as only one declaration for a given

symbol is encountered during the expansion of a macro.

The following rules apply to a local SET variable symbol:

v Within a macro definition, it must not be the same as any symbolic parameter

declared in the prototype statement.

v It must not be the same as any global variable symbol declared within the same

local scope.

v The same variable symbol must not be declared or used as two different types of

SET symbols; for example, as a SETA and a SETB symbol, within the same local

scope.

v Do not begin a local SET symbol with &SYS, because these characters are used

for system variable symbols.

Chapter 9. How to write conditional assembly instructions

347

Subscripted local SET symbols

A local subscripted SET symbol is declared by the LCLA, LCLB, or LCLC

instruction.

,

▼

►►

LCLA

variable_symbol(dimension)

►◄

sequence_symbol

LCLB

LCLC

sequence_symbol

Is a sequence symbol.

variable_symbol

Is a variable symbol, with or without the leading ampersand (&).

dimension

Is the dimension of the array. It must be an unsigned, decimal, self-defining

term greater than zero.

Example:

LCLB

&B(10)

There is no limit to SET symbol dimensioning other than storage availability. The

limit specified in the explicit (LCLx) or implicit (SETx) declaration can also be

exceeded by later SETx statements. The dimension shows the number of SET

variables associated with the subscripted SET symbol. The assembler assigns an

initial value to every variable in the array thus declared.

Subscripted local SET symbol: A subscripted local SET symbol can be used only

if the declaration has a subscript, which represents a dimension; an unsubscripted

local SET symbol can be used only if the declaration had no subscript, except for a

number attribute reference to the dimensioned SET symbol.

Alternative format for LCLx statements

The assembler permits an alternative statement format for LCLx instructions:

Cont.

LCLA

&LOCAL_SYMBOL_FOR_DC_GEN,

X

&COUNTER_FOR_INNER_LOOP,

X

&COUNTER_FOR_OUTER_LOOP,

X

&COUNTER_FOR_TRAILING_LOOP

Assigning values to SET symbols

You can assign values to SET symbols by using the SETA, SETB, SETC, SETAF, and

SETCF instructions (SETx). You can also use these instructions to implicitly define

local SET symbols. Local SET symbols need not be declared explicitly with LCLA,

LCLB, or LCLC statements. The assembler considers any undeclared variable

symbol found in the name field of a SETx statement to be a local SET symbol. It is

given the initial value specified in the operand field of SETA, SETB, and SETC

instructions, and the value returned from the external function specified in the

operand of SETAF and SETCF instructions. If the symbol in the name field is

subscripted, it is declared as a subscripted SET symbol.

348

HLASM V1R6 Language Reference

Spaces do not terminate the operand field when used in logical expressions and in

built-in functions. For more information, see “Logical (SETB) expressions” on page

372.

Introducing Built-In Functions

The assembler provides built-in functions for the SETA, SETB, and SETC

expressions.

Each function returns one value - an arithmetic value for SETA, a binary bit for

SETB, and a character string for SETC.

There are two different forms of invocation for the built-in functions:

v The logical-expression format encloses the function and operands in

parentheses. In the unary format, the function is followed by the one operand.

In the binary format, the function is placed between the two operands. For both

unary and binary formats, the function is separated from the operand or

operands by spaces.

Logical-expression unary format

►►

(built-in_function operand)

►◄

Logical-expression binary format

►►

(operand built-in_function operand)

►◄

(A OR B) and (&J SLL 2) are examples of binary logical-expression format

functions, and (NOT C) and (SIGNED &J) are examples of unary

logical-expression format functions.

v The function-invocation format has the function first, followed by one or more

operands in parentheses.

Function-invocation format

►► built-in_function(operand

)

►◄

▼

, operand

FIND(’abcde’,’d’) is an example of a function-invocation format. (The

equivalent logical-expression format is (’abcde’ FIND ’d’).)

Spaces are not allowed between the arguments of functions in

function-invocation format.

Chapter 9. How to write conditional assembly instructions

349

In either format, the operand is an expression of the type expected by the built-in

function. (The particular details of the number of operands and the operand type

are provided with the information for each built-in function.)

Conditional-assembly functions do not always behave like functions in traditional

high-level languages. The results of a function might not be automatically

converted to the type expected in the invoking expression, and nested invocations

might not produce expected results. In general, it is safest to invoke only one

conditional assembly function in a SET expression or AIF statement.

Some functions are available in one format, some are available in both. Table 57,

which provides a summary of all the built-in functions, shows the forms in which

a function is available.

Because some function names such as AND and OR are used both as arithmetic

operators and as logical connectives, their use might appear to be ambiguous. For

example, the function (1 AND 2) in an arithmetic expression is interpreted as the

logical AND of the two 32 bit SETA expressions 1 and 2, resulting in zero. In a

logical expression, the two nonzero operands are converted to 1 (meaning "true")

and the result is 1. Similarly, the function (1 XOR 2) in an arithmetic expression

has value 3, while in a logical expression it has value 0.

To avoid ambiguities, such function names are interpreted as arithmetic operators

in SETA statements, and as logical operators in SETB and AIF statements.

Table 57. Summary of Built-In Functions and Operators

Function

Type

L-E¹

F-I²

Result³

Operands³

Page

A2B

Representation conversion

U

C

A

“Character-

valued

built-in

functions”

on page 381

A2C

Representation conversion

U

C

A

“Character-

valued

built-in

functions”

on page 381

A2D

Representation conversion

U

C

A

“Character-

valued

built-in

functions”

on page 381

A2X

Representation conversion

U

C

A

“Character-

valued

built-in

functions”

on page 381

AND

Logical

U

A

A

“Arithmetic

(SETA)

expressions”

on page

359

350

HLASM V1R6 Language Reference

┌───────────┐

│

│

│Arithmetic │

│Expression │

│

│

!─────┬─────┘

│

⌂ Can be any of

├────────────┬───────────┬────────────────────┬──────────┐

⌂

⌂

⌂

⌂

⌂

┌─────┴─────┐ ┌────┴────┐ ┌────┴──────────────┐ ┌───┴────┐

───┴────┐

│Arithmetic │ │ (Arith. │ │ Arithmetic-Valued │ │+Arith. │ │-Arith. │

│Term

│ │ Exp.)

│ │ Built-in Function │ │⌂ Exp. │ │⌂ Exp. │

!─────┬─────┘ !─────────┘ !───────────────────┘ !┼───────┘ !┼───────┘

│

!────┬─────┘

⌂ Can be any of

│

├─────────────┬─────────────┬─────────────┐

unary operators

⌂

⌂

⌂

⌂

┌─────┴─────┐ ┌─────┴─────┐ ┌─────┴─────┐ ┌─────┴─────┐

│

│ │Predefined │ │ Self-

│ │

│

│ Variable

│ │Absolute

│ │ Defining

│ │ Attribute │

│ Symbol

│ │Ordinary

│ │ Term

│ │ Reference │

│

│ │Symbol

│ │

│ │

│

Operators Allowed

!───────────┘ !───────────┘ !───────────┘ !─────┬─────┘

│

Unary:

+ Positive

│

- Negative

│ Can

⌂ only be Binary: + Addition

┌─────┴─────┐

- Subtraction

│ Length

│

* Multiplication

│ Scale

│

/ Division

│ Integer

│

│ Count

│

Arith. Exp. = Arithmetic Expression

│ Number

│

│ Defined

│

!───────────┘

Figure 47. Defining arithmetic (SETA) expressions

Table 58 shows the variable symbols that are allowed as terms in an arithmetic

expression.

Table 58. Variable symbols allowed as terms in arithmetic expressions

Variable symbol

Restrictions

Example

Valid value

SETA

None

---

---

SETB

None

---

---

SETC

Value must evaluate to

123

123

an unsigned binary,

hexadecimal, or decimal

self-defining term

Symbolic parameters

Value must be a

&PARAM

X’A1’

self-defining term

&SUBLIST(3)

C’Z’

Corresponding operand

&SYSLIST(3)

24

&SYSLIST(n)

or sublist entry must be

a self-defining term

&SYSLIST(3,2)

B’101’

&SYSLIST(n,m)

Chapter 9. How to write conditional assembly instructions

357

Table 58. Variable symbols allowed as terms in arithmetic expressions (continued)

Variable symbol

Restrictions

Example

Valid value

None

---

---

&SYSDATC

&SYSM_HSEV

&SYSM_SEV

&SYSNDX

&SYSNEST

&SYSOPT_DBCS

&SYSOPT_RENT

&SYSOPT_XOBJECT

&SYSSTMT

The following example shows a SETA statement with a valid self-defining term in

its operand field:

&ASYM1

SETA C’D’

&ASYM1 has value 196 (C’D’)

The second statement in the following example is valid because in the two

positions in the SETA operand where a term is required (either side of the + sign),

the assembler finds a valid self-defining term:

&CSYM2

SETC

’C’’A’’’

&CSYM2 has value C’A’

&ASYM3

SETA

&CSYM2+&CSYM2

&ASYM3 has value 386 (C’A’ + C’A’)

If the variable symbol is the same as the character value, the assembler considers

the variable symbol to be an implicitly defined local SETA symbol, which is given

a value of zero. For example:

&ASYM2

SETA &ASYM2

&ASYM2 has a value 0.

A SET statement is not rescanned by the assembler to see if substitutions might

affect the originally determined syntax. The original syntax of the self-defining

term must be correct. Therefore the assembler does not construct a self-defining

term in a SETA statement. The third statement of the next example shows this:

&CSYM3

SETC

’3’

&CSYM has value 3 (C’3’)

&ASYM3

SETA

&CSYM3

&ASYM has value 3

&ASYM4

SETA

C’&ASYM3’

Invalid self-defining term

In this example C'&ASYM3' is not a valid term.

Subscripted SETA symbols

The SETA symbol in the name field can be subscripted. If the same SETA symbol

has not been previously declared in a GBLA or LCLA instruction with an allowable

dimension, or has not been implicitly declared in a SETA instruction as a scalar

(unsubscripted) variable symbol, then the symbol is implicitly declared as a local

SETA array variable.

The assembler assigns the value of the expression in the operand field to the

position in the declared array given by the value of the subscript. The subscript

expression must not be 0 or have a negative value.

358

HLASM V1R6 Language Reference

Arithmetic (SETA) expressions

Table 59 shows how arithmetic expressions can be used.

Table 59. Use of arithmetic expressions

Used in

Used as

Example

SETA instruction

Operand

&A1 SETA &A1+2

AIF or SETB instruction

Term in arithmetic AIF

(&A*10 GT 30).A

relation

Subscripted SET symbols

Subscript

&ASYM(&A+10-&C)

Substring notation

Subscript

’STRING’(&A*2,&A-1)

Sublist notation

Subscript

Given sublist (A,B,C,D)

named &PARAM,

if &A=1 then &PARAM(&A+1)=B

&SYSLIST

Subscript

&SYSLIST(&M+1,&N-2)

&SYSLIST(N’&SYSLIST)

SETC instruction

Character string in

operand

Given &C SETC

’5-10*&A’ ▌1▐

if &A=10 then

&C=5-10*10 ▌2▐

Given &D SETC

’5-10*&A’ ▌1▐

if &A=-10 then

&D=5-10*10▌3▐

Built-in functions

Operand

&VAR SETA

(NOT &OP1) &VAR SETA

BYTE(64)

When an arithmetic expression is used in the operand field of a SETC instruction

(see ▌1▐ in Table 59), the assembler assigns the character value representing the

arithmetic expression to the SETC symbol, after substituting values (see ▌2▐ in

Table 59) into any variable symbols. It does not evaluate the arithmetic expression.

The mathematical sign (+ or -) is not included in the substituted value of a variable

symbol (see ▌3▐ in Table 59), and any insignificant leading zeros are removed.

Here are the built-in functions for arithmetic (SETA) expressions:

AND

Format: Logical-expression

Operands: Arithmetic

Output: (aexpr1 AND aexpr2) provides an arithmetic result where each bit

position in the result is set to 1 if the corresponding bit positions in both

operands contain 1, otherwise, the result bit is set to 0.

Example

After the following statements &VAR contains the arithmetic value +2.

Name

Operation

Operand

&OP1

SETA

10

&OP2

SETA

2

&VAR

SETA

(&OP1 AND &OP2)

B2A

Chapter 9. How to write conditional assembly instructions

359

Content      ..     17      18      19      20     ..