At its very core a computer is capable

At its very core, a computer is capable of only performing 2 things: • ADD • COMPARE We have already discussed some of the arithmetic, let’s look at the logical operations

Compare Packed Decimal • Compare two packed decimal fields: – CP M 1(L 1), M 2(L 2) • Compare first field to second field • Set a condition code based on results – M 1(L 1) = M 2(L 2) – M 1(L 1) > M 2(L 2) – M 1(L 1) < M 2(L 2) • Then test the condition code • Maybe you remember that the condition code is located within the PSW

Condition Code • 4 bits located within the processor (PSW bits: 18 -19) Cond. Code PSW bits 18 & 19 M 1(L 1) = M 2(L 2) 1000 00 M 1(L 1) < M 2(L 2) 0100 01 M 1(L 1) > M 2(L 2) 0010 10 Not used --- 11

So How Do You Test CC? • Branch-on-Condition Instruction

So How Does It Work? • Compare Mask and CC • If corresponding bits are both 1, then Branch to address in Operand 2 • If corresponding bits are not 1, then fall through to the next instruction (don’t Branch) CP BC TC-HRS, 40 HRS 2, CALC-OT * or BH CALC-OT In the example, Time-Card Hours Worked is compared to 40 Hours. If Time-Card Hours is greater than 40 Hours, then Branch to Calculate Overtime Pay. If Time-Card Hours is not greater than 40, fall through to the instruction following the BC. Of course, the field names have also been defined … 40 HRS DC PL 2’ 40’ TC-HRS DS CL 2

Another Example FIELDA FIELDB 00 01 23 45 67 8 C CP BC BC BC 00 08 76 54 32 1 C FIELDA, FIELDB 8, SAME 4, LOWER 2, HIGHER LOWER Which Branch is taken? _______ (BE) (BL) (BH)

Now, that more or less takes care of COMPARE … Let’s Take a Look at the ADD side of a processor • Of course, it seems that a computer can do more than just ADD and COMPARE. There are instructions that let you Subtract, Multiply, and Divide as well. • However, the processor converts Subtract, Divide, and Multiply into an ADD, then performs the arithmetic. Multiply is simple: just perform addition of the values by the number of times of the multiplier. • Subtraction and Division are a little more complicated. First, the value being added needs to be converted into its twos-complement form, then the numbers are added (or for Division, added the number of times of the value of the divisor. • All of this has very little importance to us.

Packed Decimal Numbers • Manipulating numbers in their decimal format is generally used for those numbers that are read into memory from an external source. These values are always read-in in their zoned-decimal format. They are characters: a single byte per character. The numbers appear as a string of characters, such as ‘F 1 F 2 F 3 F 4 F 5 F 6 F 7 F 8 F 9 F 0’. • These numbers are characters and, therefore, cannot be manipulated. • They must be converted from zoned-decimal to packed-decimal. They would appear without their zone character ‘ 1234567890 F’ or ‘ 1234567890 C’ in memory. To accomplish this necessary change in the look of the numbers, use the PACK instruction, such as: PACKNO, ZONENO

PACK Instruction In machine format, PACK is an SS-type instruction (memory-to-memory) ‘F 2’ is the op-code and is 1 byte in length. L 1 and L 2 represent the length (in bytes) of each of the operands in memory. They do not need to be the same length. Each pair of B 1 D 1 and B 2 D 2 are the two memory locations. In the PACK instruction example on the prior slide, B 1 D 1 is the PACKNO field and B 2 D 2 is the ZONENO field. When executed, the format of the B 2 D 2 (ZONENO) operand is changed from zoned to packed, and the result is placed in the B 1 D 1 (PACKNO) operand.

PACK Instruction As the zoned value of the B 2 D 2 operand is converted to packed, the numeric bits of each byte are treated as a digit and the zoned bits are ignored, except the zoned bits in the rightmost byte, which are treated as a sign. The sign and digits are moved unchanged to the first operand are not checked for validity. If the B 1 D 1 field is larger than needed, zeros will pad to the left. If B 1 D 1 is too small, truncation takes place on the left. Assume, in the prior slide’s example, that ZONENO is 8 bytes and PACKNO is 6 bytes. (PACKNO, ZONENO) PACKNO ZONENO DS DC ZONENO Contents: CL 6 CL 8’ 24681357’ ‘F 2 F 4 F 6 F 8 F 1 F 3 F 5 F 7’

When the PACK instruction has executed … PACKNO, ZONENO Before PACKNO n/a ZONENO F 2 F 4 F 6 F 8 F 1 F 3 F 5 F 7 After 00002468135 C F 2 F 4 F 6 F 8 F 1 F 3 F 5 F 7 The result of the instruction’s execution is the 6 -bytes (padded with zeros) that you can now use for decimal arithmetic. The right-most character (‘C’) is the positive sign character (it may also be ‘F’). The character ‘D’ identifies a negative value. You need to be careful in determining the proper length for the B 1 D 1 operand. Note: PACK does not set the cond. Code.

ADD packed decimal numbers The second operand (B 2 D 2) is added to the first operand (B 1 D 1), and the resulting sum is place at the first operand location. Operands are in packed-decimal format before and after execution. The addition is algebraic and takes into account the value of the sign bits. If the first operand is too short to contain the sum, a decimal overflow occurs (cond. code = 3). If B 1 D 1 is longer than the length needed, padding is done with leading zeros. Example on the next slide

Add Packed Instruction Example Assume that the sign, packed-decimal number at location ADDER (4 bytes) is to be added to the signed, packed-decimal number at location ADDEND (3 bytes). For this example, also assume that R 12 points to ADDEND and R 13 points to ADDED. ADDER Before After AP AP ADDEND 01 12 34 5 C 38 46 0 D 73 88 5 C 38 46 0 D ADDEND(3), ADDER(4) - or – 0(3, 12), 0(4, 13) Note that the signs are different. In effect, the values are subtracted. There is no overflow since the sum fits in the first operand location. Condition code is set to 2: result is greater than 0.

Zero and Add Pack Instruction (ZAP) The second operand is placed at the first operand location. This is the equivalent of an add to zero. All operands are in packed decimal format. The condition code is set: 0 = result is zero, 1 = result is negative, 2 = result is positive, 3 = overflow. Examples follow a little later is this slide presentation.

Subtract Packed Instruction Subtract is very similar to Add, except that the result is different. The second operand (B 2 D 2) is subtracted from the first operand (B 1 D 1) and the resulting difference is placed at the first-operand location (B 1 D 1). The operands and results are in packed-decimal format. Example on the next slide

Subtract Packed Instruction Example 00303 C FB 21 404 A 4048 003042 FB 11 4048 003048 123 C 00304 A 04567 C 25 SUBTR 1 26 SUBTR 2 * 28 P 1 29 P 2 SP SP : DC DC P 2, P 1, P 1 P 2= 04 44 4 C P 1= 00 0 C P’ 123’ P’ 4567’ P 1= 12 3 C P 2= 04 56 7 C SUBTR 2 clears a field to zeros. Subtracting a field from itself, as in SUBTR 2, is more efficient but requires valid packed data in operand 1. SP sets the condition code: 0 = result is 0, 1 = result is negative, 2 = result is positive, 3 = result overflow.

Multiply Packed Instruction The product of the first operand (multiplicand) and the second operand (multiplier) is placed at the first operand location. All operands are in packed decimal format. The multiplier length cannot exceed 15 digits (L 2 cannot be greater than 7) and must be less length than the multiplicand. The multiplicand must have at least as many bytes of leftmost zeros as the total number of bytes in the multiplier, otherwise the product will not fit when the instruction has executed. All values are packed decimal and the condition code is not set.

Multiply Packed Example * MULTPLD MULTPLR PRODUCT ZAP MP : DC DC DS PRODUCT, MULTPLD PRODUCT, MULTPLR 00 00 12 34 56 0 C 01 17 28 32 00 0 C PL 4’ 1234560’ PL 2’ 950’ PL 6 Recall that the ZAP instruction is like a Move, moving the second operand to the first operand assuming both fields are formatted as packed decimal. To the right of the two instructions (as comments) you can see the value of PRODUCT after each instruction executes. PRODUCT is defined as 6 bytes (the sum byte count of MULTPLR and MULTPLD lengths.

Another Multiply Packed Instruction Example 50 51 52 53 54 55 56 57 58 * * * HRS RATE WAGE MULTIPLY, GENERATE 3 DECIMALS, ROUND: ------------------ZAP WAGE, HRS 00 00 01 20 5 C MP WAGE, RATE 00 10 30 27 5 C SRP WAGE, 63. 5 00 01 03 02 8 C : DC P’ 120. 5’ 01 20 5 C DC P’ 8. 55’ 85 5 C DS PL 5 MULTIPLY SHIFT/ROUND This example multiplies a 3 -byte field, HRS, by a 2 -byte field, RATE. The product, WAGE, is therefore defined as 5 bytes in length. Since HRS has one decimal and RATE has 2, the generated product has three implied decimal places. Because only two decimal places are required for dollars and cents, the unwanted rightmost digit is rounded. A Shift and Round Packed instruction (SRP) shifts the product one digit to the right, leaving two decimal places. To the right of the instructions, appearing as comments is the value of WAGE after each instruction executes.

Divide Packed Decimal Instruction Aren’t all these packed-decimal instructions beginning to look alike? Unfortunately the Divide instruction is a little more complicated than the others. The first operand (B 1 D 1), which is the dividend, is divided by the second operand (B 2 D 2) and divisor. The resulting quotient and remainder are placed at the first operand location. All values must be packed decimal format. The quotient is placed in the leftmost portion of the first operand. The number of bytes in the quotient is equal to the difference between the dividend and divisor lengths (L 1 -L 2). The remainder is placed in the rightmost portion of the same operand is the same length as the divisor. The condition code is not changed.

A Typical Decimal Divide Instruction Example * DIVDND DIVSOR RESULT ZAP DP : DS DS DS RESULT, DIVDND RESULT, DIVSOR PL 4 PL 1 PL 5 Dividend Divisor Quotient/Remainder In the typical situation, you do not know the values that are to be divided, so you plan for all possible situations. Divide by zero is not allowed, so your program will be abnormally terminated. The next worst case is when the divisor is one. This means that the quotient will equal (and cannot exceed) the value of the dividend. 1234567 / 1 = 1234567 Dividend Divisor Quotient = Dividend

A Typical Decimal Divide Instruction Example A convention is to provide the length of the quotient equal at least to that of the dividend. In addition, the length of the remainder always equals that of the divisor. Therefore, you should define the operand 1 field to be a length of at least the dividend plus the divisor. The result will be padded to the left with leading zeros. Here is a more realistic example: * DIVDND DIVSOR RESULT ZAP DP : DC DC DS RESULT, DIVDND RESULT, DIVSOR 00 12 34 56 7 C 04 11 52 2 C 1 C PL 4’ 1234567’ PL 1’ 3’ PL 5 Dividend Divisor Quotient/Remainder Since DIVDND contains 4 bytes and DIVSOR contains 1 byte, RESULT should contain at least 5 bytes, although it may be longer. The ZPA instruction initializes the dividend in RESULT. After the DP, the first 4 bytes of RESULT contain the quotient, with its sign, and the fifth byte contains the remainder, with its sign. The reaminder is 1 byte, the same length as the divisor.

Now that the decimal arithmetic is done, what’s next? Many times you have to provide for an implied decimal point, so you can use the following rule: The number of decimal places in a quotient equals the number in the dividend minus the number in the divisor. For example, if the dividend contains four decimal places, and the divisor contains one, then the quotient has three: dividend divisor xx. xxxx x. x = xx. xxx quotient

And finally ? … UNPK Now that all the decimal arithmetic is done in our program, we have a result that is a packed decimal number. This number is not printable since it is not character numbers. So we need to convert the packed-decimal numbers to zoned-decimal numbers. For this, use the UNPK (unpack) instruction. UNPK is pretty much the opposite of the PACK instruction. The format of the second operand (B 2 D 2) is changed from packed to zoned, and the result is placed at the first-operand location. Signs are placed in the first-operand location unchanged. Zone bits with ‘ 1111’ are supplied for all bytes except the rightmost byte which is the sign. Padding takes place to the left, truncation also takes place on the left. The condition code remains unchanged.

UNPK instruction example ZONED, PACKED * PACKED UNPK : DC ZONED DS ZL 5 PL 3’ 12345’ 12 34 5 C F 1 F 2 F 3 F 4 C 5 On the right, UNPK reverses the PACKed sign ‘C’ and the digit ‘ 5’ in the receiving ZONEd field. All other digits are placed in the receiving filed with a zone of ‘F’. Now the receiving field is printable (except for the rightmost byte). To take care of the rightmost byte, you can use something like the OI (Or Immediate) instruction to change the sign field in the receiving field to an ‘F’. For the ZONED field above, this would appear as: OI ZONED+4, ’F 0’ The rightmost byte now is changed to ‘F 5’ and will print as the digit 5.

Input/Output Operations Connecting to external data (see page 90)

Several Requirements • A file or data set (on a device) • An area of memory describing the data file being used (DCB) • The file must be “connected” to the program using it (OPEN/CLOSE) • An area in memory to stage the records being read or written (buffer) – usually defined by Define Storage (DS) and probably subdivided: BUFFER DS 0 CL 80

Input/Output Operations OPEN identifies the DCB that describes the file being OPEN’d. To retrieve a record from the OPEN file, issue GET. Get identifies the DCB (GET from which file…) and identifies the buffer into which to GET the record. OPEN GET DCB 1, INPUT ---DCB 1, DATA 1 Start STM OPEN : :

Order of an I/O Operation • • Input file is available Program OPEN’s the file – completes filling in DCB Read (GET) the first record O/S performs the request while program waits Program is notified that operation has completed – I/O Interrupt Program processes the record Program loops through reading the records from the file CLOSE the file when done – DCB EODAD=eof-rtn entry pt.

AND In the Program eofrtn OPEN dcbname : GET dcbname, inarea : B NXTREC CLOSE dcbname inarea dcbname DS DCB NXTREC CLnn LRECL=nn, RECFM=F, MACRF=G, EODAD=eofrtn, DDNAME=filename

Output Operation Example NXTREC OPEN dcbname : PUT dcbname, outarea : B NXTREC CLOSE dcbname outarea dcbname DS DCB CLnn LRECL=nn, RECFM=F, MACRF=G, DDNAME=filename There is no EODAD= parameter for an output DCB since an end-of-file condition doesn’t occur on output files.

NOTE: When using PC/370 Emulator • PC sees data as ASCII • Mainframe sees data as EBCDIC • Data needs to appear on your PC as though it is mainframe data • So … – Before every OPEN, modify the DCB by coding: OI dcbname+10, X’ 08’ so PC sees data as EBCDIC

BEGIN *** LOOP *** INDCB OUTDCB *** INBUFF EMP# EMPNAME OUTBUFF START REGS : OPEN FILES OI INDCB+10, X’ 08’ OPEN INDCB, INPUT OI OUTDCB+10, X’ 08’ OPEN OUTDCB, OUTPUT : GET INDCB, INBUFF ADD and more … PUT OUTDCB, OUTBUFF B LOOP DEFINE FILES DCB LREC=80, RECFM=F, EODAD=EOFRTN … DCB LREC=80, RECFM=F, MACRF=P … DEFINE BUFFERS DS 0 CL 80 DS CL 6 DS CL 1 DS CL 20 : DC CL 80’ ‘ * 80 blanks :

SAMPLE WORKING PROGRAM WITH I/O *** READ INPUT & WRITE OUTPUT TO FILE START 0 * REGS BEGIN **** OPEN FILES OI INDCB+10, X'08' OPEN INDCB, INPUT OI OUTDCB+10, X'08' OPEN OUTDCB, OUTPUT * : LOOP GET INDCB, INBUFF MVC OUTBUFF, INBUFF * and more … PUT OUTDCB, OUTBUFF WTO OUTBUFF B LOOP EOFRTN CLOSE INDCB CLOSE OUTDCB RETURN *** DEFINE FILES *********-*********-*********-*****-** INDCB RECFM=F, EODAD=EOFRTN, DDNAME=F: TESTNAMES. TXT, X DSORG=S, MACRF=G, LRECL=29 OUTDCB RECFM=FB, MACRF=P, DSORG=S, LRECL=29, X DDNAME=F: TESTNAMES 1. TXT *** DEFINE BUFFERS INBUFF DS 0 CL 27 EMP# DS CL 6 DS CL 1 EMPNAME DS CL 20 OUTBUFF DC CL 27' ' * 27 blanks CARRCTRL DC XL 2'0 D 25' END BEGIN

Assemble the program Console Output of Sample Working Program Linkage Editor step execution Execute the program step followed by the console output from the WTO in the program.