COMPILATION LISTING OF SEGMENT transaction_call Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/04/82 1737.4 mst Thu Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 /* Command Interface to transaction_call_. 12* 13* Rewritten 8-Mar-79 by M. N. Davidoff. 14**/ 15 transaction_call: 16 trc: 17 procedure; 18 19 /* auotmatic */ 20 21 declare arg_count fixed binary; 22 declare arg_length fixed binary (21); 23 declare arg_list_ptr pointer; 24 declare arg_ptr pointer; 25 declare argument_no fixed binary; 26 declare argx fixed binary; 27 declare code fixed binary (35); 28 declare operation char (32); 29 declare tcf_io_switch char (32); 30 declare tcf_iocb_ptr pointer; 31 declare transaction_no fixed binary (35); 32 33 /* based */ 34 35 declare arg_string char (arg_length) based (arg_ptr); 36 37 /* builtin */ 38 39 declare addr builtin; 40 declare index builtin; 41 declare length builtin; 42 declare null builtin; 43 declare rtrim builtin; 44 declare string builtin; 45 46 /* condition */ 47 48 declare program_interrupt condition; 49 declare transaction_failure condition; 50 51 /* internal static */ 52 53 declare command char (16) internal static options (constant) initial ("transaction_call"); 54 55 /* external static */ 56 57 declare error_table_$asynch_change 58 fixed binary (35) external static; 59 declare error_table_$badopt fixed binary (35) external static; 60 61 /* entry */ 62 63 declare com_err_ entry options (variable); 64 declare com_err_$suppress_name entry options (variable); 65 declare cu_$arg_count entry (fixed binary); 66 declare cu_$arg_list_ptr entry (pointer); 67 declare cu_$arg_ptr entry (fixed binary, pointer, fixed binary (21), fixed binary (35)); 68 declare cu_$arg_ptr_rel entry (fixed binary, pointer, fixed binary (21), fixed binary (35), pointer); 69 declare cv_dec_check_ entry (char (*), fixed binary (35)) returns (fixed binary (35)); 70 declare ioa_ entry options (variable); 71 declare iox_$look_iocb entry (char (*), pointer, fixed binary (35)); 72 declare transaction_call_$assign 73 entry (pointer, fixed binary (35), fixed binary (35)); 74 declare transaction_call_$change_current_transaction_no 75 entry (pointer, fixed binary (35), fixed binary (35)); 76 declare transaction_call_$commit 77 entry (pointer, fixed binary (35), fixed binary (35)); 78 declare transaction_call_$number 79 entry (pointer, fixed binary (35), fixed binary (35)); 80 declare transaction_call_$rollback 81 entry (pointer, fixed binary (35), fixed binary (35)); 82 declare transaction_call_$status 83 entry (pointer, fixed binary (35), bit (36) aligned, pointer, fixed binary, 84 fixed binary (35)); 85 declare transaction_call_$transact 86 entry (pointer, char (*), fixed binary (35), fixed binary (35)); 87 1 1 /* BEGIN INCLUDE FILE ... transaction_call.incl.pl1 */ 1 2 1 3 /* Written 6-Mar-79 by M. N. Davidoff. */ 1 4 1 5 /* automatic */ 1 6 1 7 declare trc_flags bit (36) aligned; 1 8 declare trc_status_ptr pointer; 1 9 1 10 /* based */ 1 11 1 12 declare 1 trc_flag_s aligned based (addr (trc_flags)), 1 13 2 verify_refs bit (1) unaligned, /* on to check for asychronous changes */ 1 14 2 list bit (1) unaligned, /* on to print ref list on user_output until asynch change */ 1 15 2 pad bit (34) unaligned; /* Must be zero */ 1 16 1 17 declare 1 trc_status aligned based (trc_status_ptr), 1 18 2 version fixed binary (17), /* Must be 1 */ 1 19 2 transaction_no fixed binary (35), /* transaction information applies to */ 1 20 2 transaction_status fixed binary (17), /* transaction's status */ 1 21 2 passive_refs fixed binary (34), /* number of items referenced but not modified */ 1 22 2 non_passive_refs fixed binary (34); /* number of items modified */ 1 23 1 24 /* internal static */ 1 25 1 26 declare trc_VERIFY_REFS bit (36) aligned internal static options (constant) initial ("1"b); 1 27 declare trc_status_version_1 fixed binary internal static options (constant) initial (1); 1 28 1 29 /* transaction status codes */ 1 30 1 31 declare trc_INCOMPLETE fixed binary internal static options (constant) initial (0); 1 32 declare trc_COMMITTED fixed binary internal static options (constant) initial (1); 1 33 declare trc_ROLLED_BACK fixed binary internal static options (constant) initial (2); 1 34 declare trc_UNDEFINED fixed binary internal static options (constant) initial (3); 1 35 1 36 /* END INCLUDE FILE ... transaction_call.incl.pl1 */ 88 89 90 /* program */ 91 92 call cu_$arg_list_ptr (arg_list_ptr); 93 94 call cu_$arg_count (arg_count); 95 if arg_count < 2 96 then do; 97 call com_err_$suppress_name (0, command, "Usage: ^a operation tcf_io_switch {args}", command); 98 return; 99 end; 100 101 do argx = 1 to 2; 102 call cu_$arg_ptr (argx, arg_ptr, arg_length, code); 103 if code ^= 0 104 then do; 105 call com_err_ (code, command, "Argument ^d.", argx); 106 return; 107 end; 108 109 if index (arg_string, "-") = 1 110 then do; 111 call com_err_ (error_table_$badopt, command, "^a", arg_string); 112 return; 113 end; 114 115 else if argx = 1 116 then operation = arg_string; 117 else tcf_io_switch = arg_string; 118 end; 119 120 call iox_$look_iocb (tcf_io_switch, tcf_iocb_ptr, code); 121 if code ^= 0 122 then do; 123 call com_err_ (code, command, "^a", tcf_io_switch); 124 return; 125 end; 126 127 if operation = "assign" | operation = "a" 128 then call assign; 129 130 else if operation = "change_current_transaction_no" | operation = "cctn" 131 then call change_current_transaction_no; 132 133 else if operation = "commit" | operation = "c" 134 then call commit; 135 136 else if operation = "number" | operation = "n" 137 then call number; 138 139 else if operation = "rollback" | operation = "r" 140 then call rollback; 141 142 else if operation = "status" | operation = "s" 143 then call status; 144 145 else if operation = "transact" | operation = "t" 146 then call transact; 147 148 else do; 149 call com_err_ (0, command, "Specified operation is not implemented by this command. ^a", operation); 150 return; 151 end; 152 153 return; 154 155 /* Get a new transaction number. */ 156 157 assign: 158 procedure; 159 160 if arg_count ^= 2 161 then do; 162 call com_err_$suppress_name (0, command, "Usage: ^a assign tcf_io_switch", command); 163 return; 164 end; 165 166 call transaction_call_$assign (tcf_iocb_ptr, transaction_no, code); 167 if code ^= 0 168 then do; 169 call com_err_ (code, command, "Assigning a transaction number."); 170 return; 171 end; 172 173 call ioa_ ("Transaction ^d.", transaction_no); 174 end assign; 175 176 /* Change to another transaction. */ 177 178 change_current_transaction_no: 179 procedure; 180 181 argument_no = 0; 182 do argx = 3 to arg_count; 183 call cu_$arg_ptr (argx, arg_ptr, arg_length, code); 184 if code ^= 0 185 then do; 186 call com_err_ (code, command, "Argument ^d.", argx); 187 return; 188 end; 189 190 if index (arg_string, "-") = 1 191 then do; 192 call com_err_ (error_table_$badopt, command, "^a", arg_string); 193 return; 194 end; 195 196 else do; 197 argument_no = argument_no + 1; 198 199 if argument_no = 1 200 then do; 201 transaction_no = cv_dec_check_ (arg_string, code); 202 if code ^= 0 203 then do; 204 call com_err_ (0, command, "Transaction number expected. ^a", arg_string); 205 return; 206 end; 207 end; 208 end; 209 end; 210 211 if argument_no ^= 1 212 then do; 213 call com_err_$suppress_name (0, command, 214 "Usage: ^a change_current_transaction_no tcf_io_switch transaction_no", command); 215 return; 216 end; 217 218 call transaction_call_$change_current_transaction_no (tcf_iocb_ptr, transaction_no, code); 219 if code ^= 0 220 then do; 221 call com_err_ (code, command, "Changing the current transaction number."); 222 return; 223 end; 224 end change_current_transaction_no; 225 226 /* Commit a transaction. */ 227 228 commit: 229 procedure; 230 231 if arg_count ^= 2 232 then do; 233 call com_err_$suppress_name (0, command, "Usage: ^a commit tcf_io_switch", command); 234 return; 235 end; 236 237 call transaction_call_$commit (tcf_iocb_ptr, transaction_no, code); 238 if code ^= 0 239 then do; 240 call com_err_ (code, command, "Committing transaction ^d.", transaction_no); 241 return; 242 end; 243 244 if transaction_no ^= 0 245 then call ioa_ ("Transaction ^d committed.", transaction_no); 246 end commit; 247 248 /* Get the current transaction number. */ 249 250 number: 251 procedure; 252 253 if arg_count ^= 2 254 then do; 255 call com_err_$suppress_name (0, command, "Usage: ^a number tcf_io_switch", command); 256 return; 257 end; 258 259 call transaction_call_$number (tcf_iocb_ptr, transaction_no, code); 260 if code ^= 0 261 then do; 262 call com_err_ (code, command, "Getting current transaction number."); 263 return; 264 end; 265 266 call ioa_ ("The current transaction number is ^d.", transaction_no); 267 end number; 268 269 /* Rollback a transaction. */ 270 271 rollback: 272 procedure; 273 274 if arg_count ^= 2 275 then do; 276 call com_err_$suppress_name (0, command, "Usage: ^a rollback tcf_io_switch", command); 277 return; 278 end; 279 280 call transaction_call_$rollback (tcf_iocb_ptr, transaction_no, code); 281 if code ^= 0 282 then do; 283 call com_err_ (code, command, "Rolling back transaction ^d.", transaction_no); 284 return; 285 end; 286 287 if transaction_no ^= 0 288 then call ioa_ ("Transaction ^d rolled back.", transaction_no); 289 end rollback; 290 291 /* Get a transaction's status. */ 292 293 status: 294 procedure; 295 296 declare 1 status_s aligned like trc_status; 297 declare 1 sw unaligned, 298 2 brief bit (1), 299 2 verify_refs bit (1), 300 2 list bit (1); 301 declare transaction_status fixed binary; 302 303 string (sw) = ""b; 304 transaction_no = 0; 305 306 argument_no = 0; 307 do argx = 3 to arg_count; 308 call cu_$arg_ptr (argx, arg_ptr, arg_length, code); 309 if code ^= 0 310 then do; 311 call com_err_ (code, command, "Argument ^d.", argx); 312 return; 313 end; 314 315 if arg_string = "-brief" | arg_string = "-bf" 316 then sw.brief = "1"b; 317 318 else if arg_string = "-verify" | arg_string = "-vf" 319 then sw.verify_refs = "1"b; 320 321 else if arg_string = "-list" | arg_string = "-ls" 322 then sw.list = "1"b; 323 324 else if index (arg_string, "-") = 1 325 then do; 326 call com_err_ (error_table_$badopt, command, "^a", arg_string); 327 return; 328 end; 329 330 else do; 331 argument_no = argument_no + 1; 332 333 if argument_no = 1 334 then do; 335 transaction_no = cv_dec_check_ (arg_string, code); 336 if code ^= 0 337 then do; 338 call com_err_ (0, command, "Transaction number expected. ^a", arg_string); 339 return; 340 end; 341 end; 342 end; 343 end; 344 345 if argument_no > 1 346 then do; 347 call com_err_$suppress_name (0, command, 348 "Usage: ^a status tcf_io_switch {transaction_no} {-control_args}", command); 349 return; 350 end; 351 352 trc_flags = ""b; 353 trc_flag_s.verify_refs = sw.verify_refs; 354 trc_flag_s.list = sw.list; 355 356 status_s.version = trc_status_version_1; 357 358 if sw.brief 359 then trc_status_ptr = null; 360 else trc_status_ptr = addr (status_s); 361 362 if sw.list 363 then call ioa_ ("^/Reference list^[ until first asychronous change^]:", sw.verify_refs); 364 365 call transaction_call_$status (tcf_iocb_ptr, transaction_no, trc_flags, trc_status_ptr, transaction_status, code); 366 if code ^= 0 & code ^= error_table_$asynch_change 367 then do; 368 call com_err_ (code, command, "Getting the status of ^[the current transaction^s^;transaction ^d^].", 369 transaction_no = 0, transaction_no); 370 return; 371 end; 372 373 if transaction_no ^= 0 | ^sw.brief 374 then call ioa_ ("^/transaction:^2-^[^d^s^;^s^d^]", sw.brief, transaction_no, status_s.transaction_no); 375 376 call ioa_ ("status:^3-^[^[incomplete^;committed^;rolled back^;undefined^]^s^;^s^d^]", 377 trc_INCOMPLETE <= transaction_status & transaction_status <= trc_UNDEFINED, transaction_status + 1, 378 transaction_status); 379 380 if transaction_status ^= trc_UNDEFINED & ^sw.brief 381 then call ioa_ ("passive references:^2-^d^/non-passive references:^-^d", status_s.passive_refs, 382 status_s.non_passive_refs); 383 384 if code ^= 0 385 then call com_err_ (code, command); 386 end status; 387 388 /* Execute a command line as a transaction. */ 389 390 transact: 391 procedure; 392 393 declare command_line_length fixed binary (21); 394 declare first_command_line_arg fixed binary; 395 declare retry_limit fixed binary; 396 declare 1 sw unaligned, 397 2 signal bit (1), 398 2 no_signal bit (1); 399 400 string (sw) = ""b; 401 retry_limit = 0; 402 403 first_command_line_arg = 0; 404 argx = 3; 405 do while (argx <= arg_count); 406 call cu_$arg_ptr (argx, arg_ptr, arg_length, code); 407 if code ^= 0 408 then do; 409 call com_err_ (code, command, "Argument ^d.", argx); 410 return; 411 end; 412 413 if first_command_line_arg > 0 414 then command_line_length = command_line_length + length (arg_string) + 1; 415 416 else if arg_string = "-retry" 417 then do; 418 argx = argx + 1; 419 if argx > arg_count 420 then do; 421 call com_err_ (0, command, "Missing retry limit after -retry."); 422 return; 423 end; 424 425 call cu_$arg_ptr (argx, arg_ptr, arg_length, code); 426 if code ^= 0 427 then do; 428 call com_err_ (code, command, "Argument ^d.", argx); 429 return; 430 end; 431 432 retry_limit = cv_dec_check_ (arg_string, code); 433 if code ^= 0 434 then do; 435 call com_err_ (0, command, "Retry limit expected. ^a", arg_string); 436 return; 437 end; 438 end; 439 440 else if arg_string = "-signal" 441 then sw.signal = "1"b; 442 443 else if arg_string = "-no_signal" 444 then sw.no_signal = "1"b; 445 446 else if index (arg_string, "-") = 1 447 then do; 448 call com_err_ (error_table_$badopt, command, "^a", arg_string); 449 return; 450 end; 451 452 else do; 453 first_command_line_arg = argx; 454 command_line_length = length (arg_string); 455 end; 456 457 argx = argx + 1; 458 end; 459 460 if first_command_line_arg = 0 461 then do; 462 call com_err_$suppress_name (0, command, "Usage: ^a transact tcf_io_switch {-control_args} command_line", 463 command); 464 return; 465 end; 466 467 if sw.signal & sw.no_signal 468 then do; 469 call com_err_ (0, command, "The -signal and -no_signal control arguments are incompatible."); 470 return; 471 end; 472 473 sw.signal = ^sw.no_signal; 474 475 begin; 476 declare command_line char (command_line_length); 477 declare one_more_time bit (1); 478 declare try fixed binary; 479 480 do argx = first_command_line_arg to arg_count; 481 call cu_$arg_ptr_rel (argx, arg_ptr, arg_length, code, arg_list_ptr); 482 if code ^= 0 483 then do; 484 call com_err_ (code, command, "Argument ^d.", argx); 485 return; 486 end; 487 488 if argx = first_command_line_arg 489 then command_line = arg_string; 490 else command_line = rtrim (command_line) || " " || arg_string; 491 end; 492 493 if sw.signal 494 then on program_interrupt 495 goto execute_command_line; 496 497 try = 0; 498 499 execute_command_line: 500 one_more_time = "1"b; 501 do while (try <= retry_limit & code = error_table_$asynch_change | one_more_time); 502 one_more_time = "0"b; 503 try = try + 1; 504 505 call transaction_call_$transact (tcf_iocb_ptr, command_line, transaction_no, code); 506 end; 507 508 if code = 0 509 then call ioa_ ("The transaction committed on try ^d with transaction number ^d.", try, transaction_no); 510 511 else if code = error_table_$asynch_change 512 then if sw.signal 513 then signal transaction_failure; 514 else call com_err_ (code, command, "On try ^d.", try); 515 516 else call com_err_ (code, command, "On transaction ^d.", transaction_no); 517 end; 518 end transact; 519 520 end transaction_call; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/04/82 1620.4 transaction_call.pl1 >dumps>old>recomp>transaction_call.pl1 88 1 07/19/79 1547.0 transaction_call.incl.pl1 >ldd>include>transaction_call.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. addr builtin function dcl 39 ref 353 354 360 arg_count 000100 automatic fixed bin(17,0) dcl 21 set ref 94* 95 160 182 231 253 274 307 405 419 480 arg_length 000101 automatic fixed bin(21,0) dcl 22 set ref 102* 109 111 111 115 117 183* 190 192 192 201 201 204 204 308* 315 315 318 318 321 321 324 326 326 335 335 338 338 406* 413 416 425* 432 432 435 435 440 443 446 448 448 454 481* 488 490 arg_list_ptr 000102 automatic pointer dcl 23 set ref 92* 481* arg_ptr 000104 automatic pointer dcl 24 set ref 102* 109 111 115 117 183* 190 192 201 204 308* 315 315 318 318 321 321 324 326 335 338 406* 413 416 425* 432 435 440 443 446 448 454 481* 488 490 arg_string based char unaligned dcl 35 set ref 109 111* 115 117 190 192* 201* 204* 315 315 318 318 321 321 324 326* 335* 338* 413 416 432* 435* 440 443 446 448* 454 488 490 argument_no 000106 automatic fixed bin(17,0) dcl 25 set ref 181* 197* 197 199 211 306* 331* 331 333 345 argx 000107 automatic fixed bin(17,0) dcl 26 set ref 101* 102* 105* 115* 182* 183* 186* 307* 308* 311* 404* 405 406* 409* 418* 418 419 425* 428* 453 457* 457 480* 481* 484* 488* brief 000213 automatic bit(1) level 2 packed unaligned dcl 297 set ref 315* 358 373 373* 380 code 000110 automatic fixed bin(35,0) dcl 27 set ref 102* 103 105* 120* 121 123* 166* 167 169* 183* 184 186* 201* 202 218* 219 221* 237* 238 240* 259* 260 262* 280* 281 283* 308* 309 311* 335* 336 365* 366 366 368* 384 384* 406* 407 409* 425* 426 428* 432* 433 481* 482 484* 501 505* 508 511 514* 516* com_err_ 000014 constant entry external dcl 63 ref 105 111 123 149 169 186 192 204 221 240 262 283 311 326 338 368 384 409 421 428 435 448 469 484 514 516 com_err_$suppress_name 000016 constant entry external dcl 64 ref 97 162 213 233 255 276 347 462 command 000000 constant char(16) initial unaligned dcl 53 set ref 97* 97* 105* 111* 123* 149* 162* 162* 169* 186* 192* 204* 213* 213* 221* 233* 233* 240* 255* 255* 262* 276* 276* 283* 311* 326* 338* 347* 347* 368* 384* 409* 421* 428* 435* 448* 462* 462* 469* 484* 514* 516* command_line 000100 automatic char unaligned dcl 476 set ref 488* 490* 490 505* command_line_length 000224 automatic fixed bin(21,0) dcl 393 set ref 413* 413 454* 476 cu_$arg_count 000020 constant entry external dcl 65 ref 94 cu_$arg_list_ptr 000022 constant entry external dcl 66 ref 92 cu_$arg_ptr 000024 constant entry external dcl 67 ref 102 183 308 406 425 cu_$arg_ptr_rel 000026 constant entry external dcl 68 ref 481 cv_dec_check_ 000030 constant entry external dcl 69 ref 201 335 432 error_table_$asynch_change 000010 external static fixed bin(35,0) dcl 57 ref 366 501 511 error_table_$badopt 000012 external static fixed bin(35,0) dcl 59 set ref 111* 192* 326* 448* first_command_line_arg 000225 automatic fixed bin(17,0) dcl 394 set ref 403* 413 453* 460 480 488 index builtin function dcl 40 ref 109 190 324 446 ioa_ 000032 constant entry external dcl 70 ref 173 244 266 287 362 373 376 380 508 iox_$look_iocb 000034 constant entry external dcl 71 ref 120 length builtin function dcl 41 ref 413 454 list 0(02) 000213 automatic bit(1) level 2 in structure "sw" packed unaligned dcl 297 in procedure "status" set ref 321* 354 362 list 0(01) based bit(1) level 2 in structure "trc_flag_s" packed unaligned dcl 1-12 in procedure "trc" set ref 354* no_signal 0(01) 000227 automatic bit(1) level 2 packed unaligned dcl 396 set ref 443* 467 473 non_passive_refs 4 000206 automatic fixed bin(34,0) level 2 dcl 296 set ref 380* null builtin function dcl 42 ref 358 one_more_time 000100 automatic bit(1) unaligned dcl 477 set ref 499* 501 502* operation 000111 automatic char(32) unaligned dcl 28 set ref 115* 127 127 130 130 133 133 136 136 139 139 142 142 145 145 149* passive_refs 3 000206 automatic fixed bin(34,0) level 2 dcl 296 set ref 380* program_interrupt 000000 stack reference condition dcl 48 ref 493 retry_limit 000226 automatic fixed bin(17,0) dcl 395 set ref 401* 432* 501 rtrim builtin function dcl 43 ref 490 signal 000227 automatic bit(1) level 2 packed unaligned dcl 396 set ref 440* 467 473* 493 511 status_s 000206 automatic structure level 1 dcl 296 set ref 360 string builtin function dcl 44 set ref 303* 400* sw 000213 automatic structure level 1 packed unaligned dcl 297 in procedure "status" set ref 303* sw 000227 automatic structure level 1 packed unaligned dcl 396 in procedure "transact" set ref 400* tcf_io_switch 000121 automatic char(32) unaligned dcl 29 set ref 117* 120* 123* tcf_iocb_ptr 000132 automatic pointer dcl 30 set ref 120* 166* 218* 237* 259* 280* 365* 505* transaction_call_$assign 000036 constant entry external dcl 72 ref 166 transaction_call_$change_current_transaction_no 000040 constant entry external dcl 74 ref 218 transaction_call_$commit 000042 constant entry external dcl 76 ref 237 transaction_call_$number 000044 constant entry external dcl 78 ref 259 transaction_call_$rollback 000046 constant entry external dcl 80 ref 280 transaction_call_$status 000050 constant entry external dcl 82 ref 365 transaction_call_$transact 000052 constant entry external dcl 85 ref 505 transaction_failure 000000 stack reference condition dcl 49 ref 511 transaction_no 000134 automatic fixed bin(35,0) dcl 31 in procedure "trc" set ref 166* 173* 201* 218* 237* 240* 244 244* 259* 266* 280* 283* 287 287* 505* 508* 516* transaction_no 1 000206 automatic fixed bin(35,0) level 2 in structure "status_s" dcl 296 in procedure "status" set ref 304* 335* 365* 368 368* 373 373* 373* transaction_status 000214 automatic fixed bin(17,0) dcl 301 set ref 365* 376 376 376 376* 380 trc_INCOMPLETE constant fixed bin(17,0) initial dcl 1-31 ref 376 trc_UNDEFINED constant fixed bin(17,0) initial dcl 1-34 ref 376 380 trc_flag_s based structure level 1 dcl 1-12 trc_flags 000135 automatic bit(36) dcl 1-7 set ref 352* 353 354 365* trc_status based structure level 1 dcl 1-17 trc_status_ptr 000136 automatic pointer dcl 1-8 set ref 358* 360* 365* trc_status_version_1 constant fixed bin(17,0) initial dcl 1-27 ref 356 try 000101 automatic fixed bin(17,0) dcl 478 set ref 497* 501 503* 503 508* 514* verify_refs 0(01) 000213 automatic bit(1) level 2 in structure "sw" packed unaligned dcl 297 in procedure "status" set ref 318* 353 362* verify_refs based bit(1) level 2 in structure "trc_flag_s" packed unaligned dcl 1-12 in procedure "trc" set ref 353* version 000206 automatic fixed bin(17,0) level 2 dcl 296 set ref 356* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. trc_COMMITTED internal static fixed bin(17,0) initial dcl 1-32 trc_ROLLED_BACK internal static fixed bin(17,0) initial dcl 1-33 trc_VERIFY_REFS internal static bit(36) initial dcl 1-26 NAMES DECLARED BY EXPLICIT CONTEXT. assign 001261 constant entry internal dcl 157 ref 127 change_current_transaction_no 001404 constant entry internal dcl 178 ref 130 commit 001724 constant entry internal dcl 228 ref 133 execute_command_line 004041 constant label dcl 499 ref 493 number 002051 constant entry internal dcl 250 ref 136 rollback 002171 constant entry internal dcl 271 ref 139 status 002316 constant entry internal dcl 293 ref 142 transact 003146 constant entry internal dcl 390 ref 145 transaction_call 000626 constant entry external dcl 15 trc 000617 constant entry external dcl 15 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 4474 4550 4237 4504 Length 5022 4237 54 236 234 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME trc 496 external procedure is an external procedure. assign internal procedure shares stack frame of external procedure trc. change_current_transaction_no internal procedure shares stack frame of external procedure trc. commit internal procedure shares stack frame of external procedure trc. number internal procedure shares stack frame of external procedure trc. rollback internal procedure shares stack frame of external procedure trc. status internal procedure shares stack frame of external procedure trc. transact internal procedure shares stack frame of external procedure trc. begin block on line 475 130 begin block uses auto adjustable storage, and enables or reverts conditions. on unit on line 493 64 on unit STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME begin block on line 475 000100 one_more_time begin block on line 475 000100 command_line begin block on line 475 000101 try begin block on line 475 trc 000100 arg_count trc 000101 arg_length trc 000102 arg_list_ptr trc 000104 arg_ptr trc 000106 argument_no trc 000107 argx trc 000110 code trc 000111 operation trc 000121 tcf_io_switch trc 000132 tcf_iocb_ptr trc 000134 transaction_no trc 000135 trc_flags trc 000136 trc_status_ptr trc 000206 status_s status 000213 sw status 000214 transaction_status status 000224 command_line_length transact 000225 first_command_line_arg transact 000226 retry_limit transact 000227 sw transact THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as r_le_a r_ge_a set_stack alloc_cs cat_realloc_cs enter_begin leave_begin call_ext_out_desc call_ext_out return tra_ext alloc_auto_adj signal enable shorten_stack ext_entry int_entry THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ com_err_$suppress_name cu_$arg_count cu_$arg_list_ptr cu_$arg_ptr cu_$arg_ptr_rel cv_dec_check_ ioa_ iox_$look_iocb transaction_call_$assign transaction_call_$change_current_transaction_no transaction_call_$commit transaction_call_$number transaction_call_$rollback transaction_call_$status transaction_call_$transact THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$asynch_change error_table_$badopt LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 15 000616 92 000633 94 000641 95 000650 97 000653 98 000703 101 000704 102 000711 103 000726 105 000730 106 000761 109 000762 111 000776 112 001030 115 001031 117 001040 118 001043 120 001045 121 001066 123 001070 124 001117 127 001120 130 001132 133 001144 136 001156 139 001170 142 001202 145 001214 149 001226 150 001257 153 001260 157 001261 160 001262 162 001265 163 001315 166 001316 167 001331 169 001333 170 001357 173 001360 174 001403 178 001404 181 001405 182 001406 183 001415 184 001432 186 001434 187 001465 190 001466 192 001502 193 001534 197 001535 199 001536 201 001541 202 001564 204 001566 205 001622 209 001623 211 001625 213 001630 215 001660 218 001661 219 001674 221 001676 222 001722 224 001723 228 001724 231 001725 233 001730 234 001760 237 001761 238 001774 240 001776 241 002025 244 002026 246 002050 250 002051 253 002052 255 002055 256 002105 259 002106 260 002121 262 002123 263 002147 266 002150 267 002170 271 002171 274 002172 276 002175 277 002225 280 002226 281 002241 283 002243 284 002272 287 002273 289 002315 293 002316 303 002317 304 002321 306 002322 307 002323 308 002332 309 002347 311 002351 312 002402 315 002403 318 002420 321 002433 324 002446 326 002460 327 002512 331 002513 333 002514 335 002517 336 002542 338 002544 339 002600 343 002601 345 002603 347 002606 349 002636 352 002637 353 002640 354 002645 356 002655 358 002657 360 002666 362 002670 365 002715 366 002736 368 002743 370 003000 373 003001 376 003033 380 003075 384 003126 386 003145 390 003146 400 003147 401 003151 403 003152 404 003153 405 003155 406 003160 407 003175 409 003177 410 003230 413 003231 416 003240 418 003246 419 003247 421 003252 422 003277 425 003300 426 003315 428 003317 429 003350 432 003351 433 003376 435 003400 436 003437 438 003440 440 003441 443 003450 446 003457 448 003471 449 003523 453 003524 454 003526 457 003530 458 003531 460 003532 462 003534 464 003564 467 003565 469 003575 470 003622 473 003623 475 003630 476 003633 505 003643 480 003646 481 003656 482 003675 484 003700 485 003731 488 003734 490 003747 491 004013 493 004016 497 004040 499 004041 501 004043 502 004055 503 004056 505 004057 506 004103 508 004104 511 004133 514 004145 516 004176 517 004224 518 004225 ----------------------------------------------------------- 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