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