COMPILATION LISTING OF SEGMENT vrmu_data_length Compiled by: Multics PL/I Compiler, Release 28d, of October 4, 1983 Compiled at: Honeywell Multics Op. - System M Compiled on: 11/21/84 1437.3 mst Wed Options: optimize map 1 /* *********************************************************** 2* * * 3* * * 4* * Copyright, (C) Honeywell Information Systems Inc., 1981 * 5* * * 6* * * 7* *********************************************************** */ 8 9 /* ****************************************************** 10* * * 11* * * 12* * Copyright (c) 1972 by Massachusetts Institute of * 13* * Technology and Honeywell Information Systems, Inc. * 14* * * 15* * * 16* ****************************************************** */ 17 18 /* HISTORY: 19* originally written by jim gray - - April 1979 20* Modified by Rickie E. Brinegar on December 28, 1979 to make code a non static 21* variable as opposed to the declaration of int static options 22* (constant) it was originally declared as. 23* Modified by Rickie E. Brinegar on January 9, 1980 to change the declaration of 24* return_value from in static options (constant) to automatic. 25* Modified by Jim Gray - - 80-9-18, to add the $get_data_pad_length entry, so that mu_build_tuple 26* count have a common data primitive routine to get the amount of padding for aligned 27* data types from. 28* 29* Modified by R. Harvey -- 83-04-03 renamed from mu_data_class and cleaned up 30* some not-completely-qualified structure element references. 31**/ 32 33 34 vrmu_data_length: get_data_bit_length: procedure (input_descriptor) returns (fixed bin (35)); 35 36 /* DESCRIPTION: 37* given a 36-bit multics pl1 argument descriptor 38* this routine determines the number of bits of storage 39* that the data type, alignment, and precision or size 40* requires when residing in memory, not counting words 41* skipped to obtain even word boundaries. 42* the descriptor is assumed to be valid, with correct values for 43* scale, precision, size, etc. for that data type, since this is to 44* be an efficient run-time routine having had error checks made elsewhere. 45* also, the data is assumed to be scalar, i.e. that there are 46* no array bounds, as this will be expanded elsewhere. 47* decimal 4-bit non-byte aligned are treated as byte aligned data. 48* The entry $get_data_pad_length returns instead of the storage bit length, 49* the amount of padding that aligned data types needed. 50**/ 51 52 /* PARAMETERS: 53* input_descriptor - - (input) bit(36) multics pl1 argument descriptor, 54* see subsystem writers guide for format. 55* 56* bit_length - - (output) returned storage space needed in bits, 57* declared fixed bin(35). 58* 59* pad_length - - (output) fixed bin(35), for the $get_data_pad_length only, this is the number 60* of bits required to pad aligned data out to it's full size. 61* it will be 0 for unaligned data types ; 62* 63* sub_error_ - - (output) condition, signaled upon occurence of error 64**/ 65 66 /* get local version of the descriptor */ 67 68 descriptor = input_descriptor; 69 70 call common (); 71 72 return (bit_length); 73 74 75 76 77 78 79 /* entry to return the amount of padding space used */ 80 81 get_data_pad_length: entry (entry_descriptor) returns (fixed bin (35)); 82 83 descriptor = entry_descriptor; 84 85 pad_length = 0; /* for unaligned types */ 86 87 call common (); 88 89 return (pad_length); 90 91 common: procedure (); 92 93 /* CASE STRUCTURE BASED ON THE DATA TYPE */ 94 95 goto case (descriptor_type.type); 96 97 /* UNUSED */ 98 case (0): 99 call unimplemented_data_type (); 100 goto end_case; 101 102 /* REAL FIXED BINARY SHORT */ 103 case (1): 104 bit_length = descriptor_precision.precision + SIGN; 105 if descriptor_packed_flag.packed then ; 106 else do; 107 pad_length = ONE_WORD - bit_length; 108 bit_length = ONE_WORD; 109 end; 110 goto end_case; 111 112 /* REAL FIXED BINARY LONG */ 113 case (2): 114 bit_length = descriptor_precision.precision + SIGN; 115 if descriptor_packed_flag.packed then ; 116 else do; 117 pad_length = TWO_WORD - bit_length; 118 bit_length = TWO_WORD; 119 end; 120 goto end_case; 121 122 /* REAL FLOATING BINARY SHORT */ 123 case (3): 124 bit_length = descriptor_precision.precision + ONE_BYTE; 125 if descriptor_packed_flag.packed then ; 126 else do; 127 pad_length = ONE_WORD - bit_length; 128 bit_length = ONE_WORD; 129 end; 130 goto end_case; 131 132 /* REAL FLOATING BINARY LONG */ 133 case (4): 134 bit_length = descriptor_precision.precision + ONE_BYTE; 135 if descriptor_packed_flag.packed then ; 136 else do; 137 pad_length = TWO_WORD - bit_length; 138 bit_length = TWO_WORD; 139 end; 140 goto end_case; 141 142 /* COMPLEX FIXED BINARY SHORT */ 143 case (5): 144 bit_length = DOUBLE * (descriptor_precision.precision + SIGN); 145 if descriptor_packed_flag.packed then ; 146 else do; 147 pad_length = TWO_WORD - bit_length; 148 bit_length = TWO_WORD; 149 end; 150 goto end_case; 151 152 /* COMPLEX FIXED BINARY LONG */ 153 case (6): 154 bit_length = DOUBLE * (descriptor_precision.precision + SIGN); 155 if descriptor_packed_flag.packed then ; 156 else do; 157 pad_length = FOUR_WORD - bit_length; 158 bit_length = FOUR_WORD; 159 end; 160 goto end_case; 161 162 /* COMPLEX FLOATING BINARY SHORT */ 163 case (7): 164 bit_length = DOUBLE * (descriptor_precision.precision + ONE_BYTE); 165 if descriptor_packed_flag.packed then ; 166 else do; 167 pad_length = TWO_WORD - bit_length; 168 bit_length = TWO_WORD; 169 end; 170 goto end_case; 171 172 /* COMPLEX FLOATING BINARY LONG */ 173 case (8): 174 bit_length = DOUBLE * (descriptor_precision.precision + ONE_BYTE); 175 if descriptor_packed_flag.packed then ; 176 else do; 177 pad_length = FOUR_WORD - bit_length; 178 bit_length = FOUR_WORD; 179 end; 180 goto end_case; 181 182 /* REAL FIXED DECIMAL */ 183 case (9): 184 bit_length = ONE_BYTE * (descriptor_precision.precision + SIGN); 185 if descriptor_packed_flag.packed then ; 186 else call pad_to_word_boundary (); 187 goto end_case; 188 189 /* REAL FLOATING DECIMAL */ 190 case (10): 191 bit_length = ONE_BYTE * (descriptor_precision.precision + SIGN_AND_EXPONENT); 192 if descriptor_packed_flag.packed then ; 193 else call pad_to_word_boundary (); 194 goto end_case; 195 196 /* COMPLEX FIXED DECIMAL */ 197 case (11): 198 bit_length = DOUBLE * ONE_BYTE * (descriptor_precision.precision + SIGN); 199 if descriptor_packed_flag.packed then ; 200 else call pad_to_word_boundary (); 201 goto end_case; 202 203 /* COMPLEX FLOATING DECIMAL */ 204 case (12): 205 bit_length = DOUBLE * ONE_BYTE * (descriptor_precision.precision + SIGN_AND_EXPONENT); 206 if descriptor_packed_flag.packed then ; 207 else call pad_to_word_boundary (); 208 goto end_case; 209 210 /* POINTER */ 211 case (13): 212 if descriptor_packed_flag.packed then 213 bit_length = ONE_WORD; 214 else bit_length = TWO_WORD; 215 goto end_case; 216 217 /* OFFSET */ 218 case (14): 219 if descriptor_packed_flag.packed then 220 call invalid_alignment (); 221 else bit_length = ONE_WORD; 222 goto end_case; 223 224 /* LABEL */ 225 case (15): 226 if descriptor_packed_flag.packed then 227 call invalid_alignment (); 228 else bit_length = FOUR_WORD; 229 goto end_case; 230 231 /* ENTRY */ 232 case (16): 233 if descriptor_packed_flag.packed then 234 call invalid_alignment (); 235 else bit_length = FOUR_WORD; 236 goto end_case; 237 238 /* NOTE: this length is correct for structures declared 239* without arrays only. (i.e. only scalar elements) */ 240 241 /* STRUCTURE */ 242 case (17): 243 bit_length = ONE_WORD * descriptor_size.size; 244 goto end_case; 245 246 /* AREA */ 247 case (18): 248 bit_length = ONE_WORD * descriptor_size.size; 249 goto end_case; 250 251 /* BIT STRING */ 252 case (19): 253 bit_length = descriptor_size.size; 254 if descriptor_packed_flag.packed then ; 255 else call pad_to_word_boundary (); 256 goto end_case; 257 258 /* VARYING BIT STRING */ 259 case (20): 260 bit_length = descriptor_size.size + ONE_WORD; 261 if descriptor_packed_flag.packed then 262 call invalid_alignment (); 263 else call pad_to_word_boundary (); 264 goto end_case; 265 266 /* CHARACTER STRING */ 267 case (21): 268 bit_length = ONE_BYTE * descriptor_size.size; 269 if descriptor_packed_flag.packed then ; 270 else call pad_to_word_boundary (); 271 goto end_case; 272 273 /* VARYING CHARACTER STRING */ 274 case (22): 275 bit_length = (ONE_BYTE * descriptor_size.size) + ONE_WORD; 276 if descriptor_packed_flag.packed then 277 call invalid_alignment (); 278 else call pad_to_word_boundary (); 279 goto end_case; 280 281 /* FILE */ 282 case (23): 283 bit_length = FOUR_WORD; 284 goto end_case; 285 286 /* UNUSED */ 287 case (24): 288 case (25): 289 case (26): 290 case (27): 291 case (28): 292 call unimplemented_data_type (); 293 goto end_case; 294 295 /* REAL FIXED DECIMAL LEADING OVERPUNCHED SIGN 9-BIT */ 296 case (29): 297 bit_length = ONE_BYTE * descriptor_precision.precision; 298 if descriptor_packed_flag.packed then ; 299 else call pad_to_word_boundary (); 300 goto end_case; 301 302 /* REAL FIXED DECIMAL TRAILING OVERPUNCHED SIGN 9-BIT */ 303 case (30): 304 bit_length = ONE_BYTE * descriptor_precision.precision; 305 if descriptor_packed_flag.packed then ; 306 else call pad_to_word_boundary (); 307 goto end_case; 308 309 /* UNUSED */ 310 case (31): 311 case (32): 312 call unimplemented_data_type (); 313 goto end_case; 314 315 /* REAL FIXED BINARY SHORT UNSIGNED */ 316 case (33): 317 bit_length = descriptor_precision.precision; 318 if descriptor_packed_flag.packed then ; 319 else do; 320 pad_length = ONE_WORD - bit_length; 321 bit_length = ONE_WORD; 322 end; 323 goto end_case; 324 325 /* REAL FIXED BINARY LONG UNSIGNED */ 326 case (34): 327 bit_length = descriptor_precision.precision; 328 if descriptor_packed_flag.packed then ; 329 else do; 330 pad_length = TWO_WORD - bit_length; 331 bit_length = TWO_WORD; 332 end; 333 goto end_case; 334 335 /* REAL FIXED DECIMAL UNSIGNED 9-BIT */ 336 case (35): 337 bit_length = ONE_BYTE * descriptor_precision.precision; 338 if descriptor_packed_flag.packed then ; 339 else call pad_to_word_boundary (); 340 goto end_case; 341 342 /* REAL FIXED DECIMAL TRAILING SIGN 9-BIT */ 343 case (36): 344 bit_length = ONE_BYTE * (descriptor_precision.precision + SIGN); 345 if descriptor_packed_flag.packed then ; 346 else call pad_to_word_boundary (); 347 goto end_case; 348 349 /* UNUSED */ 350 case (37): 351 call unimplemented_data_type (); 352 goto end_case; 353 354 /* NOTE: non-byte-aligned decimal 4-bit requires knowledge of 355* physical 1/2 byte alignment to determine actual bit length, 356* thus it is unsupported by pl1, and MRDS, and the returned 357* bit length will be the same as if it were the corresponding 358* byte aligned decimal 4-bit data type. */ 359 360 /* REAL FIXED DECIMAL UNSIGNED 4-BIT */ 361 case (38): 362 bit_length = ONE_BYTE * floor ((descriptor_precision.precision + PAD) / PER_BYTE_FACTOR); 363 if descriptor_packed_flag.packed then ; 364 else call pad_to_word_boundary (); 365 goto end_case; 366 367 /* REAL FIXED DECIMAL TRAILING SIGN 4-BIT */ 368 case (39): 369 bit_length = ONE_BYTE * floor ((descriptor_precision.precision + SIGN_AND_PAD) / PER_BYTE_FACTOR); 370 if descriptor_packed_flag.packed then ; 371 else call pad_to_word_boundary (); 372 goto end_case; 373 374 /* UNUSED */ 375 case (40): 376 call unimplemented_data_type (); 377 goto end_case; 378 379 /* REAL FIXED DECIMAL LEADING SIGN 4-BIT */ 380 case (41): 381 bit_length = ONE_BYTE * floor ((descriptor_precision.precision + SIGN_AND_PAD) / PER_BYTE_FACTOR); 382 if descriptor_packed_flag.packed then ; 383 else call pad_to_word_boundary (); 384 goto end_case; 385 386 /* REAL FLOATING DECIMAL 4-BIT */ 387 case (42): 388 bit_length = ONE_BYTE * floor ((descriptor_precision.precision + SIGN_EXPONENT_AND_PAD) / PER_BYTE_FACTOR); 389 if descriptor_packed_flag.packed then ; 390 else call pad_to_word_boundary (); 391 goto end_case; 392 393 /* REAL FIXED DECIMAL LEADING SIGN 4-BIT BYTE-ALIGNED */ 394 case (43): 395 bit_length = ONE_BYTE * floor ((descriptor_precision.precision + SIGN_AND_PAD) / PER_BYTE_FACTOR); 396 if descriptor_packed_flag.packed then ; 397 else call pad_to_word_boundary (); 398 goto end_case; 399 400 /* REAL FLOATING DECIMAL 4-BIT BYTE-ALIGNED */ 401 case (44): 402 bit_length = ONE_BYTE * floor ((descriptor_precision.precision + SIGN_EXPONENT_AND_PAD) / PER_BYTE_FACTOR); 403 if descriptor_packed_flag.packed then ; 404 else call pad_to_word_boundary (); 405 goto end_case; 406 407 /* COMPLEX FIXED DECIMAL LEADING SIGN 4-BIT BYTE-ALIGNED */ 408 case (45): 409 bit_length = DOUBLE * ONE_BYTE * floor ((descriptor_precision.precision + SIGN_AND_PAD) / PER_BYTE_FACTOR); 410 if descriptor_packed_flag.packed then ; 411 else call pad_to_word_boundary (); 412 goto end_case; 413 414 /* COMPLEX FLOATING DECIMAL 4-BIT BYTE-ALIGNED */ 415 case (46): 416 bit_length = DOUBLE * ONE_BYTE * floor ((descriptor_precision.precision + SIGN_EXPONENT_AND_PAD) / PER_BYTE_FACTOR); 417 if descriptor_packed_flag.packed then ; 418 else call pad_to_word_boundary (); 419 goto end_case; 420 421 /* UNUSED */ 422 case (47): 423 case (48): 424 case (49): 425 case (50): 426 case (51): 427 case (52): 428 case (53): 429 case (54): 430 case (55): 431 case (56): 432 case (57): 433 case (58): 434 case (59): 435 case (60): 436 case (61): 437 case (62): 438 case (63): 439 call unimplemented_data_type (); 440 goto end_case; 441 442 /* END OF DESCRIPTOR TYPE CASE STATEMENT */ 443 end_case: 444 445 end; 446 447 pad_to_word_boundary: procedure (); 448 449 /* fill out the bit length to reflect a word boundary aligned, 450* integral number of words storage space */ 451 452 if mod (bit_length, ONE_WORD) = 0 then ; 453 else do; 454 pad_length = (ONE_WORD - mod (bit_length, ONE_WORD)); 455 bit_length = bit_length + pad_length; 456 end; 457 458 end; 459 460 unimplemented_data_type: procedure (); 461 462 /* report that an unused data type was given in the descriptor */ 463 464 code = mrds_error_$invalid_dm_descriptor; 465 466 call sub_err_ (code, caller_name, continue, info_ptr, return_value, 467 "^/An invalid data type = ^d, ""^a"", was given in the descriptor.", 468 descriptor_type.type, mu_display_descriptor (addr (descriptor))); 469 470 bit_length, pad_length = 0; 471 472 end; 473 474 invalid_alignment: procedure (); 475 476 /* report incorrect use of the packed feature */ 477 478 code = mrds_error_$invalid_dm_descriptor; 479 480 call sub_err_ (code, caller_name, continue, info_ptr, return_value, 481 "^/The unaligned (packed) attribute can not be used with the data type = ""^a"".", 482 mu_display_descriptor (addr (descriptor))); 483 484 bit_length, pad_length = 0; 485 486 end; 487 488 declare SIGN_AND_PAD fixed bin init (2) int static options (constant); /* sign digit + 1/2 byte padding */ 489 declare SIGN_EXPONENT_AND_PAD fixed bin init (4) int static options (constant); /* sign digit, exp byte, + 1/2 byte pad */ 490 declare PAD fixed bin init (1) int static options (constant); /* 1/2 byte padding */ 491 declare PER_BYTE_FACTOR fixed bin init (2) int static options (constant); /* number of digits per byte */ 492 declare SIGN_AND_EXPONENT fixed bin init (2) int static options (constant); /* float decimal exp and sign char space */ 493 declare DOUBLE fixed bin init (2) int static options (constant); /* multiplier for complex numbers */ 494 declare SIGN fixed bin init (1) int static options (constant); /* space for sign */ 495 declare input_descriptor bit (36); /* users descriptor parameter */ 496 declare code fixed bin (35) init (0); /* error encoding */ 497 declare caller_name char (14) init ("mu_data_length") int static options (constant); /* name of calling routine */ 498 declare continue char (1) init ("c") int static options (constant); /* after printing, keep going */ 499 declare info_ptr ptr init (null ()) int static options (constant); /* unused */ 500 declare return_value fixed bin (35) init (0); 501 declare bit_length fixed bin (35); /* returned storage length */ 502 declare sub_err_ entry options (variable); /* error reporting routine */ 503 declare (mod, addr, floor) builtin; 504 declare descriptor bit (36); /* basic multics pl1 descriptor */ 505 declare ONE_WORD fixed bin init (36) int static options (constant); /* bit length of a word */ 506 declare TWO_WORD fixed bin init (72) int static options (constant); /* bit length of two words */ 507 declare FOUR_WORD fixed bin init (144) int static options (constant); /* bit length of four words */ 508 declare ONE_BYTE fixed bin init (9) int static options (constant); /* bit length of a byte (character) */ 509 declare 1 descriptor_precision unal based (addr (descriptor)), /* overlay for arith precision */ 510 2 unused bit (24) unal, /* skip over first part */ 511 2 precision unsigned fixed bin (12) unal; /* arith precision */ 512 declare 1 descriptor_packed_flag unal based (addr (descriptor)), /* overlay for packed */ 513 2 unused_1 bit (7) unal, 514 2 packed bit (1) unal, /* ON => unaligned */ 515 2 unused_2 bit (28) unal; 516 declare 1 descriptor_type unal based (addr (descriptor)), /* overlay for descriptor type */ 517 2 unused_1 bit (1) unal, 518 2 type unsigned fixed bin (6) unal, /* descriptor type code */ 519 2 unused_2 bit (29) unal; 520 declare mrds_error_$invalid_dm_descriptor fixed bin (35) ext; /* bad data type */ 521 declare mu_display_descriptor entry (ptr) returns (char (120) varying); /* for trouble reporting */ 522 declare 1 descriptor_size unal based (addr (descriptor)), /* string/area/structure size overlay */ 523 2 unused bit (12) unal, 524 2 size unsigned fixed bin (24) unal; /* size field */ 525 declare pad_length fixed bin (35); /* length to pad aligned data types */ 526 declare entry_descriptor bit (36); /* descriptor paramter for pad length entry */ 527 end; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/21/84 0934.1 vrmu_data_length.pl1 >special_ldd>online>mrds_install>vrmu_data_length.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. DOUBLE constant fixed bin(17,0) initial dcl 493 ref 143 153 163 173 197 204 408 415 FOUR_WORD constant fixed bin(17,0) initial dcl 507 ref 157 158 177 178 228 235 282 ONE_BYTE constant fixed bin(17,0) initial dcl 508 ref 123 133 163 173 183 190 197 204 267 274 296 303 336 343 361 368 380 387 394 401 408 415 ONE_WORD 001443 constant fixed bin(17,0) initial dcl 505 ref 107 108 127 128 211 221 242 247 259 274 320 321 452 454 454 PAD constant fixed bin(17,0) initial dcl 490 ref 361 PER_BYTE_FACTOR 001444 constant fixed bin(17,0) initial dcl 491 ref 361 368 380 387 394 401 408 415 SIGN constant fixed bin(17,0) initial dcl 494 ref 103 113 143 153 183 197 343 SIGN_AND_EXPONENT constant fixed bin(17,0) initial dcl 492 ref 190 204 SIGN_AND_PAD constant fixed bin(17,0) initial dcl 488 ref 368 380 394 408 SIGN_EXPONENT_AND_PAD constant fixed bin(17,0) initial dcl 489 ref 387 401 415 TWO_WORD constant fixed bin(17,0) initial dcl 506 ref 117 118 137 138 147 148 167 168 214 330 331 addr builtin function dcl 503 ref 95 103 105 113 115 123 125 133 135 143 145 153 155 163 165 173 175 183 185 190 192 197 199 204 206 211 218 225 232 242 247 252 254 259 261 267 269 274 276 296 298 303 305 316 318 326 328 336 338 343 345 361 363 368 370 380 382 387 389 394 396 401 403 408 410 415 417 466 466 466 480 480 bit_length 000102 automatic fixed bin(35,0) dcl 501 set ref 72 103* 107 108* 113* 117 118* 123* 127 128* 133* 137 138* 143* 147 148* 153* 157 158* 163* 167 168* 173* 177 178* 183* 190* 197* 204* 211* 214* 221* 228* 235* 242* 247* 252* 259* 267* 274* 282* 296* 303* 316* 320 321* 326* 330 331* 336* 343* 361* 368* 380* 387* 394* 401* 408* 415* 452 454 455* 455 470* 484* caller_name 000103 constant char(14) initial unaligned dcl 497 set ref 466* 480* code 000100 automatic fixed bin(35,0) initial dcl 496 set ref 464* 466* 478* 480* 496* continue 000102 constant char(1) initial unaligned dcl 498 set ref 466* 480* descriptor 000103 automatic bit(36) unaligned dcl 504 set ref 68* 83* 95 103 105 113 115 123 125 133 135 143 145 153 155 163 165 173 175 183 185 190 192 197 199 204 206 211 218 225 232 242 247 252 254 259 261 267 269 274 276 296 298 303 305 316 318 326 328 336 338 343 345 361 363 368 370 380 382 387 389 394 396 401 403 408 410 415 417 466 466 466 480 480 descriptor_packed_flag based structure level 1 packed unaligned dcl 512 descriptor_precision based structure level 1 packed unaligned dcl 509 descriptor_size based structure level 1 packed unaligned dcl 522 descriptor_type based structure level 1 packed unaligned dcl 516 entry_descriptor parameter bit(36) unaligned dcl 526 ref 81 83 floor builtin function dcl 503 ref 361 368 380 387 394 401 408 415 info_ptr 000100 constant pointer initial dcl 499 set ref 466* 480* input_descriptor parameter bit(36) unaligned dcl 495 ref 34 34 68 mod builtin function dcl 503 ref 452 454 mrds_error_$invalid_dm_descriptor 000012 external static fixed bin(35,0) dcl 520 ref 464 478 mu_display_descriptor 000014 constant entry external dcl 521 ref 466 480 packed 0(07) based bit(1) level 2 packed unaligned dcl 512 ref 105 115 125 135 145 155 165 175 185 192 199 206 211 218 225 232 254 261 269 276 298 305 318 328 338 345 363 370 382 389 396 403 410 417 pad_length 000104 automatic fixed bin(35,0) dcl 525 set ref 85* 89 107* 117* 127* 137* 147* 157* 167* 177* 320* 330* 454* 455 470* 484* precision 0(24) based fixed bin(12,0) level 2 packed unsigned unaligned dcl 509 ref 103 113 123 133 143 153 163 173 183 190 197 204 296 303 316 326 336 343 361 368 380 387 394 401 408 415 return_value 000101 automatic fixed bin(35,0) initial dcl 500 set ref 466* 480* 500* size 0(12) based fixed bin(24,0) level 2 packed unsigned unaligned dcl 522 ref 242 247 252 259 267 274 sub_err_ 000010 constant entry external dcl 502 ref 466 480 type 0(01) based fixed bin(6,0) level 2 packed unsigned unaligned dcl 516 set ref 95 466* NAMES DECLARED BY EXPLICIT CONTEXT. case 000000 constant label array(0:63) dcl 98 ref 95 common 000251 constant entry internal dcl 91 ref 70 87 end_case 001245 constant label dcl 443 ref 100 110 120 130 140 150 160 170 180 187 194 201 208 215 222 229 236 244 249 256 264 271 279 284 293 300 307 313 323 333 340 347 352 365 372 377 384 391 398 405 412 419 440 get_data_bit_length 000175 constant entry external dcl 34 get_data_pad_length 000230 constant entry external dcl 81 invalid_alignment 001357 constant entry internal dcl 474 ref 218 225 232 261 276 pad_to_word_boundary 001246 constant entry internal dcl 447 ref 186 193 200 207 255 263 270 278 299 306 339 346 364 371 383 390 397 404 411 418 unimplemented_data_type 001265 constant entry internal dcl 460 ref 98 287 310 350 375 422 vrmu_data_length 000206 constant entry external dcl 34 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 1546 1564 1445 1556 Length 1746 1445 16 145 101 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME get_data_bit_length 280 external procedure is an external procedure. common internal procedure shares stack frame of external procedure get_data_bit_length. pad_to_word_boundary internal procedure shares stack frame of external procedure get_data_bit_length. unimplemented_data_type internal procedure shares stack frame of external procedure get_data_bit_length. invalid_alignment internal procedure shares stack frame of external procedure get_data_bit_length. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME get_data_bit_length 000100 code get_data_bit_length 000101 return_value get_data_bit_length 000102 bit_length get_data_bit_length 000103 descriptor get_data_bit_length 000104 pad_length get_data_bit_length THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return mod_fx1 ext_entry floor_fx2 divide_fx1 THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. mu_display_descriptor sub_err_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. mrds_error_$invalid_dm_descriptor LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 496 000165 500 000166 34 000171 68 000214 70 000221 72 000222 81 000226 83 000236 85 000243 87 000244 89 000245 91 000251 95 000252 98 000260 100 000261 103 000262 105 000266 107 000272 108 000300 110 000302 113 000303 115 000307 117 000313 118 000321 120 000323 123 000324 125 000330 127 000334 128 000342 130 000344 133 000345 135 000351 137 000355 138 000363 140 000365 143 000366 145 000373 147 000377 148 000405 150 000407 153 000410 155 000415 157 000421 158 000427 160 000431 163 000432 165 000437 167 000443 168 000451 170 000453 173 000454 175 000461 177 000465 178 000473 180 000475 183 000476 185 000503 186 000507 187 000510 190 000511 192 000516 193 000522 194 000523 197 000524 199 000533 200 000537 201 000540 204 000541 206 000550 207 000554 208 000555 211 000556 214 000564 215 000566 218 000567 221 000574 222 000576 225 000577 228 000604 229 000606 232 000607 235 000614 236 000616 242 000617 244 000623 247 000624 249 000630 252 000631 254 000634 255 000640 256 000641 259 000642 261 000646 263 000653 264 000654 267 000655 269 000661 270 000665 271 000666 274 000667 276 000674 278 000701 279 000702 282 000703 284 000705 287 000706 293 000707 296 000710 298 000714 299 000720 300 000721 303 000722 305 000726 306 000732 307 000733 310 000734 313 000735 316 000736 318 000741 320 000745 321 000753 323 000755 326 000756 328 000761 330 000765 331 000773 333 000775 336 000776 338 001002 339 001006 340 001007 343 001010 345 001015 346 001021 347 001022 350 001023 352 001024 361 001025 363 001040 364 001044 365 001045 368 001046 370 001061 371 001065 372 001066 375 001067 377 001070 380 001071 382 001104 383 001110 384 001111 387 001112 389 001125 390 001131 391 001132 394 001133 396 001146 397 001152 398 001153 401 001154 403 001167 404 001173 405 001174 408 001175 410 001212 411 001216 412 001217 415 001220 417 001235 418 001241 419 001242 422 001243 440 001244 443 001245 447 001246 452 001247 454 001255 455 001260 458 001264 460 001265 464 001266 466 001271 470 001354 472 001356 474 001357 478 001360 480 001363 484 001440 486 001442 ----------------------------------------------------------- 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