COMPILATION LISTING OF SEGMENT mrds_dsl_init_res Compiled by: Multics PL/I Compiler, Release 33a, of May 30, 1990 Compiled at: ACTC Technologies Inc. Compiled on: 10/17/90 0817.0 mdt Wed Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1988 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1981 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 /****^ HISTORY COMMENTS: 13* 1) change(85-11-17,Dupuis), approve(85-12-16,MCR7314), 14* audit(86-02-04,Brunelle), install(86-02-05,MR12.0-1013): 15* Deleted some unused declarations (see mrds #141) 16* 2) change(86-02-12,Spitzer), approve(86-02-12,MCR7311), 17* audit(86-09-02,Blair), install(86-10-16,MR12.0-1187): 18* added checks to see if there are any domains or relations in the database 19* now that rmdb can make these kind of database. if none, set various ptrs 20* in the dbcb to null or to null structures. 21* changed mu_temp_segments$free_segments to release them instead (so they get 22* truncated). 23* 3) change(86-08-13,Hergert), approve(88-07-13,MCR7903), 24* audit(88-07-13,Dupuis), install(88-08-01,MR12.2-1073): 25* Removed changes made on 84-08-31 and reinstalled the old MR10.2 code. The 26* way it was doing domain proc initiations was very slow. 27* 4) change(87-01-22,Hergert), approve(88-07-13,MCR7903), 28* audit(88-07-13,Dupuis), install(88-08-01,MR12.2-1073): 29* For new parser, added initializtion of dbcb.se_info_ptr. 30* 5) change(90-10-10,Zimmerman), approve(90-10-10,MCR8215), 31* audit(90-10-15,Gray), install(90-10-17,MR12.4-1044): 32* Add dm_not_available handler to execute clean shutdown if an attempt is 33* made to open a data_management db when data_management is not available. 34* END HISTORY COMMENTS */ 35 36 37 mrds_dsl_init_res: init_res: proc (view_dir, view_ent, dsm_sw, ready_mode, db_index, dbcb_ptr, administrator, error_code); 38 39 /* 40* BEGIN_DESCRIPTION: 41* 42* This routine, given the path name of a database model or submodel, will 43* "open" that database, returning a pointer to the resultant model created 44* upon opening, and a database index to be used in all future reference to 45* the database for file ready/finish, data retrieve/modify, and database 46* close operations. 47* END_DESCRIPTION 48* 49*Known Bugs: 50* 82-08-23 Davids: The values of the access_costs for a page_file type 51* database must be determined (it wouldn't hurt to redetermine the values for 52* the vfile case either) 53* 54*Other Problems: 55* 56* PARAMETERS: 57* 58* view_dir - - (input) char (*) database model or submodel pathname down to 59* the directory level 60* 61* view_ent - - (input) char(*) database model or submodel entryname under the 62* above directory 63* 64* dsm_sw - - (input) bit(1), on => submodel to be opened, else model 65* 66* ready_mode - - (input) fixed bin, 5 => retrieve mode, 6 => update mode. 67* 68* db_index - - (output) fixed bin(35) variable holding the database index 69* returned for the newly opened database, whose value will be 0 upon error or 70* incomplete open 71* 72* dbcb_ptr - - (output) pointer to the resultant model built during opening 73* 74* administrator - - (output) bit (1) "1"b -> if the opener is a DBA 75* 76* error_code - - (output) fixed bin(35) error type encoding, 0 unless an 77* error occurred 78* 79* sub_error_ - - (output) condition, signaled upon detection of error for 80* further info 81* 82* 83* 84* HISTORY: 85* 86* 78-08-01 Oris Friesen: Originally written. 87* 88* 79-03-14 Al Kepner: Modified to remove quiesce_sw parameter. 89* 90* 79-03-23 Al Kepner: Modified to set dbcb.transact_ctl_seg. 91* 92* 79-05-31 Al Kepner: Modified to create the segment for current selection 93* expression allocations. 94* 95* 79-07-01 Jim Gray : Rewritten to 96* 1) add sub_err_ reporting of errors and structured error handling 97* 2) correct handling of submodels 98* 3) correct db_index subroutine calls 99* 4) add backing out of an open upon error 100* 5) correctly initialize dbcb 101* 6) improve interface to init_res 102* 7) add proper initialization 103* 8) document the modules logic 104* 105* 80-10-01 Lindsey Spratt: Modified to use new submodel system; calls to 106* dsmd_$foo were altered to be calls to the actual mrds_dsm_foo module, a 107* submodel_iocb_ptr (in external static) was added to keep track of the 108* "current" submodel opening (a better technology might be to have the 109* submodel iocb ptr part of the dbcb). 110* 111* 80-10-24 Jim Gray : Modified to add initialization of new dbcb bit 112* "new_select_expr". 113* 114* 80-11-03 Jim Gray : Modified to change delete_$ptr to hcs_$delentry_seg 115* calls for performance. 116* 117* 80-11-07 Jim Gray : Modified to add opening security checks so that if the 118* database model is secured, it can not be opened via the model and if opened 119* by a submodel, the submodel must reside in the submodel dir under the 120* database. 121* 122* 80-11-18 Jim Gray : Modified to remove link access violation trick with 123* db_model when doing a secure open (allowed submodel not being under db_dir) 124* 125* 80-11-19 Jim Gray : Modified to compare uid's of given submodel, and actual 126* db_dir>sm_dir>submodel, so add_names on submodel_dir could be used. Also, 127* links into the submodels are allowed, but links out from the submodel dir 128* are not. 129* 130* 80-12-09 Jim Gray : only the latest version control segment is now allowed 131* to be used in opening a database until an AMDB -rs is done to update the 132* version of the dbc to 5, and the seg name to "db.control" This is done via 133* the mu_concurrency_control$open_control_segment routine. 134* 135* 80-12-24 Jim Gray : improved error message for cases where no "w" access to 136* database control segment, when attempting to log new opener. 137* 138* 81-01-12 Jim Gray : added submodel version parameter to mu_sec_init_res, 139* and now init it from the submodel header, when a submodel opening is used. 140* 141* 81-01-22 Davids: changed mrds_dsm_open_read to mrds_dsm_open$read. also 142* removed the mrds_dsm_entry_dcls include file. 143* 144* 81-01-31 Jim Gray : added setting of needed access for DBA types, if ac 145* access violation occurs. 146* 147* 81-02-10 Jim Gray : made the check for the submodel being in the sm_dir 148* when the database is secured, an external routine mrds_dm_secured_submodel, 149* so that other commands could make use of it. 150* 151* 81-04-06 Jim Gray : added ability of DBA to be allowed to open through the 152* model view for a secured database. 153* 154* 81-04-30 Jim Gray : added ability of a DBA to open through an un-installed 155* submodel. 156* 157* 81-05-13 Rickie E. Brinegar : Modified to fill the administrator bit in 158* the resultant. 159* 160* 81-06-05 Davids: changed the include file mrds_dsm_header_str to 161* mrds_dsm_header, (user interface include file to internal mrds 162* include file). 163* 164* 81-07-06 Jim Gray : added init for dbcb.open_mode, 165* new_select_expr, no_optimize, print_search_order, 166* last_store_rel_name, last_s_e_id_num 167* 168* 81-12-07 Roger Lackey : change the initization of the variable caller_name 169* from mrds_dsl_open to mrds_dsl_init_res. 170* 171* 82-08-20 Mike Kubicar : Added the initialization of dbcb.store_vector to 172* the init_dbcb routine. 173* 174* 82-08-23 Davids: added code to initialize the dbcb.relmgr_entries and 175* dbcb.access_cost substructures depending on type of database, i.e. 176* vfile or page_file. 177* 178* 82-09-09 Mike Kubicar : Added the initialization of dbcb.modify_vector. 179* 180* 82-10-12 Davids: modifications so that module would compile - 181* changed references to dbcb.store_vector and modify_vector to store and 182* modify_vector_ptr. Changed references to dbcb.relmgr_entries.delete_tuple_by_id 183* and modify_tuple_by_id to delete and modify_tuples_by_id. Deleted reference 184* to dbcb.transact_ctl_seg and replaced it with dbcb.transactions_needed 185* which is set to "1"b if the db_model_db_type ^= 1. Also set the value of 186* dbcb.relmgr_entries.put_tuple and dbcb.cursor_ptrs_storage_ptr and 187* dbcb.cursor_storage_area_ptr. This included adding to the clean_up 188* procedure to delete cursor_storage_area_ptr. 189* 190* 82-10-13 Davids: changed vrm_* entries to vfile_relmgr_$* 191* 192* 82-10-15 Davids: removed call to mu_define_area to set up the cursor 193* storage area (dbcb.cursor_storage_area_ptr) and the code in the clean_up 194* routine to clean it up. The area is no set up by mu_cursor_manager_$get 195* 196* 83-01-25 Roger Lackey : Applied get_shortest_path_ to db_path and dsm_path 197* so sub_err_ messages (limited to 256 chars) would 198* display more of the message. 199* 200* 83-02-02 Davids: Added call to hcs_$get_uid_seg to set the dbcb.dbc_uid 201* element in the internal proc init_dbcb. Added the exit_init_dbcb label 202* to branch to incase of an error. 203* 204* 83-02-10 Mike Kubicar : Removed the call to get shortest path since it 205* caused the database names printed by dmod and friends to be somewhere 206* between non-obvious and wrong. 207* 208* 83-02-14 Davids: modified to use the new db_type_flags in the db_model 209* structure instead of the old numeric db_type. 210* 211* 83-02-25 Davids: modified to set the new concurrency_on and rollback_on 212* elements in the dbcb structure. 213* 214* 83-04-25 Davids: Modified to reduce deep nesting by having error states 215* call the new error_exit procedure which cleans up and does a non-local 216* goto to leave this procedure. Removed the call to get a temp segment to 217* base an area on when the opening is via a submodel so that space will be 218* avaialble to read the submodel header, instead just increased the size of 219* the local_area variable by 100 (to 200) to allow space to allocate the 220* header. Added code in-line to close the submodel after the call to 221* mu_sec_init_res so that a normal exit does not need to call the clean up 222* handler. Modified the error handling in the internal procedure init_dbcb 223* so that it calls the error_exit procedure instead of goto the exit_init_dbcb 224* label which just caused the procedure to return. Eliminated the extra rtrim 225* on the view_ent variable when the input_path is built in 226* get_model_path_and_pointer. Modified the allocation of the simple and 227* general type vectors to be allocated in the dbcb.static_area instead of the 228* system free area. 229* 230* 83-05-02 Davids: Deleted references to the dm_specification include file 231* since mike removed the get_next_search_specification pointer from the dbcb. 232* Removed code in the init_dbcb internal proc that set the pointer and 233* allocated and filled in the structure. Modified so that instead of calling 234* hcs_$make_seg to create the curdat, stadat, and select_area segments a call 235* to mu_temp_segments$get_temp_segments is made. The clean_up procedure was 236* modified to call either mu_temp_segments$free_all_temp_segments if the 237* temp_dir is the pdir or delete_all_temp_segments if its some other temp dir. 238* the db_pic variable was created to be a character representation of the db 239* index so that it could be used to make the caller to mu_temp_segments 240* unique. the res_in_pdir was created to keep track of where the segments were 241* created. The new flag in the dbcb resultant_in_pdir is set from res_in_pdir. 242* All this was done so that multiple openings (when using the pdir as a temp 243* dir) will be faster. The first opening will be somewhat slower since there 244* is more overhead in using temp segments than in just creating a segment. 245* 246* 83-05-04 Davids: Changed the name that the temp segments are gotten with 247* from mrds_dsl_init_resDBI to MRDSDBI so that all temp segments can be 248* cleaned up with 1 call in mrds_dsl_close. 249* 250* 83-05-06 Davids: Modified so that the cleanup handler does not explicitly 251* delete the rdbi segment in case of an error but just calls mu_temp_segments 252* to do the correct thing (delete or release). This should have been done 253* yesterday! It caused strange segment number problems if an opening failed 254* because the segment was gone but mu_temp_segments was still handing out 255* a pointer to it. 256* 257* 83-05-17 Davids: Renamed the internal procedure create_resultant to 258* create_resultant_segments since it does not actually fill in the 259* dbcb and rdbi structures. Also create_resultant_segments now gets four 260* temp segments instead of 3, the fourth is four the rdbi segment which 261* is no longer obtained in the mu_sec_init_res module. Created the 262* internal procedures copy_resultant_data and generate_resultant_data. 263* copy will copy the dbcb and rdbi segments from the database dir if they 264* exist and update the process dependent values while generate will generate 265* the resultant data from the model as it used to do (its the same code just 266* moved into an internal proc). 267* 268* 83-05-18 Davids: Added a new input parameter - ready_mode. This is needed 269* to update the rm_rel_info structures in the rdbi segment if the segment is 270* copied from a saved version. Added the internal procedures (with calls in 271* copy_resultant_data) update_rm_domain_info and update_rm_rel_info (which 272* also updates the rm_attr_info structure). These procedures complete the 273* process of updating the rdbi structures so that they can be used by this 274* process in this database opening. The internal proc build_entry was also 275* added. this entry was copied from mu_sec_make_res and is used to make an 276* entry varaible given a path_name$entry_name. Also cahnged the init_dbcb 277* internal proc to set the res_laready_made element of the dbcb to OFF while 278* copy_resultant_data internal proc sets it to "1"b. 279* 280* 83-05-20 Davids: Added the entries report_on_res_creation_(on off) and the 281* internal static variable report_on_res_creation. These are debugging aids 282* to report how the resultant was actually created. Also added code in the 283* copy_resultant_data procedure to check the version of the saved resultant 284* and not use it if it is not equal to the mrds_data_$saved_res_version 285* element. 286* 287* 83-05-23 Davids: Added the new output parameter administrator. "1"b -> 288* that the opener is a DBA for the database. This is needed so that open 289* does not also have to determine if the opener is a DBA. If the opener is 290* a DBA and the resultant is made from scratch than open will create a 291* copy of the resultant in the db dir. Also the rm_db_info.mdbm_secured 292* bit is not set based on the db_model.mdbm_secured bit instead of relying 293* on the stored value. 294* 295* 83-05-26 Davids: Modified so that the rm_db_info.db_path and dsm_path are 296* updated from the saved value when the saved resultant is used to open the 297* db. This was needed because the path that was used to open the db might not 298* be the actual db_path, i.e. links and the path the user actual used should be 299* used. Added the call to error_exit in build_entry after the sub_err_ call 300* reporting that the encode procedure could not be found, this prevents the 301* database from being opened anyway. Added code in update_rm_rel_info to try 302* to initiate the the relation models and report and error and fail to open 303* if the opener does not have access to read the model. Also to check the 304* version number of the id_list structure and if its not the expected value, i.e. 305* 1 to not use the saved resultant in the opening. 306* 307* 83-06-01 Davids: Removed the reference to the dm_specification include file 308* which was not used. Also fixed the loop that adjusted the key_attr_ptrs 309* pointers in rm_rel_info so that it looped though all the key_attr_ptrs 310* instead of just the last one. 311* 312* 83-06-02 Mike Kubicar : Updated relation manager calling sequence 313* declarations. 314* 315* 83-06-09 Davids: Modified internal proc copy_resultant_data to 316* give the dba access if he doesn't have it and to just generate 317* a resultant from scratch if a non-DBA doesn't have access to the 318* saved dbcb and rdbi segments or if any other error occurs. 319* 320* 83-08-03 Mike Kubicar : Added code to initialize the new dbcb entry 321* element_id_list_segment_ptr which points to the segment which contains 322* the static element id lists. It also gets this segment at database 323* opening time. 324* 325* 84-08-31 Thanh Nguyen: Modified the build_entry proc to handle the case 326* of same entry name for check or encode or decode procs but located in 327* different directory. 328* 329* 84-09-04 John Hergert: Added the initialization of dbcb.compiled_se_info_ptr 330* 331* 84-10-16 Thanh Nguyen: Modified the build_entry proc to call hcs_$make_entry 332* with the entrypoint name because it may be different than the entry name. 333* 334* 84-11-22 John Hergert: Fixed bug where trying to open large dbs caused 335* strange problems. This was because the variable chars was declared fb17 336* which wasn't large enough to handle the number of bits in the rdbi seg 337* in the resultant_segs dir. Changed it to fb24. 338* 339* 85-01-15 Thanh Nguyen: Added the initialization of dbcb.work_area_ptr. 340* 341* 85-04-14 Thanh Nguyen: Added code to automatically update the rdbi and dbcb 342* segments under resultant_segs.dir when the saved_res_version is changed. 343* Also added code to initialize new reserved ptrs, words and entries of the 344* new dbcb structure. 345**/ 346 347 /* initialize */ 348 349 error_code = 0; 350 submodel_version, db_index = 0; 351 dbcb_ptr, rdbi_ptr = null (); 352 curdat_ptr, stadat_ptr = null (); 353 model_seg_ptr = null (); 354 clean_up_condition = OFF; 355 submodel_open = OFF; 356 res_in_pdir = OFF; 357 db_pic = 0; 358 359 /* establish handler to undo loose ends if users does a quit/release */ 360 361 on cleanup begin; 362 clean_up_condition = ON; 363 if ^substr (db_mrds_dsl_init_res, 1, 1) then ; 364 else on sub_error_ ; /* ignore sub_err_ calls during cleanup */ 365 call clean_up (); 366 end; 367 368 /* establish handler to exit gracefully if an attempt is made to open a Data_Management file when DM is not running. */ 369 370 371 on dm_not_available_ begin; 372 373 error_code = dm_error_$system_not_initialized; 374 call sub_err_ (error_code, caller_name, continue, info_ptr, return_value, ""); 375 call error_exit; 376 377 end; 378 379 /* construct pathnames of the model, the submodel if needed, and get 380* a pointer to the db_model segment in the database */ 381 382 call get_model_path_and_pointer (); 383 384 385 /* set up the concurrent access control */ 386 387 call mu_concurrency_control$open_control_segment (db_path, dbc_ptr, bc, error_code); 388 if error_code ^= 0 389 then call error_exit; 390 391 392 /* now the non-secure resultant segments can be made, 393* and a database index obtained for this opening */ 394 395 call create_resultant_segments (); 396 397 if ^dsm_sw 398 then call copy_resultant_data; 399 else call generate_resultant_data; 400 401 /* this user must be added to the list of database openers */ 402 403 call mu_sec_reg_user (dbcb.dbc_ptr, rdbi_ptr, error_code); 404 if error_code ^= 0 405 then call error_exit; /* error is reported to user in a lower routine */ 406 else dbcb.dbc_incr = ON; 407 408 exit_mrds_dsl_init_res: 409 return; 410 411 report_on_res_creation_on: entry; 412 413 report_on_res_creation = "1"b; 414 415 return; 416 417 418 419 report_on_res_creation_off: entry; 420 421 report_on_res_creation = "0"b; 422 423 return; 424 425 get_model_path_and_pointer: procedure (); 426 427 /* obtain the pathname to the database model, directly if this is for a model opening, 428* indirectly if this is a submodel opening, and also get the submodel pathname */ 429 430 if length (rtrim (view_dir)) + length (rtrim (view_ent)) + 1 > length (input_path) 431 then do; 432 error_code = error_table_$dirlong; 433 call error_exit; 434 end; 435 else input_path = rtrim (view_dir) || ">" || rtrim (view_ent); 436 437 if ^dsm_sw 438 then do; /* model opening */ 439 db_path = input_path; 440 dsm_path = db_path; /* equal since model opening */ 441 end; 442 else do; /* submodel opening */ 443 dsm_path = input_path; 444 call mrds_dsm_open$read /* get the model path from the submodel */ 445 (dsm_path, submodel_iocb_ptr, error_code); 446 if error_code ^= 0 447 then do; 448 call sub_err_ (error_code, caller_name, continue, info_ptr, return_value, "^/^a^a^a", 449 "Unable to open the submodel using the pathname """, dsm_path, """."); 450 call error_exit; 451 end; 452 453 submodel_open = ON; 454 455 call mrds_dsm_read_header (addr (local_area), header_ptr, submodel_iocb_ptr, error_code); 456 if error_code ^= 0 457 then do; 458 call sub_err_ (error_code, caller_name, continue, info_ptr, return_value, "^/^a^a^a", 459 "Unable to get the header information from the submodel using the pathname """, 460 dsm_path, """."); 461 call error_exit; 462 end; 463 464 db_path = header_ptr -> mrds_dsm_header.database_pn; 465 submodel_version = header_ptr -> mrds_dsm_header.dsm_generator_version; 466 end; 467 468 call initiate_file_ /* get a pointer to the common model segment */ 469 (db_path, "db_model", R_ACCESS, dbm_ptr, (0), code); 470 if code = error_table_$moderr 471 then do; 472 call mrds_dm_authorization$set_needed_access (rtrim (db_path), code); /* fails if caller not DBA */ 473 if code ^= 0 474 then code = error_table_$moderr; 475 else call initiate_file_ (db_path, "db_model", R_ACCESS, dbm_ptr, (0), code); 476 end; 477 if dbm_ptr = null () 478 then do; 479 error_code = code; 480 call sub_err_ (error_code, caller_name, continue, info_ptr, return_value, "^/^a^a^a", 481 "Unable to get a pointer to db_model under the database directory """, db_path, """."); 482 call error_exit; 483 end; 484 485 call mrds_dm_authorization$get_user_class (rtrim (db_path), addr (local_area), 486 mrds_authorization_structure_version, mrds_authorization_ptr, error_code); 487 if error_code ^= 0 488 then call error_exit; 489 490 administrator = mrds_authorization.administrator; /* send the type of user back to mrds_dsl_open */ 491 492 if db_model.mdbm_secured 493 then do; /* if database has been secured */ 494 if ^mrds_authorization.administrator 495 then do; /* administrators can always open */ 496 if ^dsm_sw /* normal users must open via a submodel */ 497 then do; 498 499 error_code = mrds_error_$inc_secure_open; 500 call sub_err_ (error_code, caller_name, continue, info_ptr, return_value, 501 "^/^a^a^a ^a", 502 "The path """, db_path, 503 """ refers to a database that has been secured,", 504 "and can only be be opened via a secure submodel by a non-DBA."); 505 call error_exit; 506 end; 507 508 if ^mrds_dm_secured_submodel /* it must be a secure submodel */ 509 (rtrim (db_path), rtrim (view_dir), rtrim (view_ent)) 510 then do; 511 error_code = mrds_error_$inc_secure_open; 512 call sub_err_ (error_code, caller_name, continue, info_ptr, return_value, 513 "^/^a^a^a^a^a ^a^a^a", 514 "The submodel """, dsm_path, """ refers to a database """, 515 db_path, """ that has been secured,", 516 "but the submodel itself is not in the databases inferior directory """, 517 mrds_data_$submodel_dir_name, """."); 518 call error_exit; 519 end; 520 end; 521 end; 522 end; 523 524 create_resultant_segments: procedure (); 525 526 /* the dbcb(database control) segment, and select area segments must be created, 527* and a database index must be obtained for this opening */ 528 529 /* create the dbcb segment */ 530 531 resultant_dir = mrds_dsl_resultant_storage$get (); 532 if substr (resultant_dir, 2, 15) = "process_dir_dir" 533 then resultant_dir = ">pdd>" || substr (resultant_dir, 18); 534 535 call hcs_$make_seg (resultant_dir, unique_chars_ ("0"b) || ".mrds.dbcb", "", 536 RW, dbcb_ptr, error_code); 537 if dbcb_ptr = null () 538 then do; 539 call sub_err_ (error_code, caller_name, continue, info_ptr, return_value, "^/^a^a^a^a^a", 540 "Unable to create the resultant model dbcb segment under the directory """, 541 resultant_dir, """ for the database """, dsm_path, """."); 542 call error_exit; 543 end; 544 545 call mu_database_index$get_database_index /* get a database opening index for the user */ 546 (db_index, dbcb_ptr); /* save ptr and get index for it */ 547 if db_index = 0 548 then do; 549 error_code = mrds_error_$too_many_dbs; 550 call sub_err_ (error_code, caller_name, continue, info_ptr, return_value, "^/^a ^d ^a^a^a", 551 "The maximum number of database openings =", mrds_data_$max_dbs, "has been exceeded by """, 552 dsm_path, """."); 553 call error_exit; 554 end; 555 db_pic = db_index; 556 557 process_dir = get_pdir_ (); 558 if substr (process_dir, 2, 15) = "process_dir_dir" 559 then process_dir = ">pdd>" || substr (process_dir, 18); 560 561 if resultant_dir = process_dir 562 then res_in_pdir = "1"b; 563 else res_in_pdir = "0"b; 564 565 call mu_temp_segments$get_temp_segments (db_index, "MRDS" || db_pic, ptr_array, error_code); 566 if error_code ^= 0 567 then do; 568 call sub_err_ (error_code, caller_name, continue, info_ptr, return_value, 569 "Could not create temporary segments for the opening of ^a", dsm_path); 570 call error_exit; 571 end; 572 curdat_ptr = ptr_array (1); /* tuple retrieve area */ 573 stadat_ptr = ptr_array (2); /* "first selerct tuple" retrieve area */ 574 model_seg_ptr = ptr_array (3); /* select area segment */ 575 rdbi_ptr = ptr_array (4); /* rdbi segment */ 576 el_id_seg_ptr = ptr_array (5); /* Element id lists */ 577 578 model_area_ptr = pointer (model_seg_ptr, size (model_seg)); 579 dbcb.select_area_ptr = model_area_ptr; 580 call mrds_dsl_init_select_area /* initialize the select area segment */ 581 (dbcb_ptr, error_code); 582 if error_code ^= 0 583 then do; 584 call sub_err_ (error_code, caller_name, continue, 585 info_ptr, return_value, "^/^a^a^a", 586 "Unable to initialize the select area for database """, 587 dsm_path, """."); 588 call error_exit; 589 end; 590 end; 591 592 copy_resultant_data: proc; 593 594 dcl saved_rdbi_ptr ptr; /* pointer to the saved copy of the rdbi segment */ 595 dcl rdbi_bit_count fixed bin (24); /* bit count of the saved rdbi segment */ 596 dcl saved_dbcb_ptr ptr; /* pointer to the saved copy of the dbcb segment */ 597 dcl dbcb_bit_count fixed bin (24); /* bit count of the saved dbcb segment */ 598 dcl chars fixed bin (24); /* number of characters in the rdbi and dbcb segments */ 599 dcl chars_overlay char (chars) based;/* character overlay for copying the segments */ 600 dcl bad_id_list_version bit (1); /* "1"b => the structure of the id_list has changed */ 601 602 call initiate_file_ (rtrim (db_path) || ">resultant_segs.dir", "rdbi", R_ACCESS, 603 saved_rdbi_ptr, rdbi_bit_count, error_code); 604 if error_code = error_table_$moderr | error_code = error_table_$no_info 605 then do; /* see if access can be set */ 606 call mrds_dm_authorization$set_needed_access (rtrim (db_path), code); 607 if code = 0 608 then call initiate_file_ (rtrim (db_path) || ">resultant_segs.dir", "rdbi", R_ACCESS, 609 saved_rdbi_ptr, rdbi_bit_count, error_code); 610 end; 611 if error_code ^= 0 /* if there is any error just */ 612 then do; /* give up and generate a copy */ 613 call generate_resultant_data; 614 goto exit_copy_resultant_data; 615 end; 616 617 call initiate_file_ (rtrim (db_path) || ">resultant_segs.dir", "dbcb", R_ACCESS, 618 saved_dbcb_ptr, dbcb_bit_count, error_code); 619 if error_code = error_table_$moderr | error_code = error_table_$no_info 620 then do; /* see if access can be set */ 621 call mrds_dm_authorization$set_needed_access (rtrim (db_path), code); 622 if code = 0 623 then call initiate_file_ (rtrim (db_path) || ">resultant_segs.dir", "dbcb", R_ACCESS, 624 saved_dbcb_ptr, dbcb_bit_count, error_code); 625 end; 626 if error_code ^= 0 /* if there is any error just */ 627 then do; /* give up and generate a copy */ 628 call generate_resultant_data; 629 goto exit_copy_resultant_data; 630 end; 631 632 if saved_rdbi_ptr -> rm_db_info.saved_res_version ^= mrds_data_$saved_res_version 633 then do; 634 call generate_resultant_data; 635 if mrds_authorization.administrator then do; 636 /* He/She is a DBA so let update the saved_res_version and the dbcb struture for resultant_segs.dir */ 637 saved_rdbi_ptr -> rm_db_info.saved_res_version = mrds_data_$saved_res_version; 638 saved_dbcb_ptr -> dbcb = dbcb; 639 end; 640 goto exit_copy_resultant_data; 641 end; 642 643 chars = divide (rdbi_bit_count, 9, 24, 0) + 1; /* add 1 to make sure that any bits after */ 644 rdbi_ptr -> chars_overlay = saved_rdbi_ptr -> chars_overlay; /* the last full character are also copyed */ 645 646 rm_db_info.administrator = mrds_authorization.administrator; 647 rm_db_info.mdbm_secured = db_model.mdbm_secured; 648 rm_db_info.db_path = db_path; 649 rm_db_info.sm_path = dsm_path; 650 rm_db_info.ra_ptr = ptr (rdbi_ptr, rel (rm_db_info.ra_ptr)); 651 rm_db_info.tra_ptr = ptr (rdbi_ptr, rel (rm_db_info.tra_ptr)); 652 if rm_db_info.domain_list_ptr ^= null 653 then do; 654 rm_db_info.domain_list_ptr = ptr (rdbi_ptr, rel (rm_db_info.domain_list_ptr)); 655 656 call update_rm_domain_info; 657 end; 658 659 bad_id_list_version = "0"b; 660 call update_rm_rel_info (bad_id_list_version); 661 if bad_id_list_version 662 then do; 663 call generate_resultant_data; 664 goto exit_copy_resultant_data; 665 end; 666 667 chars = divide (dbcb_bit_count, 9, 17, 0) + 1; 668 dbcb_ptr -> chars_overlay = saved_dbcb_ptr -> chars_overlay; 669 670 call hcs_$get_uid_seg (dbc_ptr, dbcb.dbc_uid, error_code); 671 if error_code ^= 0 672 then do; 673 call sub_err_ (error_code, caller_name, continue, info_ptr, return_value, 674 "Unable to obtain the unique identifier of the data base control segment, opening will be aborted"); 675 call error_exit; 676 end; 677 dbcb.work_area_ptr = null (); /* just make sure it is null. */ 678 dbcb.reserved_ptrs (*) = null (); 679 dbcb.dbc_ptr = dbc_ptr; 680 dbcb.select_area_ptr = model_area_ptr; 681 dbcb.current_data_ptr = curdat_ptr; 682 dbcb.static_data_ptr = stadat_ptr; 683 dbcb.rdbi_ptr = rdbi_ptr; 684 dbcb.element_id_list_segment_ptr = el_id_seg_ptr; 685 dbcb.resultant_in_pdir = res_in_pdir; 686 dbcb.dbi = db_index; 687 dbcb.res_already_made = "1"b; 688 if dbcb.scope_ptr = null 689 then do; 690 max_file_init = 0; 691 allocate scope_info set (scope_ptr) in (dbcb.static_area); 692 scope_info.mbz1 = "0"b; 693 scope_info.active_scopes = 0; 694 dbcb.scope_ptr = scope_ptr; 695 end; 696 else dbcb.scope_ptr = ptr (dbcb_ptr, rel (dbcb.scope_ptr)); 697 dbcb.store_vector_ptr = ptr (dbcb_ptr, rel (dbcb.store_vector_ptr)); 698 dbcb.modify_vector_ptr = ptr (dbcb_ptr, rel (dbcb.modify_vector_ptr)); 699 if db_model.db_type_flags.vfile_type 700 then do; /* vfile type data base */ 701 dbcb.relmgr_entries.open = vfile_relmgr_$open; 702 dbcb.relmgr_entries.close = vfile_relmgr_$close; 703 dbcb.relmgr_entries.create_cursor = vfile_relmgr_$create_cursor; 704 dbcb.relmgr_entries.destroy_cursor = vfile_relmgr_$destroy_cursor; 705 dbcb.relmgr_entries.set_scope = vfile_relmgr_$set_scope; 706 dbcb.relmgr_entries.delete_tuples_by_id = vfile_relmgr_$delete_tuples_by_id; 707 dbcb.relmgr_entries.modify_tuples_by_id = vfile_relmgr_$modify_tuples_by_id; 708 dbcb.relmgr_entries.get_tuple_by_id = vfile_relmgr_$get_tuple_by_id; 709 dbcb.relmgr_entries.get_tuples_by_spec = vfile_relmgr_$get_tuples_by_spec; 710 dbcb.relmgr_entries.get_tuple_id = vfile_relmgr_$get_tuple_id; 711 dbcb.relmgr_entries.put_tuple = vfile_relmgr_$put_tuple; 712 dbcb.relmgr_entries.get_count = vfile_relmgr_$get_count; 713 dbcb.relmgr_entries.get_population = vfile_relmgr_$get_population; 714 dbcb.relmgr_entries.get_duplicate_key_count = vfile_relmgr_$get_duplicate_key_count; 715 dbcb.relmgr_entries.create_relation = vfile_relmgr_$create_relation; 716 dbcb.relmgr_entries.create_index = vfile_relmgr_$create_index; 717 dbcb.relmgr_entries.destroy_relation_by_path = vfile_relmgr_$destroy_relation_by_path; 718 end; 719 else do; /* page_file type database */ 720 721 dm_system_state = dm_gate_$dm_get_system_state(); /* 12.4 This will signal dm_not_available if the dm system is down. */ 722 dbcb.relmgr_entries.open = relation_manager_$open; 723 dbcb.relmgr_entries.close = relation_manager_$close; 724 dbcb.relmgr_entries.create_cursor = relation_manager_$create_cursor; 725 dbcb.relmgr_entries.destroy_cursor = relation_manager_$destroy_cursor; 726 dbcb.relmgr_entries.set_scope = relation_manager_$set_scope; 727 dbcb.relmgr_entries.delete_tuples_by_id = relation_manager_$delete_tuples_by_id; 728 dbcb.relmgr_entries.modify_tuples_by_id = relation_manager_$modify_tuples_by_id; 729 dbcb.relmgr_entries.get_tuple_by_id = relation_manager_$get_tuple_by_id; 730 dbcb.relmgr_entries.get_tuples_by_spec = relation_manager_$get_tuples_by_spec; 731 dbcb.relmgr_entries.get_tuple_id = relation_manager_$get_tuple_id; 732 dbcb.relmgr_entries.put_tuple = relation_manager_$put_tuple; 733 dbcb.relmgr_entries.get_count = relation_manager_$get_count; 734 dbcb.relmgr_entries.get_population = relation_manager_$get_population; 735 dbcb.relmgr_entries.get_duplicate_key_count = relation_manager_$get_duplicate_key_count; 736 dbcb.relmgr_entries.create_relation = relation_manager_$create_relation; 737 dbcb.relmgr_entries.create_index = relation_manager_$create_index; 738 dbcb.relmgr_entries.destroy_relation_by_path = relation_manager_$destroy_relation_by_path; 739 740 end; 741 742 if report_on_res_creation 743 then call ioa_ ("Resultant has been created by copying from the saved copy: version is ^a", 744 saved_rdbi_ptr -> rm_db_info.saved_res_version); 745 746 exit_copy_resultant_data: 747 return; 748 749 end; 750 751 update_rm_domain_info: proc; 752 753 dcl domain_header_ptr ptr; 754 dcl found bit (1); 755 dcl NULLOFFSET bit (18) init ((18)"1"b) internal static options (constant); 756 757 domain_header_ptr = ptr (dbm_ptr, db_model.domain_ptr); 758 rdi_ptr = rm_db_info.domain_list_ptr; 759 do while (rdi_ptr ^= null ()); 760 if (rm_domain_info.ck_proc | rm_domain_info.encd_proc | rm_domain_info.decd_proc) 761 then do; 762 di_ptr = domain_header_ptr; 763 found = "0"b; 764 do while (^found & di_ptr ^= null ()); 765 if domain_info.name = rm_domain_info.name 766 then found = "1"b; 767 else 768 if domain_info.fwd_thread = NULLOFFSET 769 then di_ptr = null (); 770 else di_ptr = ptr (dbm_ptr, domain_info.fwd_thread); 771 end; 772 if ^found 773 then do; 774 error_code = mrds_error_$incons_db; 775 call sub_err_ (error_code, caller_name, continue, info_ptr, return_value, 776 "The domain ^a is listed in the saved rdbi structure but not in the model.", 777 rm_domain_info.name); 778 call error_exit; 779 end; 780 if rm_domain_info.ck_proc 781 then rm_domain_info.ck_proc_entry = build_entry (domain_info.check_path_ptr, dbm_ptr, "check"); 782 if rm_domain_info.encd_proc 783 then rm_domain_info.encd_proc_entry = build_entry (domain_info.encd_path_ptr, dbm_ptr, "encode"); 784 if rm_domain_info.decd_proc 785 then rm_domain_info.decd_proc_entry = build_entry (domain_info.decd_path_ptr, dbm_ptr, "decode"); 786 end; 787 if rm_domain_info.next_domain_ptr = null () 788 then rdi_ptr = null (); 789 else do; 790 rm_domain_info.next_domain_ptr = ptr (rdbi_ptr, rel (rm_domain_info.next_domain_ptr)); 791 rdi_ptr = rm_domain_info.next_domain_ptr; 792 end; 793 end; 794 795 return; 796 797 end; 798 799 update_rm_rel_info: proc (urri_bad_id_list_version); 800 801 dcl urri_bad_id_list_version bit (1); 802 dcl (i, j) fixed bin; 803 dcl SCOPE_UPDATE fixed bin init (6) internal static options (constant); 804 dcl rel_model_ptr ptr; /* used to be sure that opener still has access to the relation model segments */ 805 806 rmra_ptr = rm_db_info.ra_ptr; 807 do i = 1 to rm_rel_array.num_rels; 808 rm_rel_array.rel_data (i).ri_ptr = ptr (rdbi_ptr, rel (rm_rel_array.rel_data (i).ri_ptr)); 809 rmri_ptr = rm_rel_array.rel_data (i).ri_ptr; 810 call initiate_file_ ((rm_db_info.db_path), rtrim (rm_rel_info.model_name) || ".m", R_ACCESS, rel_model_ptr, (0), error_code); 811 if error_code = error_table_$moderr 812 then do; 813 call mrds_dm_authorization$set_needed_access (rtrim (rm_db_info.db_path), error_code); 814 if error_code = 0 815 then call initiate_file_ ((rm_db_info.db_path), rtrim (rm_rel_info.model_name) || ".m", R_ACCESS, rel_model_ptr, (0), error_code); 816 else error_code = error_table_$moderr; 817 end; 818 if rel_model_ptr = null () 819 then do; 820 call sub_err_ (error_code, caller_name, "c", null (), return_value, 821 "^/Unable to get a pointer to the model segment ""^a>^a.m""", rm_db_info.db_path, rm_rel_info.model_name); 822 call error_exit; 823 end; 824 rm_rel_info.modify = (ready_mode = SCOPE_UPDATE); 825 rm_rel_info.store = rm_rel_info.modify; 826 rm_rel_info.delete = rm_rel_info.modify; 827 rm_rel_info.mdbm_secured = rm_db_info.mdbm_secured; 828 rm_rel_info.ready_mode = ready_mode; 829 rm_rel_info.id_list_ptr = ptr (rdbi_ptr, rel (rm_rel_info.id_list_ptr)); 830 if rm_rel_info.id_list_ptr -> id_list.version ^= ID_LIST_VERSION_1 831 then do; 832 urri_bad_id_list_version = "1"b; 833 goto exit_update_rm_rel_info; 834 end; 835 rm_rel_info.scope_flags_ptr = ptr (dbcb_ptr, rel (rm_rel_info.scope_flags_ptr)); 836 do j = 1 to rm_rel_info.nkey_attr; 837 rm_rel_info.key_attr_ptrs (j) = ptr (rdbi_ptr, rel (rm_rel_info.key_attr_ptrs (j))); 838 end; 839 do j = 1 to rm_rel_info.num_attr; 840 rm_rel_info.attr_ptrs (j) = ptr (rdbi_ptr, rel (rm_rel_info.attr_ptrs (j))); 841 rai_ptr = rm_rel_info.attr_ptrs (j); 842 rm_attr_info.domain_ptr = ptr (rdbi_ptr, rel (rm_attr_info.domain_ptr)); 843 rm_attr_info.mdbm_secured = rm_db_info.mdbm_secured; 844 end; 845 end; 846 847 exit_update_rm_rel_info: 848 return; 849 850 end; 851 852 build_entry: 853 proc (path_entry_offset, base_pointer, proc_type) returns (entry); 854 855 /* DESCRIPTION: 856* 857* This procedure initiates the segment referenced by the pathname structure 858* at the given offset The pointer to the initiated segment is returned in the 859* output_ptr parameter. If the segment could not be initiated the error 860* procedure is called. 861* 862**/ 863 864 dcl output_entry entry variable; /* output -- entry of initiated segment */ 865 dcl proc_type char (*); /* type of procedure being set up */ 866 dcl path_entry_offset bit (18); /* offset in the given area to the path_entry struct */ 867 dcl base_pointer ptr; /* base of segment for given path_entry */ 868 dcl cv_entry_ entry (char (*), ptr, fixed bin (35)) returns (entry); 869 870 path_entry_ptr = pointer (base_pointer, path_entry_offset); 871 output_entry = 872 cv_entry_ (path_entry.path || "$" || path_entry.entry, null, 873 error_code); 874 875 if error_code ^= 0 then do; 876 call sub_err_ (error_code, caller_name, "c", null (), return_value, 877 "^/Unable to build an entry variable for the ""^a""" 878 || " procedure using the path$entry = ^a$^a for the domain ^a", 879 proc_type, path_entry.path, path_entry.entry, rm_domain_info.name); 880 error_code = mrds_error_$bad_domain_proc; 881 call error_exit; 882 end; 883 884 return (output_entry); 885 886 end build_entry; 887 888 generate_resultant_data: proc; 889 890 /* now fill in the dbcb(database control block) structure */ 891 892 call init_dbcb (); 893 894 /* the secure resultant model structures must be filled in, 895* after obtaining the secure resultant segment, and a pointer to 896* it must be returned to be saved in the non-secure portion */ 897 898 call mu_sec_init_res (dsm_path, submodel_version, db_path, 899 dbm_ptr, dbcb_ptr, rdbi_ptr, error_code); 900 if error_code ^= 0 /* init_res reports it's own errors */ 901 then call error_exit; 902 903 if report_on_res_creation 904 then call ioa_ ("Resultant has been created from scratch: version is ^a", 905 rm_db_info.saved_res_version); 906 907 if submodel_open /* can now close the submodel, if one was opened */ 908 then do; 909 call mrds_dsm_close (submodel_iocb_ptr, error_code); 910 submodel_open = OFF; 911 if error_code ^= 0 912 then do; 913 call sub_err_ (code, caller_name, continue, info_ptr, return_value, "^/^a^a^a", 914 "Unable to close the submodel """, dsm_path, """."); 915 call error_exit; 916 end; 917 end; 918 919 rm_db_info.administrator = mrds_authorization.administrator; 920 dbcb.rdbi_ptr = rdbi_ptr; 921 922 return; 923 924 end; 925 926 927 init_dbcb: procedure (); 928 929 /* initialize the database control block structure, 930* the non-secure portion of the resultant model */ 931 932 call hcs_$get_uid_seg (dbc_ptr, dbcb.dbc_uid, error_code); 933 if error_code ^= 0 934 then do; 935 call sub_err_ (error_code, caller_name, continue, info_ptr, return_value, 936 "Unable to obtain the unique identifier of the data base control segment, opening will be aborted"); 937 call error_exit; 938 end; 939 dbcb.dbc_ptr = dbc_ptr; 940 dbcb.rdbi_ptr = null (); 941 dbcb.range_ptr = null (); 942 dbcb.select_ptr = null (); 943 dbcb.sv_ptr = null (); 944 dbcb.so_ptr = null (); 945 dbcb.ti_ptr = null (); 946 dbcb.lit_ptr = null (); 947 dbcb.current_ptr = null (); 948 dbcb.ss_ptr = null (); 949 dbcb.retr_info_ptr = null (); 950 dbcb.trel_info_ptr = null (); 951 dbcb.sti_ptr = null (); 952 dbcb.sfi_ptr = null (); 953 dbcb.scope_ptr = null (); 954 dbcb.select_area_ptr = model_area_ptr; 955 dbcb.current_data_ptr = curdat_ptr; 956 dbcb.static_data_ptr = stadat_ptr; 957 dbcb.element_id_list_segment_ptr = el_id_seg_ptr; 958 dbcb.store_area_ptr = null (); 959 dbcb.retrieve_area_ptr = null (); 960 dbcb.modify_area_ptr = null (); 961 dbcb.delete_area_ptr = null (); 962 dbcb.def_temp_rel_area_ptr = null (); 963 dbcb.compiled_se_info_ptr = null (); 964 dbcb.work_area_ptr = null (); 965 dbcb.se_info_ptr = null (); 966 dbcb.reserved_ptrs (*) = null (); 967 dbcb.cursor_ptrs_storage_ptr = null (); 968 dbcb.cursor_storage_area_ptr = null (); 969 dbcb.parser_work_area_ptr = null (); 970 971 dbcb.another_flag = OFF; 972 dbcb.current_flag = OFF; 973 dbcb.dbc_incr = OFF; 974 dbcb.delete_flag = OFF; 975 dbcb.dup_retain = OFF; 976 dbcb.prev_select = OFF; 977 dbcb.possible_op = OFF; 978 dbcb.sel_clause = OFF; 979 dbcb.dsm_sw = dsm_sw; 980 dbcb.val_rtrv = OFF; 981 dbcb.val_mod = OFF; 982 dbcb.val_del = OFF; 983 dbcb.val_dtr = OFF; 984 dbcb.resultant_in_pdir = res_in_pdir; 985 dbcb.transactions_needed = db_model.db_type_flags.transactions_needed; 986 dbcb.concurrency_on = db_model.db_type_flags.concurrency_on; 987 dbcb.rollback_on = db_model.db_type_flags.rollback_on; 988 989 dbcb.open_mode = OFF; 990 dbcb.new_select_expr = ON; 991 dbcb.no_optimize = OFF; 992 dbcb.print_search_order = OFF; 993 dbcb.res_already_made = OFF; 994 dbcb.user_started_transaction = OFF; 995 dbcb.non_shared_to_shared = OFF; 996 dbcb.reserved = OFF; 997 998 dbcb.nseq_sch = 0; 999 dbcb.nind_sch = 0; 1000 dbcb.nhash_sch = 0; 1001 dbcb.nlk_sch = 0; 1002 dbcb.cur_lit_offset = 0; 1003 dbcb.dbi = db_index; 1004 dbcb.last_s_e_id_num = 0; 1005 dbcb.se_transaction_id = "0"b; 1006 dbcb.last_store_rel_name = " "; 1007 dbcb.reserved_words (*) = 0; 1008 if db_model.db_type_flags.vfile_type 1009 then do; /* vfile type data base */ 1010 dbcb.relmgr_entries.open = vfile_relmgr_$open; 1011 dbcb.relmgr_entries.close = vfile_relmgr_$close; 1012 dbcb.relmgr_entries.create_cursor = vfile_relmgr_$create_cursor; 1013 dbcb.relmgr_entries.destroy_cursor = vfile_relmgr_$destroy_cursor; 1014 dbcb.relmgr_entries.set_scope = vfile_relmgr_$set_scope; 1015 dbcb.relmgr_entries.delete_tuples_by_id = vfile_relmgr_$delete_tuples_by_id; 1016 dbcb.relmgr_entries.modify_tuples_by_id = vfile_relmgr_$modify_tuples_by_id; 1017 dbcb.relmgr_entries.get_tuple_by_id = vfile_relmgr_$get_tuple_by_id; 1018 dbcb.relmgr_entries.get_tuples_by_spec = vfile_relmgr_$get_tuples_by_spec; 1019 dbcb.relmgr_entries.get_tuple_id = vfile_relmgr_$get_tuple_id; 1020 dbcb.relmgr_entries.put_tuple = vfile_relmgr_$put_tuple; 1021 dbcb.relmgr_entries.get_count = vfile_relmgr_$get_count; 1022 dbcb.relmgr_entries.get_population = vfile_relmgr_$get_population; 1023 dbcb.relmgr_entries.get_duplicate_key_count = vfile_relmgr_$get_duplicate_key_count; 1024 dbcb.relmgr_entries.create_relation = vfile_relmgr_$create_relation; 1025 dbcb.relmgr_entries.create_index = vfile_relmgr_$create_index; 1026 dbcb.relmgr_entries.destroy_relation_by_path = vfile_relmgr_$destroy_relation_by_path; 1027 dbcb.access_costs.total_primary_key_cost = 11; 1028 dbcb.access_costs.access_cost = 7.95; 1029 dbcb.access_costs.access_overhead = 250; 1030 dbcb.access_costs.us_access_cost = 2.6; 1031 dbcb.access_costs.os_access_cost = 6.0; 1032 end; 1033 else do; /* page_file type database */ 1034 dm_system_state = dm_gate_$dm_get_system_state(); /* 12.4 This will signal dm_not_available_ if the dm system is down. */ 1035 dbcb.relmgr_entries.open = relation_manager_$open; 1036 dbcb.relmgr_entries.close = relation_manager_$close; 1037 dbcb.relmgr_entries.create_cursor = relation_manager_$create_cursor; 1038 dbcb.relmgr_entries.destroy_cursor = relation_manager_$destroy_cursor; 1039 dbcb.relmgr_entries.set_scope = relation_manager_$set_scope; 1040 dbcb.relmgr_entries.delete_tuples_by_id = relation_manager_$delete_tuples_by_id; 1041 dbcb.relmgr_entries.modify_tuples_by_id = relation_manager_$modify_tuples_by_id; 1042 dbcb.relmgr_entries.get_tuple_by_id = relation_manager_$get_tuple_by_id; 1043 dbcb.relmgr_entries.get_tuples_by_spec = relation_manager_$get_tuples_by_spec; 1044 dbcb.relmgr_entries.get_tuple_id = relation_manager_$get_tuple_id; 1045 dbcb.relmgr_entries.put_tuple = relation_manager_$put_tuple; 1046 dbcb.relmgr_entries.get_count = relation_manager_$get_count; 1047 dbcb.relmgr_entries.get_population = relation_manager_$get_population; 1048 dbcb.relmgr_entries.get_duplicate_key_count = relation_manager_$get_duplicate_key_count; 1049 dbcb.relmgr_entries.create_relation = relation_manager_$create_relation; 1050 dbcb.relmgr_entries.create_index = relation_manager_$create_index; 1051 dbcb.relmgr_entries.destroy_relation_by_path = relation_manager_$destroy_relation_by_path; 1052 dbcb.access_costs.total_primary_key_cost = 11; 1053 dbcb.access_costs.access_cost = 7.95; 1054 dbcb.access_costs.access_overhead = 250; 1055 dbcb.access_costs.us_access_cost = 2.6; 1056 dbcb.access_costs.os_access_cost = 6.0; 1057 1058 1059 end; 1060 1061 1062 1063 dbcb.static_area = empty (); 1064 1065 stv_number_of_dimensions = mrds_data_$max_attributes; 1066 allocate simple_typed_vector in (dbcb.static_area) set (dbcb.store_vector_ptr); 1067 1068 gtv_number_of_dimensions = mrds_data_$max_attributes; 1069 allocate general_typed_vector in (dbcb.static_area) set (dbcb.modify_vector_ptr); 1070 1071 return; 1072 1073 end; 1074 1075 error_exit: procedure (); 1076 1077 call clean_up; 1078 1079 goto exit_mrds_dsl_init_res; 1080 1081 end; 1082 1083 clean_up: procedure (); 1084 1085 if submodel_open 1086 then do; 1087 call mrds_dsm_close (submodel_iocb_ptr, code); 1088 submodel_open = OFF; 1089 if code = 0 | clean_up_condition then ; 1090 else call sub_err_ (code, caller_name, continue, info_ptr, return_value, "^/^a^a^a", 1091 "Unable to close the submodel """, dsm_path, """."); 1092 end; 1093 1094 if res_in_pdir /* segments in pdir may be resused */ 1095 then call mu_temp_segments$release_all_temp_segments ("MRDS" || db_pic, code); 1096 else call mu_temp_segments$delete_all_temp_segments ("MRDS" || db_pic, code); 1097 if code ^= 0 & code ^= error_table_$argerr 1098 then call sub_err_ (code, caller_name, continue, info_ptr, return_value, 1099 "Could not free the temp segments created."); 1100 1101 if db_index ^= 0 1102 then do; 1103 call mu_database_index$reset_resultant_model_pointer (db_index, (dbcb_ptr)); 1104 db_index = 0; 1105 end; 1106 1107 if dbcb_ptr ^= null () 1108 then do; 1109 call hcs_$delentry_seg (dbcb_ptr, code); 1110 if code ^= 0 1111 then call sub_err_ (code, caller_name, continue, info_ptr, return_value, "^/^a^a^a", 1112 "Unable to delete the dbcb segment for database """, dsm_path, """."); 1113 dbcb_ptr = null (); 1114 end; 1115 end; 1116 1117 dcl (header_ptr, /* points to dsm header record */ 1118 dbc_ptr) ptr; /* point to the data base control segment */ 1119 1120 dcl bc fixed bin (24); /* bit count of data base control segment */ 1121 dcl code fixed bin (35); /* return status code */ 1122 1123 dcl dsm_sw bit (1); /* ON => data submodel name is being used */ 1124 1125 dcl ready_mode fixed bin; /* mode that the database will be opened with */ 1126 1127 dcl administrator bit (1); /* "1"b => that the user is a DBA */ 1128 1129 dcl db_index fixed bin (35); /* data base index value */ 1130 dcl db_path char (168); /* absolute path name of data base */ 1131 dcl dsm_path char (168); /* submodel path name */ 1132 dcl view_dir char (*); /* view path directory */ 1133 dcl view_ent char (*); /* view path entry name */ 1134 1135 dcl RW fixed bin (5) int static init (01010b) options (constant); /* code for read/write access */ 1136 dcl hcs_$make_seg entry (char (*), char (*), char (*), fixed bin (5), ptr, fixed bin (35)); 1137 dcl mu_temp_segments$get_temp_segments entry (fixed bin (35), char (*), (*) ptr, fixed bin (35)); 1138 dcl mu_temp_segments$release_all_temp_segments entry (char (*), fixed bin (35)); 1139 dcl hcs_$get_uid_seg entry (ptr, bit (36) aligned, fixed bin (35)); 1140 dcl unique_chars_ entry (bit (*)) returns (char (15)); 1141 dcl initiate_file_ entry (char (*), char (*), bit (*), ptr, fixed bin (24), fixed bin (35)); 1142 1143 1144 dcl (null, 1145 addr, 1146 fixed, 1147 length, 1148 pointer, 1149 rel, 1150 rtrim, 1151 substr, 1152 empty, 1153 divide, 1154 ptr) builtin; 1155 1156 dcl cleanup condition; 1157 dcl clean_up_condition bit (1); /* on => cleanup signaled */ 1158 1159 dcl mrds_data_$max_attributes ext fixed bin (35); 1160 dcl mrds_data_$saved_res_version ext char (8); 1161 dcl sys_info$max_seg_size fixed bin (35) ext; 1162 1163 dcl mrds_dsm_close entry (ptr, fixed bin (35)); 1164 dcl mrds_dsm_open$read entry (char (*), ptr, fixed bin (35)); 1165 dcl mrds_dsm_read_header entry (ptr, ptr, ptr, fixed bin (35)); 1166 dcl mu_sec_init_res entry (char (168), fixed bin, char (168), ptr, ptr, ptr, fixed bin (35)); 1167 dcl mu_sec_reg_user entry (ptr, ptr, fixed bin (35)); 1168 dcl OFF bit (1) init ("0"b); /* false value */ 1169 dcl ON bit (1) init ("1"b); /* true value */ 1170 dcl mu_database_index$get_database_index entry (fixed bin (35), ptr); /* gets database index definition */ 1171 dcl sub_err_ entry options (variable); /* error reporting routine */ 1172 dcl caller_name char (20) init ("mrds_dsl_init_res"); /* name of calling routine */ 1173 dcl continue char (1) init ("c"); /* don't stop after printing mesg */ 1174 dcl info_ptr ptr init (null ());/* unused */ 1175 dcl return_value fixed bin (35) init (0); /* unused */ 1176 dcl submodel_open bit (1); /* on => submodel has been opened */ 1177 dcl submodel_iocb_ptr ptr ext init (null); /* External static pointer to iocb 1178* of submodel. Used by mu_sec_init_res, 1179* mus_get_relation_names, and 1180* mus_get_attribute_names to 1181* refer to a common opening of the submodel. */ 1182 dcl error_code fixed bin (35); /* error type status encoding */ 1183 dcl input_path char (168); /* path input by user */ 1184 dcl hcs_$delentry_seg entry (ptr, fixed bin (35)); /* delets segs without ref names */ 1185 dcl mu_database_index$reset_resultant_model_pointer entry (fixed bin (35), ptr); /* removes db index definition */ 1186 dcl mrds_data_$max_dbs fixed bin (35) ext;/* max number of open databases */ 1187 dcl sub_error_ condition; /* signaled when sub_err_ called */ 1188 dcl mrds_dsl_init_select_area entry (ptr, fixed bin (35)); /* selection expre area init */ 1189 dcl mrds_error_$too_many_dbs fixed bin (35) ext; /* >64 databases open attempt */ 1190 dcl resultant_dir char (168); /* storage location of resultant model */ 1191 dcl process_dir char (168); /* path to the process directory */ 1192 dcl mrds_dsl_resultant_storage$get entry returns (char (168)); /* gets resultant model directory */ 1193 dcl ptr_array (5) ptr; /* array of pointers for mu_temp_segment */ 1194 dcl curdat_ptr ptr; /* points to current data segment */ 1195 dcl stadat_ptr ptr; /* points to static data segment */ 1196 dcl el_id_seg_ptr ptr; /* points to element id list segments */ 1197 dcl delete_seg bit (6) init ("000100"b); /* switches to delete segment */ 1198 dcl dm_error_$system_not_initialized fixed bin (35) ext static; 1199 dcl mrds_error_$inc_secure_open fixed bin (35) ext; /* incorrect method for opening secure db */ 1200 dcl mrds_error_$incons_db fixed bin (35) ext static; 1201 dcl mrds_error_$bad_domain_proc fixed bin (35) ext static; 1202 dcl mrds_data_$submodel_dir_name char (16) ext; /* name of submodel dir under db dir */ 1203 dcl mrds_dm_secured_submodel entry (char (*), char (*), char (*)) 1204 returns (bit (1)); /* returns true if submodel in submodel dir */ 1205 dcl mrds_dm_authorization$get_user_class entry (char (*), ptr, fixed bin, ptr, fixed bin (35)); /* DBA detecter */ 1206 dcl local_area area (200); /* space for submodeldsm header and DBA info */ 1207 dcl mu_concurrency_control$open_control_segment entry (char (168), ptr, fixed bin (24), fixed bin (35)); /* get ptr to control seg */ 1208 dcl submodel_version fixed bin; /* version of submodel opened, or 0 */ 1209 dcl error_table_$moderr fixed bin (35) ext;/* incorrect access */ 1210 dcl error_table_$no_info fixed bin (35) ext static; /* no access to seg and no s access on dir */ 1211 dcl error_table_$dirlong fixed bin (35) ext static; 1212 dcl mrds_dm_authorization$set_needed_access entry (char (*), fixed bin (35)); /* sets access for DBA types */ 1213 dcl res_in_pdir bit (1); /* true ==> resultant created in pdir */ 1214 dcl db_pic pic "999"; 1215 dcl report_on_res_creation bit (1) internal static init ("0"b); 1216 /* "1"b => message indicating how resultant was created will be sent to terminal */ 1217 dcl dm_system_state char (4) aligned; /* Results from dm_gate_$dm_get_system_state. Not used: call checks for dm. */ 1218 dcl ioa_ entry options (variable); 1219 dcl get_pdir_ entry () returns (char (168)); 1220 dcl mu_temp_segments$delete_all_temp_segments entry (char (*), fixed bin (35)); 1221 dcl error_table_$argerr fixed bin (35) ext; 1222 1223 dcl vfile_relmgr_$open entry (char (*), char (*), bit (36) aligned, fixed bin (35)); 1224 dcl vfile_relmgr_$close entry (bit (36) aligned, fixed bin (35)); 1225 dcl vfile_relmgr_$create_cursor entry (bit (36) aligned, ptr, ptr, fixed bin (35)); 1226 dcl vfile_relmgr_$destroy_cursor entry (ptr, ptr, fixed bin (35)); 1227 dcl vfile_relmgr_$set_scope entry (bit (36) aligned, bit (2) aligned, bit (2) aligned, fixed bin (35)); 1228 dcl vfile_relmgr_$put_tuple entry (ptr, ptr, bit (36) aligned, fixed bin (35)); 1229 dcl vfile_relmgr_$delete_tuples_by_id entry (ptr, ptr, fixed bin (35), fixed bin (35)); 1230 dcl vfile_relmgr_$modify_tuples_by_id entry (ptr, ptr, ptr, fixed bin (35), fixed bin (35)); 1231 dcl vfile_relmgr_$get_tuple_by_id entry (ptr, bit (36) aligned, ptr, ptr, ptr, fixed bin (35)); 1232 dcl vfile_relmgr_$get_tuples_by_spec entry (ptr, ptr, ptr, ptr, ptr, fixed bin (35)); 1233 dcl vfile_relmgr_$get_tuple_id entry (ptr, ptr, ptr, ptr, fixed bin (35)); 1234 dcl vfile_relmgr_$get_count entry (ptr, ptr, fixed bin (35), fixed bin (35)); 1235 dcl vfile_relmgr_$get_population entry (ptr, fixed bin (35), fixed bin (35)); 1236 dcl vfile_relmgr_$get_duplicate_key_count entry entry (ptr, bit (36) aligned, fixed bin (17), fixed bin (35), fixed bin (35)); 1237 dcl vfile_relmgr_$create_relation entry (char (*), char (*), ptr, ptr, 1238 bit (36) aligned, bit (36) aligned, fixed bin (35)); 1239 dcl vfile_relmgr_$create_index entry (bit (36) aligned, ptr, bit (36) aligned, 1240 fixed bin, bit (36) aligned, fixed bin (35)); 1241 dcl vfile_relmgr_$destroy_relation_by_path entry (bit (36) aligned, 1242 fixed bin (35)); 1243 dcl relation_manager_$open entry (char (*), char (*), bit (36) aligned, fixed bin (35)); 1244 dcl relation_manager_$close entry (bit (36) aligned, fixed bin (35)); 1245 dcl relation_manager_$create_cursor entry (bit (36) aligned, ptr, ptr, fixed bin (35)); 1246 dcl relation_manager_$destroy_cursor entry (ptr, ptr, fixed bin (35)); 1247 dcl relation_manager_$set_scope entry (bit (36) aligned, bit (2) aligned, bit (2) aligned, fixed bin (35)); 1248 dcl relation_manager_$put_tuple entry (ptr, ptr, bit (36) aligned, fixed bin (35)); 1249 dcl relation_manager_$delete_tuples_by_id entry (ptr, ptr, fixed bin (35), fixed bin (35)); 1250 dcl relation_manager_$modify_tuples_by_id entry (ptr, ptr, ptr, fixed bin (35), fixed bin (35)); 1251 dcl relation_manager_$get_tuple_by_id entry (ptr, bit (36) aligned, ptr, ptr, ptr, fixed bin (35)); 1252 dcl relation_manager_$get_tuples_by_spec entry (ptr, ptr, ptr, ptr, ptr, fixed bin (35)); 1253 dcl relation_manager_$get_tuple_id entry (ptr, ptr, ptr, ptr, fixed bin (35)); 1254 dcl relation_manager_$get_count entry (ptr, ptr, fixed bin (35), fixed bin (35)); 1255 dcl relation_manager_$get_population entry (ptr, fixed bin (35), fixed bin (35)); 1256 dcl relation_manager_$get_duplicate_key_count entry (ptr, bit (36) aligned, fixed bin (17), fixed bin (35), fixed bin (35)); 1257 dcl relation_manager_$create_relation entry (char (*), char (*), ptr, ptr, 1258 bit (36) aligned, bit (36) aligned, fixed bin (35)); 1259 dcl relation_manager_$create_index entry (bit (36) aligned, ptr, bit (36) aligned, 1260 fixed bin, bit (36) aligned, fixed bin (35)); 1261 dcl relation_manager_$destroy_relation_by_path entry (bit (36) aligned, 1262 fixed bin (35)); 1263 dcl dm_gate_$dm_get_system_state entry () returns (char(4) aligned); 1264 dcl dm_not_available_ condition; 1265 1266 1267 1 1 /* BEGIN INCLUDE FILE ... access_mode_values.incl.pl1 1 2* 1 3* Values for the "access mode" argument so often used in hardcore 1 4* James R. Davis 26 Jan 81 MCR 4844 1 5* Added constants for SM access 4/28/82 Jay Pattin 1 6* Added text strings 03/19/85 Chris Jones 1 7**/ 1 8 1 9 1 10 /* format: style4,delnl,insnl,indattr,ifthen,dclind10 */ 1 11 dcl ( 1 12 N_ACCESS init ("000"b), 1 13 R_ACCESS init ("100"b), 1 14 E_ACCESS init ("010"b), 1 15 W_ACCESS init ("001"b), 1 16 RE_ACCESS init ("110"b), 1 17 REW_ACCESS init ("111"b), 1 18 RW_ACCESS init ("101"b), 1 19 S_ACCESS init ("100"b), 1 20 M_ACCESS init ("010"b), 1 21 A_ACCESS init ("001"b), 1 22 SA_ACCESS init ("101"b), 1 23 SM_ACCESS init ("110"b), 1 24 SMA_ACCESS init ("111"b) 1 25 ) bit (3) internal static options (constant); 1 26 1 27 /* The following arrays are meant to be accessed by doing either 1) bin (bit_value) or 1 28* 2) divide (bin_value, 2) to come up with an index into the array. */ 1 29 1 30 dcl SEG_ACCESS_MODE_NAMES (0:7) init ("null", "W", "E", "EW", "R", "RW", "RE", "REW") char (4) internal 1 31 static options (constant); 1 32 1 33 dcl DIR_ACCESS_MODE_NAMES (0:7) init ("null", "A", "M", "MA", "S", "SA", "SM", "SMA") char (4) internal 1 34 static options (constant); 1 35 1 36 dcl ( 1 37 N_ACCESS_BIN init (00000b), 1 38 R_ACCESS_BIN init (01000b), 1 39 E_ACCESS_BIN init (00100b), 1 40 W_ACCESS_BIN init (00010b), 1 41 RW_ACCESS_BIN init (01010b), 1 42 RE_ACCESS_BIN init (01100b), 1 43 REW_ACCESS_BIN init (01110b), 1 44 S_ACCESS_BIN init (01000b), 1 45 M_ACCESS_BIN init (00010b), 1 46 A_ACCESS_BIN init (00001b), 1 47 SA_ACCESS_BIN init (01001b), 1 48 SM_ACCESS_BIN init (01010b), 1 49 SMA_ACCESS_BIN init (01011b) 1 50 ) fixed bin (5) internal static options (constant); 1 51 1 52 /* END INCLUDE FILE ... access_mode_values.incl.pl1 */ 1268 1269 2 1 /* BEGIN INCLUDE FILE - dm_id_list.incl.pl1 */ 2 2 2 3 /* DESCRIPTION 2 4* The id_list structure is used to identify attributes, fields and 2 5* dimensions by various modules of the Data Management System. 2 6**/ 2 7 2 8 /* HISTORY: 2 9*Written by Matthew Pierret, '82. 2 10*Modified: 2 11*08/17/83 by Matthew Pierret: Made version constant 'internal static options 2 12* (constant)' and to initialize automatic variables. 2 13**/ 2 14 2 15 /* format: style2,ind3 */ 2 16 dcl 1 id_list aligned based (id_list_ptr), 2 17 2 version fixed bin (35), 2 18 2 number_of_ids fixed bin (17), 2 19 2 id (il_number_of_ids refer (id_list.number_of_ids)) fixed bin (17); 2 20 2 21 dcl id_list_ptr ptr init (null); 2 22 dcl il_number_of_ids fixed bin (17) init (-1); 2 23 dcl ID_LIST_VERSION_1 fixed bin (17) init (1) internal static options (constant); 2 24 2 25 /* END INCLUDE FILE - dm_id_list.incl.pl1 */ 1270 1271 3 1 /* --------------- BEGIN include file status_structures.incl.pl1 --------------- */ 3 2 3 3 /* Revised from existing include files 09/26/78 by C. D. Tavares */ 3 4 3 5 /* This include file contains branch and link structures returned by 3 6* hcs_$status_ and hcs_$status_long. */ 3 7 3 8 dcl 1 status_branch aligned based (status_ptr), 3 9 2 short aligned, 3 10 3 type fixed bin (2) unaligned unsigned, /* seg, dir, or link */ 3 11 3 nnames fixed bin (16) unaligned unsigned, /* number of names */ 3 12 3 names_relp bit (18) unaligned, /* see entry_names dcl */ 3 13 3 dtcm bit (36) unaligned, /* date/time contents last modified */ 3 14 3 dtu bit (36) unaligned, /* date/time last used */ 3 15 3 mode bit (5) unaligned, /* caller's effective access */ 3 16 3 raw_mode bit (5) unaligned, /* caller's raw "rew" modes */ 3 17 3 pad1 bit (8) unaligned, 3 18 3 records_used fixed bin (18) unaligned unsigned, /* number of NONZERO pages used */ 3 19 3 20 /* Limit of information returned by hcs_$status_ */ 3 21 3 22 2 long aligned, 3 23 3 dtd bit (36) unaligned, /* date/time last dumped */ 3 24 3 dtem bit (36) unaligned, /* date/time branch last modified */ 3 25 3 lvid bit (36) unaligned, /* logical volume ID */ 3 26 3 current_length fixed bin (12) unaligned unsigned, /* number of last page used */ 3 27 3 bit_count fixed bin (24) unaligned unsigned, /* reported length in bits */ 3 28 3 pad2 bit (8) unaligned, 3 29 3 copy_switch bit (1) unaligned, /* copy switch */ 3 30 3 tpd_switch bit (1) unaligned, /* transparent to paging device switch */ 3 31 3 mdir_switch bit (1) unaligned, /* is a master dir */ 3 32 3 damaged_switch bit (1) unaligned, /* salvager warned of possible damage */ 3 33 3 synchronized_switch bit (1) unaligned, /* DM synchronized file */ 3 34 3 pad3 bit (5) unaligned, 3 35 3 ring_brackets (0:2) fixed bin (6) unaligned unsigned, 3 36 3 uid bit (36) unaligned; /* unique ID */ 3 37 3 38 dcl 1 status_link aligned based (status_ptr), 3 39 2 type fixed bin (2) unaligned unsigned, /* as above */ 3 40 2 nnames fixed bin (16) unaligned unsigned, 3 41 2 names_relp bit (18) unaligned, 3 42 2 dtem bit (36) unaligned, 3 43 2 dtd bit (36) unaligned, 3 44 2 pathname_length fixed bin (17) unaligned, /* see pathname */ 3 45 2 pathname_relp bit (18) unaligned; /* see pathname */ 3 46 3 47 dcl status_entry_names (status_branch.nnames) character (32) aligned 3 48 based (pointer (status_area_ptr, status_branch.names_relp)), 3 49 /* array of names returned */ 3 50 status_pathname character (status_link.pathname_length) aligned 3 51 based (pointer (status_area_ptr, status_link.pathname_relp)), 3 52 /* link target path */ 3 53 status_area_ptr pointer, 3 54 status_ptr pointer; 3 55 3 56 dcl (Link initial (0), 3 57 Segment initial (1), 3 58 Directory initial (2)) fixed bin internal static options (constant); 3 59 /* values for type fields declared above */ 3 60 3 61 /* ---------------- END include file status_structures.incl.pl1 ---------------- */ 1272 1273 4 1 /* BEGIN mrds_dbcb.incl.pl1 -- jaw, 11/7/78 */ 4 2 4 3 4 4 4 5 /****^ HISTORY COMMENTS: 4 6* 1) change(85-11-17,Dupuis), approve(85-12-16,MCR7314), 4 7* audit(86-02-04,Brunelle), install(86-02-05,MR12.0-1013): 4 8* This entry is being made to cover the change made on 85-07-01 by Thanh 4 9* Nguyen. The scopes_changed flag was added to make checking for this 4 10* more efficient (mrds error list #137). 4 11* 2) change(86-06-10,Blair), approve(86-08-07,MCR7491), 4 12* audit(86-08-07,Gilcrease), install(86-08-15,MR12.0-1127): 4 13* Add a bit called dont_check_txn_id to indicate whether or not we should 4 14* care if multiple txns use the same selection_expression. (mrds #156) 4 15* 3) change(87-11-23,Hergert), approve(88-06-28,MCR7903), 4 16* audit(88-06-28,Dupuis), install(88-08-01,MR12.2-1073): 4 17* Added parser_work_area_ptr and mrds_se_info_ptr for new parser. 4 18* END HISTORY COMMENTS */ 4 19 4 20 4 21 /* WARNING 4 22* If the dbcb structure is changed then the mrds_data_ 4 23* item saved_res_version MUST be incremented to invalidate all 4 24* existing saved resultants 4 25**/ 4 26 4 27 /* HISTORY : 4 28* 4 29* modified by Jim Gray - - 80-10-24, to add new_select_expr bit for 4 30* tid_list management 4 31* 4 32* 81-1-9 Jim Gray : added like reference for ease in making the 4 33* phony resultant in mu_database_index, without having the area dcl 4 34* included. 4 35* 4 36* 81-06-17 Roger Lackey : added last_store_rel_name for use by 4 37* mrds_dsl_store 4 38* 4 39* 81-06-26 Roger Lackey : Added no_optimize and print_search_order 4 40* switches 4 41* 4 42* 81-07-06 Jim Gray : added identifier for the current selection 4 43* expression, so that relation statistics can be updated relative 4 44* to number of selection expressions seem. Also removed init for 4 45* last_store_rel_name, as this iw now properly done in 4 46* mrds_dsl_init_res. 4 47* 4 48* 81-07-17 Roger Lackey : added pred_ptr and unused_ptrs. 4 49* 4 50* 82-08-19 Mike Kubicar : added store_vector field. This is needed 4 51* for the conversion to the relation manager. 4 52* 4 53* 82-08-23 Davids: added the relmgr_entries and access_costs 4 54* substructures so that the entries and costs can change 4 55* depending on the type of database that is opened. 4 56* 4 57* 82-09-09 Mike Kubicar : added modify_vector field. This is needed 4 58* since modify uses a different vector type (general) than does store. 4 59* 4 60* 82-09-20 Davids: changed names of (store modify)_vector to 4 61* (store modify)_vector_ptr. Also (delete modify)_tuple_by_id to 4 62* (delete modify)_tuples_by_id. added the element cursor_storage_ptr 4 63* which should be inited to null and will be set by mu_cursor_manager_$get 4 64* during the first call. 4 65* 4 66* 82-09-21 Davids: renamed cursor_storage_ptr to cursor_ptrs_storage_ptr 4 67* since it deals with the pointers to the cursors and not the cursors 4 68* themelves and added the element cursor_storage_area_ptr which points 4 69* to the area where the cursors are kept. 4 70* 4 71* 82-09-22 Davids: renamed the transact_ctl_seg to transactions_needed. 4 72* the transact_ctl_seg always had a value of 0 and really didn't mean 4 73* anything. 4 74* 4 75* 82-09-22 Mike Kubicar : added create_relation, create_index and 4 76* destroy_relation_by_opening to relmgr_entries. They are needed 4 77* by mrds_dsl_define_temp_rel. 4 78* 4 79* 82-09-24 Donna Woodka : added put_tuple to relmgr_entries. It 4 80* is needed by mu_store. 4 81* 4 82* 82-11-12 Davids: changed the declaration of the access_costs from fixed 4 83* bin to float bin since the values are not integers. 4 84* 4 85* 83-02-02 Davids: added the dbc_uid element. This will allow mrds to make 4 86* sure that the dbc_ptr still points to the correct segment. Element was 4 87* added to the end of the structure to allow modules that don't use 4 88* the element to continue to reference the dbcb structure without recompiling. 4 89* 4 90* 83-02-25 Davids: added the concurrency_on and rollback_on elements. These 4 91* are needed so that temp rels can be created with the same file attributes 4 92* as the permanent relations. 4 93* 4 94* 83-05-02 Mike Kubicar : Deleted get_next_search_specification_ptr and 4 95* added the resultant_in_pdir bit. 4 96* 4 97* 83-05-18 Davids: reduced the number of reserved bits to 14 (from 15) and 4 98* added the res_already_made element. 4 99* 4 100* 83-05-24 Mike Kubicar : Updated the relation manager calling sequences. 4 101* 4 102* 83-08-03 Mike Kubicar : Added the element_id_list_segment_ptr and removed 4 103* one of the unused pointers. 4 104* 4 105* 83-09-20 Ron Harvey: Added relmgr_entries.get_population. 4 106* 4 107* 84-08-27 John Hergert: Created compiled_se_info_ptr from unused_ptrs(2) 4 108* leaving unused_ptrs(1). 4 109* 4 110* 85-01-15 Thanh Nguyen: Added the work_area_ptr and removed the last 4 111* unused_ptrs (1). 4 112* 4 113* 85-04-12 Thanh Nguyen: Added user_started_transaction and 4 114* non_shared_to_shared flags. Also added se_transaction_id and some more 4 115* spare ptrs, entries and reserved storages for future enhancement, since 4 116* we changed the saved_res_version from rslt0001 to rslt0002. 4 117* 4 118* 85-07-01 Thanh Nguyen: Added scopes_changed flag. This flag is set by 4 119* common routine of mrds_dsl_set_scope, reset by mrds_dsl_optimize and 4 120* mrds_dsl_gen_srch_prog when building of a new search_vars. 4 121**/ 4 122 4 123 4 124 /* this structure is based on the {unique_name}.mrds.dbcb segment 4 125* that constitutes the non-secure portion of the resultant model that is 4 126* created during the opening of a database. it contains variables that 4 127* are used during the runtime access of the database, and an area 4 128* for evaluation of requests. it points to four other 4 129* segments in the resultant model, {unique_name}.mrds.rdbi, the secure 4 130* portion of the resultant(see mdbm_rm_db_info.incl.pl1), 4 131* {unique_name}.mrds.select, an area for selection expression evaluation, 4 132* {unique_name}.mrds.curdat, and {unique_name}.mrds.stadat, two segments 4 133* used in the elimination of duplicate tuples during a retrieve. 4 134* the dbcb area holds the structure in mdbm_scope_info.incl.pl1 4 135* that is used when the database is using the file scope mechanism 4 136* for concurrency control over file readying. the segment overlayed via 4 137* mrds_dbc.incl.pl1 structure is pointed to and also handles concurrency control, 4 138* across database openings. the pointer to this dbcb structure is kept in a table 4 139* which associates database indexes(returned from a call to dsl_$open), with particular 4 140* opening instances of resultant models. (see mu_database_index routine) */ 4 141 4 142 dcl 1 dbcb aligned based (dbcb_ptr), /* DBCB -- non-secure portion */ 4 143 2 data like dbcb_data, 4 144 2 static_area area (sys_info$max_seg_size - fixed (rel (addr (dbcb.static_area)))); 4 145 4 146 dcl dbcb_ptr ptr; 4 147 4 148 declare 1 dbcb_data based, /* info part of dbcb, separated out so that 4 149* like references can avoid getting the area declaration */ 4 150 2 rdbi_ptr ptr, /* pointer to write protected mdbm_util_ info. */ 4 151 2 range_ptr ptr, /* ptr to range structure, or null */ 4 152 2 select_ptr ptr, /* ptr to select list, or null */ 4 153 2 sv_ptr ptr, /* pointer to search variables */ 4 154 2 so_ptr ptr, /* pointer to search operators */ 4 155 2 ti_ptr ptr, /* pointer to tuple info */ 4 156 2 lit_ptr ptr, /* pointer to the literal area, or null */ 4 157 2 current_ptr ptr, /* ptr to select list resulting from -current clause */ 4 158 2 ss_ptr ptr, /* ptr to select sets block if not simple s.e. */ 4 159 2 retr_info_ptr ptr, /* ptr to retrieve info area */ 4 160 2 trel_info_ptr ptr, /* ptr to retrieve info area */ 4 161 2 sti_ptr ptr, /* pointer to store info */ 4 162 2 dbc_ptr ptr, /* pointer to the data base control segment */ 4 163 2 sfi_ptr ptr, /* points to head of scalar function list */ 4 164 2 scope_ptr ptr, /* points to array of scope tuples */ 4 165 2 select_area_ptr ptr, /* ptr to area for current selection expression allocations */ 4 166 2 current_data_ptr ptr, /* ptr to one of 2 segments used by mrds_dsl_retrieve 4 167* for eliminating duplicate tuples. */ 4 168 2 static_data_ptr ptr, /* ptr to one of 2 segments used by mrds_dsl_retrieve 4 169* for eliminating duplicate tuples. */ 4 170 2 store_area_ptr ptr, /* temp storage area for dsl_$store */ 4 171 2 retrieve_area_ptr ptr, /* temp storage for dsl_$retrieve */ 4 172 2 modify_area_ptr ptr, /* temp storage area for dsl_$modify */ 4 173 2 delete_area_ptr ptr, /* temp storage area for dsl_$delete */ 4 174 2 def_temp_rel_area_ptr ptr, /* temp storage area for dsl_$define_temp_rel */ 4 175 2 pred_ptr ptr, /* Pointer to pred_array */ 4 176 2 store_vector_ptr ptr, /* Vector structure used during store operations */ 4 177 2 modify_vector_ptr ptr, /* Used during modifies */ 4 178 2 element_id_list_segment_ptr ptr, /* Points to the segment used to hold element_id_list structures */ 4 179 2 compiled_se_info_ptr ptr, /* points to the segment containing all info on compiled sexs */ 4 180 2 work_area_ptr ptr, /* Work area for encode/decode value allocations in mu_retrieve */ 4 181 2 se_info_ptr ptr, /* Points to se_info struct. Primarily for error reports */ 4 182 2 parser_work_area_ptr ptr, /* work area for parser */ 4 183 2 reserved_ptrs (4) ptr, /* Reserved for future use */ 4 184 2 another_flag bit (1) unal, /* on if predicate was -another */ 4 185 2 current_flag bit (1) unal, /* on if predicate was -current clause */ 4 186 2 dbc_incr bit (1) unal, /* on if dbc open mode has been incremented for this user */ 4 187 2 delete_flag bit (1) unal, /* On if search was called from mrds_dsl_sec_delete */ 4 188 2 dup_retain bit (1) unaligned, /* On if dup tuples allowed for retrieval */ 4 189 2 prev_select bit (1) unal, /* on if prev. select block processed in this s.e. */ 4 190 2 possible_op bit (1) unal, /* on of arith op. allowed */ 4 191 2 sel_clause bit (1) unal, /* on if currently in select clause */ 4 192 2 dsm_sw bit (1) unal, /* on if data base was opened via data submodel */ 4 193 2 val_rtrv bit (1) unal, /* if s.e. valid for retrieve */ 4 194 2 val_mod bit (1) unal, /* for modify */ 4 195 2 val_del bit (1) unal, /* for delete */ 4 196 2 val_dtr bit (1) unal, /* for define temp rel */ 4 197 2 transactions_needed bit (1) unal, /* On => transaction must be started or in progress does 4 198* not imply that the database is of type page_file */ 4 199 2 open_mode bit (3) unal, /* 0=>unknown, 1=>r, 2=>u, 3=>er, 4=>eu, >4=>bad */ 4 200 2 new_select_expr bit (1) unal, /* on => starting a new tid list management period */ 4 201 2 no_optimize bit (1) unal, /* On => no optimize */ 4 202 2 print_search_order bit (1) unal, /* On => print the search order */ 4 203 2 resultant_in_pdir bit (1) unal, /* On => Temp segments are in the process dir */ 4 204 2 res_already_made bit (1) unal, /* On => resultant has been made based on a saved copy */ 4 205 2 user_started_transaction bit (1) unal, /* On => user already started his own transaction. */ 4 206 2 non_shared_to_shared bit (1) unal, /* On => user changed the scope from non shared to shared 4 207* inside a sequence of -another selection expression. */ 4 208 2 scopes_changed bit (1) unal, /* On => scopes had been changed by set_scopes or delete_scopes */ 4 209 2 dont_check_txn_id bit (1) unal, /* On => cpmd needs same selection exp across multiple txns */ 4 210 2 reserved bit (10) unal, /* reserved for future use */ 4 211 2 nseq_sch fixed bin (35), /* no. tuples located via sequential search */ 4 212 2 nind_sch fixed bin (35), /* no. tuples located via index search */ 4 213 2 nhash_sch fixed bin (35), /* no. tuples located via hash search */ 4 214 2 nlk_sch fixed bin (35), /* no tuples located via link search */ 4 215 2 cur_lit_offset fixed bin (35), /* current bit offset in literal string */ 4 216 2 dbi fixed bin (35), /* database index for this opening */ 4 217 2 last_s_e_id_num fixed bin (35), /* identifying number for last selection expression seen */ 4 218 2 se_transaction_id bit (36) aligned, /* transaction id from beginning of select expression */ 4 219 2 last_store_rel_name char (32), /* Name of relation last used for store */ 4 220 2 cursor_ptrs_storage_ptr ptr, /* pointer to space where cursor ptrs are stored */ 4 221 2 cursor_storage_area_ptr ptr, /* pointer to area where the cursors are kept */ 4 222 2 reserved_words (10) fixed bin (35), /* Reserved for future use */ 4 223 2 relmgr_entries, /* relation manager entries */ 4 224 3 open entry (char (*), char (*), bit (36) aligned, fixed bin (35)), 4 225 3 close entry (bit (36) aligned, fixed bin (35)), 4 226 3 create_cursor entry (bit (36) aligned, ptr, ptr, fixed bin (35)), 4 227 3 destroy_cursor entry (ptr, ptr, fixed bin (35)), 4 228 3 set_scope entry (bit (36) aligned, bit (2) aligned, bit (2) aligned, fixed bin (35)), 4 229 3 delete_tuples_by_id entry (ptr, ptr, fixed bin (35), fixed bin (35)), 4 230 3 modify_tuples_by_id entry (ptr, ptr, ptr, fixed bin (35), fixed bin (35)), 4 231 3 get_tuple_by_id entry (ptr, bit (36) aligned, ptr, ptr, ptr, fixed bin (35)), 4 232 3 get_tuples_by_spec entry (ptr, ptr, ptr, ptr, ptr, fixed bin (35)), 4 233 3 get_tuple_id entry (ptr, ptr, ptr, ptr, fixed bin (35)), 4 234 3 put_tuple entry (ptr, ptr, bit (36) aligned, fixed bin (35)), 4 235 3 get_count entry (ptr, ptr, fixed bin (35), fixed bin (35)), 4 236 3 get_duplicate_key_count entry (ptr, bit (36) aligned, fixed bin (17), fixed bin (35), fixed bin (35)), 4 237 3 get_population entry (ptr, fixed bin (35), fixed bin (35)), 4 238 3 create_relation entry (char (*), char (*), ptr, ptr, bit (36) aligned, bit (36) aligned, fixed bin (35)), 4 239 3 create_index entry (bit (36) aligned, ptr, bit (36) aligned, fixed bin (17), bit (36) aligned, fixed bin (35)), 4 240 3 destroy_relation_by_path entry (char (*), char (*), fixed bin (35)), 4 241 3 reserved_entries (5) entry (), 4 242 2 access_costs, /* access costs for permute */ 4 243 3 total_primary_key_cost float bin, 4 244 3 access_cost float bin, 4 245 3 access_overhead float bin, 4 246 3 us_access_cost float bin, 4 247 3 os_access_cost float bin, 4 248 2 dbc_uid bit (36) aligned, /* uid of the segment containing the dbc structure */ 4 249 2 concurrency_on bit (1) unal, /* "1"b implies dmfile concurrency is being used */ 4 250 2 rollback_on bit (1) unal; /* "1"b iomplies before journaling is to be done */ 4 251 4 252 /* END mrds_dbcb.incl.pl1 */ 4 253 4 254 1274 1275 5 1 /* BEGIN mdbm_rm_db_info.incl.pl1 -- jaw, 11/7/78 */ 5 2 5 3 5 4 5 5 /****^ HISTORY COMMENTS: 5 6* 1) change(86-08-13,Hergert),, approve(88-06-28,MCR7903), 5 7* audit(88-06-28,Dupuis), install(88-08-01,MR12.2-1073): 5 8* Removed change of 84-11-02. i.e. replaced even_word_pad. 5 9* END HISTORY COMMENTS */ 5 10 5 11 5 12 /* WARNING 5 13* If the rm_db_info structure is changed then the mrds_data_ 5 14* item saved_res_version MUST be incremented to invalidate all 5 15* existing saved resultants 5 16**/ 5 17 5 18 /* DESCRIPTION: This structure is based on a segment 5 19* {unique_name}.mrds.rdbi that represents the secure portion of the 5 20* resultant model that is created partially at database open time, 5 21* (the rm_file_array, and rm_rel_array) and partially at ready_file 5 22* time, (the rm_file_info, rm_rel_info, rm_attr_info, 5 23* rm_domain_info, rm_plink_info and rm_clink_info). it's purpose is 5 24* to provide an efficient means of accessing database model 5 25* information, as seen from the possibly submodel view of the user, 5 26* and his current state of "files readied". it is the secure part 5 27* because it contains the model information which needs to be 5 28* protected from general knowledge, and this segment will 5 29* eventually be capable of being in a lower ring. the structure 5 30* itself points to four arrays that are allocated in it's area, 5 31* that in turn point to the other structures mentions above, also 5 32* allocated in the rm_db_info.static_area. the arrays are the 5 33* rm_file_array, and rm_rel_array. their are a pair for temporary 5 34* relations, initially empty, and a pair for normal model 5 35* files/relations. the normal rm_file_array is initialized to a 5 36* list of all known file names, the rm_rel_array only gets relation 5 37* names as files are readied. the rm_file_array points to 5 38* rm_file_infos for each file (see mdbm_rm_file_info.incl.pl1) and 5 39* the rm_rel_array points to rm_rel_info for each relation 5 40* "readied". (see mdbm_rm_rel_info.incl.pl1). (the arrays are in 5 41* mdbm_rm_file_array.incl.pl1 and mdbm_rm_rel_array.incl.pl1). the 5 42* file infos point to contained rel infos, the rel infos point to 5 43* contained attr infos, and those in turn to domain infos. (see 5 44* mdbm_rm_attr_info.incl.pl1 and mdbm_rm_domain_info.incl.pl1) 5 45* foreign keys are represented by the structures 5 46* mdbm_rm_plink_info.incl.pl1, and mdbm_rm_clink_info.incl.pl1. the 5 47* pathnames of the model and submodel, if any, are also maintained 5 48* in rm_db_info. the pointer to this rm_db_info segment is obtained 5 49* from the dbcb segment tructure(see mrds_dbcb.incl.pl1) see the 5 50* individual include files for further organization information, 5 51* and particular data structures. 5 52* 5 53* HISTORY: 5 54* 5 55* 80-02-01 Jim Gray : Modified to put area on even word boundary, 5 56* so that define_area_ could be used to make it an extensible area 5 57* 5 58* 81-1-9 Jim Gray : added like reference to make the phony 5 59* resultant in mu_database_index easier to keep, since no reference 5 60* to the area is needed. 5 61* 5 62* 81-1-12 Jim Gray : added version of submodel used in opening to 5 63* resultant. 5 64* 5 65* 81-05-13 Rickie E. Brinegar: added the administrator bit to the 5 66* structure. 5 67* 5 68* 81-05-28 Jim Gray : removed pointers to file_arrays, since they 5 69* are now combined into the rel_array. Removed the control file 5 70* info which was unused. Added pointer to head of domain list, 5 71* which is to be used to insure only one copy of each domain info. 5 72* 5 73* 83-05-19 Davids: Added the saved_res_version element. 5 74* 5 75* 84-11-02 Thanh Nguyen: Replaced the even_word_pad by the 5 76* ref_name_proc_ptr to point to list of reference name of the 5 77* check, encode, or decode proc. 5 78* 5 79* CAUTION: The structure entries from db_version to sm_path should 5 80* not be moved or have their declarations changed because they are 5 81* used in the handling of old version database openings. 5 82* 5 83* 5 84**/ 5 85 5 86 dcl 1 rm_db_info aligned based (rdbi_ptr), /* data base info, located at base of res. dm. seg. */ 5 87 2 data like rm_db_info_data, 5 88 2 static_area area (sys_info$max_seg_size - fixed (rel (addr (rm_db_info.static_area)))); 5 89 5 90 dcl rdbi_ptr ptr; 5 91 5 92 declare 1 rm_db_info_data based, /* separate declaration of info, so others can use 5 93* like reference to it without getting the area as well */ 5 94 2 db_version fixed bin, /* version no. of db */ 5 95 2 sm_version fixed bin unal, /* version of submodel used unal, 0 if model opening */ 5 96 2 val_level fixed bin unal, /* validation level for this db. */ 5 97 2 db_path char (168), /* abs. path of db. */ 5 98 2 sm_path char (168), /* path of submodel or model */ 5 99 2 mdbm_secured bit (1) unal, /* ON => database is secured */ 5 100 2 administrator bit (1) unal, /* ON => user is an administrator */ 5 101 2 pad bit (34) unal, /* for future use */ 5 102 2 saved_res_version char (8), /* version of the saved resultant in the 5 103* dbcb and rdbi segments in the db dir */ 5 104 2 domain_list_ptr ptr, /* pointer to head of list of domain_info's */ 5 105 2 ra_ptr ptr, /* pointer to rel. array */ 5 106 2 tra_ptr ptr, /* to rel array for temp rels */ 5 107 2 even_word_pad fixed bin (71) aligned; /* padding to put area on even word boundary */ 5 108 5 109 /* END mdbm_rm_db_info.incl.pl1 */ 5 110 5 111 1276 1277 6 1 /* BEGIN mdbm_rm_rel_array.incl.pl1 -- jaw, 8/9/78 */ 6 2 6 3 /* WARNING 6 4* If the rm_rel_array structure is changed then the mrds_data_ 6 5* item saved_res_version MUST be incremented to invalidate all 6 6* existing saved resultants 6 7**/ 6 8 6 9 /* HISTORY: 6 10* 6 11* 81-05-28 Jim Gray : added model_name and file_id as part of 6 12* combining funtions of file_array and rel_array into one 6 13* structure. This will only allow 1 relation per file model now. 6 14* Also changed structure to allow more efficient searching 6 15* via and index builtin, rather than a programmed loop. 6 16* Search is now I = index(string(rm_rel_array.name), "!" || in_name) 6 17* with I = ((I - 1) / 33) + 1 to convert from a char to array index. 6 18* 6 19**/ 6 20 6 21 6 22 /* this structure is allocated in the static are of the structure 6 23* in mdbm_rm_db_info.incl.pl1, the secure portion of the database 6 24* resultant model upon opening the database. two copies are 6 25* allocated, one for temporary relations, initially empty, and one 6 26* for relations known to the opener, which has a length sufficient 6 27* for all relations known to the user, but whose names, etc. will 6 28* not be filled in until the file containing that particular 6 29* relation is readied. the rm_db_info structure contains a pointer 6 30* to the rel_arrays, and the array entries, when "readied", point 6 31* to the mdbm_rm_rel_info.incl.pl1 structures containing model 6 32* information about the relation, it's attributes, etc. */ 6 33 6 34 dcl 1 rm_rel_array aligned based (rmra_ptr), /* array of open relations */ 6 35 2 num_rels fixed bin, /* no. rels in db. */ 6 36 2 name (1:rm_num_rels_init refer (rm_rel_array.num_rels)) unal, 6 37 3 mark char (1) unal, /* separator character = "!" */ 6 38 3 submodel char (32) unal, /* name of relation is submodel view, model opening => model name */ 6 39 2 rel_data (rm_num_rels_init refer (rm_rel_array.num_rels)), 6 40 3 model_name char (30), /* name of relation in model */ 6 41 3 ri_ptr ptr unal ; /* pointer to rm_rel_info */ 6 42 6 43 dcl rmra_ptr ptr; 6 44 dcl rm_num_rels_init fixed bin; 6 45 6 46 /* END mdbm_rm_rel_array.incl.pl1 */ 6 47 6 48 1278 1279 7 1 /* BEGIN mdbm_rm_rel_info.incl.pl1 -- jaw, 11/16/78 */ 7 2 7 3 /* WARNING 7 4* If the rm_rel_info structure is changed then the mrds_data_ 7 5* item saved_res_version MUST be incremented to invalidate all 7 6* existing saved resultants 7 7**/ 7 8 7 9 /* HISTORY: 7 10* 7 11* Modified by Jim Gray - - May 1980, to include model number of 7 12* attributes, and varying attributes, so that partial view 7 13* submodels will have the info needed to properly set up the 7 14* varying length array headers in the tuple structure. 7 15* 7 16* Modified by Jim Gray - - 80-11-06, to rename r_perm = 7 17* status_perm, s_perm = append_tuple_perm, d_perm = 7 18* delete_tuple_perm, and make m_perm = unused_perm. 7 19* 7 20* 81-01-23 Jim Gray : added bit to indicate whether the last model 7 21* view attribute was varying character or bit, since a partial view 7 22* submodel will not have this information in the resultant, and it 7 23* is needed for determining the new tuple length in mus_mod_ubtup, 7 24* since with exact length storage of varying length attributes, 7 25* each tuple can be a different length, which is can only be 7 26* determined by examining the tuple itself. 7 27* 7 28* 81-01-29 Jim Gray : added curent tuple count, to provide for 7 29* interface to allow temp rel population to be known, and to 7 30* provide a more efficient means of finding an approx. current perm 7 31* relation population. 7 32* 7 33* 81-05-28 Jim Gray : removed structure elements referring to 7 34* blocked files, foreign keys, and ids procedures. Also set number 7 35* of files per rel to a constant of 1. 7 36* 7 37* 81-05-28 Jim Gray : combined data from rm_file_info into this 7 38* structure so that only one structure per relation is needed. 7 39* 7 40* 81-07-02 Jim Gray : added total_key and dup_key vfile statistics 7 41* counts. Also added number of operations count since last 7 42* statistics update, and a time since the statistics were last 7 43* updated. 7 44* 7 45* 81-07-06 Jim Gray : added a per selection expression update 7 46* identifier so that small relations could be updated on a per S.E. 7 47* basis 7 48* 7 49* 82-04-21 R. Lackey : Added number_selected (ri_niocbs_init refer (rm_rel_info.niocbs)) fixed bin (35) 7 50* to end of structure TR 12205 (Suggestion). 7 51* 7 52* 82-08-19 D. Woodka : Removed rm_rel_info.max_data_len field for 7 53* the DMS conversion. 7 54* 7 55* 82-08-30 Davids: added the opening_id element and removed the iocb 7 56* array and the niocb element for DMS conversion. Also removed the 7 57* number_selected array (and ri_niocbs_init) since subsets are not 7 58* going to be used. 7 59* 7 60* 82-09-20 Mike Kubicar : changed rm_rel_info.rel_id to bit (36) aligned 7 61* so that it can be used with relation manager. Also added 7 62* rm_rel_info.primary_key_index_id for relation manager. 7 63* 7 64* 82-09-22 Mike Kubicar : Removed the, now useless, fields var_attr_ptrs, 7 65* nvar_atts, model_nvar_atts. 7 66* 7 67* 82-09-24 Davids: Removed current_key_count and current_dup_key_count 7 68* since the duplicate key count for each secondary index is now being 7 69* kept in the attr_info structure and key_count was only needed to 7 70* help in calculating the average selectivity of each index which 7 71* can now be gotten directly from each index's dup key count. Also 7 72* removed the file_id element since it is no longer needed for 7 73* anything. 7 74* 7 75* 82-09-27 Mike Kubicar : removed file_id_len for the same reason file_id 7 76* was removed. 7 77* 7 78* 82-11-05 Mike Kubicar : added a pointer to an id_list structure to be 7 79* used when retrieving tuples from this relation. 7 80* 7 81* 83-04-06 Davids: Added the scope_flags_ptr which points to the scope_flags structure 7 82* for the relation. Note that this structure is part of the resultant NOT 7 83* part of the db.control structure. The scopes are duplicated in the resultant 7 84* to reduce contention for the db.control structure. Note also that the pointer 7 85* will always point to a scope_flags structure even if no scopes have been 7 86* set on the relation, the structure is allocated when the db is opened. 7 87**/ 7 88 7 89 7 90 /* DESCRIPTION: 7 91* 7 92* This structure is allocated in the area part of the structure in 7 93* mdbm_rm_db_info.incl.pl1 as part of the resultant model created 7 94* at open time for a database. There will be one of these 7 95* rm_rel_info structures for each relation appearing in the 7 96* database view (there may be less than the total in the database 7 97* for a submodel openings). There will also be one for each 7 98* temporary relation currently defined for that opening. 7 99* 7 100* The structure in mdbm_rm_rel_array.incl.pl1 contains pointers to 7 101* all rm_rel_info structures allocated. It is used for searching 7 102* for the appropriate structure. This array is pointed to by 7 103* rm_db_info. There are two arrays, one for perm rels, one for temp 7 104* rels. 7 105* 7 106* The rm_rel_info structure points to the 7 107* mdbm_rm_attr_info.incl.pl1 structures, one for each attribute 7 108* appearing in this view of the relation. Each of these in turn 7 109* point to a mdbm_rm_domain_info.incl.pl1 structure for the domain 7 110* info for each attr. 7 111* 7 112* Most of the other information here deals with specifics of the 7 113* relation's logical definition, such as key and secondary index 7 114* attribute inidicators, security permissions, and tuple physical 7 115* construction details. 7 116* 7 117**/ 7 118 7 119 dcl 1 rm_rel_info aligned based (rmri_ptr), /* relation information */ 7 120 2 name char (32), /* from submodel */ 7 121 2 model_name char (30), /* from model */ 7 122 2 rel_id bit (36) aligned, /* unique id. */ 7 123 2 retrieve bit (1) unal, /* operations allowed by this view */ 7 124 2 modify bit (1) unal, 7 125 2 delete bit (1) unal, 7 126 2 store bit (1) unal, 7 127 2 total_key bit (1) unal, /* on if view includes full primary key */ 7 128 2 indexed bit (1) unal, /* on if exists sec. index */ 7 129 2 mdbm_secured bit (1) unal, /* on if mdbm must check security */ 7 130 2 status_perm bit (1) unal, /* if user has status. perm. */ 7 131 2 append_tuple_perm bit (1) unal, /* if user has store perm. */ 7 132 2 delete_tuple_perm bit (1) unal, /* if user has del. perm. */ 7 133 2 unused_perm bit (1) unal, /* for future use. */ 7 134 2 last_model_attr_char_var bit (1) unal, /* on => last model varying attr is char */ 7 135 2 reserved bit (24) unal, /* for future use */ 7 136 2 num_attr fixed bin, /* total no. of attr. in rel. */ 7 137 2 model_num_attr fixed bin, /* total attrs in model relation */ 7 138 2 nkey_attr fixed bin, /* no. of key attr. */ 7 139 2 model_nkey_attr fixed bin, /* total number of keys in model */ 7 140 2 primary_key_index_id bit (36) aligned, /* Index id of relation's primary key */ 7 141 2 nsec_inds fixed bin, /* no. sec. indexes */ 7 142 2 max_key_len fixed bin (35), /* max length (chars) of primary key */ 7 143 2 current_tuple_population fixed bin (35), /* last known total tuple count for this relation */ 7 144 2 last_statistics_update_count fixed bin, /* number of operations's, since this rels stats were updated */ 7 145 2 last_statistics_update_time fixed bin (71),/* last time this rels stats were updated */ 7 146 2 last_statistics_update_s_e_ref_num fixed bin (35), /* last select expr ID that updated this rels stats */ 7 147 2 ready_mode fixed bin, /* 1 => r, 2 => mr, 3 => u, 4 => l, 5 => sr, 6 => su */ 7 148 2 file_type fixed bin, /* 1 => unblocked, 2 => blocked, 3 => temporary */ 7 149 2 tuple_id_len fixed bin, /* no. bits in local tuple id */ 7 150 2 opening_id bit (36) aligned, /* relation manager opening is */ 7 151 2 key_attr_ptrs (nkey_attr_init refer (rm_rel_info.nkey_attr)) ptr, /* ptrs to key attr. */ 7 152 2 attr_ptrs (natts_init refer (rm_rel_info.num_attr)) ptr, /* ptrs to all attr. */ 7 153 2 id_list_ptr ptr, /* Id list for retrieves from the relation */ 7 154 2 scope_flags_ptr ptr; /* pointer to the scope_flags structure for the rel */ 7 155 7 156 dcl rmri_ptr ptr; 7 157 dcl (nkey_attr_init, 7 158 natts_init, 7 159 nvar_atts_init) fixed bin; 7 160 7 161 /* END mdbm_rm_rel_info.incl.pl1 */ 7 162 7 163 1280 1281 8 1 /* BEGIN mdbm_rm_attr_info.incl.pl1 -- jaw, 11/16/78 */ 8 2 8 3 /* WARNING 8 4* If the rm_attr_info structure is changed then the mrds_data_ 8 5* item saved_res_version MUST be incremented to invalidate all 8 6* existing saved resultants 8 7**/ 8 8 8 9 /* 8 10* 8 11* Modified by Jim Gray - - 80-11-05, to add mdbm_secured bit, so 8 12* that rm_rel_info does not have to be checked 8 13* 8 14* 81-05-28 Jim Gray : removed structure elements referring to 8 15* foreign keys. 8 16* 8 17* 82-08-19 D. Woodka : removed rm_attr_info.bit_offset for the DMS 8 18* conversion. 8 19* 8 20* 82-09-15 Davids: added the number_of_dups field. 8 21* 8 22* 82-09-20 Mike Kubicar : changed the index_id field to be bit (36) 8 23* aligned. This is to conform with the new definition in the database 8 24* model. Also removed the now useless field varying. 8 25* 8 26* 82-11-05 Davids: added the field model_defn_order and clarified the 8 27* comment for the field defn_order. 8 28* 8 29* 83-05-23 Mike Kubicar : changed number_of_dups to fixed bin (35) since 8 30* that's what relation manager returns. 8 31* 8 32**/ 8 33 8 34 8 35 /* 8 36* this structure is allocated in the static area of 8 37* mdbm_rm_db_info.incl.pl1 once for each attribute per relation in 8 38* a readied file. it in turn points to 8 39* mdbm_rm_domain_info.incl.pl1 for the attributes domain. the 8 40* rm_attr_info is pointed to by mdbm_rm_rel_info.incl.pl1. all 8 41* structures are in the rm_db_info area. the attribute data 8 42* position within a tuple as stored in the data file are kept in 8 43* this resultant model of the attribute. 8 44* */ 8 45 8 46 dcl 1 rm_attr_info aligned based (rai_ptr), /* resultant attr. info */ 8 47 2 name char (32), /* from submodel */ 8 48 2 model_name char (32), /* from model */ 8 49 2 key_attr bit (1) unal, /* if key attribute */ 8 50 2 index_attr bit (1) unal, /* if secondary index */ 8 51 2 read_perm bit (1) unal, /* user has retr. permission */ 8 52 2 modify_perm bit (1) unal, /* user has modify permission */ 8 53 2 mdbm_secured bit (1) unal, /* on => database secured */ 8 54 2 reserved bit (30) unal, /* for future use */ 8 55 2 index_id bit (36) aligned, /* index id if index_attr */ 8 56 2 defn_order fixed bin, /* relative order in which attr is defined in the view */ 8 57 2 key_order fixed bin, /* relative order defined in prim. key */ 8 58 2 bit_length fixed bin (35), /* length if fixed, max. len. if var. */ 8 59 2 domain_ptr ptr, /* to domain info */ 8 60 2 number_of_dups fixed bin (35), /* if the attribute is indexed this will 8 61* be the number of duplicate values, exact 8 62* for a page_file database, an estimate for a vfile type */ 8 63 2 model_defn_order fixed bin; /* relative order in which attr is defined in the model */ 8 64 8 65 dcl rai_ptr ptr int automatic init (null ()); 8 66 8 67 /* END mdbm_rm_attr_info.incl.pl1 */ 8 68 8 69 1282 1283 9 1 /* BEGIN mdbm_rm_domain_info.incl.pl1 -- jaw, 9/26/78 */ 9 2 9 3 /* WARNING 9 4* If the rm_domain_info structure is changed then the mrds_data_ 9 5* item saved_res_version MUST be incremented to invalidate all 9 6* existing saved resultants 9 7**/ 9 8 9 9 /* DESCRIPTION: 9 10* 9 11* This structure is allocated in the mdbm_rm_db_info.incl.pl1 9 12* static area, once per attribute used in a relation in a readied 9 13* file. it is pointed to by the mdbm_rm_attr_info.incl.pl1, and may 9 14* point to mdbm_rm_ck_and_group.incl.pl1 if a "-check" option 9 15* boolean expression was declared for this domain. it contains the 9 16* descriptor for this domain data type, and other resultant model 9 17* information. 9 18* 9 19* 9 20* HISTORY: 9 21* 9 22* 81-05-06 Rickie E. Brinegar: Modified ck_proc, encode_proc, 9 23* decode_proc to be entry variables instead of entry pointers. This 9 24* allows these programs to be written in languages other than pl1. 9 25* 9 26* 81-05-28 Jim Gray : removed unused procedure points, and unused 9 27* check stack structure elements. Also made the descriptors bit 9 28* (36) in this structure, rather than pointers to the descriptors 9 29* elsewhere. Also removed un-needed redundant assign_ parameters, 9 30* that are actually available in the descriptors. 9 31* 9 32* 9 33**/ 9 34 9 35 dcl 1 rm_domain_info aligned based (rdi_ptr), /* domain information */ 9 36 2 name char (32), /* domain name */ 9 37 2 db_desc bit (36), /* to desc. for db. */ 9 38 2 user_desc bit (36), /* desc for user visible data */ 9 39 2 user_bit_len fixed bin, /* storage length of users data */ 9 40 2 ck_proc_entry entry variable, /* to check proc. entry */ 9 41 2 encd_proc_entry entry variable, /* to encode proc entry */ 9 42 2 decd_proc_entry entry variable, /* to decode proc entry */ 9 43 2 ck_proc bit (1) unal, /* Is there a check proc */ 9 44 2 encd_proc bit (1) unal, /* Is there an encode proc */ 9 45 2 decd_proc bit (1) unal, /* Is there a decode proc */ 9 46 2 pad bit (33) unal, 9 47 2 next_domain_ptr ptr ; /* to next domain, in list of all domains */ 9 48 /* to check stack and groups */ 9 49 9 50 9 51 dcl rdi_ptr ptr int automatic init (null ()); 9 52 9 53 /* END mdbm_rm_domain_info.incl.pl1 */ 9 54 9 55 1284 1285 10 1 /* BEGIN INCLUDE FILE mrds_dsm_header.incl.pl1 10 2* 10 3*This include file is for internal MRDS use only - it is not to be 10 4*documented in any user manual. 10 5* 10 6*81-06-01 Davids: This is a copy of the mrds_dsm_header_str 10 7*include file, it is to be used by all mrds routines. The 10 8*structure name has been changed from dsm_header_record to 10 9*mrds_dsm_header to avoid conflicts when both this include file 10 10*and mrds_dsm_header_str are included (mrds_dsm_dsmd). 10 11**/ 10 12 10 13 dcl 1 mrds_dsm_header based, /* header structure for a MRDS submodel */ 10 14 2 dsm_generator_version fixed bin init (0), /* version number of submodel created by CMDSM */ 10 15 2 date_time_generated fixed bin (71) init (0), /* convert data to binary form of creation time */ 10 16 2 database_pn char (168) init (""), /* pathname of database this submodel is valid for */ 10 17 2 name char (32) init (""), /* identifying name for this header structure */ 10 18 2 num_of_relations fixed bin (35) init (0), /* number of relations in submodel view of database */ 10 19 2 creator_id char (32) init ("") ; /* the person.project.tag of the submodel creator */ 10 20 10 21 /* END INCLUDE FILE mrds_dsm_header.incl.pl1 */ 1286 1287 11 1 /* BEGIN INCLUDE FILE mdbm_db_model.incl.pl1 -- jaw, 10/2/78 */ 11 2 11 3 11 4 /****^ HISTORY COMMENTS: 11 5* 1) change(79-02-01,Gray), approve(), audit(), install(): 11 6* modified to save space occupied by model 11 7* 2) change(80-11-03,Gray), approve(), audit(), install(): 11 8* to add mdbm_secured bit in db_model 11 9* 3) change(82-04-09,Davids), approve(), audit(), install(): 11 10* collapsed the following into an unused_offset array: 11 11* chng_before_path_ptr chng_err_path_ptr chng_after_path_ptr 11 12* copy_before_path_ptr copy_err_path_ptr copy_after_path_ptr 11 13* dsply_before_path_pt dsply_err_path_pt dsply_after_path_ptr 11 14* accs_before_path_ptr accs_err_path_ptr accs_after_path_ptr 11 15* unused_1 11 16* Also changed the name of unused_2 to restructuring_history_offset 11 17* and changed the comment on the changer structure to indicate 11 18* that it will contain on database creation information. 11 19* 4) change(82-04-14,Davids), approve(), audit(), install(): 11 20* used one of the unused_offsets to point to a message which indicates 11 21* why the db is inconsistent. The offset will be null when the db is created 11 22* and set the first time the message is used. this is so it will be 11 23* consistent with existing data bases. Also added the message structure. 11 24* 5) change(82-04-28,Davids), approve(), audit(), install(): 11 25* added the undo_request element to the message structure 11 26* 6) change(82-05-04,Davids), approve(), audit(), install(): 11 27* changed unused_offset (12) to last_restructruring_history_offset and 11 28* changed restructuring_history_offset to first_restructuring_history_offset 11 29* 7) change(82-08-19,Davids), approve(), audit(), install(): 11 30* changed the meaning of db_type from 1 => relational and 2 => CODASYL to 11 31* 1 => vfile database and 2 => page_file database. Up to this point all 11 32* database types were equal to 1. 11 33* 8) change(83-02-14,Davids), approve(), audit(), install(): 11 34* changed db_type from a fixed bin unal to a substructure of 18 bit (1) unal 11 35* flags. This will allow information about transactions and dm_file 11 36* concurrency to be independent of the db_type, i.e. vfile or dm_file. The 11 37* change is compatable with all datamodels created by the released version 11 38* of mrds. 11 39* 9) change(83-02-15,Davids), approve(), audit(), install(): 11 40* added the rollback_on flag to the db_type_flags since it appears that you 11 41* can have a dmfile database that requires transactions but does not have any 11 42* journalizing. Also switched the order of the transactions_needed and 11 43* concurrency_on flags - this makes the change compatable with existing 11 44* dmfile databases except when displaying the model since concurrency_on and 11 45* rollback_on will be off in the model even though the dmfile relations had 11 46* them on during creation. 11 47* 10) change(83-02-22,Kubicar), approve(), audit(), install(): 11 48* Removed ctl_file_path_ptr. 11 49* 11) change(85-11-08,Spitzer), approve(85-12-03,MCR7311), 11 50* audit(86-09-02,Blair), install(86-10-16,MR12.0-1187): 11 51* used 1 unused offset for unreferenced attribute linked lists in db_model, 11 52* 1 unused bit flag in domain_info to indicate an unreferenced domain, 1 bit 11 53* in the flag word for rmdb copying. 11 54* END HISTORY COMMENTS */ 11 55 11 56 11 57 /* this include file contains the structures that go into the make up 11 58* of the "db_model" segment in the model for the database. 11 59* in addition there file_model.m segments, 1 for each database file(see mdbm_file_model.incl.pl1) 11 60* 11 61* the db_model structure goes at the base of the segment, and contains items unique to 11 62* the whole databse. in addition, it has an area of size to fill the 11 63* rest of a segment, that holds the lists of files and domains in the database. 11 64* these lists are singly forward linked lists. all "pointers" in the database model 11 65* are maintained as offsets(bit (18)) from the base of the particular model segment 11 66* since actual pointers are process dependent on segment number. 11 67* the remaining structures are first a path_entry one to save pathnames in, 11 68* and the stack_item and constent structures, used to save a boolean 11 69* expression in polish form, with the stack represented by a linked list. 11 70* the final structure is one for identifying the status of version information */ 11 71 11 72 dcl 1 db_model aligned based (dbm_ptr),/* base of db_model segment, allocated once per database */ 11 73 2 version unal fixed bin, /* data base version, currently 4 */ 11 74 2 db_type_flags unal, 11 75 3 copy_good bit (1) unal, /* "1"b => copy of the db_model is the valid copy */ 11 76 3 unused (13) bit (1) unal, 11 77 3 rollback_on bit (1) unal, /* "1"b => before journaling is to be done */ 11 78 3 concurrency_on bit (1) unal, /* "1"b => dm_file concurrency is being used */ 11 79 3 transactions_needed bit (1) unal, /* "1"b => transactions are needed to reference data */ 11 80 3 vfile_type bit (1) unal, /* "1"b => vfile type relations, "0"b => dm_file type relations */ 11 81 2 uniq_sw_name char (32), /* per database unique attach switch name for files */ 11 82 2 consistant bit (1) unal, /* ON => correctly created/restructured database, ok to open */ 11 83 2 mdbm_secured bit (1) unal, /* on => database has been secured */ 11 84 2 reserved bit (34) unal, /* reserved for flags */ 11 85 2 blk_file_id_len unal fixed bin, /* no. bits required for blocked file id. */ 11 86 2 unblk_file_id_len unal fixed bin, /* number of file id bits, unblocked file */ 11 87 2 num_blk_files unal fixed bin, /* number of blocked files defined in db */ 11 88 2 num_unblk_files unal fixed bin, /* number of unblocked files defined in db */ 11 89 2 num_rels unal fixed bin, /* number of relations defined in db. */ 11 90 2 num_domains unal fixed bin, /* number of domains defined */ 11 91 2 num_dyn_links unal fixed bin, /* no. dynamic links defined */ 11 92 2 max_max_tuples unal fixed bin (35), /* maximum max_tuples across all files */ 11 93 2 pad_1 unal fixed bin (35), /* for future use */ 11 94 2 pad_2 unal fixed bin (35), /* for future use */ 11 95 2 version_ptr bit (18), /* offset to version structure */ 11 96 2 file_ptr unal bit (18), /* offset to first in threaded list of file_infos */ 11 97 2 domain_ptr unal bit (18), /* offset to first in list of domain_infos */ 11 98 2 unreferenced_attribute_ptr unal bit (18), /* offset to first in list of unreferenced attr_infos */ 11 99 2 unused_offsets (11) unal bit (18), /* extra offsets if needed */ 11 100 2 last_restructuring_history_offset unal bit (18), /* offset to last restructuring history entry */ 11 101 2 inconsistent_message_offset unal bit (18), /* offset to message indicating why db is inconsistent */ 11 102 2 first_restructuring_history_offset unal bit (18), /* offset to first restructuring history entry */ 11 103 2 changer_ptr unal bit (18), /* offset to information about db creation */ 11 104 2 dbm_area area (sys_info$max_seg_size - fixed (rel (addr (db_model.dbm_area))) - 1); 11 105 11 106 dcl dbm_ptr ptr; 11 107 11 108 /* the files in the database each have a file_info containing 11 109* their name, the file_model for each file is found by initiating the 11 110* segment "file_name.m" (i.e. the file's name with suffix ".m") 11 111* the file_info list is a singly linked list in definition order */ 11 112 11 113 dcl 1 file_info aligned based (fi_ptr), /* list of file names and numbers */ 11 114 2 file_name char (30), /* name of file */ 11 115 2 file_id bit (36), /* id number of file */ 11 116 2 fwd_ptr unal bit (18), /* thread to next in list */ 11 117 2 unused unal bit (18); /* for future expansion */ 11 118 11 119 dcl fi_ptr ptr; 11 120 11 121 /* each domain used in the database will have a domain info saved in the db_model 11 122* segment. it describes the domain of the given name, and it's options. 11 123* the domain_info's form a singly linked list in definition order */ 11 124 11 125 dcl 1 domain_info aligned based (di_ptr), /* one for each domain defined */ 11 126 2 name char (32), /* name of domain */ 11 127 2 db_desc_is_ptr bit (1) unal, /* on if descriptor is pointer to real desc. */ 11 128 2 user_desc_is_ptr bit (1) unal, /* on if user desc is ptr */ 11 129 2 no_conversion bit (1) unal, /* if no conversion allowed */ 11 130 2 procedures_present bit (1) unal, /* on => ids type procedures present */ 11 131 2 unreferenced bit (1) unal, /* on => this domain is not used in any attribute */ 11 132 2 reserved bit (31) unal, 11 133 2 db_desc bit (36), /* desc. for item in db, or ptr to it */ 11 134 2 user_desc bit (36), /* desc. for user-visible attr, or ptr */ 11 135 2 ave_len fixed bin (35), /* average length of varying string */ 11 136 2 nck_items unal fixed bin, /* no. items in check stack */ 11 137 2 fwd_thread unal bit (18), /* offset to next in list */ 11 138 2 check_path_ptr unal bit (18), /* integ. check proc. */ 11 139 2 ck_stack_ptr unal bit (18), /* to check stack */ 11 140 2 encd_path_ptr unal bit (18), /* encode procedure */ 11 141 2 decd_path_ptr unal bit (18), /* decode procedure */ 11 142 2 str_before_path_ptr unal bit (18), /* proc paths and entries */ 11 143 2 str_err_path_ptr unal bit (18), 11 144 2 str_after_path_ptr unal bit (18), 11 145 2 get_before_path_ptr unal bit (18), 11 146 2 get_err_path_ptr unal bit (18), 11 147 2 get_after_path_ptr unal bit (18), 11 148 2 mod_before_path_ptr unal bit (18), 11 149 2 mod_err_path_ptr unal bit (18), 11 150 2 mod_after_path_ptr unal bit (18), 11 151 2 unused_1 unal bit (18), /* for future expansion */ 11 152 2 unused_2 unal bit (18), 11 153 2 changer_ptr unal bit (18); /* pointer to change_id and chane_time structure */ 11 154 11 155 dcl di_ptr ptr; 11 156 11 157 /* information necessary for attributes that are not used in any relation */ 11 158 11 159 dcl 1 unreferenced_attribute aligned based (ua_ptr), 11 160 2 name char (32), /* name of attribute */ 11 161 2 domain_ptr bit (18) unal, /* to domain_info */ 11 162 2 fwd_thread bit (18) unal, /* to next in list */ 11 163 2 unused (2) bit (18) unal; 11 164 11 165 dcl ua_ptr ptr; 11 166 11 167 11 168 /* space saving pathname$entryname structure, to be allocated 11 169* only when a path$entry has to be saved, else only a bit(18) 11 170* offset takes up space in the main model structure */ 11 171 11 172 declare 1 path_entry based (path_entry_ptr), 11 173 2 path char (168), /* pathname portion of desired path$entry */ 11 174 2 entry char (32), /* entryname portion of desired path$entry */ 11 175 2 reserved unal bit (36); /* for future use */ 11 176 11 177 declare path_entry_ptr ptr; 11 178 11 179 11 180 11 181 11 182 11 183 /* declarations for model of postfix stack holding the check option boolean expression 11 184* the following encoding values indicate the corresponding type of stack element 11 185* 11 186* 1 = 11 187* 2 ^= 11 188* 3 > 11 189* 4 < 11 190* 5 >= 11 191* 6 <= 11 192* 11 193* 10 and 11 194* 20 or 11 195* 30 not 11 196* 11 197* 40 - (minus) 11 198* 11 199* 50 domain variable(same name as domain) 11 200* 11 201* 60 constant(number, bit string, or character string) 11 202* 11 203**/ 11 204 11 205 11 206 declare 1 stack_item based (stack_item_ptr), /* element of stack model list */ 11 207 2 next bit (18), /* link to next in list */ 11 208 2 type fixed binary, /* code for this element type */ 11 209 2 value_ptr bit (18); /* pointer to variable holding value, 11 210* if this is a constant element type */ 11 211 11 212 declare stack_item_ptr ptr; /* pointer to a stack element */ 11 213 11 214 11 215 11 216 declare 1 constant based (constant_ptr), /* variable size space for constant's value storage */ 11 217 2 length fixed bin (35), /* length allocated to hold value */ 11 218 2 value bit (alloc_length refer (constant.length)) aligned; /* value for this constant */ 11 219 11 220 declare constant_ptr ptr; /* pointer to constant's value space */ 11 221 11 222 declare alloc_length fixed binary (35) internal static; /* amount of space to allocate for constant's value */ 11 223 11 224 /* version structure, giving status of source for CMDB/RMDB, 11 225* status of model, and status of resultant */ 11 226 11 227 /* version number is in form MM.N.Y 11 228* where MM is the major version number, N is the minor version alteration, 11 229* and Y is the lastest modification to that alteration, 11 230* where M and N represent numbers 0-9, and Y is a letter */ 11 231 11 232 declare 1 version_status unal based (version_status_ptr), 11 233 2 cmdb_rmdb, 11 234 3 major fixed bin, 11 235 3 minor fixed bin, 11 236 3 modification char (4), 11 237 2 model, 11 238 3 major fixed bin, 11 239 3 minor fixed bin, 11 240 3 modification char (4), 11 241 2 resultant, 11 242 3 major fixed bin, 11 243 3 minor fixed bin, 11 244 3 modification char (4); 11 245 11 246 declare version_status_ptr ptr; 11 247 11 248 11 249 /* maintains information only about the db creation */ 11 250 11 251 declare 1 changer unal based (changer_ptr), 11 252 2 id char (32), 11 253 2 time fixed bin (71), 11 254 2 next bit (18); /* to next in the singly linked list */ 11 255 11 256 declare changer_ptr ptr; 11 257 11 258 11 259 dcl 01 message_str unal based (message_str_ptr), /* general purpose structure to hold messages */ 11 260 02 len fixed bin, /* length of the message */ 11 261 02 text char (message_str_len refer (message_str.len)), /* actual message */ 11 262 02 name char (32), /* name of thing that set the message */ 11 263 02 undo_request char (100), /* rmdb request that will undo the operation 11 264* that caused the database to become inconsistent */ 11 265 02 mbz bit (36); /* for possible extensions, like an offset to another message */ 11 266 11 267 dcl message_str_ptr ptr; /* pointer to the message_str structure */ 11 268 11 269 dcl message_str_len fixed bin; /* initail length of the text string in message_str */ 11 270 11 271 /* END INCLUDE FILE mdbm_db_model.incl.pl1 */ 11 272 11 273 1288 1289 12 1 /* BEGIN mdbm_scope_info.incl.pl1 -- odf 8/8/78 */ 12 2 12 3 /* WARNING 12 4* If the scope_info or scope_flags structure is changed then the 12 5* mrds_data_ item saved_res_version MUST be incremented to invalidate 12 6* all existing saved resultants 12 7**/ 12 8 12 9 /* Modified by Jim Gray - - 80-11-17, to add back store/delete/modify permissions */ 12 10 12 11 /* 80-12-10 Jim Gray : change name of store to append_tuple, delete to delete_tuple, 12 12* modify to modify_attr, retrieve to read_attr, remvoe update, put level 4 12 13* qualifiers for permit/prevent modes and to put pads in standard format */ 12 14 12 15 /* 80-12-11 Jim Gray : added submodel version of file/rel name for convenience */ 12 16 12 17 /* 80-12-22 Jim Gray : added like referenced structure so linus_scope_data.incl 12 18* could make use of it for compatibility. */ 12 19 12 20 /* 81-1-11 Jim Gray : added touched bit to scope_flags, so that 12 21* the fact that null scope has been set can be displayed */ 12 22 12 23 /* 85-04-14 Thanh Nguyen: Made scope_flags to be aligned so we could access the 12 24* prevent flags from any pointer which directly pointed to scope_flags itself 12 25* (i.e rm_rel_info.scope_flags_ptr). */ 12 26 12 27 /* this structure is to be allocated in the mrds_dbcb.incl.pl1 static area, 12 28* and is used to maintain the scope mechanism for file access. 12 29* It contains the scope permit/prevent operations that this user 12 30* has set in his view for this opening instance. */ 12 31 12 32 dcl 1 scope_info aligned based (scope_ptr), /* array of scope tuples for this user */ 12 33 FPublicDomainSoftware.trans M.i2>udd>Tolts>Fakoury>mtgs>PublicDomainSoftware.trans؋ &@( F r>0a d >6caudi's.cb M.i(>user_dir_dir>Tolts>Fakoury>lib>caudi.cb؋ r F >caudi.cb d >caudi's >&A >0a 3Jbound_dfm_bug_fixes.mcr M.iD$ >0a3؋ >0*@ >* >* *@ *  &:… >0a daily.absin M.i$ >0a؋ >*  >0*@ >*  *@ * j &: $ $>0a Ieaster M.i$ B b>0a ؋ J>* R B>0* Z J>* b R*@ Z* &A r r>0a jinitials M.i'$ >0a؋ >0*@ >* >* *@ *  j&Ap >0a mcr8147 M.iD$ >0a55؋ >0*@ >* >* *@ * T &M3  >0a multics_history MЅK$ , L>0a"؋ 4>0*@ < ,>* D 4>* L <*@ D* &L` \ \>0a TNmultics_faq M.jj|$ z >0aC؋ >0*@ z>* >* *@ * T&:~ >0a my_ready_message M.j$ >0a؋ >* >0* >* *@ * > &B"R >0a 0obseratories M.j'j|$  6>0a؋ >0*@ & >* . >* 6 &*@ .* &> D F F>0a >9wno.ml M.jK$ d >0a/؋ l>0*@ t d>* | l>* t*@ |* >&e M| >0a classes e M;K@$ >0a؋ >0*@e >*e >*e *@e *e ( && LN& >0a rick.mls & LN0`C$ >0a_؋ END INCLUDE FILE mrds_select_area.incl.pl1 */ 14 12 1294 1295 15 1 /* BEGIN INCLUDE FILE mrds_debug_names.incl.pl1 Jim Gray 8/7/79 */ 15 2 15 3 /* this include file associates module names with debug switches 15 4* that are stored in the data segment mrds_debug_ 15 5* each module has it's own bit(9) debug switch, to define for various 15 6* debug actions, with new module names to be added to the end 15 7* of this list using the next in order array index in mrds_debug_ 15 8* the convention for naming is db_{module's full name} 15 9* for the defined declaration over mrds_debug_$switch. 15 10* module.name array is then changed to reflect the new 15 11* number of modules, with the full module name added to the bottom 15 12* of the initialize list for the name array. 15 13* the module name array is used by the command level interface that sets/resets 15 14* the current status of the debug switches for each module. 15 15* the modules themselves use the db_{module name} declared variable for 15 16* that module to interagate the bits for proper debug action to take. 15 17* the definition of the meaning of the 9-bits is up to each individual module's 15 18* designer. */ 15 19 15 20 15 21 /* 15 22* HISTORY 15 23* 15 24* 80-11-12 Davids: added db_mus_mod_ubtup 15 25* 15 26* 80-11-13 Davids: added db_mu_sec_get_tuple and db_mu_sec_get_tid 15 27* 15 28* 80-12-15 Jim Gray : added mrds_dsl_set_fscope to display non 15 29* error info about being queued, and request being granted after 15 30* being queued. 15 31* 15 32* 81-01-15 Jim Gray : added mu_concurrency_control bit to allow 15 33* running MR8 and MR9 mrds against the same database at the same 15 34* time. 15 35* 15 36* 81-02-02 Jim Gray : added bit for mrds_rst_dmdm to allow 15 37* displaying internal tuple format bit offset, rather than the user 15 38* view. 15 39* 15 40* 81-02-06 Jim Gray : added bit for new mu_open_name_manager, to 15 41* dump an element from the list, when display_open_names entry 15 42* called with switch set. 15 43* 15 44* 81-05-20 Jim Gray : added bit for mrds_dsl_where_clause display 15 45* of sub_err_ messages, when cross domain compare occurs. 15 46* 15 47* 81-06-17 Jim Gray : added bit for mu_open_iocb_manager to display 15 48* iocb slot and rel name. 15 49* 15 50* 81-07-08 Jim Gray : added comment for bit 4 in mrds_dsl_permute 15 51* 15 52* 81-07-17 Jim Gray : added comment for bit 5 in mrds_dsl_permute 15 53* 15 54* 81-07-18 Jim Gray : added bit 1 for mrds_dsl_gen_srch_prog that 15 55* allows key searches, other than than specified by permute to be 15 56* done as comparisons instead. 15 57* 15 58* 81-07-22 Jim Gray : added comment about bit 2 in 15 59* mrds_dsl_gen_srch_prog 15 60**/ 15 61 15 62 declare ( 15 63 db_mrds_dsl_eval_expr bit (9) unal defined (mrds_debug_$switch (1)), 15 64 db_mrds_dsl_get_token bit (9) unal defined (mrds_debug_$switch (2)), 15 65 db_mrds_dsl_permute bit (9) unal defined (mrds_debug_$switch (3)), 15 66 db_mrds_dsl_optimize bit (9) unal defined (mrds_debug_$switch (4)), 15 67 db_mrds_dsl_search bit (9) unal defined (mrds_debug_$switch (5)), 15 68 db_mrds_dsl_translate bit (9) unal defined (mrds_debug_$switch (6)), 15 69 db_mu_retrieve bit (9) unal defined (mrds_debug_$switch (7)), 15 70 db_mrds_dsl_open bit (9) unal defined (mrds_debug_$switch (8)), 15 71 db_mrds_dsl_close bit (9) unal defined (mrds_debug_$switch (9)), 15 72 db_mrds_dsl_init_res bit (9) unal defined (mrds_debug_$switch (10)), 15 73 db_mu_sec_init_res bit (9) unal defined (mrds_debug_$switch (11)), 15 74 db_mus_mod_ubtup bit (9) unal defined (mrds_debug_$switch (12)), 15 75 db_mu_sec_get_tuple bit (9) unal defined (mrds_debug_$switch (13)), 15 76 db_mu_sec_get_tid bit (9) unal defined (mrds_debug_$switch (14)), 15 77 db_mrds_dsl_set_fscope bit (9) unal defined (mrds_debug_$switch (15)), 15 78 db_mu_concurrency_control bit (9) unal defined (mrds_debug_$switch (16)), 15 79 db_mrds_rst_dmdm bit (9) unal defined (mrds_debug_$switch (17)), 15 80 db_mu_open_name_manager bit (9) unal defined (mrds_debug_$switch (18)), 15 81 db_mrds_dsl_where_clause bit (9) unal defined (mrds_debug_$switch (19)), 15 82 db_mu_open_iocb_manager bit (9) unal defined (mrds_debug_$switch (20)), 15 83 db_mrds_dsl_gen_srch_prog bit (9) unal defined (mrds_debug_$switch (21)) 15 84 ) ; 15 85 15 86 /* list of known module names, with index into name array 15 87* the same as that into mrds_debug_$switch, 15 88* number is the current count of defined module names, 15 89* name is the modules full name. */ 15 90 15 91 declare 1 module options (constant) internal static, 15 92 2 number fixed bin init (21), 15 93 2 name char (32) dimension (21) init ( 15 94 "mrds_dsl_eval_expr", /* 1 => display value of each expression */ 15 95 "mrds_dsl_get_token", /* 1 => display the current token */ 15 96 "mrds_dsl_permute", /* each 1 => lost cost path found, 15 97* 2 => reverse partial path 15 98* 3 => use range order for path 15 99* 4 => display access method costs 15 100* 5 => display details of final low cost path */ 15 101 "mrds_dsl_optimize", /* 1 => pred tree, 15 102* 2 => paths to consider, 3 => calc_cost on */ 15 103 "mrds_dsl_search", /* 1 => display each tuple located */ 15 104 "mrds_dsl_translate", /* 1 => display the search program */ 15 105 "mu_retrieve", /* 1 => display values compared, 2 => display tuple data */ 15 106 "mrds_dsl_open", /* 1 => allow cleanup sub_error_ */ 15 107 "mrds_dsl_close", /* 1 => allow cleanup sub_error_ */ 15 108 "mrds_dsl_init_res", /* 1 => allow cleanup sub_error_ */ 15 109 "mu_sec_init_res", /* 1 => allow cleanup sub_error_ */ 15 110 "mus_mod_ubtup", /* 1 => consistency checking between the old 15 111* and new tuple during modifies will be done */ 15 112 "mu_sec_get_tuple", /* 1 => attribute values 15 113* will be zeroed in the tuple structure 15 114* is don't have read permission. */ 15 115 "mu_sec_get_tid", /* 1 => read permission to the key 15 116* is checked (if db is secured) */ 15 117 "mrds_dsl_set_fscope", /* 1 => display being queued, 15 118* and request granted from queue messages */ 15 119 "mu_concurrency_control", /* 1 => allow both dbc and db.control segs under db 15 120* so can test both MR8 and MR9 mrds 15 121* against the same database at the same time */ 15 122 "mrds_rst_dmdm", /* 1 => allow internal form of bit offset value 15 123* for attributes to be displayed, rather than user view */ 15 124 "mu_open_name_manager", /* 1 => dump mrds_open_name tree node structure, 15 125* when display_open_names entry called */ 15 126 "mrds_dsl_where_clause", /* 1 => display details of cross domain compares */ 15 127 "mu_open_iocb_manager", /* 1 => display relation and slot getting iocb for */ 15 128 "mrds_dsl_gen_srch_prog" /* 1 => do additional conditions as sequential, not key searches 15 129* when the original access was a key, 15 130* and the additional conditions can be done as key also 15 131* 2 => force key searches, regardless of strategy 15 132* used to decide between compare or key search */ 15 133 ) ; 15 134 15 135 declare mrds_debug_$switch (1:400) bit (9) unal ext ; /* data segment debug array */ 15 136 15 137 /* END INCLUDE FILE mrds_debug_names.incl.pl1 */ 15 138 1296 1297 16 1 /* BEGIN INCLUDE FILE mrds_authorization.incl.pl1 - - 81-01-20 Jim Gray */ 16 2 16 3 /* HISTORY: 16 4* 16 5* 81-01-20 Jim Gray : original created for the mmi_$get_authorization interface 16 6* 16 7**/ 16 8 16 9 /* DESCRIPTION: 16 10* 16 11* this structure returns the callers user_class 16 12* either database administrator or normal user. 16 13* Note that these separate classes were used to allow 16 14* future expansion to the user classes, rather than 16 15* make them logical "not"'s of one another. 16 16* NOTE: a DBA is always also a normal user, thus if the caller 16 17* is a DBA, his normal_user bit will be on also. 16 18* 16 19**/ 16 20 16 21 16 22 declare 1 mrds_authorization aligned based (mrds_authorization_ptr), 16 23 2 version fixed bin, /* version number of this structure */ 16 24 2 administrator bit (1) unal, /* caller is a DBA */ 16 25 2 normal_user bit (1) unal, /* caller has no special priviledges */ 16 26 2 mbz bit (34) unal ; 16 27 16 28 16 29 declare mrds_authorization_ptr ptr ; /* pointer for referring to the structure */ 16 30 16 31 declare mrds_authorization_structure_version fixed bin init (1) int static options (constant) ; 16 32 16 33 /* END INCLUDE FILE mrds_authorization.incl.pl1 */ 1298 1299 17 1 /* *********************************************************** 17 2* * * 17 3* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 17 4* * * 17 5* *********************************************************** */ 17 6 /* BEGIN INCLUDE FILE - vu_typed_vector.incl.pl1 */ 17 7 17 8 /* Written by Lindsey Spratt, 04/02/82. 17 9*Modified: 17 10*09/01/82 by Lindsey Spratt: Changed value_ptr in simple_typed_vector to be 17 11* unaligned. Changed the type number of the simple_typed_vector to 17 12* "3" from "1". The OLD_SIMPLE_TYPED_VECTOR_TYPE is now an invalid 17 13* type. 17 14**/ 17 15 17 16 /* format: style2,ind3 */ 17 17 dcl 1 simple_typed_vector based (simple_typed_vector_ptr), 17 18 2 type fixed bin (17) unal, 17 19 2 number_of_dimensions 17 20 fixed bin (17) unal, 17 21 2 dimension (stv_number_of_dimensions refer (simple_typed_vector.number_of_dimensions)), 17 22 3 value_ptr ptr unaligned; 17 23 17 24 dcl 1 general_typed_vector based (general_typed_vector_ptr), 17 25 2 type fixed bin (17) unal, 17 26 2 number_of_dimensions 17 27 fixed bin (17) unal, 17 28 2 dimension (gtv_number_of_dimensions refer (general_typed_vector.number_of_dimensions)), 17 29 3 identifier fixed bin (17) unal, 17 30 3 pad bit (18) unal, 17 31 3 value_ptr ptr unal; 17 32 17 33 dcl simple_typed_vector_ptr 17 34 ptr; 17 35 dcl stv_number_of_dimensions 17 36 fixed bin (17); 17 37 17 38 dcl general_typed_vector_ptr 17 39 ptr; 17 40 dcl gtv_number_of_dimensions 17 41 fixed bin (17); 17 42 17 43 dcl ( 17 44 OLD_SIMPLE_TYPED_VECTOR_TYPE 17 45 init (1), /* value_ptr was aligned. */ 17 46 GENERAL_TYPED_VECTOR_TYPE 17 47 init (2), 17 48 SIMPLE_TYPED_VECTOR_TYPE 17 49 init (3) 17 50 ) fixed bin (17) internal static options (constant); 17 51 17 52 /* END INCLUDE FILE - vu_typed_vector.incl.pl1 */ 1300 1301 1302 end mrds_dsl_init_res; 1303 1304 SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 10/17/90 0817.0 mrds_dsl_init_res.pl1 >spec>install>1044>mrds_dsl_init_res.pl1 1268 1 04/11/85 1552.6 access_mode_values.incl.pl1 >ldd>include>access_mode_values.incl.pl1 1270 2 10/14/83 1709.1 dm_id_list.incl.pl1 >ldd>include>dm_id_list.incl.pl1 1272 3 11/22/82 1055.7 status_structures.incl.pl1 >ldd>include>status_structures.incl.pl1 1274 4 08/04/88 2143.3 mrds_dbcb.incl.pl1 >ldd>include>mrds_dbcb.incl.pl1 1276 5 08/04/88 2143.3 mdbm_rm_db_info.incl.pl1 >ldd>include>mdbm_rm_db_info.incl.pl1 1278 6 10/14/83 1709.1 mdbm_rm_rel_array.incl.pl1 >ldd>include>mdbm_rm_rel_array.incl.pl1 1280 7 10/14/83 1709.1 mdbm_rm_rel_info.incl.pl1 >ldd>include>mdbm_rm_rel_info.incl.pl1 1282 8 10/14/83 1709.1 mdbm_rm_attr_info.incl.pl1 >ldd>include>mdbm_rm_attr_info.incl.pl1 1284 9 10/14/83 1709.1 mdbm_rm_domain_info.incl.pl1 >ldd>include>mdbm_rm_domain_info.incl.pl1 1286 10 10/14/83 1708.9 mrds_dsm_header.incl.pl1 >ldd>include>mrds_dsm_header.incl.pl1 1288 11 10/17/86 1504.3 mdbm_db_model.incl.pl1 >ldd>include>mdbm_db_model.incl.pl1 1290 12 04/18/85 1728.1 mdbm_scope_info.incl.pl1 >ldd>include>mdbm_scope_info.incl.pl1 1292 13 10/14/83 1708.6 mdbm_seg_area.incl.pl1 >ldd>include>mdbm_seg_area.incl.pl1 1294 14 10/14/83 1708.6 mrds_select_area.incl.pl1 >ldd>include>mrds_select_area.incl.pl1 1296 15 10/14/83 1709.0 mrds_debug_names.incl.pl1 >ldd>include>mrds_debug_names.incl.pl1 1298 16 10/14/83 1708.8 mrds_authorization.incl.pl1 >ldd>include>mrds_authorization.incl.pl1 1300 17 10/14/83 1709.1 vu_typed_vector.incl.pl1 >ldd>include>vu_typed_vector.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. ID_LIST_VERSION_1 constant fixed bin(17,0) initial dcl 2-23 ref 830 NULLOFFSET constant bit(18) initial packed unaligned dcl 755 ref 767 OFF 000241 automatic bit(1) initial packed unaligned dcl 1168 set ref 354 355 356 910 971 972 973 974 975 976 977 978 980 981 982 983 989 991 992 993 994 995 996 1088 1168* ON 000242 automatic bit(1) initial packed unaligned dcl 1169 set ref 362 406 453 990 1169* RW 000002 constant fixed bin(5,0) initial dcl 1135 set ref 535* R_ACCESS 000063 constant bit(3) initial packed unaligned dcl 1-11 set ref 468* 475* 602* 607* 617* 622* 810* 814* SCOPE_UPDATE constant fixed bin(17,0) initial dcl 803 ref 824 access_cost 277 based float bin(27) level 4 dcl 4-142 set ref 1028* 1053* access_costs 276 based structure level 3 dcl 4-142 access_overhead 300 based float bin(27) level 4 dcl 4-142 set ref 1029* 1054* active_scopes 5 based fixed bin(17,0) level 2 dcl 12-32 set ref 693* addr builtin function dcl 1144 ref 455 455 485 485 638 1063 administrator 1 based bit(1) level 2 in structure "mrds_authorization" packed packed unaligned dcl 16-22 in procedure "init_res" ref 490 494 635 646 919 administrator 126(01) based bit(1) level 3 in structure "rm_db_info" packed packed unaligned dcl 5-86 in procedure "init_res" set ref 646* 919* administrator parameter bit(1) packed unaligned dcl 1127 in procedure "init_res" set ref 37 37 490* another_flag 106 based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 971* attr_ptrs based pointer array level 2 dcl 7-119 set ref 840* 840 841 bad_id_list_version 001116 automatic bit(1) packed unaligned dcl 600 set ref 659* 660* 661 base_pointer parameter pointer dcl 867 ref 852 870 bc 000104 automatic fixed bin(24,0) dcl 1120 set ref 387* caller_name 000243 automatic char(20) initial packed unaligned dcl 1172 set ref 374* 448* 458* 480* 500* 512* 539* 550* 568* 584* 673* 775* 820* 876* 913* 935* 1090* 1097* 1110* 1172* chars 001115 automatic fixed bin(24,0) dcl 598 set ref 643* 644 644 667* 668 668 chars_overlay based char packed unaligned dcl 599 set ref 644* 644 668* 668 check_path_ptr 15 based bit(18) level 2 packed packed unaligned dcl 11-125 set ref 780* ck_proc 30 based bit(1) level 2 packed packed unaligned dcl 9-35 ref 760 780 ck_proc_entry 14 based entry variable level 2 dcl 9-35 set ref 780* clean_up_condition 000240 automatic bit(1) packed unaligned dcl 1157 set ref 354* 362* 1089 cleanup 000232 stack reference condition dcl 1156 ref 361 close 152 based entry variable level 4 dcl 4-142 set ref 702* 723* 1011* 1036* code 000105 automatic fixed bin(35,0) dcl 1121 set ref 468* 470 472* 473 473* 475* 479 606* 607 621* 622 913* 1087* 1089 1090* 1094* 1096* 1097 1097 1097* 1109* 1110 1110* compiled_se_info_ptr 66 based pointer level 3 dcl 4-142 set ref 963* concurrency_on 304 based bit(1) level 3 in structure "dbcb" packed packed unaligned dcl 4-142 in procedure "init_res" set ref 986* concurrency_on 0(33) based bit(1) level 3 in structure "db_model" packed packed unaligned dcl 11-72 in procedure "init_res" ref 986 continue 000250 automatic char(1) initial packed unaligned dcl 1173 set ref 374* 448* 458* 480* 500* 512* 539* 550* 568* 584* 673* 775* 913* 935* 1090* 1097* 1110* 1173* create_cursor 156 based entry variable level 4 dcl 4-142 set ref 703* 724* 1012* 1037* create_index 242 based entry variable level 4 dcl 4-142 set ref 716* 737* 1025* 1050* create_relation 236 based entry variable level 4 dcl 4-142 set ref 715* 736* 1024* 1049* cur_lit_offset 113 based fixed bin(35,0) level 3 dcl 4-142 set ref 1002* curdat_ptr 000466 automatic pointer dcl 1194 set ref 352* 572* 681 955 current_data_ptr 40 based pointer level 3 dcl 4-142 set ref 681* 955* current_flag 106(01) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 972* current_ptr 16 based pointer level 3 dcl 4-142 set ref 947* cursor_ptrs_storage_ptr 130 based pointer level 3 dcl 4-142 set ref 967* cursor_storage_area_ptr 132 based pointer level 3 dcl 4-142 set ref 968* cv_entry_ 000240 constant entry external dcl 868 ref 871 data based structure level 2 in structure "rm_db_info" dcl 5-86 in procedure "init_res" data based structure level 2 in structure "dbcb" dcl 4-142 in procedure "init_res" database_pn 4 based char(168) initial level 2 packed packed unaligned dcl 10-13 ref 464 db_index parameter fixed bin(35,0) dcl 1129 set ref 37 37 350* 545* 547 555 565* 686 1003 1101 1103* 1104* db_model based structure level 1 dcl 11-72 db_mrds_dsl_init_res defined bit(9) packed unaligned dcl 15-62 ref 363 db_path 000106 automatic char(168) packed unaligned dcl 1130 in procedure "init_res" set ref 387* 439* 440 464* 468* 472 472 475* 480* 485 485 500* 508 508 512* 602 606 606 607 617 621 621 622 648 898* db_path 2 based char(168) level 3 in structure "rm_db_info" dcl 5-86 in procedure "init_res" set ref 648* 810 813 813 814 820* db_pic 001010 automatic picture(3) packed unaligned dcl 1214 set ref 357* 555* 565 1094 1096 db_type_flags 0(18) based structure level 2 packed packed unaligned dcl 11-72 dbc_incr 106(02) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 406* 973* dbc_ptr 30 based pointer level 3 in structure "dbcb" dcl 4-142 in procedure "init_res" set ref 403* 679* 939* dbc_ptr 000102 automatic pointer dcl 1117 in procedure "init_res" set ref 387* 670* 679 932* 939 dbc_uid 303 based bit(36) level 3 dcl 4-142 set ref 670* 932* dbcb based structure level 1 dcl 4-142 set ref 638* 638 dbcb_bit_count 001114 automatic fixed bin(24,0) dcl 597 set ref 617* 622* 667 dbcb_data based structure level 1 unaligned dcl 4-148 dbcb_ptr parameter pointer dcl 4-146 set ref 37 37 351* 403 406 535* 537 545* 579 580* 638 638 668 670 677 678 679 680 681 682 683 684 685 686 687 688 691 694 696 696 696 697 697 697 698 698 698 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 835 898* 920 932 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 989 990 991 992 993 994 995 996 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1063 1063 1066 1066 1069 1069 1103 1107 1109* 1113* dbi 114 based fixed bin(35,0) level 3 dcl 4-142 set ref 686* 1003* dbm_ptr 001036 automatic pointer dcl 11-106 set ref 468* 475* 477 492 647 699 757 757 770 780* 782* 784* 898* 985 986 987 1008 decd_path_ptr 16(18) based bit(18) level 2 packed packed unaligned dcl 11-125 set ref 784* decd_proc 30(02) based bit(1) level 2 packed packed unaligned dcl 9-35 ref 760 784 decd_proc_entry 24 based entry variable level 2 dcl 9-35 set ref 784* def_temp_rel_area_ptr 54 based pointer level 3 dcl 4-142 set ref 962* delete 21(02) based bit(1) level 2 packed packed unaligned dcl 7-119 set ref 826* delete_area_ptr 52 based pointer level 3 dcl 4-142 set ref 961* delete_flag 106(03) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 974* delete_seg 000474 automatic bit(6) initial packed unaligned dcl 1197 set ref 1197* delete_tuples_by_id 172 based entry variable level 4 dcl 4-142 set ref 706* 727* 1015* 1040* destroy_cursor 162 based entry variable level 4 dcl 4-142 set ref 704* 725* 1013* 1038* destroy_relation_by_path 246 based entry variable level 4 dcl 4-142 set ref 717* 738* 1026* 1051* di_ptr 001040 automatic pointer dcl 11-155 set ref 762* 764 765 767 767* 770* 770 780 782 784 divide builtin function dcl 1144 ref 643 667 dm_error_$system_not_initialized 000070 external static fixed bin(35,0) dcl 1198 ref 373 dm_gate_$dm_get_system_state 000234 constant entry external dcl 1263 ref 721 1034 dm_not_available_ 001012 stack reference condition dcl 1264 ref 371 dm_system_state 001011 automatic char(4) dcl 1217 set ref 721* 1034* domain_header_ptr 001126 automatic pointer dcl 753 set ref 757* 762 domain_info based structure level 1 dcl 11-125 domain_list_ptr 132 based pointer level 3 dcl 5-86 set ref 652 654* 654 758 domain_ptr 22(18) based bit(18) level 2 in structure "db_model" packed packed unaligned dcl 11-72 in procedure "init_res" ref 757 domain_ptr 26 based pointer level 2 in structure "rm_attr_info" dcl 8-46 in procedure "init_res" set ref 842* 842 dsm_generator_version based fixed bin(17,0) initial level 2 dcl 10-13 ref 465 dsm_path 000160 automatic char(168) packed unaligned dcl 1131 set ref 440* 443* 444* 448* 458* 512* 539* 550* 568* 584* 649 898* 913* 1090* 1110* dsm_sw parameter bit(1) packed unaligned dcl 1123 in procedure "init_res" ref 37 37 397 437 496 979 dsm_sw 106(08) based bit(1) level 3 in structure "dbcb" packed packed unaligned dcl 4-142 in procedure "init_res" set ref 979* dup_retain 106(04) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 975* el_id_seg_ptr 000472 automatic pointer dcl 1196 set ref 576* 684 957 element_id_list_segment_ptr 64 based pointer level 3 dcl 4-142 set ref 684* 957* empty builtin function dcl 1144 ref 1063 1206 encd_path_ptr 16 based bit(18) level 2 packed packed unaligned dcl 11-125 set ref 782* encd_proc 30(01) based bit(1) level 2 packed packed unaligned dcl 9-35 ref 760 782 encd_proc_entry 20 based entry variable level 2 dcl 9-35 set ref 782* entry 52 based char(32) level 2 packed packed unaligned dcl 11-172 set ref 871 876* error_code parameter fixed bin(35,0) dcl 1182 set ref 37 37 349* 373* 374* 387* 388 403* 404 432* 444* 446 448* 455* 456 458* 479* 480* 485* 487 499* 500* 511* 512* 535* 539* 549* 550* 565* 566 568* 580* 582 584* 602* 604 604 607* 611 617* 619 619 622* 626 670* 671 673* 774* 775* 810* 811 813* 814 814* 816* 820* 871* 875 876* 880* 898* 900 909* 911 932* 933 935* error_table_$argerr 000126 external static fixed bin(35,0) dcl 1221 ref 1097 error_table_$dirlong 000114 external static fixed bin(35,0) dcl 1211 ref 432 error_table_$moderr 000110 external static fixed bin(35,0) dcl 1209 ref 470 473 604 619 811 816 error_table_$no_info 000112 external static fixed bin(35,0) dcl 1210 ref 604 619 fixed builtin function dcl 1144 ref 638 1063 found 001130 automatic bit(1) packed unaligned dcl 754 set ref 763* 764 765* 772 fwd_thread 14(18) based bit(18) level 2 packed packed unaligned dcl 11-125 ref 767 770 general_typed_vector based structure level 1 packed packed unaligned dcl 17-24 set ref 1069 get_count 222 based entry variable level 4 dcl 4-142 set ref 712* 733* 1021* 1046* get_duplicate_key_count 226 based entry variable level 4 dcl 4-142 set ref 714* 735* 1023* 1048* get_pdir_ 000122 constant entry external dcl 1219 ref 557 get_population 232 based entry variable level 4 dcl 4-142 set ref 713* 734* 1022* 1047* get_tuple_by_id 202 based entry variable level 4 dcl 4-142 set ref 708* 729* 1017* 1042* get_tuple_id 212 based entry variable level 4 dcl 4-142 set ref 710* 731* 1019* 1044* get_tuples_by_spec 206 based entry variable level 4 dcl 4-142 set ref 709* 730* 1018* 1043* gtv_number_of_dimensions 001063 automatic fixed bin(17,0) dcl 17-40 set ref 1068* 1069 1069 hcs_$delentry_seg 000054 constant entry external dcl 1184 ref 1109 hcs_$get_uid_seg 000020 constant entry external dcl 1139 ref 670 932 hcs_$make_seg 000012 constant entry external dcl 1136 ref 535 header_ptr 000100 automatic pointer dcl 1117 set ref 455* 464 465 i 001140 automatic fixed bin(17,0) dcl 802 set ref 807* 808 808 809* id_list based structure level 1 dcl 2-16 id_list_ptr based pointer level 2 in structure "rm_rel_info" dcl 7-119 in procedure "init_res" set ref 829* 829 830 id_list_ptr 001020 automatic pointer initial dcl 2-21 in procedure "init_res" set ref 2-21* il_number_of_ids 001022 automatic fixed bin(17,0) initial dcl 2-22 set ref 2-22* info_ptr 000252 automatic pointer initial dcl 1174 set ref 374* 448* 458* 480* 500* 512* 539* 550* 568* 584* 673* 775* 913* 935* 1090* 1097* 1110* 1174* initiate_file_ 000024 constant entry external dcl 1141 ref 468 475 602 607 617 622 810 814 input_path 000256 automatic char(168) packed unaligned dcl 1183 set ref 430 435* 439 443 ioa_ 000120 constant entry external dcl 1218 ref 742 903 j 001141 automatic fixed bin(17,0) dcl 802 set ref 836* 837 837* 839* 840 840 841* key_attr_ptrs 44 based pointer array level 2 dcl 7-119 set ref 837* 837 last_s_e_id_num 115 based fixed bin(35,0) level 3 dcl 4-142 set ref 1004* last_store_rel_name 117 based char(32) level 3 dcl 4-142 set ref 1006* length builtin function dcl 1144 ref 430 430 430 lit_ptr 14 based pointer level 3 dcl 4-142 set ref 946* local_area 000476 automatic area(200) dcl 1206 set ref 455 455 485 485 1206* max_file_init 001044 automatic fixed bin(17,0) dcl 12-58 set ref 690* 691 691 mbz1 based bit(144) level 2 dcl 12-32 set ref 692* mdbm_secured 20(04) based bit(1) level 2 in structure "rm_attr_info" packed packed unaligned dcl 8-46 in procedure "init_res" set ref 843* mdbm_secured 126 based bit(1) level 3 in structure "rm_db_info" packed packed unaligned dcl 5-86 in procedure "init_res" set ref 647* 827 843 mdbm_secured 11(01) based bit(1) level 2 in structure "db_model" packed packed unaligned dcl 11-72 in procedure "init_res" ref 492 647 mdbm_secured 21(06) based bit(1) level 2 in structure "rm_rel_info" packed packed unaligned dcl 7-119 in procedure "init_res" set ref 827* model_area_ptr 001052 automatic pointer initial dcl 13-18 set ref 13-18* 578* 579 680 954 model_name 10 based char(30) level 2 dcl 7-119 set ref 810 814 820* model_seg based structure level 1 dcl 13-9 ref 578 model_seg_ptr 001050 automatic pointer initial dcl 13-13 set ref 353* 13-13* 574* 578 578 modify 21(01) based bit(1) level 2 packed packed unaligned dcl 7-119 set ref 824* 825 826 modify_area_ptr 50 based pointer level 3 dcl 4-142 set ref 960* modify_tuples_by_id 176 based entry variable level 4 dcl 4-142 set ref 707* 728* 1016* 1041* modify_vector_ptr 62 based pointer level 3 dcl 4-142 set ref 698* 698 1069* mrds_authorization based structure level 1 dcl 16-22 mrds_authorization_ptr 001060 automatic pointer dcl 16-29 set ref 485* 490 494 635 646 919 mrds_authorization_structure_version 000072 constant fixed bin(17,0) initial dcl 16-31 set ref 485* mrds_data_$max_attributes 000026 external static fixed bin(35,0) dcl 1159 ref 1065 1068 mrds_data_$max_dbs 000060 external static fixed bin(35,0) dcl 1186 set ref 550* mrds_data_$saved_res_version 000030 external static char(8) packed unaligned dcl 1160 ref 632 637 mrds_data_$submodel_dir_name 000100 external static char(16) packed unaligned dcl 1202 set ref 512* mrds_debug_$switch 000236 external static bit(9) array packed unaligned dcl 15-135 ref 363 363 mrds_dm_authorization$get_user_class 000104 constant entry external dcl 1205 ref 485 mrds_dm_authorization$set_needed_access 000116 constant entry external dcl 1212 ref 472 606 621 813 mrds_dm_secured_submodel 000102 constant entry external dcl 1203 ref 508 mrds_dsl_init_select_area 000062 constant entry external dcl 1188 ref 580 mrds_dsl_resultant_storage$get 000066 constant entry external dcl 1192 ref 531 mrds_dsm_close 000034 constant entry external dcl 1163 ref 909 1087 mrds_dsm_header based structure level 1 unaligned dcl 10-13 mrds_dsm_open$read 000036 constant entry external dcl 1164 ref 444 mrds_dsm_read_header 000040 constant entry external dcl 1165 ref 455 mrds_error_$bad_domain_proc 000076 external static fixed bin(35,0) dcl 1201 ref 880 mrds_error_$inc_secure_open 000072 external static fixed bin(35,0) dcl 1199 ref 499 511 mrds_error_$incons_db 000074 external static fixed bin(35,0) dcl 1200 ref 774 mrds_error_$too_many_dbs 000064 external static fixed bin(35,0) dcl 1189 ref 549 mu_concurrency_control$open_control_segment 000106 constant entry external dcl 1207 ref 387 mu_database_index$get_database_index 000046 constant entry external dcl 1170 ref 545 mu_database_index$reset_resultant_model_pointer 000056 constant entry external dcl 1185 ref 1103 mu_sec_init_res 000042 constant entry external dcl 1166 ref 898 mu_sec_reg_user 000044 constant entry external dcl 1167 ref 403 mu_temp_segments$delete_all_temp_segments 000124 constant entry external dcl 1220 ref 1096 mu_temp_segments$get_temp_segments 000014 constant entry external dcl 1137 ref 565 mu_temp_segments$release_all_temp_segments 000016 constant entry external dcl 1138 ref 1094 name based char(32) level 2 in structure "domain_info" dcl 11-125 in procedure "init_res" ref 765 name based char(32) level 2 in structure "rm_domain_info" dcl 9-35 in procedure "init_res" set ref 765 775* 876* new_select_expr 106(17) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 990* next_domain_ptr 32 based pointer level 2 dcl 9-35 set ref 787 790* 790 791 nfiles 4 based fixed bin(17,0) level 2 dcl 12-32 set ref 691* nhash_sch 111 based fixed bin(35,0) level 3 dcl 4-142 set ref 1000* nind_sch 110 based fixed bin(35,0) level 3 dcl 4-142 set ref 999* nkey_attr 24 based fixed bin(17,0) level 2 dcl 7-119 ref 829 829 830 835 835 836 840 840 841 nlk_sch 112 based fixed bin(35,0) level 3 dcl 4-142 set ref 1001* no_optimize 106(18) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 991* non_shared_to_shared 106(23) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 995* nseq_sch 107 based fixed bin(35,0) level 3 dcl 4-142 set ref 998* null builtin function dcl 1144 ref 351 352 353 1174 2-21 8-65 9-51 12-59 13-13 13-18 14-6 14-10 477 537 652 677 678 688 759 764 767 787 787 818 820 820 871 871 876 876 940 941 942 943 944 945 946 947 948 949 950 951 952 953 958 959 960 961 962 963 964 965 966 967 968 969 1107 1113 num_attr 22 based fixed bin(17,0) level 2 dcl 7-119 ref 829 829 830 835 835 839 num_rels based fixed bin(17,0) level 2 dcl 6-34 ref 807 808 808 809 number_of_dimensions 0(18) based fixed bin(17,0) level 2 in structure "general_typed_vector" packed packed unaligned dcl 17-24 in procedure "init_res" set ref 1069* number_of_dimensions 0(18) based fixed bin(17,0) level 2 in structure "simple_typed_vector" packed packed unaligned dcl 17-17 in procedure "init_res" set ref 1066* open 146 based entry variable level 4 dcl 4-142 set ref 701* 722* 1010* 1035* open_mode 106(14) based bit(3) level 3 packed packed unaligned dcl 4-142 set ref 989* os_access_cost 302 based float bin(27) level 4 dcl 4-142 set ref 1031* 1056* output_entry 001156 automatic entry variable dcl 864 set ref 871* 884 parser_work_area_ptr 74 based pointer level 3 dcl 4-142 set ref 969* path based char(168) level 2 packed packed unaligned dcl 11-172 set ref 871 876* path_entry based structure level 1 packed packed unaligned dcl 11-172 path_entry_offset parameter bit(18) packed unaligned dcl 866 ref 852 870 path_entry_ptr 001042 automatic pointer dcl 11-177 set ref 870* 871 871 876 876 pointer builtin function dcl 1144 ref 578 870 possible_op 106(06) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 977* prev_select 106(05) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 976* print_search_order 106(19) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 992* proc_type parameter char packed unaligned dcl 865 set ref 852 876* process_dir 000402 automatic char(168) packed unaligned dcl 1191 set ref 557* 558 558* 558 561 ptr builtin function dcl 1144 ref 650 651 654 696 697 698 757 770 790 808 829 835 837 840 842 ptr_array 000454 automatic pointer array dcl 1193 set ref 565* 572 573 574 575 576 put_tuple 216 based entry variable level 4 dcl 4-142 set ref 711* 732* 1020* 1045* ra_ptr 134 based pointer level 3 dcl 5-86 set ref 650* 650 806 rai_ptr 001032 automatic pointer initial dcl 8-65 set ref 8-65* 841* 842 842 843 range_ptr 2 based pointer level 3 dcl 4-142 set ref 941* rdbi_bit_count 001110 automatic fixed bin(24,0) dcl 595 set ref 602* 607* 643 rdbi_ptr based pointer level 3 in structure "dbcb" dcl 4-142 in procedure "init_res" set ref 683* 920* 940* rdbi_ptr 001024 automatic pointer dcl 5-90 in procedure "init_res" set ref 351* 403* 575* 644 646 647 648 649 650 650 650 651 651 651 652 654 654 654 683 758 790 806 808 810 813 813 814 820 827 829 837 840 842 843 898* 903 919 920 rdi_ptr 001034 automatic pointer initial dcl 9-51 set ref 9-51* 758* 759 760 760 760 765 775 780 780 782 782 784 784 787 787* 790 790 791* 791 876 ready_mode parameter fixed bin(17,0) dcl 1125 in procedure "init_res" ref 37 37 824 828 ready_mode 37 based fixed bin(17,0) level 2 in structure "rm_rel_info" dcl 7-119 in procedure "init_res" set ref 828* rel builtin function dcl 1144 ref 638 650 651 654 696 697 698 790 808 829 835 837 840 842 1063 rel_data based structure array level 2 dcl 6-34 rel_model_ptr 001142 automatic pointer dcl 804 set ref 810* 814* 818 relation_manager_$close 000174 constant entry external dcl 1244 ref 723 1036 relation_manager_$create_cursor 000176 constant entry external dcl 1245 ref 724 1037 relation_manager_$create_index 000230 constant entry external dcl 1259 ref 737 1050 relation_manager_$create_relation 000226 constant entry external dcl 1257 ref 736 1049 relation_manager_$delete_tuples_by_id 000206 constant entry external dcl 1249 ref 727 1040 relation_manager_$destroy_cursor 000200 constant entry external dcl 1246 ref 725 1038 relation_manager_$destroy_relation_by_path 000232 constant entry external dcl 1261 ref 738 1051 relation_manager_$get_count 000220 constant entry external dcl 1254 ref 733 1046 relation_manager_$get_duplicate_key_count 000224 constant entry external dcl 1256 ref 735 1048 relation_manager_$get_population 000222 constant entry external dcl 1255 ref 734 1047 relation_manager_$get_tuple_by_id 000212 constant entry external dcl 1251 ref 729 1042 relation_manager_$get_tuple_id 000216 constant entry external dcl 1253 ref 731 1044 relation_manager_$get_tuples_by_spec 000214 constant entry external dcl 1252 ref 730 1043 relation_manager_$modify_tuples_by_id 000210 constant entry external dcl 1250 ref 728 1041 relation_manager_$open 000172 constant entry external dcl 1243 ref 722 1035 relation_manager_$put_tuple 000204 constant entry external dcl 1248 ref 732 1045 relation_manager_$set_scope 000202 constant entry external dcl 1247 ref 726 1039 relmgr_entries 146 based structure level 3 dcl 4-142 report_on_res_creation 000010 internal static bit(1) initial packed unaligned dcl 1215 set ref 413* 421* 742 903 res_already_made 106(21) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 687* 993* res_in_pdir 001007 automatic bit(1) packed unaligned dcl 1213 set ref 356* 561* 563* 685 984 1094 reserved 106(26) based bit(10) level 3 packed packed unaligned dcl 4-142 set ref 996* reserved_ptrs 76 based pointer array level 3 dcl 4-142 set ref 678* 966* reserved_words 134 based fixed bin(35,0) array level 3 dcl 4-142 set ref 1007* resultant_dir 000330 automatic char(168) packed unaligned dcl 1190 set ref 531* 532 532* 532 535* 539* 561 resultant_in_pdir 106(20) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 685* 984* retr_info_ptr 22 based pointer level 3 dcl 4-142 set ref 949* retrieve_area_ptr 46 based pointer level 3 dcl 4-142 set ref 959* return_value 000254 automatic fixed bin(35,0) initial dcl 1175 set ref 374* 448* 458* 480* 500* 512* 539* 550* 568* 584* 673* 775* 820* 876* 913* 935* 1090* 1097* 1110* 1175* ri_ptr based pointer array level 3 packed packed unaligned dcl 6-34 set ref 808* 808 809 rm_attr_info based structure level 1 dcl 8-46 rm_db_info based structure level 1 dcl 5-86 rm_db_info_data based structure level 1 unaligned dcl 5-92 rm_domain_info based structure level 1 dcl 9-35 rm_rel_array based structure level 1 dcl 6-34 rm_rel_info based structure level 1 dcl 7-119 rmra_ptr 001026 automatic pointer dcl 6-43 set ref 806* 807 808 808 809 rmri_ptr 001030 automatic pointer dcl 7-156 set ref 809* 810 814 820 824 825 825 826 826 827 828 829 829 830 835 835 836 837 837 839 840 840 841 rollback_on 0(32) based bit(1) level 3 in structure "db_model" packed packed unaligned dcl 11-72 in procedure "init_res" ref 987 rollback_on 304(01) based bit(1) level 3 in structure "dbcb" packed packed unaligned dcl 4-142 in procedure "init_res" set ref 987* rtrim builtin function dcl 1144 ref 430 430 435 435 472 472 485 485 508 508 508 508 508 508 602 606 606 607 617 621 621 622 810 813 813 814 saved_dbcb_ptr 001112 automatic pointer dcl 596 set ref 617* 622* 638 668 saved_rdbi_ptr 001106 automatic pointer dcl 594 set ref 602* 607* 632 637 644 742 saved_res_version 127 based char(8) level 3 dcl 5-86 set ref 632 637* 742* 903* scope_flags based structure level 1 dcl 12-42 scope_flags_ptr based pointer level 2 dcl 7-119 set ref 835* 835 scope_info based structure level 1 dcl 12-32 set ref 691 scope_ptr 34 based pointer level 3 in structure "dbcb" dcl 4-142 in procedure "init_res" set ref 688 694* 696* 696 953* scope_ptr 001046 automatic pointer initial dcl 12-59 in procedure "init_res" set ref 12-59* 691* 692 693 694 se_info_ptr 72 based pointer level 3 dcl 4-142 set ref 965* se_transaction_id 116 based bit(36) level 3 dcl 4-142 set ref 1005* sel_clause 106(07) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 978* select_area_ptr 001056 automatic pointer initial dcl 14-10 in procedure "init_res" set ref 14-10* select_area_ptr 36 based pointer level 3 in structure "dbcb" dcl 4-142 in procedure "init_res" set ref 579* 680* 954* select_area_struct_ptr 001054 automatic pointer initial dcl 14-6 set ref 14-6* select_ptr 4 based pointer level 3 dcl 4-142 set ref 942* set_scope 166 based entry variable level 4 dcl 4-142 set ref 705* 726* 1014* 1039* sfi_ptr 32 based pointer level 3 dcl 4-142 set ref 952* simple_typed_vector based structure level 1 packed packed unaligned dcl 17-17 set ref 1066 size builtin function dcl 13-20 ref 578 sm_path 54 based char(168) level 3 dcl 5-86 set ref 649* so_ptr 10 based pointer level 3 dcl 4-142 set ref 944* ss_ptr 20 based pointer level 3 dcl 4-142 set ref 948* stadat_ptr 000470 automatic pointer dcl 1195 set ref 352* 573* 682 956 static_area 306 based area level 2 dcl 4-142 set ref 638 691 1063* 1063 1066 1069 static_data_ptr 42 based pointer level 3 dcl 4-142 set ref 682* 956* sti_ptr 26 based pointer level 3 dcl 4-142 set ref 951* store 21(03) based bit(1) level 2 packed packed unaligned dcl 7-119 set ref 825* store_area_ptr 44 based pointer level 3 dcl 4-142 set ref 958* store_vector_ptr 60 based pointer level 3 dcl 4-142 set ref 697* 697 1066* stv_number_of_dimensions 001062 automatic fixed bin(17,0) dcl 17-35 set ref 1065* 1066 1066 sub_err_ 000050 constant entry external dcl 1171 ref 374 448 458 480 500 512 539 550 568 584 673 775 820 876 913 935 1090 1097 1110 sub_error_ 000000 stack reference condition dcl 1187 ref 364 submodel_iocb_ptr 000052 external static pointer initial dcl 1177 set ref 444* 455* 909* 1087* submodel_open 000255 automatic bit(1) packed unaligned dcl 1176 set ref 355* 453* 907 910* 1085 1088* submodel_version 001006 automatic fixed bin(17,0) dcl 1208 set ref 350* 465* 898* substr builtin function dcl 1144 ref 363 532 532 558 558 sv_ptr 6 based pointer level 3 dcl 4-142 set ref 943* sys_info$max_seg_size 000032 external static fixed bin(35,0) dcl 1161 ref 638 1063 ti_ptr 12 based pointer level 3 dcl 4-142 set ref 945* total_primary_key_cost 276 based float bin(27) level 4 dcl 4-142 set ref 1027* 1052* tra_ptr 136 based pointer level 3 dcl 5-86 set ref 651* 651 transactions_needed 106(13) based bit(1) level 3 in structure "dbcb" packed packed unaligned dcl 4-142 in procedure "init_res" set ref 985* transactions_needed 0(34) based bit(1) level 3 in structure "db_model" packed packed unaligned dcl 11-72 in procedure "init_res" ref 985 trel_info_ptr 24 based pointer level 3 dcl 4-142 set ref 950* unique_chars_ 000022 constant entry external dcl 1140 ref 535 urri_bad_id_list_version parameter bit(1) packed unaligned dcl 801 set ref 799 832* us_access_cost 301 based float bin(27) level 4 dcl 4-142 set ref 1030* 1055* user_started_transaction 106(22) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 994* val_del 106(11) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 982* val_dtr 106(12) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 983* val_mod 106(10) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 981* val_rtrv 106(09) based bit(1) level 3 packed packed unaligned dcl 4-142 set ref 980* version based fixed bin(35,0) level 2 dcl 2-16 ref 830 vfile_relmgr_$close 000132 constant entry external dcl 1224 ref 702 1011 vfile_relmgr_$create_cursor 000134 constant entry external dcl 1225 ref 703 1012 vfile_relmgr_$create_index 000166 constant entry external dcl 1239 ref 716 1025 vfile_relmgr_$create_relation 000164 constant entry external dcl 1237 ref 715 1024 vfile_relmgr_$delete_tuples_by_id 000144 constant entry external dcl 1229 ref 706 1015 vfile_relmgr_$destroy_cursor 000136 constant entry external dcl 1226 ref 704 1013 vfile_relmgr_$destroy_relation_by_path 000170 constant entry external dcl 1241 ref 717 1026 vfile_relmgr_$get_count 000156 constant entry external dcl 1234 ref 712 1021 vfile_relmgr_$get_duplicate_key_count 000162 constant entry external dcl 1236 ref 714 1023 vfile_relmgr_$get_population 000160 constant entry external dcl 1235 ref 713 1022 vfile_relmgr_$get_tuple_by_id 000150 constant entry external dcl 1231 ref 708 1017 vfile_relmgr_$get_tuple_id 000154 constant entry external dcl 1233 ref 710 1019 vfile_relmgr_$get_tuples_by_spec 000152 constant entry external dcl 1232 ref 709 1018 vfile_relmgr_$modify_tuples_by_id 000146 constant entry external dcl 1230 ref 707 1016 vfile_relmgr_$open 000130 constant entry external dcl 1223 ref 701 1010 vfile_relmgr_$put_tuple 000142 constant entry external dcl 1228 ref 711 1020 vfile_relmgr_$set_scope 000140 constant entry external dcl 1227 ref 705 1014 vfile_type 0(35) based bit(1) level 3 packed packed unaligned dcl 11-72 ref 699 1008 view_dir parameter char packed unaligned dcl 1132 ref 37 37 430 435 508 508 view_ent parameter char packed unaligned dcl 1133 ref 37 37 430 435 508 508 work_area_ptr 70 based pointer level 3 dcl 4-142 set ref 677* 964* NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. A_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 A_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 DIR_ACCESS_MODE_NAMES internal static char(4) initial array packed unaligned dcl 1-33 Directory internal static fixed bin(17,0) initial dcl 3-56 E_ACCESS internal static bit(3) initial packed unaligned dcl 1-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 GENERAL_TYPED_VECTOR_TYPE internal static fixed bin(17,0) initial dcl 17-43 Link internal static fixed bin(17,0) in@u2rp@=LS(&H &zu&rLh2zzar,Attendees rRyҢ  au*@rZSiteSA u6>*@rWright u>Multics ur&qF`JuaTransactions qIQ2au*@q6hZ*@r&F`Jva.Proceedings.1 IQ-..au*@L*@rMSGD uPLASTICS uTOBSWE u~p*@rDEVM uh*@rLNMLPROD u~*@rLSTDSPPT u *@rEngAdmin u *@rDickson u*@r>Guest u *@rZTolts u*@r*@rpDPS-E u*@r 15-62 db_mrds_dsl_translate defined bit(9) packed unaligned dcl 15-62 db_mrds_dsl_where_clause defined bit(9) packed unaligned dcl 15-62 db_mrds_rst_dmdm defined bit(9) packed unaligned dcl 15-62 db_mu_concurrency_control defined bit(9) packed unaligned dcl 15-62 db_mu_open_iocb_manager defined bit(9) packed unaligned dcl 15-62 db_mu_open_name_manager defined bit(9) packed unaligned dcl 15-62 db_mu_retrieve defined bit(9) packed unaligned dcl 15-62 db_mu_sec_get_tid defined bit(9) packed unaligned dcl 15-62 db_mu_sec_get_tuple defined bit(9) packed unaligned dcl 15-62 db_mu_sec_init_res defined bit(9) packed unaligned dcl 15-62 db_mus_mod_ubtup defined bit(9) packed unaligned dcl 15-62 fi_ptr automatic pointer dcl 11-119 file_info based structure level 1 dcl 11-113 general_typed_vector_ptr automatic pointer dcl 17-38 message_str based structure level 1 packed packed unaligned dcl 11-259 message_str_len automatic fixed bin(17,0) dcl 11-269 message_str_ptr automatic pointer dcl 11-267 model_area based area dcl 13-16 module internal static structure level 1 unaligned dcl 15-91 natts_init automatic fixed bin(17,0) dcl 7-157 nkey_attr_init automatic fixed bin(17,0) dcl 7-157 nvar_atts_init automatic fixed bin(17,0) dcl 7-157 rm_num_rels_init automatic fixed bin(17,0) dcl 6-44 scope_rdy internal static bit(6) initial packed unaligned dcl 12-60 scope_rdy_array based bit(1) array packed unaligned dcl 12-61 select_area based area dcl 14-8 select_area_struct based structure level 1 dcl 14-2 simple_typed_vector_ptr automatic pointer dcl 17-33 stack_item based structure level 1 unaligned dcl 11-206 stack_item_ptr automatic pointer dcl 11-212 status_area_ptr automatic pointer dcl 3-47 status_branch based structure level 1 dcl 3-8 status_entry_names based char(32) array dcl 3-47 status_link based structure level 1 dcl 3-38 status_pathname based char dcl 3-47 status_ptr automatic pointer dcl 3-47 ua_ptr automatic pointer dcl 11-165 unreferenced_attribute based structure level 1 dcl 11-159 version_status based structure level 1 packed packed unaligned dcl 11-232 version_status_ptr automatic pointer dcl 11-246 NAMES DECLARED BY EXPLICIT CONTEXT. build_entry 005742 constant entry internal dcl 852 ref 780 782 784 clean_up 007360 constant entry internal dcl 1083 ref 365 1077 copy_resultant_data 003423 constant entry internal dcl 592 ref 397 create_resultant_segments 002572 constant entry internal dcl 524 ref 395 error_exit 007342 constant entry internal dcl 1075 ref 375 388 404 433 450 461 482 487 505 518 542 553 570 588 675 778 822 881 900 915 937 exit_copy_resultant_data 004706 constant label dcl 746 ref 614 629 640 664 exit_mrds_dsl_init_res 001265 constant label dcl 408 set ref 1079 exit_update_rm_rel_info 005741 constant label dcl 847 ref 833 generate_resultant_data 006144 constant entry internal dcl 888 ref 399 613 628 634 663 get_model_path_and_pointer 001313 constant entry internal dcl 425 ref 382 init_dbcb 006343 constant entry internal dcl 927 ref 892 init_res 000746 constant entry external dcl 37 mrds_dsl_init_res 000772 constant entry external dcl 37 report_on_res_creation_off 001302 constant entry external dcl 419 report_on_res_creation_on 001267 constant entry external dcl 411 update_rm_domain_info 004707 constant entry internal dcl 751 ref 656 update_rm_rel_info 005211 constant entry internal dcl 799 ref 660 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 11116 11360 7740 11126 Length 12332 7740 242 735 1155 2 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME init_res 1398 external procedure is an external procedure. on unit on line 361 70 on unit enables or reverts conditions. on unit on line 364 64 on unit on unit on line 371 92 on unit get_model_path_and_pointer internal procedure shares stack frame of external procedure init_res. create_resultant_segments internal procedure shares stack frame of external procedure init_res. copy_resultant_data internal procedure shares stack frame of external procedure init_res. update_rm_domain_info internal procedure shares stack frame of external procedure init_res. update_rm_rel_info internal procedure shares stack frame of external procedure init_res. build_entry internal procedure shares stack frame of external procedure init_res. generate_resultant_data internal procedure shares stack frame of external procedure init_res. init_dbcb internal procedure shares stack frame of external procedure init_res. error_exit 64 internal procedure is called by several nonquick procedures. clean_up 146 internal procedure is called by several nonquick procedures. STORAGE FOR INTERNAL STATIC VARIABLES. LOC IDENTIFIER BLOCK NAME 000010 report_on_res_creation init_res STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME init_res 000100 header_ptr init_res 000102 dbc_ptr init_res 000104 bc init_res 000105 code init_res 000106 db_path init_res 000160 dsm_path init_res 000240 clean_up_condition init_res 000241 OFF init_res 000242 ON init_res 000243 caller_name init_res 000250 continue init_res 000252 info_ptr init_res 000254 return_value init_res 000255 submodel_open init_res 000256 input_path init_res 000330 resultant_dir init_res 000402 process_dir init_res 000454 ptr_array init_res 000466 curdat_ptr init_res 000470 stadat_ptr init_res 000472 el_id_seg_ptr init_res 000474 delete_seg init_res 000476 local_area init_res 001006 submodel_version init_res 001007 res_in_pdir init_res 001010 db_pic init_res 001011 dm_system_state init_res 001020 id_list_ptr init_res 001022 il_number_of_ids init_res 001024 rdbi_ptr init_res 001026 rmra_ptr init_res 001030 rmri_ptr init_res 001032 rai_ptr init_res 001034 rdi_ptr init_res 001036 dbm_ptr init_res 001040 di_ptr init_res 001042 path_entry_ptr init_res 001044 max_file_init init_res 001046 scope_ptr init_res 001050 model_seg_ptr init_res 001052 model_area_ptr init_res 001054 select_area_struct_ptr init_res 001056 select_area_ptr init_res 001060 mrds_authorization_ptr init_res 001062 stv_number_of_dimensions init_res 001063 gtv_number_of_dimensions init_res 001106 saved_rdbi_ptr copy_resultant_data 001110 rdbi_bit_count copy_resultant_data 001112 saved_dbcb_ptr copy_resultant_data 001114 dbcb_bit_count copy_resultant_data 001115 chars copy_resultant_data 001116 bad_id_list_version copy_resultant_data 001126 domain_header_ptr update_rm_domain_info 001130 found update_rm_domain_info 001140 i update_rm_rel_info 001141 j update_rm_rel_info 001142 rel_model_ptr update_rm_rel_info 001156 output_entry build_entry THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as alloc_char_temp cat_realloc_chars call_ext_out_desc call_ext_out call_int_this call_int_other return_mac tra_ext_1 enable_op shorten_stack ext_entry ext_entry_desc int_entry op_alloc_ op_empty_ THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. cv_entry_ dm_gate_$dm_get_system_state get_pdir_ hcs_$delentry_seg hcs_$get_uid_seg hcs_$make_seg initiate_file_ ioa_ mrds_dm_authorization$get_user_class mrds_dm_authorization$set_needed_access mrds_dm_secured_submodel mrds_dsl_init_select_area mrds_dsl_resultant_storage$get mrds_dsm_close mrds_dsm_open$read mrds_dsm_read_header mu_concurrency_control$open_control_segment mu_database_index$get_database_index mu_database_index$reset_resultant_model_pointer mu_sec_init_res mu_sec_reg_user mu_temp_segments$delete_all_temp_segments mu_temp_segments$get_temp_segments mu_temp_segments$release_all_temp_segments relation_manager_$close relation_manager_$create_cursor relation_manager_$create_index relation_manager_$create_relation relation_manager_$delete_tuples_by_id relation_manager_$destroy_cursor relation_manager_$destroy_relation_by_path relation_manager_$get_count relation_manager_$get_duplicate_key_count relation_manager_$get_population relation_manager_$get_tuple_by_id relation_manager_$get_tuple_id relation_manager_$get_tuples_by_spec relation_manager_$modify_tuples_by_id relation_manager_$open relation_manager_$put_tuple relation_manager_$set_scope sub_err_ unique_chars_ vfile_relmgr_$close vfile_relmgr_$create_cursor vfile_relmgr_$create_index vfile_relmgr_$create_relation vfile_relmgr_$delete_tuples_by_id vfile_relmgr_$destroy_cursor vfile_relmgr_$destroy_relation_by_path vfile_relmgr_$get_count vfile_relmgr_$get_duplicate_key_count vfile_relmgr_$get_population vfile_relmgr_$get_tuple_by_id vfile_relmgr_$get_tuple_id vfile_relmgr_$get_tuples_by_spec vfile_relmgr_$modify_tuples_by_id vfile_relmgr_$open vfile_relmgr_$put_tuple vfile_relmgr_$set_scope THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. dm_error_$system_not_initialized error_table_$argerr error_table_$dirlong error_table_$moderr error_table_$no_info mrds_data_$max_attributes mrds_data_$max_dbs mrds_data_$saved_res_version mrds_data_$submodel_dir_name mrds_debug_$switch mrds_error_$bad_domain_proc mrds_error_$inc_secure_open mrds_error_$incons_db mrds_error_$too_many_dbs submodel_iocb_ptr sys_info$max_seg_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 1168 000701 1169 000702 1172 000704 1173 000707 1174 000711 1175 000713 1197 000714 1206 000716 2 21 000721 2 22 000723 8 65 000725 9 51 000727 12 59 000730 13 13 000731 13 18 000732 14 6 000733 14 10 000734 37 000737 349 001013 350 001015 351 001017 352 001022 353 001025 354 001027 355 001031 356 001032 357 001033 361 001040 362 001054 363 001057 364 001064 365 001101 366 001106 371 001107 373 001123 374 001127 375 001162 377 001167 382 001170 387 001171 388 001207 395 001216 397 001217 399 001227 403 001230 404 001246 406 001256 408 001265 411 001266 413 001275 415 001300 419 001301 421 001310 423 001312 425 001313 430 001314 432 001351 433 001354 434 001360 435 001361 437 001410 439 001417 440 001422 441 001425 443 001426 444 001431 446 001452 448 001455 450 001534 453 001540 455 001542 456 001562 458 001565 461 001644 464 001650 465 001654 468 001656 470 001716 472 001722 473 001756 475 001765 477 002025 479 002031 480 002034 482 002113 485 002117 487 002172 490 002202 492 002210 494 002214 496 002217 499 002224 500 002227 505 002321 508 002325 511 002442 512 002447 518 002565 522 002571 524 002572 531 002573 532 002602 535 002621 537 002705 539 002712 542 003005 545 003011 547 003023 549 003026 550 003031 553 003123 555 003127 557 003141 558 003150 561 003167 563 003177 565 003200 566 003230 568 003233 570 003276 572 003302 573 003304 574 003306 575 003310 576 003312 578 003314 579 003317 580 003323 582 003334 584 003337 588 003416 590 003422 592 003423 602 003424 604 003512 606 003522 607 003556 610 003647 611 003650 613 003653 614 003654 617 003655 619 003742 621 003752 622 004006 625 004077 626 004100 628 004103 629 004104 632 004105 634 004116 635 004117 637 004123 638 004132 640 004150 643 004151 644 004155 646 004161 647 004167 648 004175 649 004200 650 004203 651 004207 652 004214 654 004221 656 004225 659 004226 660 004227 661 004231 663 004234 664 004235 667 004236 668 004242 670 004251 671 004264 673 004267 675 004326 677 004332 678 004337 679 004356 680 004362 681 004366 682 004372 683 004376 684 004401 685 004405 686 004414 687 004416 688 004420 690 004424 691 004425 692 004441 693 004444 694 004445 695 004451 696 004452 697 004456 698 004464 699 004472 701 004475 702 004504 703 004507 704 004512 705 004515 706 004520 707 004523 708 004526 709 004531 710 004534 711 004537 712 004542 713 004545 714 004550 715 004553 716 004556 717 004561 718 004564 721 004565 722 004574 723 004604 724 004607 725 004612 726 004615 727 004620 728 004623 729 004626 730 004631 731 004634 732 004637 733 004642 734 004645 735 004650 736 004653 737 004656 738 004661 742 004664 746 004706 751 004707 757 004710 758 004716 759 004721 760 004726 762 004732 763 004734 764 004735 765 004746 767 004757 770 004767 771 004772 772 004773 774 004775 775 005001 778 005043 780 005047 782 005102 784 005135 787 005172 790 005202 791 005206 793 005207 795 005210 799 005211 806 005213 807 005216 808 005225 809 005244 810 005246 811 005340 813 005346 814 005403 816 005501 818 005505 820 005511 822 005567 824 005573 825 005604 826 005611 827 005616 828 005624 829 005625 830 005640 832 005644 833 005651 835 005652 836 005660 837 005667 838 005675 839 005677 840 005707 841 005722 842 005723 843 005727 844 005735 845 005737 847 005741 852 005742 870 005753 871 005765 875 006033 876 006037 880 006125 881 006131 884 006135 888 006144 892 006145 898 006146 900 006172 903 006201 907 006224 909 006226 910 006240 911 006242 913 006245 915 006324 919 006330 920 006337 922 006342 927 006343 932 006344 933 006362 935 006365 937 006424 939 006430 940 006435 941 006440 942 006443 943 006446 944 006451 945 006454 946 006457 947 006462 948 006465 949 006470 950 006473 951 006476 952 006501 953 006504 954 006507 955 006513 956 006517 957 006523 958 006527 959 006532 960 006535 961 006540 962 006543 963 006546 964 006551 965 006554 966 006557 967 006576 968 006602 969 006605 971 006610 972 006616 973 006623 974 006630 975 006635 976 006642 977 006647 978 006654 979 006661 980 006665 981 006672 982 006677 983 006704 984 006711 985 006716 986 006723 987 006730 989 006735 990 006742 991 006747 992 006754 993 006761 994 006766 995 006773 996 007000 998 007005 999 007006 1000 007007 1001 007010 1002 007011 1003 007012 1004 007014 1005 007015 1006 007016 1007 007021 1008 007035 1010 007040 1011 007047 1012 007052 1013 007055 1014 007060 1015 007063 1016 007066 1017 007071 1018 007074 1019 007077 1020 007102 1021 007105 1022 007110 1023 007113 1024 007116 1025 007121 1026 007124 1027 007127 1028 007131 1029 007133 1030 007135 1031 007137 1032 007141 1034 007142 1035 007151 1036 007161 1037 007164 1038 007167 1039 007172 1040 007175 1041 007200 1042 007203 1043 007206 1044 007211 1045 007214 1046 007217 1047 007222 1048 007225 1049 007230 1050 007233 1051 007236 1052 007241 1053 007243 1054 007245 1055 007247 1056 007251 1063 007253 1065 007265 1066 007270 1068 007312 1069 007315 1071 007340 1075 007341 1077 007347 1079 007354 1083 007357 1085 007365 1087 007370 1088 007400 1089 007403 1090 007410 1094 007467 1096 007513 1097 007533 1101 007577 1103 007603 1104 007617 1107 007622 1109 007626 1110 007637 1113 007721 1115 007725 ----------------------------------------------------------- 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