COMPILATION LISTING OF SEGMENT fs_msf_rb_util_ Compiled by: Multics PL/I Compiler, Release 28e, of February 14, 1985 Compiled at: Honeywell Multics Op. - System M Compiled on: 04/08/85 1150.3 mst Mon Options: optimize map 1 /* ************************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 4* * * 5* * Copyright, (C) Massachusetts Institute of Technology, 1983 * 6* * * 7* ************************************************************** */ 8 9 /* fs_msf_rb_util_.pl1 -- set and get ring brackets for MSF's */ 10 /* format: style2,idind30,indcomtxt */ 11 /* BIM 831022 */ 12 13 fs_msf_rb_util_: 14 procedure; 15 16 declare (Dir_name, Entryname) character (*); 17 declare Brackets (*) fixed bin (3); 18 declare Code fixed bin (35); 19 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 */ 20 2 1 /* BEGIN INCLUDE FILE . . . star_structures.incl.pl1 */ 2 2 2 3 /* This include file contains structures for the hcs_$star_, 2 4* hcs_$star_list_ and hcs_$star_dir_list_ entry points. 2 5* 2 6* Written 23 October 1978 by Monte Davidoff. 2 7* Modified January 1979 by Michael R. Jordan to use unsigned and different pointers for different structures. 2 8* Modified June 1981 by C. Hornig to count link pathnames more efficiently. 2 9**/ 2 10 2 11 /* automatic */ 2 12 2 13 declare star_branch_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching branch count */ 2 14 declare star_entry_count fixed binary; /* hcs_$star_: number of matching entries */ 2 15 declare star_entry_ptr pointer; /* hcs_$star_: pointer to array of entry information */ 2 16 declare star_list_branch_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to array of info */ 2 17 declare star_link_count fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: matching link count */ 2 18 declare star_linkx fixed binary; /* hcs_$star_list_, hcs_$star_dir_list_: index into star_links */ 2 19 declare star_names_ptr pointer; /* hcs_$star_: pointer to array of entry names */ 2 20 declare star_list_names_ptr pointer; /* hcs_$star_list_, hcs_$star_dir_list_: ptr to entry names */ 2 21 declare star_select_sw fixed binary (3); /* hcs_$star_list_, hcs_$star_dir_list_: what info to return */ 2 22 2 23 /* based */ 2 24 2 25 /* hcs_$star_ entry structure */ 2 26 2 27 declare 1 star_entries (star_entry_count) aligned based (star_entry_ptr), 2 28 2 type fixed binary (2) unsigned unaligned, 2 29 /* storage system type */ 2 30 2 nnames fixed binary (16) unsigned unaligned, 2 31 /* number of names of entry that match star_name */ 2 32 2 nindex fixed binary (18) unsigned unaligned; 2 33 /* index of first name in star_names */ 2 34 2 35 /* hcs_$star_ name structure */ 2 36 2 37 declare star_names (sum (star_entries (*).nnames)) char (32) based (star_names_ptr); 2 38 2 39 /* hcs_$star_list_ branch structure */ 2 40 2 41 declare 1 star_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 2 42 2 type fixed binary (2) unsigned unaligned, 2 43 /* storage system type */ 2 44 2 nnames fixed binary (16) unsigned unaligned, 2 45 /* number of names of entry that match star_name */ 2 46 2 nindex fixed binary (18) unsigned unaligned, 2 47 /* index of first name in star_list_names */ 2 48 2 dtcm bit (36) unaligned, /* date-time contents of branch were last modified */ 2 49 2 dtu bit (36) unaligned, /* date-time branch was last used */ 2 50 2 mode bit (5) unaligned, /* user's access mode to the branch */ 2 51 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 2 52 2 master_dir bit (1) unaligned, /* is branch a master directory */ 2 53 2 pad bit (7) unaligned, 2 54 2 records fixed binary (18) unsigned unaligned; 2 55 /* records used by branch */ 2 56 2 57 /* hcs_$star_dir_list_ branch structure */ 2 58 2 59 declare 1 star_dir_list_branch (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 2 60 2 type fixed binary (2) unsigned unaligned, 2 61 /* storage system type */ 2 62 2 nnames fixed binary (16) unsigned unaligned, 2 63 /* number of names of entry that match star_name */ 2 64 2 nindex fixed binary (18) unsigned unaligned, 2 65 /* index of first name in star_list_names */ 2 66 2 dtem bit (36) unaligned, /* date-time directory entry of branch was last modified */ 2 67 2 pad bit (36) unaligned, 2 68 2 mode bit (5) unaligned, /* user's access mode to the branch */ 2 69 2 raw_mode bit (5) unaligned, /* user's ACL access mode */ 2 70 2 master_dir bit (1) unaligned, /* is branch a master directory */ 2 71 2 bit_count fixed binary (24) unaligned; 2 72 /* bit count of the branch */ 2 73 2 74 /* hcs_$star_list_ and hcs_$star_dir_list_ link structure */ 2 75 2 76 declare 1 star_links (star_branch_count + star_link_count) aligned based (star_list_branch_ptr), 2 77 2 type fixed binary (2) unsigned unaligned, 2 78 /* storage system type */ 2 79 2 nnames fixed binary (16) unsigned unaligned, 2 80 /* number of names of entry that match star_name */ 2 81 2 nindex fixed binary (18) unsigned unaligned, 2 82 /* index of first name in star_list_names */ 2 83 2 dtem bit (36) unaligned, /* date-time link was last modified */ 2 84 2 dtd bit (36) unaligned, /* date-time the link was last dumped */ 2 85 2 pathname_len fixed binary (18) unsigned unaligned, 2 86 /* length of the pathname of the link */ 2 87 2 pathname_index fixed binary (18) unsigned unaligned; 2 88 /* index of start of pathname in star_list_names */ 2 89 2 90 /* hcs_$star_list_ and hcs_$star_dir_list_ name array */ 2 91 2 92 declare star_list_names char (32) based (star_list_names_ptr) 2 93 dimension (star_links (star_branch_count + star_link_count).nindex 2 94 + star_links (star_branch_count + star_link_count).nnames 2 95 + divide (star_links (star_branch_count + star_link_count).pathname_len + 31, 32, 17, 0) 2 96 * binary ( 2 97 (star_links (star_branch_count + star_link_count).type = star_LINK) 2 98 & (star_select_sw >= star_LINKS_ONLY_WITH_LINK_PATHS), 1)); 2 99 2 100 /* hcs_$star_list_ and hcs_$star_dir_list_ link pathname */ 2 101 2 102 declare star_link_pathname char (star_links (star_linkx).pathname_len) 2 103 based (addr (star_list_names (star_links (star_linkx).pathname_index))); 2 104 2 105 /* internal static */ 2 106 2 107 /* star_select_sw values */ 2 108 2 109 declare star_LINKS_ONLY fixed binary (2) internal static options (constant) initial (1); 2 110 declare star_BRANCHES_ONLY fixed binary (2) internal static options (constant) initial (2); 2 111 declare star_ALL_ENTRIES fixed binary (2) internal static options (constant) initial (3); 2 112 declare star_LINKS_ONLY_WITH_LINK_PATHS 2 113 fixed binary (3) internal static options (constant) initial (5); 2 114 declare star_ALL_ENTRIES_WITH_LINK_PATHS 2 115 fixed binary (3) internal static options (constant) initial (7); 2 116 2 117 /* storage system types */ 2 118 2 119 declare star_LINK fixed binary (2) unsigned internal static options (constant) initial (0); 2 120 declare star_SEGMENT fixed binary (2) unsigned internal static options (constant) initial (1); 2 121 declare star_DIRECTORY fixed binary (2) unsigned internal static options (constant) initial (2); 2 122 2 123 /* END INCLUDE FILE . . . star_structures.incl.pl1 */ 21 22 23 declare get_system_free_area_ entry returns (pointer); 24 declare hcs_$star_ entry (character (*), character (*), fixed bin (2), pointer, fixed bin, 25 pointer, pointer, fixed bin (35)); 26 declare pathname_ entry (character (*), character (*)) returns (character (168)); 27 declare fs_standard_object_$set_segment_ring_brackets 28 entry (character (*), character (*), (*) fixed bin (3), fixed bin (35)); 29 declare fs_standard_object_$set_directory_ring_brackets 30 entry (character (*), character (*), (*) fixed bin (3), fixed bin (35)); 31 declare fs_standard_object_$get_directory_ring_brackets 32 entry (character (*), character (*), (*) fixed bin (3), fixed bin (35)); 33 declare hcs_$get_user_access_modes entry (character (*), character (*), character (*), fixed bin, 34 bit (36) aligned, bit (36) aligned, fixed bin (35)); 35 36 declare error_table_$moderr external static fixed bin (35); 37 38 declare segment_brackets (3) fixed bin (3); 39 declare directory_brackets (2) fixed bin (3); 40 declare bx fixed bin; 41 declare code fixed bin (35); 42 declare cleanup condition; 43 declare dir_mode bit (36) aligned; 44 declare msf_directory character (168); 45 46 47 set: 48 entry (Dir_name, Entryname, Brackets, Code); 49 50 Code = 0; 51 msf_directory = pathname_ (Dir_name, Entryname); 52 53 /**** * This program has a basic design flaw. It is not capable of */ 54 /**** * backing out if it encounters an error partway through, 55* since that would require us to remember all the original 56* ring brackets of the original MSF. To make things reasonable, 57* it just ignores null links and dirs in the MSF dir, 58* rather than reporting error_table_$inconsistent_msf. 59* Failure to set the MSF dir brackets, though, is reported 60* as an error. */ 61 62 63 call hcs_$get_user_access_modes (Dir_name, Entryname, "", -1, dir_mode, (""b), Code); 64 if Code ^= 0 65 then return; /* Cant possibly have enough access */ 66 if (dir_mode & SM_ACCESS) = ""b 67 then do; 68 Code = error_table_$moderr; 69 return; 70 end; 71 /**** * First to the dir, to get a lack of access to containing dir */ 72 73 directory_brackets (1) = Brackets (1); 74 directory_brackets (2) = Brackets (2); 75 call fs_standard_object_$set_directory_ring_brackets (Dir_name, Entryname, directory_brackets, Code); 76 if Code ^= 0 77 then return; 78 star_names_ptr, star_entry_ptr = null (); 79 on cleanup 80 begin; 81 if star_names_ptr ^= null () 82 then free star_names; 83 if star_entry_ptr ^= null () 84 then free star_entries; 85 star_names_ptr, star_entry_ptr = null (); 86 end; 87 88 call hcs_$star_ (msf_directory, "**", star_BRANCHES_ONLY, get_system_free_area_ (), star_entry_count, 89 star_entry_ptr, star_names_ptr, Code); 90 91 if Code ^= 0 92 then return; /* We must lack access, neh? */ 93 94 segment_brackets (1) = Brackets (1); 95 segment_brackets (2), segment_brackets (3) = Brackets (2); 96 do bx = 1 to star_entry_count; 97 if star_entries (bx).type = star_SEGMENT 98 then do; 99 call fs_standard_object_$set_segment_ring_brackets (msf_directory, 100 star_names (star_entries (bx).nindex), segment_brackets, code); 101 if Code = 0 102 then Code = code; 103 end; 104 end; 105 106 free star_names; 107 free star_entries; 108 return; 109 110 111 get: 112 entry (Dir_name, Entryname, Brackets, Code); 113 114 Code = 0; 115 call fs_standard_object_$get_directory_ring_brackets (Dir_name, Entryname, Brackets, Code); 116 return; 117 end fs_msf_rb_util_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 04/08/85 1128.5 fs_msf_rb_util_.pl1 >spec>on>41-15>fs_msf_rb_util_.pl1 20 1 04/08/85 1113.3 access_mode_values.incl.pl1 >spec>on>41-15>access_mode_values.incl.pl1 21 2 06/10/82 1045.5 star_structures.incl.pl1 >ldd>include>star_structures.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. Brackets parameter fixed bin(3,0) array dcl 17 set ref 47 73 74 94 95 111 115* Code parameter fixed bin(35,0) dcl 18 set ref 47 50* 63* 64 68* 75* 76 88* 91 101 101* 111 114* 115* Dir_name parameter char unaligned dcl 16 set ref 47 51* 63* 75* 111 115* Entryname parameter char unaligned dcl 16 set ref 47 51* 63* 75* 111 115* SM_ACCESS constant bit(3) initial unaligned dcl 1-11 ref 66 bx 000114 automatic fixed bin(17,0) dcl 40 set ref 96* 97 99* cleanup 000116 stack reference condition dcl 42 ref 79 code 000115 automatic fixed bin(35,0) dcl 41 set ref 99* 101 dir_mode 000124 automatic bit(36) dcl 43 set ref 63* 66 directory_brackets 000112 automatic fixed bin(3,0) array dcl 39 set ref 73* 74* 75* error_table_$moderr 000026 external static fixed bin(35,0) dcl 36 ref 68 fs_standard_object_$get_directory_ring_brackets 000022 constant entry external dcl 31 ref 115 fs_standard_object_$set_directory_ring_brackets 000020 constant entry external dcl 29 ref 75 fs_standard_object_$set_segment_ring_brackets 000016 constant entry external dcl 27 ref 99 get_system_free_area_ 000010 constant entry external dcl 23 ref 88 88 hcs_$get_user_access_modes 000024 constant entry external dcl 33 ref 63 hcs_$star_ 000012 constant entry external dcl 24 ref 88 msf_directory 000125 automatic char(168) unaligned dcl 44 set ref 51* 88* 99* nindex 0(18) based fixed bin(18,0) array level 2 packed unsigned unaligned dcl 2-27 ref 99 nnames 0(02) based fixed bin(16,0) array level 2 packed unsigned unaligned dcl 2-27 ref 81 106 pathname_ 000014 constant entry external dcl 26 ref 51 segment_brackets 000106 automatic fixed bin(3,0) array dcl 38 set ref 94* 95* 95* 99* star_BRANCHES_ONLY 000011 constant fixed bin(2,0) initial dcl 2-110 set ref 88* star_SEGMENT constant fixed bin(2,0) initial unsigned dcl 2-120 ref 97 star_entries based structure array level 1 dcl 2-27 ref 83 107 star_entry_count 000100 automatic fixed bin(17,0) dcl 2-14 set ref 81 83 88* 96 106 107 star_entry_ptr 000102 automatic pointer dcl 2-15 set ref 78* 81 83 83 85* 88* 97 99 106 107 star_names based char(32) array unaligned dcl 2-37 set ref 81 99* 106 star_names_ptr 000104 automatic pointer dcl 2-19 set ref 78* 81 81 85* 88* 99 106 type based fixed bin(2,0) array level 2 packed unsigned unaligned dcl 2-27 ref 97 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. A_ACCESS internal static bit(3) initial 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 unaligned dcl 1-33 E_ACCESS internal static bit(3) initial unaligned dcl 1-11 E_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 M_ACCESS internal static bit(3) initial unaligned dcl 1-11 M_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 N_ACCESS internal static bit(3) initial unaligned dcl 1-11 N_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 REW_ACCESS internal static bit(3) initial unaligned dcl 1-11 REW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RE_ACCESS internal static bit(3) initial unaligned dcl 1-11 RE_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 RW_ACCESS internal static bit(3) initial unaligned dcl 1-11 RW_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 R_ACCESS internal static bit(3) initial unaligned dcl 1-11 R_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SA_ACCESS internal static bit(3) initial unaligned dcl 1-11 SA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SEG_ACCESS_MODE_NAMES internal static char(4) initial array unaligned dcl 1-30 SMA_ACCESS internal static bit(3) initial unaligned dcl 1-11 SMA_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 SM_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 S_ACCESS internal static bit(3) initial unaligned dcl 1-11 S_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 W_ACCESS internal static bit(3) initial unaligned dcl 1-11 W_ACCESS_BIN internal static fixed bin(5,0) initial dcl 1-36 star_ALL_ENTRIES internal static fixed bin(2,0) initial dcl 2-111 star_ALL_ENTRIES_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 2-114 star_DIRECTORY internal static fixed bin(2,0) initial unsigned dcl 2-121 star_LINK internal static fixed bin(2,0) initial unsigned dcl 2-119 star_LINKS_ONLY internal static fixed bin(2,0) initial dcl 2-109 star_LINKS_ONLY_WITH_LINK_PATHS internal static fixed bin(3,0) initial dcl 2-112 star_branch_count automatic fixed bin(17,0) dcl 2-13 star_dir_list_branch based structure array level 1 dcl 2-59 star_link_count automatic fixed bin(17,0) dcl 2-17 star_link_pathname based char unaligned dcl 2-102 star_links based structure array level 1 dcl 2-76 star_linkx automatic fixed bin(17,0) dcl 2-18 star_list_branch based structure array level 1 dcl 2-41 star_list_branch_ptr automatic pointer dcl 2-16 star_list_names based char(32) array unaligned dcl 2-92 star_list_names_ptr automatic pointer dcl 2-20 star_select_sw automatic fixed bin(3,0) dcl 2-21 NAMES DECLARED BY EXPLICIT CONTEXT. fs_msf_rb_util_ 000037 constant entry external dcl 13 get 000545 constant entry external dcl 111 set 000052 constant entry external dcl 47 NAMES DECLARED BY CONTEXT OR IMPLICATION. null builtin function ref 78 81 83 85 sum builtin function ref 81 106 STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 774 1024 616 1004 Length 1244 616 30 203 156 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME fs_msf_rb_util_ 220 external procedure is an external procedure. on unit on line 79 66 on unit STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME fs_msf_rb_util_ 000100 star_entry_count fs_msf_rb_util_ 000102 star_entry_ptr fs_msf_rb_util_ 000104 star_names_ptr fs_msf_rb_util_ 000106 segment_brackets fs_msf_rb_util_ 000112 directory_brackets fs_msf_rb_util_ 000114 bx fs_msf_rb_util_ 000115 code fs_msf_rb_util_ 000124 dir_mode fs_msf_rb_util_ 000125 msf_directory fs_msf_rb_util_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. call_ext_out_desc call_ext_out return mpfx2 enable ext_entry ext_entry_desc int_entry free_based THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. fs_standard_object_$get_directory_ring_brackets fs_standard_object_$set_directory_ring_brackets fs_standard_object_$set_segment_ring_brackets get_system_free_area_ hcs_$get_user_access_modes hcs_$star_ pathname_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$moderr LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 13 000036 47 000044 50 000072 51 000074 63 000115 64 000163 66 000166 68 000171 69 000174 73 000175 74 000206 75 000213 76 000240 78 000243 79 000246 81 000262 83 000317 85 000326 86 000332 88 000333 91 000410 94 000413 95 000424 96 000432 97 000441 99 000446 101 000502 104 000507 106 000511 107 000540 108 000542 111 000543 114 000565 115 000567 116 000615 ----------------------------------------------------------- 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