COMPILATION LISTING OF SEGMENT cobol_add2_binary_long Compiled by: Multics PL/I Compiler, Release 31b, of April 24, 1989 Compiled at: Bull HN, Phoenix AZ, System-M Compiled on: 05/24/89 1031.4 mst Wed Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) BULL HN Information Systems Inc., 1989 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 13 14 15 /****^ HISTORY COMMENTS: 16* 1) change(89-04-23,Zimmerman), approve(89-04-23,MCR8060), 17* audit(89-05-05,RWaters), install(89-05-24,MR12.3-1048): 18* MCR8060 cobol_add2_binary_long.pl1 Added Trace statements. 19* END HISTORY COMMENTS */ 20 21 22 /* Modified on 10/19/84 by FCH, [5.3-1], BUG563, new cobol_addr_tokens.incl.pl1 */ 23 /* Modified on 08/31/83 by FCH, [5.2...], trace added */ 24 /* Modified on 09/03/80 by FCH, [4.4-1], ADD a TO b generates bad code, BUG442(TR7483) */ 25 /* Modified on 1/19/77 by Bob Chang to improve the code for add 1 to comp-6 data. */ 26 /* Modified on 01/17/77 by ORN to call cobol_make_reg_token instead of cobol_make_register_token */ 27 /* Modified since Version 2.0 */ 28 29 /*{*/ 30 /* format: style3 */ 31 cobol_add2_binary_long: 32 proc (lop_token_ptr, rop_token_ptr, result_token_ptr, operation_code); 33 /***..... if Trace_Bit then call cobol_gen_driver_$Tr_Beg(MY_NAME);/**/ 34 /* 35*This procedure generates code to add or subtract two 36*binary operands using register instructions. The operands 37*can be short or long binary data items or constants. 38**/ 39 40 /* DECLARATION OF THE PARAMETERS */ 41 42 dcl lop_token_ptr ptr; 43 dcl rop_token_ptr ptr; 44 dcl result_token_ptr ptr; 45 dcl operation_code fixed bin; 46 47 /* DESCRIPTION OF THE PARAMETERS */ 48 49 /* 50*PARAMETER DESCRIPTION 51* 52*lop_token_ptr Pointer to the token that describes the left 53* operand (augend or minuend) of the 54* operation to be performed. (input) 55*rop_token_ptr Pointer to the token that describes the 56* right operand (addend or subtrahend) of the 57* operation to be performed. (input) 58*result_token_ptr Pointer to a register token (type 100) 59* that describes the register that contains 60* the result (sum or difference) of the 61* operation. If this pointer is null() on entry, 62* then a buffer in which this token is created 63* is supplied by this procedure. Otherwise 64* it must point to a work buffer in which 65* the token is to be built. 66*operation_code a code that indicates the type of arithmetic 67* operation to be performed. (input) The 68* code is defined in the following table: 69* 70* operation_code | meaning 71* =================================== 72* 1 | addition 73* 2 | subtraction 74* 75**/ 76 77 /* DECLARATION OF EXTERNAL ENTRIES */ 78 79 dcl cobol_register$load ext entry (ptr); 80 dcl cobol_make_reg_token 81 ext entry (ptr, bit (4)); 82 dcl cobol_short_to_longbin$temp 83 ext entry (ptr, ptr); 84 dcl cobol_short_to_longbin$register 85 ext entry (ptr, ptr); 86 dcl cobol_addr ext entry (ptr, ptr, ptr); 87 dcl cobol_emit ext entry (ptr, ptr, fixed bin); 88 dcl cobol_make_bin_const 89 ext entry (ptr, ptr, fixed bin); 90 dcl cobol_alloc$stack ext entry (fixed bin, fixed bin, fixed bin (24)); 91 dcl cobol_make_type9$long_bin 92 ext entry (ptr, fixed bin, fixed bin (24)); 93 dcl cobol_store_binary ext entry (ptr, ptr, bit (1)); 94 95 /* DECLARATION OF INTERNAL STATIC VARIABLES */ 96 97 98 99 /* DECLARATION OF INTERNAL STATIC DATA */ 100 101 dcl LDA bit (10) int static init ("0100111010"b); 102 /* LDA */ 103 dcl LDQ bit (10) int static init ("0100111100"b); 104 /* LDQ */ 105 dcl ADA bit (10) int static init ("0001111010"b); 106 /* ADA */ 107 dcl ADQ bit (10) int static init ("0001111100"b); 108 /* ADQ */ 109 dcl SBA bit (10) int static init ("0011111010"b); 110 /* SBA */ 111 dcl SBQ bit (10) int static init ("0011111100"b); 112 /* SBQ */ 113 114 dcl direct_lower_inst bit (36) int static init ("000000000000000000000000000000000111"b); 115 /* zero,dl */ 116 117 118 /* DECLARATION OF INTERNAL VARIABLES */ 119 120 dcl 1 input_buff aligned, 121 2 buff (1:10) ptr; 122 123 dcl 1 inst_buff aligned, 124 2 buff (1:2) fixed bin; 125 126 dcl 1 reloc_buff aligned, 127 2 buff (1:10) bit (5) aligned; 128 129 dcl temp_lop_token_ptr ptr; 130 dcl temp_rop_token_ptr ptr; 131 dcl ret_offset fixed bin (24); 132 dcl temp_op bit (10); 133 dcl temp_ptr ptr; 134 dcl call_again bit (1); 135 dcl cont_bit bit (1); 136 dcl (i, j) fixed bin; 137 138 dcl dn_ptr ptr; 139 140 141 dcl 1 register_struc, 142 2 what_reg fixed bin, 143 2 reg_no bit (4), 144 2 lock fixed bin, 145 2 already_there fixed bin, 146 2 contains fixed bin, 147 2 tok_ptr ptr, 148 2 literal bit (36); 149 150 151 152 start: 153 input_ptr = addr (input_buff); 154 inst_ptr = addr (inst_buff); 155 reloc_ptr = addr (reloc_buff); 156 157 /* Check to see if either operand is a constant token (type 2), and 158* if so, convert to an immediate constant token or pooled long binary. */ 159 160 if lop_token_ptr -> data_name.type = rtc_numlit 161 then do; /* Left operand is numeric literal. */ 162 163 temp_ptr = null (); 164 call cobol_make_bin_const (lop_token_ptr, temp_ptr, 2); 165 lop_token_ptr = temp_ptr; 166 167 end; /* Left operand is a numeric literal */ 168 169 if rop_token_ptr -> data_name.type = rtc_numlit 170 then do; /* Right operand is a numeric literal. */ 171 172 if (lop_token_ptr -> data_name.type = 9 & operation_code = 5 & lop_token_ptr -> data_name.bin_36 173 & rop_token_ptr -> numeric_lit.sign ^= "-") 174 then do; 175 176 cont_bit = "1"b; 177 j = rop_token_ptr -> numeric_lit.places_left + rop_token_ptr -> numeric_lit.places_right; 178 179 do i = 1 to j while (cont_bit); 180 if substr (rop_token_ptr -> numeric_lit.literal, i, 1) ^= "0" 181 then do; 182 183 184 if substr (rop_token_ptr -> numeric_lit.literal, i, 1) ^= "1" 185 | i ^= rop_token_ptr -> numeric_lit.places_left 186 then cont_bit = "0"b; 187 188 end; 189 190 end; 191 192 if cont_bit 193 then do; 194 195 if substr (rop_token_ptr -> numeric_lit.literal, 196 rop_token_ptr -> numeric_lit.places_left, 1) = "0" 197 then return; 198 input_struc.type = 2; 199 input_struc.operand_no = 1; 200 input_struc.lock = 0; 201 input_struc.token_ptr (1) = lop_token_ptr; 202 input_struc.size_sw (1) = 0; 203 call cobol_addr (input_ptr, inst_ptr, reloc_ptr); 204 inst_struc.fill1_op = "0001011000"b; 205 /* aos */ 206 call cobol_emit (inst_ptr, reloc_ptr, 1); 207 return; 208 209 end; 210 211 end; 212 213 temp_ptr = null (); 214 215 call cobol_make_bin_const (rop_token_ptr, temp_ptr, 2); 216 217 rop_token_ptr = temp_ptr; 218 219 end; /* Right operand is a numeric literal */ 220 221 222 /*[4.4-1]*/ 223 if operation_code = 5 224 then operation_code = 1; 225 else if operation_code = 6 226 then operation_code = 2; 227 228 if (operation_code = 2 /* subtract */ & rop_token_ptr -> data_name.type = rtc_dataname 229 & rop_token_ptr -> data_name.bin_18) 230 then do; /* Subtract operation, and subtrahend is a short binary. */ 231 232 temp_rop_token_ptr = null (); 233 call cobol_short_to_longbin$temp (rop_token_ptr, temp_rop_token_ptr); 234 temp_lop_token_ptr = lop_token_ptr; 235 236 end; /* Subtract operation, and subtrahend is a short binary. */ 237 238 else if (operation_code = 2 /* Subtract */ & rop_token_ptr -> data_name.type = rtc_register) 239 /* Subtract, subtrahend is in a register */ 240 | (lop_token_ptr -> data_name.type = rtc_register & rop_token_ptr -> data_name.type = rtc_register) 241 /* Both operands are in registers */ 242 then do; /* Store the right operand into a long binary te porary. */ 243 244 /* Allocate space on the stack, and build a data name token for it. */ 245 246 call cobol_alloc$stack (4, 0, ret_offset); 247 248 temp_rop_token_ptr = null (); 249 250 call cobol_make_type9$long_bin (temp_rop_token_ptr, 1000 /*stack*/, ret_offset); 251 252 /* Generate code to store the register into the temporary. */ 253 254 call cobol_store_binary (rop_token_ptr, temp_rop_token_ptr, call_again); 255 256 temp_lop_token_ptr = lop_token_ptr; 257 258 end; /* Store the right operand into a long binary temporary. */ 259 260 261 else if (rop_token_ptr -> data_name.type = rtc_dataname & rop_token_ptr -> data_name.bin_18) 262 & (lop_token_ptr -> data_name.type = rtc_dataname & lop_token_ptr -> data_name.bin_18) 263 then do; /* Both operands are short binary cobol data items. */ 264 265 /* Convert right operand to a long binary in a temporary. */ 266 267 temp_rop_token_ptr = null (); 268 269 call cobol_short_to_longbin$temp (rop_token_ptr, temp_rop_token_ptr); 270 271 temp_lop_token_ptr = lop_token_ptr; 272 273 end; /* Both operands are short binary cobol data items. */ 274 275 276 else if (rop_token_ptr -> data_name.type = rtc_register | lop_token_ptr -> data_name.type = rtc_register) 277 then do; /* Only one operand is in a register. */ 278 279 /* Make the left operand the register token. */ 280 281 if lop_token_ptr -> data_name.type = rtc_register 282 then do; /* Left operand pointer already points to the register token. */ 283 284 temp_lop_token_ptr = lop_token_ptr; 285 temp_rop_token_ptr = rop_token_ptr; 286 287 end; /* Left operand pointer already points to the register token. */ 288 289 else do; /* Must switch the operand pointers. */ 290 291 temp_lop_token_ptr = rop_token_ptr; 292 temp_rop_token_ptr = lop_token_ptr; 293 294 end; /* Must switch the operand pointers. */ 295 296 end; /* Only one opernad is in a register. */ 297 298 else if (rop_token_ptr -> data_name.type = rtc_dataname & rop_token_ptr -> data_name.bin_18) 299 then do; /* Right operand only is short binary cobol data item. */ 300 301 /* Switch operands, so that the right one is loaded into the register, 302* and the left one added to it. */ 303 304 temp_lop_token_ptr = rop_token_ptr; 305 temp_rop_token_ptr = lop_token_ptr; 306 307 end; /* Right operand only is a short binary cobol data item. */ 308 309 else do; /* None of the above special cases. */ 310 311 temp_lop_token_ptr = lop_token_ptr; 312 temp_rop_token_ptr = rop_token_ptr; 313 314 end; /* None of the above special cases. */ 315 316 /* Set up to call the addressability utility */ 317 318 input_struc.type = 2; 319 input_struc.operand_no = 1; 320 input_struc.lock = 0; 321 input_struc.operand.size_sw (1) = 0; 322 323 324 325 326 /* Generate code to load the A or Q, and add to or subtract from it. */ 327 328 if temp_lop_token_ptr -> data_name.type = rtc_register 329 then result_token_ptr = temp_lop_token_ptr; 330 else call load_register (temp_lop_token_ptr, result_token_ptr); 331 332 call op_to_register (temp_rop_token_ptr, result_token_ptr -> cobol_type100.register, operation_code); 333 /***..... if Trace_Bit then call cobol_gen_driver_$Tr_End(MY_NAME);/**/ 334 return; 335 336 337 338 load_register: 339 proc (operand_token_ptr, register_token_ptr); 340 341 /* 342*This procedure generates code to load a value into either the A 343*or Q register. 344**/ 345 346 /* DECLARATION OF THE PARAMETERS */ 347 348 dcl operand_token_ptr ptr; 349 dcl register_token_ptr ptr; 350 351 /* DESCRIPTION OF THE PARAMETERS */ 352 353 /* 354*PaRaMETER DEsCRIPTION 355* 356*operand_token_ptr Pointer to a token that describes the operand 357* to be loaded into the register. This token 358* can be on of the following types: 359* 1. data name token (type 9) for a short 360* or long binary data item. 361* 2. immediate constant token (type 102) 362*register_token_ptr Pointer to a register token (type 100) that 363* describes the register into which the operand 364* is loaded. If this pointer is null() on 365* entry, then space for the token is provided 366* to the user. Otherwise this pointer must 367* point to a work buffer in which the token 368* is to be built. 369**/ 370 371 372 373 /**************************************************/ 374 /* START OF EXECUTION */ 375 /* INTERNAL PROCEDURE: */ 376 /* load_register */ 377 /**************************************************/ 378 379 start_load_register: 380 if operand_token_ptr -> data_name.type = rtc_dataname 381 then do; /* Operand to be loaded is long or short binary cobol data item. */ 382 383 if operand_token_ptr -> data_name.bin_18 384 then /* Operand to be loaded is short binary. */ 385 call cobol_short_to_longbin$register (operand_token_ptr, register_token_ptr); 386 387 else do; /* Operand to be loaded is a long binary data item. */ 388 /* Establish addressability to the operand. */ 389 390 input_struc.operand.token_ptr (1) = operand_token_ptr; 391 392 call cobol_addr (input_ptr, inst_ptr, reloc_ptr); 393 394 /* Get the A or Q and locc it. */ 395 396 register_struc.what_reg = 4; /* A or Q */ 397 register_struc.lock = 1; /* lock it */ 398 register_struc.contains = 0; 399 400 call cobol_register$load (addr (register_struc)); 401 402 if register_struc.reg_no = "0001"b 403 /* A */ 404 then inst_struc_basic.fill1_op = LDA; 405 else inst_struc_basic.fill1_op = LDQ; 406 407 call cobol_emit (inst_ptr, reloc_ptr, 1); 408 409 call cobol_make_reg_token (register_token_ptr, register_struc.reg_no); 410 411 end; /* Operand to be loaded is a long binary data item. */ 412 413 414 end; /* Operand to be loaded is long or short binary cobol data item. */ 415 416 else do; /* Operand to be loaded is an immediate constant. */ 417 /* Get the A or Q, and lock it. */ 418 419 register_struc.what_reg = 4; /* A or Q */ 420 register_struc.lock = 1; 421 register_struc.contains = 0; 422 423 call cobol_register$load (addr (register_struc)); 424 425 if register_struc.reg_no = "0001"b /* A */ 426 then substr (direct_lower_inst, 19, 10) = LDA; 427 else substr (direct_lower_inst, 19, 10) = LDQ; 428 429 /* Insert the immediate value into the instruction */ 430 431 substr (direct_lower_inst, 1, 18) = 432 substr (unspec (operand_token_ptr -> immed_const.const_value), 19, 18); 433 434 call cobol_emit (addr (direct_lower_inst), null (), 1); 435 436 call cobol_make_reg_token (register_token_ptr, register_struc.reg_no); 437 438 end; /* Operand to be loaded is an immediate constant. */ 439 440 exit_load_register: 441 return; 442 443 end load_register; 444 445 446 447 448 /*{*/ 449 op_to_register: 450 proc (operand_token_ptr, register_code, op_code); 451 452 /* 453*This procedure generates code to add an operand to or subtract 454*an operand from a register. (A or Q) The operand can be a long 455*binary cobol data item, or an immediate constant. 456**/ 457 458 /* DECLARATION OF THE PARaMETERS */ 459 460 dcl operand_token_ptr ptr; 461 dcl register_code bit (4); 462 dcl op_code fixed bin; 463 464 /* DESCRIPTION OF THE PARAMETERS */ 465 466 /* 467*PARAMETER DESCRIPTION 468* 469*operand_token_ptr Pointer to a token that describes the 470*operand to be added to or subtracted from a register. (input) 471*register_code A code that identifies the register to which 472* the operation is to be performed. (input) 473* This code is defined below: 474* 475* code value | register 476* ======================================== 477* "0001"b | A register 478* "0010"b | Q register 479* ======================================== 480* 481*op_code A code that specifies the operation to 482* be performed. (input) 483* 484* code | operation 485* ======================================== 486* 1 | addition 487* 2 | subtraction 488* ========================================= 489* 490**/ 491 492 /*}*/ 493 494 /***************************************************/ 495 /* START OF EXECUTION */ 496 /* INTERNAL PROCEDURE: */ 497 /* op_to_register */ 498 /**************************************************/ 499 500 start_op_to_register: 501 if operand_token_ptr -> data_name.type = rtc_immed_const 502 then do; /* Operand is an immediate constant */ 503 504 if op_code = 1 505 then do; /* Operation is ADD */ 506 507 if register_code = "0001"b 508 then substr (direct_lower_inst, 19, 10) = ADA; 509 else substr (direct_lower_inst, 19, 10) = ADQ; 510 511 end; /* Operation is ADD */ 512 513 else do; /* Operation is SUBTRACT */ 514 515 516 if register_code = "0001"b 517 then substr (direct_lower_inst, 19, 10) = SBA; 518 else substr (direct_lower_inst, 19, 10) = SBQ; 519 520 end; /* Operation is SUBTRACT */ 521 522 substr (direct_lower_inst, 1, 18) = 523 substr (unspec (operand_token_ptr -> immed_const.const_value), 19, 18); 524 525 call cobol_emit (addr (direct_lower_inst), null (), 1); 526 527 end; /* Operand is an immediate constant. */ 528 529 530 else do; /* Operand is a long binary data item. */ 531 /* Establish addressability to the long binary. */ 532 533 input_struc.operand.token_ptr (1) = operand_token_ptr; 534 535 call cobol_addr (input_ptr, inst_ptr, reloc_ptr); 536 537 if op_code = 1 538 then do; /* Operation is ADD */ 539 540 if register_code = "0001"b 541 then inst_struc_basic.fill1_op = ADA; 542 else inst_struc_basic.fill1_op = ADQ; 543 544 end; /* Operation is ADD */ 545 546 else do; /* Operation is subtract */ 547 548 if register_code = "0001"b 549 then inst_struc_basic.fill1_op = SBA; 550 else inst_struc_basic.fill1_op = SBQ; 551 552 end; /* Operation is SUBTRACT */ 553 554 call cobol_emit (inst_ptr, reloc_ptr, 1); 555 556 end; /* Operand is a long binary data item. */ 557 558 exit_op_to_register: 559 return; 560 561 end op_to_register; 562 563 564 /***..... dcl cobol_gen_driver_$Tr_Beg entry(char(*));/**/ 565 /***..... dcl cobol_gen_driver_$Tr_End entry(char(*));/**/ 566 567 /***..... dcl Trace_Bit bit(1) static external;/**/ 568 /***..... dcl Trace_Lev fixed bin static external;/**/ 569 /***..... dcl Trace_Line char(36) static external;/**/ 570 /***..... dcl ioa_ entry options(variable); /**/ 571 /***..... dcl MY_NAME char (22) int static init ("COBOL_ADD2_BINARY_LONG");/**/ 572 573 574 /* INCLUDE FILES USED BY THIS PROCEDURE */ 575 576 /***** Declaration for builtin function *****/ 577 578 dcl (substr, mod, binary, fixed, addr, addrel, rel, length, string, unspec, null, index) 579 builtin; 580 581 /***** End of declaration for builtin function *****/ 582 1 1 1 2 /* BEGIN INCLUDE FILE ... cobol_type9.incl.pl1 */ 1 3 /* Last modified on 11/19/76 by ORN */ 1 4 1 5 /* 1 6*A type 9 data name token is entered into the name table by the data 1 7*division syntax phase for each data name described in the data division. 1 8*The replacement phase subsequently replaces type 8 user word references 1 9*to data names in the procedure division minpral file with the corresponding 1 10*type 9 tokens from the name table. 1 11**/ 1 12 1 13 /* dcl dn_ptr ptr; */ 1 14 1 15 /* BEGIN DECLARATION OF TYPE9 (DATA NAME) TOKEN */ 1 16 dcl 1 data_name based (dn_ptr), 2 1 2 2 /* begin include file ... cobol_TYPE9.incl.pl1 */ 2 3 /* Last modified on 06/19/77 by ORN */ 2 4 /* Last modified on 12/28/76 by FCH */ 2 5 2 6 /* header */ 2 7 2 size fixed bin, 2 8 2 line fixed bin, 2 9 2 column fixed bin, 2 10 2 type fixed bin, 2 11 /* body */ 2 12 2 string_ptr ptr, 2 13 2 prev_rec ptr, 2 14 2 searched bit (1), 2 15 2 duplicate bit (1), 2 16 2 saved bit (1), 2 17 2 debug_ind bit (1), 2 18 2 filler2 bit (3), 2 19 2 used_as_sub bit (1), 2 20 2 def_line fixed bin, 2 21 2 level fixed bin, 2 22 2 linkage fixed bin, 2 23 2 file_num fixed bin, 2 24 2 size_rtn fixed bin, 2 25 2 item_length fixed bin(24), 2 26 2 places_left fixed bin, 2 27 2 places_right fixed bin, 2 28 /* description */ 2 29 2 file_section bit (1), 2 30 2 working_storage bit (1), 2 31 2 constant_section bit (1), 2 32 2 linkage_section bit (1), 2 33 2 communication_section bit (1), 2 34 2 report_section bit (1), 2 35 2 level_77 bit (1), 2 36 2 level_01 bit (1), 2 37 2 non_elementary bit (1), 2 38 2 elementary bit (1), 2 39 2 filler_item bit (1), 2 40 2 s_of_rdf bit (1), 2 41 2 o_of_rdf bit (1), 2 42 2 bin_18 bit (1), 2 43 2 bin_36 bit (1), 2 44 2 pic_has_l bit (1), 2 45 2 pic_is_do bit (1), 2 46 2 numeric bit (1), 2 47 2 numeric_edited bit (1), 2 48 2 alphanum bit (1), 2 49 2 alphanum_edited bit (1), 2 50 2 alphabetic bit (1), 2 51 2 alphabetic_edited bit (1), 2 52 2 pic_has_p bit (1), 2 53 2 pic_has_ast bit (1), 2 54 2 item_signed bit(1), 2 55 2 sign_separate bit (1), 2 56 2 display bit (1), 2 57 2 comp bit (1), 2 58 2 ascii_packed_dec_h bit (1), /* as of 8/16/76 this field used for comp8. */ 2 59 2 ascii_packed_dec bit (1), 2 60 2 ebcdic_packed_dec bit (1), 2 61 2 bin_16 bit (1), 2 62 2 bin_32 bit (1), 2 63 2 usage_index bit (1), 2 64 2 just_right bit (1), 2 65 2 compare_argument bit (1), 2 66 2 sync bit (1), 2 67 2 temporary bit (1), 2 68 2 bwz bit (1), 2 69 2 variable_length bit (1), 2 70 2 subscripted bit (1), 2 71 2 occurs_do bit (1), 2 72 2 key_a bit (1), 2 73 2 key_d bit (1), 2 74 2 indexed_by bit (1), 2 75 2 value_numeric bit (1), 2 76 2 value_non_numeric bit (1), 2 77 2 value_signed bit (1), 2 78 2 sign_type bit (3), 2 79 2 pic_integer bit (1), 2 80 2 ast_when_zero bit (1), 2 81 2 label_record bit (1), 2 82 2 sign_clause_occurred bit (1), 2 83 2 okey_dn bit (1), 2 84 2 subject_of_keyis bit (1), 2 85 2 exp_redefining bit (1), 2 86 2 sync_in_rec bit (1), 2 87 2 rounded bit (1), 2 88 2 ad_bit bit (1), 2 89 2 debug_all bit (1), 2 90 2 overlap bit (1), 2 91 2 sum_counter bit (1), 2 92 2 exp_occurs bit (1), 2 93 2 linage_counter bit (1), 2 94 2 rnm_01 bit (1), 2 95 2 aligned bit (1), 2 96 2 not_user_writable bit (1), 2 97 2 database_key bit (1), 2 98 2 database_data_item bit (1), 2 99 2 seg_num fixed bin, 2 100 2 offset fixed bin(24), 2 101 2 initial_ptr fixed bin, 2 102 2 edit_ptr fixed bin, 2 103 2 occurs_ptr fixed bin, 2 104 2 do_rec char(5), 2 105 2 bitt bit (1), 2 106 2 byte bit (1), 2 107 2 half_word bit (1), 2 108 2 word bit (1), 2 109 2 double_word bit (1), 2 110 2 half_byte bit (1), 2 111 2 filler5 bit (1), 2 112 2 bit_offset bit (4), 2 113 2 son_cnt bit (16), 2 114 2 max_red_size fixed bin(24), 2 115 2 name_size fixed bin, 2 116 2 name char(0 refer(data_name.name_size)); 2 117 2 118 2 119 2 120 /* end include file ... cobol_TYPE9.incl.pl1 */ 2 121 1 17 1 18 /* END DECLARATION OF TYPE9 (DATA NAME) TOKEN */ 1 19 1 20 /* END INCLUDE FILE ... cobol_type9.incl.pl1 */ 1 21 583 3 1 3 2 /* BEGIN INCLUDE FILE ... cobol_type2.incl.pl1 */ 3 3 /* Last modified on 11/19/76 by ORN */ 3 4 3 5 /* 3 6*A type 2 numeric literal token is entered into the minpral file by the 3 7*lexical analysis phase for each numeric literal encountered in the source 3 8*program. 3 9**/ 3 10 3 11 dcl nlit_ptr ptr; 3 12 3 13 /* BEGIN DECLARATION OF TYPE2 (NUMERIC LITERAL) TOKEN */ 3 14 dcl 1 numeric_lit based (nlit_ptr), 4 1 4 2 /* begin include file ... cobol_TYPE2.incl.pl1 */ 4 3 /* Last modified on 12/28/76 by FCH */ 4 4 4 5 /* header */ 4 6 2 size fixed bin, 4 7 2 line fixed bin, 4 8 2 column fixed bin, 4 9 2 type fixed bin, 4 10 /* body */ 4 11 2 integral bit(1), 4 12 2 floating bit(1), 4 13 2 seg_range bit(1), 4 14 2 filler1 bit(4), 4 15 2 subscript bit(1), 4 16 2 sign char(1), 4 17 2 exp_sign char(1), 4 18 2 exp_places fixed bin, 4 19 2 places_left fixed bin, 4 20 2 places_right fixed bin, 4 21 2 places fixed bin, 4 22 2 literal char(0 refer(numeric_lit.places)); 4 23 4 24 4 25 4 26 /* end include file ... cobol_TYPE2.incl.pl1 */ 4 27 3 15 3 16 /* END DECLARATION OF TYPE2 (NUMERIC LITERAL) TOKEN */ 3 17 3 18 /* END INCLUDE FILE ... cobol_type2.incl.pl1 */ 3 19 584 5 1 5 2 /* BEGIN INCLUDE FILE ... cobol_addr_tokens.incl.pl1 */ 5 3 5 4 5 5 /****^ HISTORY COMMENTS: 5 6* 1) change(89-04-23,Zimmerman), approve(89-04-23,MCR8058), 5 7* audit(89-05-05,RWaters), install(89-05-24,MR12.3-1048): 5 8* MCR8058 cobol_addr_tokens.incl.pl1 Change array extents to refer to 5 9* constants rather than variables. 5 10* END HISTORY COMMENTS */ 5 11 5 12 5 13 /* Last modified on 10/1/74 by tg */ 5 14 5 15 5 16 /* parameter list */ 5 17 5 18 dcl (input_ptr, inst_ptr, reloc_ptr) ptr; 5 19 5 20 5 21 /* input_struc_basic is used for type 1 addressing */ 5 22 5 23 dcl 1 input_struc_basic based (input_ptr), 5 24 2 type fixed bin, 5 25 2 operand_no fixed bin, 5 26 2 lock fixed bin, 5 27 2 segno fixed bin, 5 28 2 char_offset fixed bin (24), 5 29 2 send_receive fixed bin; 5 30 5 31 5 32 dcl 1 input_struc based (input_ptr), 5 33 2 type fixed bin, 5 34 2 operand_no fixed bin, 5 35 2 lock fixed bin, 5 36 2 operand (0 refer (input_struc.operand_no)), 5 37 3 token_ptr ptr, 5 38 3 send_receive fixed bin, 5 39 3 ic_mod fixed bin, 5 40 3 size_sw fixed bin; 5 41 5 42 /* reloc_struc is used for all types of addressing * all types */ 5 43 5 44 dcl 1 reloc_struc (input_struc.operand_no + 1) based (reloc_ptr), 5 45 2 left_wd bit (5) aligned, 5 46 2 right_wd bit (5) aligned; 5 47 5 48 /* Instruction format for 1 word instruction */ 5 49 5 50 5 51 dcl 1 inst_struc_basic based (inst_ptr) aligned, 5 52 2 y unaligned, 5 53 3 pr bit (3) unaligned, 5 54 3 wd_offset bit (15) unaligned, 5 55 2 fill1_op bit (10) unaligned, 5 56 2 zero1 bit (1) unaligned, 5 57 2 pr_spec bit (1) unaligned, 5 58 2 tm bit (2) unaligned, 5 59 2 td bit (4) unaligned; 5 60 5 61 5 62 /* The detailed definitions of the fields in this structure 5 63* can be found in the GMAP manual section 8 */ 5 64 /* EIS instruction format for 2_4 word instructions */ 5 65 5 66 dcl 1 inst_struc based (inst_ptr) aligned, 5 67 2 inst unaligned, 5 68 3 zero1 bit (2) unaligned, 5 69 3 mf3 unaligned, 5 70 4 pr_spec bit (1) unaligned, 5 71 4 reg_or_length bit (1) unaligned, 5 72 4 zero2 bit (1) unaligned, 5 73 4 reg_mod bit (4) unaligned, 5 74 3 zero3 bit (2) unaligned, 5 75 3 mf2 unaligned, 5 76 4 pr_spec bit (1) unaligned, 5 77 4 reg_or_length bit (1) unaligned, 5 78 4 zero4 bit (1) unaligned, 5 79 4 reg_mod bit (4) unaligned, 5 80 3 fill1_op bit (10) unaligned, 5 81 3 zero5 bit (1) unaligned, 5 82 3 mf1 unaligned, 5 83 4 pr_spec bit (1) unaligned, 5 84 4 reg_or_length bit (1) unaligned, 5 85 4 zero6 bit (1) unaligned, 5 86 4 reg_mod bit (4) unaligned, 5 87 2 desc_ext unaligned, 5 88 3 desc (512) unaligned, 5 89 4 desc_od bit (36) unaligned; 5 90 5 91 /* The detailed definitions of the fields in this structure 5 92* can be found in the GMAP manual section 8. 5 93* The desc_ext is the descriptor extension of this eis 5 94* instruction. The number of descriptors associated with 5 95* this instruction is equavalent to the operand number. 5 96* Depending on operand data type, the descriptor 5 97* can be alphanumeric or numeric. The structures of the 5 98* alphanumeric and the numeric descriptors are defined 5 99* below. */ 5 100 5 101 /* alphanumeric descriptor format */ 5 102 5 103 dcl 1 desc_an based (desc_an_ptr) unaligned, 5 104 2 desc_f (512) unaligned, 5 105 3 y unaligned, 5 106 4 pr bit (3) unaligned, 5 107 4 wd_offset bit (15) unaligned, 5 108 3 char_n bit (3) unaligned, 5 109 3 zero1 bit (1) unaligned, 5 110 3 ta bit (2), 5 111 3 n bit (12) unaligned; 5 112 5 113 5 114 /* The detailed definitions of the fields in this structure can 5 115* be found in the GMAP manual section 8. */ 5 116 /* numeric descriptor format */ 5 117 5 118 dcl desc_nn_ptr ptr; 5 119 dcl desc_an_ptr ptr; 5 120 5 121 5 122 dcl 1 desc_nn based (desc_nn_ptr) unaligned, 5 123 2 desc_f (512) unaligned, 5 124 3 y unaligned, 5 125 4 pr bit (3) unaligned, 5 126 4 wd_offset bit (15) unaligned, 5 127 3 digit_n bit (3) unaligned, 5 128 3 tn bit (1) unaligned, 5 129 3 sign_type bit (2) unaligned, 5 130 3 scal bit (6) unaligned, 5 131 3 n bit (6) unaligned; 5 132 5 133 5 134 /* The detailed definitions of fields in this structure can 5 135* be found in the GMAP manual section 8. */ 5 136 /* END INCLUDE FILE ... cobol_addr_tokens.incl.pl1 */ 5 137 585 6 1 6 2 /* BEGIN INCLUDE FILE... cobol_type102.incl.pl1 */ 6 3 /* Last modified on 1/19/76 by ORN */ 6 4 6 5 /* 6 6*An immediate constant token is created during the 6 7*generation of code that performs arithmetic in the hardware 6 8*registers, for any numeric literal token whose value is within 6 9*the range: (-131072,131071). 6 10**/ 6 11 6 12 dcl immed_const_ptr ptr; 6 13 6 14 /* BEGIN DECLARATION OF TYPE102 (IMMEDIATE CONSTANT) TOKEN */ 6 15 dcl 1 immed_const based(immed_const_ptr), 6 16 /* header */ 6 17 2 size fixed bin (15), 6 18 2 line fixed bin (15), 6 19 2 column fixed bin (15), 6 20 2 type fixed bin (15), 6 21 /* body */ 6 22 2 const_value fixed bin (35); 6 23 /* END DECLARATION OF TYPE102 (IMMEDIATE CONSTANT) TOKEN */ 6 24 6 25 /* 6 26*FIELD CONTENTS 6 27* 6 28*size The total size in bytes of this immediate 6 29* constant token. 6 30*line not used 6 31*column not used 6 32*type 102 6 33*const_value The fixed binary value of the immediate constant. 6 34**/ 6 35 6 36 /* END INCLUDE FILE... cobol_type102.incl.pl1 */ 6 37 586 7 1 7 2 /* BEGIN INCLUDE FILE ... cobol_record_types.incl.pl1 */ 7 3 /* <<< LAST MODIFIED ON 09-09-75 by tlf >>> */ 7 4 7 5 dcl rtc_resword fixed bin (15) int static init(1); 7 6 dcl rtc_numlit fixed bin (15) int static init(2); 7 7 dcl rtc_alphalit fixed bin (15) int static init(3); 7 8 dcl rtc_picstring fixed bin (15) int static init(4); 7 9 dcl rtc_diag fixed bin (15) int static init(5); 7 10 dcl rtc_source fixed bin (15) int static init(6); 7 11 dcl rtc_procdef fixed bin (15) int static init(7); 7 12 dcl rtc_userwd fixed bin (15) int static init(8); 7 13 dcl rtc_dataname fixed bin (15) int static init(9); 7 14 dcl rtc_indexname fixed bin (15) int static init(10); 7 15 dcl rtc_condname fixed bin (15) int static init(11); 7 16 dcl rtc_filedef fixed bin (15) int static init(12); 7 17 dcl rtc_commdesc fixed bin (15) int static init(13); 7 18 dcl rtc_debugitems fixed bin (15) int static init(14); 7 19 dcl rtc_savedarea fixed bin (15) int static init(15); 7 20 dcl rtc_sortmerge fixed bin (15) int static init(16); 7 21 dcl rtc_mnemonic fixed bin (15) int static init(17); 7 22 dcl rtc_pararef fixed bin (15) int static init(18); 7 23 dcl rtc_eos fixed bin (15) int static init(19); 7 24 dcl rtc_reportname fixed bin (15) int static init(20); 7 25 dcl rtc_groupname fixed bin (15) int static init(21); 7 26 dcl rtc_reportentry fixed bin (15) int static init(22); 7 27 dcl rtc_unknown1 fixed bin (15) int static init(23); 7 28 dcl rtc_debugenable fixed bin (15) int static init(24); 7 29 dcl rtc_unknown2 fixed bin (15) int static init(25); 7 30 dcl rtc_unknown3 fixed bin (15) int static init(26); 7 31 dcl rtc_unknown4 fixed bin (15) int static init(27); 7 32 dcl rtc_unknown5 fixed bin (15) int static init(28); 7 33 dcl rtc_unknown6 fixed bin (15) int static init(29); 7 34 dcl rtc_internal_tag fixed bin (15) int static init(30); 7 35 dcl rtc_equate_tag fixed bin (15) int static init(31); 7 36 dcl rtc_register fixed bin (15) int static init(100); 7 37 dcl rtc_fdec_temp fixed bin (15) int static init(101); 7 38 dcl rtc_immed_const fixed bin (15) int static init(102); 7 39 7 40 /* END INCLUDE FILE ... cobol_record_types.incl.pl1 */ 7 41 587 8 1 8 2 /* BEGIN INCLUDE FILE ... cobol_type100.incl.pl1 */ 8 3 /* Last modified on 11/19/76 by ORN */ 8 4 8 5 /* 8 6*The internal register token is used only during the code generation phase. 8 7**/ 8 8 8 9 dcl cobol_type100_ptr ptr; 8 10 8 11 /* BEGIN DECLARATION OF TYPE100 (INTERNAL REGISTER) TOKEN */ 8 12 dcl 1 cobol_type100 based (cobol_type100_ptr) aligned, 8 13 /* header */ 8 14 2 size fixed bin (15), 8 15 2 line fixed bin (15), 8 16 2 column fixed bin (7), 8 17 2 type fixed bin (7), 8 18 /* body */ 8 19 2 register bit (4) unaligned; 8 20 /* END DECLARATION OF TYPE100 (INTERNAL REGISTER) TOKEN */ 8 21 8 22 /* 8 23*FIELD CONTENTS 8 24* 8 25*size The total size in bytes of this token. 8 26*line Generated sequence number of source line. 8 27* Always 0. 8 28*column The column number on the source image. 8 29* Always 0. 8 30*type 100 8 31*register The register number in the following form. 8 32* "0001"b - A register. 8 33* "0010"b - Q register. 8 34* "0011"b - A and Q registers. 8 35* "1nnn"b - index register nnn. 8 36**/ 8 37 8 38 /* END INCLUDE FILE ... cobol_type100.incl.pl1 */ 8 39 588 589 590 end cobol_add2_binary_long; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 05/24/89 0834.9 cobol_add2_binary_long.pl1 >spec>install>MR12.3-1048>cobol_add2_binary_long.pl1 583 1 03/27/82 0439.9 cobol_type9.incl.pl1 >ldd>include>cobol_type9.incl.pl1 1-17 2 11/11/82 1712.7 cobol_TYPE9.incl.pl1 >ldd>include>cobol_TYPE9.incl.pl1 584 3 03/27/82 0439.8 cobol_type2.incl.pl1 >ldd>include>cobol_type2.incl.pl1 3-15 4 11/11/82 1712.8 cobol_TYPE2.incl.pl1 >ldd>include>cobol_TYPE2.incl.pl1 585 5 05/24/89 0811.7 cobol_addr_tokens.incl.pl1 >spec>install>MR12.3-1048>cobol_addr_tokens.incl.pl1 586 6 03/27/82 0439.8 cobol_type102.incl.pl1 >ldd>include>cobol_type102.incl.pl1 587 7 03/27/82 0439.8 cobol_record_types.incl.pl1 >ldd>include>cobol_record_types.incl.pl1 588 8 03/27/82 0439.8 cobol_type100.incl.pl1 >ldd>include>cobol_type100.incl.pl1 NAMES DECLARED IN THIS COMPILATION. IDENTIFIER OFFSET LOC STORAGE CLASS DATA TYPE ATTRIBUTES AND REFERENCES (* indicates a set context) NAMES DECLARED BY DECLARE STATEMENT. ADA constant bit(10) initial packed unaligned dcl 105 ref 507 540 ADQ constant bit(10) initial packed unaligned dcl 107 ref 509 542 LDA constant bit(10) initial packed unaligned dcl 101 ref 402 425 LDQ constant bit(10) initial packed unaligned dcl 103 ref 405 427 SBA constant bit(10) initial packed unaligned dcl 109 ref 516 548 SBQ constant bit(10) initial packed unaligned dcl 111 ref 518 550 addr builtin function dcl 578 ref 152 154 155 400 400 423 423 434 434 525 525 bin_18 21(13) based bit(1) level 2 packed packed unaligned dcl 1-16 ref 228 261 261 298 383 bin_36 21(14) based bit(1) level 2 packed packed unaligned dcl 1-16 ref 172 call_again 000150 automatic bit(1) packed unaligned dcl 134 set ref 254* cobol_addr 000022 constant entry external dcl 86 ref 203 392 535 cobol_alloc$stack 000030 constant entry external dcl 90 ref 246 cobol_emit 000024 constant entry external dcl 87 ref 206 407 434 525 554 cobol_make_bin_const 000026 constant entry external dcl 88 ref 164 215 cobol_make_reg_token 000014 constant entry external dcl 80 ref 409 436 cobol_make_type9$long_bin 000032 constant entry external dcl 91 ref 250 cobol_register$load 000012 constant entry external dcl 79 ref 400 423 cobol_short_to_longbin$register 000020 constant entry external dcl 84 ref 383 cobol_short_to_longbin$temp 000016 constant entry external dcl 82 ref 233 269 cobol_store_binary 000034 constant entry external dcl 93 ref 254 cobol_type100 based structure level 1 dcl 8-12 const_value 4 based fixed bin(35,0) level 2 dcl 6-15 ref 431 522 cont_bit 000151 automatic bit(1) packed unaligned dcl 135 set ref 176* 179 184* 192 contains 4 000154 automatic fixed bin(17,0) level 2 dcl 141 set ref 398* 421* data_name based structure level 1 unaligned dcl 1-16 direct_lower_inst 000010 internal static bit(36) initial packed unaligned dcl 114 set ref 425* 427* 431* 434 434 507* 509* 516* 518* 522* 525 525 fill1_op 0(18) based bit(10) level 2 in structure "inst_struc_basic" packed packed unaligned dcl 5-51 in procedure "cobol_add2_binary_long" set ref 402* 405* 540* 542* 548* 550* fill1_op 0(18) based bit(10) level 3 in structure "inst_struc" packed packed unaligned dcl 5-66 in procedure "cobol_add2_binary_long" set ref 204* i 000152 automatic fixed bin(17,0) dcl 136 set ref 179* 180 184 184* immed_const based structure level 1 unaligned dcl 6-15 input_buff 000100 automatic structure level 1 dcl 120 set ref 152 input_ptr 000166 automatic pointer dcl 5-18 set ref 152* 198 199 200 201 202 203* 318 319 320 321 390 392* 533 535* input_struc based structure level 1 unaligned dcl 5-32 inst based structure level 2 packed packed unaligned dcl 5-66 inst_buff 000124 automatic structure level 1 dcl 123 set ref 154 inst_ptr 000170 automatic pointer dcl 5-18 set ref 154* 203* 204 206* 392* 402 405 407* 535* 540 542 548 550 554* inst_struc based structure level 1 dcl 5-66 inst_struc_basic based structure level 1 dcl 5-51 j 000153 automatic fixed bin(17,0) dcl 136 set ref 177* 179 literal 11 based char level 2 packed packed unaligned dcl 3-14 ref 180 184 195 lock 2 000154 automatic fixed bin(17,0) level 2 in structure "register_struc" dcl 141 in procedure "cobol_add2_binary_long" set ref 397* 420* lock 2 based fixed bin(17,0) level 2 in structure "input_struc" dcl 5-32 in procedure "cobol_add2_binary_long" set ref 200* 320* lop_token_ptr parameter pointer dcl 42 set ref 31 160 164* 165* 172 172 201 234 238 256 261 261 271 276 281 284 292 305 311 null builtin function dcl 578 ref 163 213 232 248 267 434 434 525 525 numeric_lit based structure level 1 unaligned dcl 3-14 op_code parameter fixed bin(17,0) dcl 462 ref 449 504 537 operand 4 based structure array level 2 unaligned dcl 5-32 operand_no 1 based fixed bin(17,0) level 2 dcl 5-32 set ref 199* 319* operand_token_ptr parameter pointer dcl 460 in procedure "op_to_register" ref 449 500 522 533 operand_token_ptr parameter pointer dcl 348 in procedure "load_register" set ref 338 379 383 383* 390 431 operation_code parameter fixed bin(17,0) dcl 45 set ref 31 172 223 223* 225 225* 228 238 332* places 10 based fixed bin(17,0) level 2 dcl 3-14 ref 180 184 195 places_left 6 based fixed bin(17,0) level 2 dcl 3-14 ref 177 184 195 places_right 7 based fixed bin(17,0) level 2 dcl 3-14 ref 177 reg_no 1 000154 automatic bit(4) level 2 packed packed unaligned dcl 141 set ref 402 409* 425 436* register 4 based bit(4) level 2 packed packed unaligned dcl 8-12 set ref 332* register_code parameter bit(4) packed unaligned dcl 461 ref 449 507 516 540 548 register_struc 000154 automatic structure level 1 unaligned dcl 141 set ref 400 400 423 423 register_token_ptr parameter pointer dcl 349 set ref 338 383* 409* 436* reloc_buff 000126 automatic structure level 1 dcl 126 set ref 155 reloc_ptr 000172 automatic pointer dcl 5-18 set ref 155* 203* 206* 392* 407* 535* 554* result_token_ptr parameter pointer dcl 44 set ref 31 328* 330* 332 ret_offset 000144 automatic fixed bin(24,0) dcl 131 set ref 246* 250* rop_token_ptr parameter pointer dcl 43 set ref 31 169 172 177 177 180 184 184 195 195 215* 217* 228 228 233* 238 238 254* 261 261 269* 276 285 291 298 298 304 312 rtc_dataname constant fixed bin(15,0) initial dcl 7-13 ref 228 261 261 298 379 rtc_immed_const constant fixed bin(15,0) initial dcl 7-38 ref 500 rtc_numlit constant fixed bin(15,0) initial dcl 7-6 ref 160 169 rtc_register constant fixed bin(15,0) initial dcl 7-36 ref 238 238 238 276 276 281 328 sign 4(09) based char(1) level 2 packed packed unaligned dcl 3-14 ref 172 size_sw 10 based fixed bin(17,0) array level 3 dcl 5-32 set ref 202* 321* substr builtin function dcl 578 set ref 180 184 195 425* 427* 431* 431 507* 509* 516* 518* 522* 522 temp_lop_token_ptr 000140 automatic pointer dcl 129 set ref 234* 256* 271* 284* 291* 304* 311* 328 328 330* temp_ptr 000146 automatic pointer dcl 133 set ref 163* 164* 165 213* 215* 217 temp_rop_token_ptr 000142 automatic pointer dcl 130 set ref 232* 233* 248* 250* 254* 267* 269* 285* 292* 305* 312* 332* token_ptr 4 based pointer array level 3 dcl 5-32 set ref 201* 390* 533* type 3 based fixed bin(17,0) level 2 in structure "data_name" dcl 1-16 in procedure "cobol_add2_binary_long" ref 160 169 172 228 238 238 238 261 261 276 276 281 298 328 379 500 type based fixed bin(17,0) level 2 in structure "input_struc" dcl 5-32 in procedure "cobol_add2_binary_long" set ref 198* 318* unspec builtin function dcl 578 ref 431 522 what_reg 000154 automatic fixed bin(17,0) level 2 dcl 141 set ref 396* 419* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. addrel builtin function dcl 578 binary builtin function dcl 578 cobol_type100_ptr automatic pointer dcl 8-9 desc_an based structure level 1 packed packed unaligned dcl 5-103 desc_an_ptr automatic pointer dcl 5-119 desc_nn based structure level 1 packed packed unaligned dcl 5-122 desc_nn_ptr automatic pointer dcl 5-118 dn_ptr automatic pointer dcl 138 fixed builtin function dcl 578 immed_const_ptr automatic pointer dcl 6-12 index builtin function dcl 578 input_struc_basic based structure level 1 unaligned dcl 5-23 length builtin function dcl 578 mod builtin function dcl 578 nlit_ptr automatic pointer dcl 3-11 rel builtin function dcl 578 reloc_struc based structure array level 1 unaligned dcl 5-44 rtc_alphalit internal static fixed bin(15,0) initial dcl 7-7 rtc_commdesc internal static fixed bin(15,0) initial dcl 7-17 rtc_condname internal static fixed bin(15,0) initial dcl 7-15 rtc_debugenable internal static fixed bin(15,0) initial dcl 7-28 rtc_debugitems internal static fixed bin(15,0) initial dcl 7-18 rtc_diag internal static fixed bin(15,0) initial dcl 7-9 rtc_eos internal static fixed bin(15,0) initial dcl 7-23 rtc_equate_tag internal static fixed bin(15,0) initial dcl 7-35 rtc_fdec_temp internal static fixed bin(15,0) initial dcl 7-37 rtc_filedef internal static fixed bin(15,0) initial dcl 7-16 rtc_groupname internal static fixed bin(15,0) initial dcl 7-25 rtc_indexname internal static fixed bin(15,0) initial dcl 7-14 rtc_internal_tag internal static fixed bin(15,0) initial dcl 7-34 rtc_mnemonic internal static fixed bin(15,0) initial dcl 7-21 rtc_pararef internal static fixed bin(15,0) initial dcl 7-22 rtc_picstring internal static fixed bin(15,0) initial dcl 7-8 rtc_procdef internal static fixed bin(15,0) initial dcl 7-11 rtc_reportentry internal static fixed bin(15,0) initial dcl 7-26 rtc_reportname internal static fixed bin(15,0) initial dcl 7-24 rtc_resword internal static fixed bin(15,0) initial dcl 7-5 rtc_savedarea internal static fixed bin(15,0) initial dcl 7-19 rtc_sortmerge internal static fixed bin(15,0) initial dcl 7-20 rtc_source internal static fixed bin(15,0) initial dcl 7-10 rtc_unknown1 internal static fixed bin(15,0) initial dcl 7-27 rtc_unknown2 internal static fixed bin(15,0) initial dcl 7-29 rtc_unknown3 internal static fixed bin(15,0) initial dcl 7-30 rtc_unknown4 internal static fixed bin(15,0) initial dcl 7-31 rtc_unknown5 internal static fixed bin(15,0) initial dcl 7-32 rtc_unknown6 internal static fixed bin(15,0) initial dcl 7-33 rtc_userwd internal static fixed bin(15,0) initial dcl 7-12 string builtin function dcl 578 temp_op automatic bit(10) packed unaligned dcl 132 NAMES DECLARED BY EXPLICIT CONTEXT. cobol_add2_binary_long 000013 constant entry external dcl 31 exit_load_register 000764 constant label dcl 440 exit_op_to_register 001157 constant label dcl 558 load_register 000542 constant entry internal dcl 338 ref 330 op_to_register 000765 constant entry internal dcl 449 ref 332 start 000020 constant label dcl 152 start_load_register 000544 constant label dcl 379 start_op_to_register 000767 constant label dcl 500 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1334 1372 1162 1344 Length 1750 1162 36 342 152 2 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME cobol_add2_binary_long 196 external procedure is an external procedure. load_register internal procedure shares stack frame of external procedure cobol_add2_binary_long. op_to_register internal procedure shares stack frame of external procedure cobol_add2_binary_long. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 direct_lower_inst cobol_add2_binary_long STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME cobol_add2_binary_long 000100 input_buff cobol_add2_binary_long 000124 inst_buff cobol_add2_binary_long 000126 reloc_buff cobol_add2_binary_long 000140 temp_lop_token_ptr cobol_add2_binary_long 000142 temp_rop_token_ptr cobol_add2_binary_long 000144 ret_offset cobol_add2_binary_long 000146 temp_ptr cobol_add2_binary_long 000150 call_again cobol_add2_binary_long 000151 cont_bit cobol_add2_binary_long 000152 i cobol_add2_binary_long 000153 j cobol_add2_binary_long 000154 register_struc cobol_add2_binary_long 000166 input_ptr cobol_add2_binary_long 000170 inst_ptr cobol_add2_binary_long 000172 reloc_ptr cobol_add2_binary_long THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as call_ext_out return_mac ext_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. cobol_addr cobol_alloc$stack cobol_emit cobol_make_bin_const cobol_make_reg_token cobol_make_type9$long_bin cobol_register$load cobol_short_to_longbin$register cobol_short_to_longbin$temp cobol_store_binary NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 31 000006 152 000020 154 000022 155 000024 160 000026 163 000034 164 000036 165 000052 169 000055 172 000063 176 000103 177 000105 179 000110 180 000121 184 000132 190 000137 192 000141 195 000143 198 000153 199 000155 200 000160 201 000161 202 000164 203 000165 204 000200 206 000204 207 000221 213 000222 215 000224 217 000242 223 000245 225 000254 228 000260 232 000303 233 000305 234 000316 236 000322 238 000323 246 000345 248 000363 250 000365 254 000402 256 000416 258 000422 261 000423 267 000434 269 000436 271 000447 273 000453 276 000454 281 000460 284 000462 285 000463 287 000464 291 000465 292 000466 296 000467 298 000470 304 000472 305 000473 307 000474 311 000475 312 000476 318 000477 319 000501 320 000504 321 000505 328 000506 330 000514 332 000524 334 000541 338 000542 379 000544 383 000551 390 000567 392 000571 396 000604 397 000606 398 000610 400 000611 402 000622 405 000633 407 000637 409 000654 414 000666 419 000667 420 000671 421 000673 423 000674 425 000705 427 000717 431 000724 434 000732 436 000752 440 000764 449 000765 500 000767 504 000774 507 000777 509 001012 511 001017 516 001020 518 001033 522 001040 525 001043 527 001063 533 001064 535 001066 537 001101 540 001105 542 001117 544 001123 548 001124 550 001136 554 001142 558 001157 ----------------------------------------------------------- Historical Background This edition of the Multics software materials and documentation is provided and donated to Massachusetts Institute of Technology by Group BULL including BULL HN Information Systems Inc. as a contribution to computer science knowledge. This donation is made also to give evidence of the common contributions of Massachusetts Institute of Technology, Bell Laboratories, General Electric, Honeywell Information Systems Inc., Honeywell BULL Inc., Groupe BULL and BULL HN Information Systems Inc. to the development of this operating system. Multics development was initiated by Massachusetts Institute of Technology Project MAC (1963-1970), renamed the MIT Laboratory for Computer Science and Artificial Intelligence in the mid 1970s, under the leadership of Professor Fernando Jose Corbato. Users consider that Multics provided the best software architecture for managing computer hardware properly and for executing programs. Many subsequent operating systems incorporated Multics principles. Multics was distributed in 1975 to 2000 by Group Bull in Europe , and in the U.S. by Bull HN Information Systems Inc., as successor in interest by change in name only to Honeywell Bull Inc. and Honeywell Information Systems Inc. . ----------------------------------------------------------- Permission to use, copy, modify, and distribute these programs and their documentation for any purpose and without fee is hereby granted,provided that the below copyright notice and historical background appear in all copies and that both the copyright notice and historical background and this permission notice appear in supporting documentation, and that the names of MIT, HIS, BULL or BULL HN not be used in advertising or publicity pertaining to distribution of the programs without specific prior written permission. Copyright 1972 by Massachusetts Institute of Technology and Honeywell Information Systems Inc. Copyright 2006 by BULL HN Information Systems Inc. Copyright 2006 by Bull SAS All Rights Reserved