COMPILATION LISTING OF SEGMENT mlsys_field_id_mgr_ Compiled by: Multics PL/I Compiler, Release 28e, of February 14, 1985 Compiled at: Honeywell Multics Op. - System M Compiled on: 06/30/86 1400.9 mst Mon Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1983 * 4* * * 5* *********************************************************** */ 6 7 /* format: off */ 8 9 /* User-defined field name/ID management for the Multics Mail System */ 10 11 /* Created: July 1983 by G. Palter */ 12 13 /* format: on,style4,delnl,insnl,ifthenstmt,ifthen */ 14 15 16 mlsys_field_id_mgr_: 17 procedure () options (rename ((alloc_, mlsys_storage_mgr_$allocate))); 18 19 return; /* not an entrypoint */ 20 21 22 /* Parameters */ 23 24 dcl P_field_name character (*) parameter; /* get_system_field_type: the field name to be checked; 25* get_user_field_id: the field name to be encoded */ 26 27 dcl P_field_id bit (36) aligned parameter; /* get_user_field_id: set to the unique field ID; 28* get_user_field_name: the field ID whose name is wanted */ 29 30 dcl P_canonical_field_name character (*) varying parameter;/* get_user_field_id, get_user_field_name: set to the 31* canonical form of the user-defined field name */ 32 33 dcl P_field_type fixed binary parameter; /* get_system_field_id: set to the type of field supplied */ 34 35 dcl P_code fixed binary (35) parameter; 36 37 38 /* Local copies of parameters */ 39 40 dcl field_type fixed binary; 41 42 43 /* User-defined field name hash table */ 44 45 dcl 1 encoded_field_id aligned, /* the encoding used in field IDs ... */ 46 2 bucket_idx fixed binary (18) unaligned unsigned, /* ... in which bucket this field name may be found */ 47 2 n_steps fixed binary (18) unaligned unsigned; /* ... # of steps from base of bucket to the name */ 48 49 dcl 1 field_name_slot aligned based (field_name_slot_ptr), /* a single slot in the hash table ... */ 50 2 next_slot_ptr pointer, /* ... -> next slot in the hash table */ 51 2 field_name_lth fixed binary (21), /* ... length of the field name in this slot */ 52 2 field_name character (field_name_slot_field_name_lth refer (field_name_slot.field_name_lth)); 53 dcl (field_name_slot_ptr, last_field_name_slot_ptr) pointer; 54 dcl field_name_slot_field_name_lth fixed binary (21); 55 56 57 /* Remaining declarations */ 58 59 dcl n_real_steps fixed binary; 60 61 dcl HYPHEN character (1) static options (constant) initial ("-"); 62 dcl HTSP character (2) static options (constant) initial (" "); 63 64 /* format: off */ 65 dcl (UPPERCASE initial ("ABCDEFGHIJKLMNOPQRSTUVWXYZ"), 66 LOWERCASE initial ("abcdefghijklmnopqrstuvwxyz")) 67 character (26) static options (constant); 68 69 dcl (error_table_$smallarg, mlsys_et_$reserved_field_name, mlsys_et_$unknown_user_field_id, 70 mlsys_et_$unsupported_reserved_field_name) 71 fixed binary (35) external; 72 /* format: on */ 73 74 dcl mlsys_hash_$hash entry (character (*), fixed binary) returns (fixed binary); 75 76 dcl (dimension, divide, hbound, index, lbound, length, ltrim, maxlength, null, rtrim, search, substr, translate, unspec, 77 verify) builtin; 78 79 /* format: off */ 80 81 dcl FIELD_TYPES_BASE_MULTIPLIER fixed binary static options (constant) initial (100); 82 /* to get from field_type_bases to real base value */ 83 84 85 /* Recognized field name prefixes used to change the class of a header field */ 86 87 dcl RECOGNIZED_PREFIXES (5) character (32) varying static options (constant) initial ( 88 "Redistributed-", "Remailed-", "Resent-", "Forwarded-", "Comment-"); 89 90 dcl FIELD_TYPE_BASES (5) fixed binary static options (constant) initial ( 91 1, 1, 1, 1, 2); 92 93 94 /* Indicates which combination of field name and class are actually supported by the mail system */ 95 96 dcl SUPPORTED_FIELDS (0:2, 18) bit (1) aligned static options (constant) initial ( 97 /*** ordinary fields */ 98 "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, 99 "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, 100 /*** redistribution fields */ 101 "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, "1"b, 102 "0"b, "0"b, "1"b, "0"b, "0"b, "0"b, "0"b, "1"b, "1"b, 103 /*** comment fields */ 104 "0"b, "1"b, "0"b, "0"b, "0"b, "0"b, "0"b, "1"b, "0"b, 105 "0"b, "0"b, "0"b, "0"b, "0"b, "0"b, "0"b, "1"b, "0"b); 106 107 108 /* All known canonical field names sorted in the ASCII collating sequence for use within lookup_field_name */ 109 110 dcl SORTED_FIELD_NAMES (25) character (32) static options (constant) initial ( 111 "Access-Class", "Acknowledge-To", "Bcc", "By", "Cc", 112 "Comment", "Comments", "Date", "Delivery-By", "Delivery-Date", 113 "From", "In-Reply-To", "Message-Id", "Posted-Date", "Re", 114 "Received", "Relayed", "Reply-To", "Return-Path", "Route", 115 "Sender", "Subj", "Subject", "To", "Via"); 116 117 dcl SORTED_FIELD_TYPES (25) fixed binary static options (constant) initial ( 118 16, 7, 14, 2, 13, 119 17, 17, 8, 6, 5, 120 9, 15, 18, 1, 10, 121 4, 4, 11, 3, 3, 122 2, 10, 10, 12, 4); 123 124 /* format: on */ 125 126 /* Determine if a given field name identifies a field supported by the system and, if so, return the type of the field */ 127 128 get_system_field_type: 129 entry (P_field_name, P_field_type, P_code); 130 131 call lookup_field_name ((P_field_name), P_field_type, P_code); 132 /* try the input name first as an optimization */ 133 134 if P_code = mlsys_et_$unsupported_reserved_field_name then return; 135 if (P_field_type ^= USER_DEFINED_FIELD) & (P_code = 0) then return; 136 137 begin; /* optimization failed: we must canonicalize the name */ 138 139 dcl canonical_field_name character (length (P_field_name)) varying; 140 141 call canonicalize_field_name (P_field_name, canonical_field_name); 142 143 call lookup_field_name (canonical_field_name, P_field_type, P_code); 144 end; 145 146 return; 147 148 /* Determine the per-process unique ID for a supplied user-defined field name along with the canonical form of said field 149* name; an error code is returned, however, if the supplied field name is one of those reserved for use by the mail 150* system */ 151 152 get_user_field_id: 153 entry (P_field_name, P_field_id, P_canonical_field_name, P_code); 154 155 begin; 156 157 dcl canonical_field_name character (length (P_field_name)) varying; 158 159 call canonicalize_field_name (P_field_name, canonical_field_name); 160 161 call lookup_field_name (canonical_field_name, field_type, P_code); 162 if P_code ^= 0 then return; /* a field that's reserved for possible future use */ 163 164 if field_type ^= USER_DEFINED_FIELD then do; 165 P_code = mlsys_et_$reserved_field_name; 166 return; 167 end; 168 169 encoded_field_id.bucket_idx = 170 mlsys_hash_$hash ((canonical_field_name), 171 dimension (hash_tables_segment.field_name_hash_table.buckets, 1)); 172 encoded_field_id.n_steps = 0; /* assume it's the first one in this bucket ... */ 173 174 last_field_name_slot_ptr = null (); /* needed in case we must add a new slot */ 175 do field_name_slot_ptr = hash_tables_segment.field_name_hash_table.buckets (encoded_field_id.bucket_idx) 176 repeat (field_name_slot.next_slot_ptr) while (field_name_slot_ptr ^= null ()); 177 if field_name_slot.field_name = canonical_field_name then go to HAVE_ENCODED_FIELD_ID; 178 encoded_field_id.n_steps = encoded_field_id.n_steps + 1; 179 last_field_name_slot_ptr = field_name_slot_ptr; 180 end; 181 182 /*** Control arrives here iff there's no matching field name already in the hash table */ 183 field_name_slot_field_name_lth = length (canonical_field_name); 184 allocate field_name_slot in (hash_tables_segment.hash_area) set (field_name_slot_ptr); 185 field_name_slot.field_name = canonical_field_name; 186 field_name_slot.next_slot_ptr = null (); 187 if last_field_name_slot_ptr = null () then /* first one in this bucket */ 188 hash_tables_segment.field_name_hash_table.buckets (encoded_field_id.bucket_idx) = field_name_slot_ptr; 189 else last_field_name_slot_ptr -> field_name_slot.next_slot_ptr = field_name_slot_ptr; 190 191 /*** Control arrives here once the field ID has been determined */ 192 HAVE_ENCODED_FIELD_ID: 193 unspec (P_field_id) = unspec (encoded_field_id); 194 P_canonical_field_name = canonical_field_name; 195 196 if length (canonical_field_name) > maxlength (P_canonical_field_name) then 197 P_code = error_table_$smallarg; /* didn't fit */ 198 else P_code = 0; 199 end; 200 201 return; 202 203 /* Return the canonical form of the user-defined field name corresponding to the given unique ID */ 204 205 get_user_field_name: 206 entry (P_field_id, P_canonical_field_name, P_code); 207 208 unspec (encoded_field_id) = unspec (P_field_id); /* get the field ID into usable form */ 209 210 if (encoded_field_id.bucket_idx < lbound (hash_tables_segment.field_name_hash_table.buckets, 1)) 211 | (encoded_field_id.bucket_idx > hbound (hash_tables_segment.field_name_hash_table.buckets, 1)) then do; 212 UNKNOWN_FIELD_ID: 213 P_code = mlsys_et_$unknown_user_field_id; 214 return; 215 end; 216 217 n_real_steps = 0; 218 do field_name_slot_ptr = hash_tables_segment.field_name_hash_table.buckets (encoded_field_id.bucket_idx) 219 repeat (field_name_slot.next_slot_ptr) while (field_name_slot_ptr ^= null ()); 220 if n_real_steps = encoded_field_id.n_steps then do; 221 if field_name_slot.field_name_lth <= maxlength (P_canonical_field_name) then do; 222 P_canonical_field_name = field_name_slot.field_name; 223 P_code = 0; /* ... it fits */ 224 end; 225 else P_code = error_table_$smallarg; 226 return; 227 end; 228 n_real_steps = n_real_steps + 1; /* not the right slot yet ... */ 229 end; 230 231 go to UNKNOWN_FIELD_ID; /* we get here iff there aren't enough slots in the bucket */ 232 233 /* Return the type of a header/envelope/redistribution field given its name */ 234 235 lookup_field_name: 236 procedure (p_canonical_field_name, p_field_type, p_code); 237 238 dcl p_canonical_field_name character (*) varying parameter; 239 dcl p_field_type fixed binary parameter; 240 dcl p_code fixed binary (35) parameter; 241 242 dcl prefixless_field_name character (length (p_canonical_field_name)) varying; 243 dcl (field_type_base, field_type, name_idx, lb, hb, idx) fixed binary; 244 245 field_type_base = ORDINARY_FIELDS_BASE; /* until proven otherwise */ 246 prefixless_field_name = p_canonical_field_name; 247 248 do idx = lbound (RECOGNIZED_PREFIXES, 1) to hbound (RECOGNIZED_PREFIXES, 1) 249 while (field_type_base = ORDINARY_FIELDS_BASE); 250 if length (RECOGNIZED_PREFIXES (idx)) < length (prefixless_field_name) then 251 if substr (prefixless_field_name, 1, length (RECOGNIZED_PREFIXES (idx))) = RECOGNIZED_PREFIXES (idx) 252 then do; 253 prefixless_field_name = substr (prefixless_field_name, (length (RECOGNIZED_PREFIXES (idx)) + 1)); 254 field_type_base = FIELD_TYPE_BASES (idx); 255 end; 256 end; 257 258 lb = lbound (SORTED_FIELD_NAMES, 1); /* prepare for binary search */ 259 hb = hbound (SORTED_FIELD_NAMES, 1); 260 field_type = USER_DEFINED_FIELD; 261 262 do while ((field_type = USER_DEFINED_FIELD) & (hb >= lb)); 263 name_idx = divide ((hb + lb), 2, 17, 0); 264 if prefixless_field_name = SORTED_FIELD_NAMES (name_idx) then field_type = SORTED_FIELD_TYPES (name_idx); 265 else if prefixless_field_name > SORTED_FIELD_NAMES (name_idx) then lb = name_idx + 1; 266 else hb = name_idx - 1; 267 end; 268 269 if field_type ^= USER_DEFINED_FIELD then 270 if SUPPORTED_FIELDS (field_type_base, field_type) then 271 field_type = field_type + (FIELD_TYPES_BASE_MULTIPLIER * field_type_base); 272 else do; /* reserved for future use */ 273 p_code = mlsys_et_$unsupported_reserved_field_name; 274 return; 275 end; 276 277 if field_type = COMMENT_FIELD then field_type = field_type + COMMENT_FIELDS_BASE; 278 279 p_field_type = field_type; /* here iff the field type is OK */ 280 p_code = 0; 281 282 return; 283 284 end lookup_field_name; 285 286 /* Create the canonical form of a field name: The canonical form is created by replacing each sequence of whitespace with 287* a single "-" and translating the first character of each resulting "token" to uppercase while translating the remaining 288* characters in the "token" to lowercase */ 289 290 canonicalize_field_name: 291 procedure (p_field_name, p_canonical_field_name); 292 293 dcl p_field_name character (*) parameter; 294 dcl p_canonical_field_name character (*) varying parameter; 295 296 dcl (start, token_lth, idx) fixed binary (21); 297 298 begin; /* caller's canonical_field_name is always large enough */ 299 300 dcl field_name character (length (p_field_name)) varying; 301 dcl canonical_field_name character (maxlength (p_canonical_field_name)) varying; 302 303 field_name = ltrim (rtrim (p_field_name, HTSP), HTSP); 304 /* copy input while removing leading/trailing whitespace */ 305 canonical_field_name = ""; /* start out with nothing */ 306 307 start = 1; 308 do while (start <= length (field_name)); 309 idx = search (substr (field_name, start), HTSP); 310 if idx = 0 then do; /* no more whitespace in the name */ 311 canonical_field_name = canonical_field_name || substr (field_name, start); 312 start = length (field_name) + 1; 313 end; 314 else do; 315 canonical_field_name = canonical_field_name || substr (field_name, start, (idx - 1)); 316 canonical_field_name = canonical_field_name || HYPHEN; 317 /* replace whitespace with a hyphen */ 318 start = start + idx; /* past all the whitespace ... */ 319 idx = verify (substr (field_name, start), HTSP); 320 if idx > 1 then start = start + idx - 1; 321 end; 322 end; 323 324 start = 1; /* now to fix the "tokens" */ 325 do while (start <= length (canonical_field_name)); 326 idx = index (substr (canonical_field_name, start), HYPHEN); 327 if idx = 0 then /* the last token ... */ 328 token_lth = length (canonical_field_name) - start + 1; 329 else token_lth = idx - 1; 330 if token_lth > 0 then /* there's a least one character ... */ 331 substr (canonical_field_name, start, 1) = 332 translate (substr (canonical_field_name, start, 1), UPPERCASE, LOWERCASE); 333 if token_lth > 1 then /* ... and there's more than one, in fact */ 334 substr (canonical_field_name, (start + 1), (token_lth - 1)) = 335 translate (substr (canonical_field_name, (start + 1), (token_lth - 1)), LOWERCASE, 336 UPPERCASE); 337 start = start + token_lth + 1; /* move past the "token" and the hyphen */ 338 end; 339 340 p_canonical_field_name = canonical_field_name; 341 end; 342 343 return; 344 345 end canonicalize_field_name; 346 1 1 /* BEGIN INCLUDE FILE ... mlsys_hash_tables_seg.incl.pl1 */ 1 2 /* Created: August 1983 by G. Palter */ 1 3 1 4 /* Definition of the hash tables used by the mail system */ 1 5 1 6 dcl 1 hash_tables_segment aligned based (mlsys_data_$hash_tables_segment_ptr), 1 7 2 field_name_hash_table, /* hash table for user-defined fields */ 1 8 3 buckets (0:511) pointer, 1 9 2 message_id_hash_table, /* hash table for non-local Message-IDs */ 1 10 3 buckets (0:511) pointer, 1 11 2 hash_area area; /* area where actual slots are allocated */ 1 12 1 13 /* END INCLUDE FILE ... mlsys_hash_tables_seg.incl.pl1 */ 347 348 2 1 /* BEGIN INCLUDE FILE ... mlsys_internal_data.incl.pl1 */ 2 2 2 3 2 4 /****^ HISTORY COMMENTS: 2 5* 1) change(86-06-11,Mills), approve(86-06-11,MCR7419), 2 6* audit(86-06-17,Margolin), install(86-06-30,MR12.0-1080): 2 7* Added mlsys_data_$domains_available. 2 8* END HISTORY COMMENTS */ 2 9 2 10 2 11 /* Created: May 1981 by G. Palter */ 2 12 /* Modified: July 1983 by G. Palter to merge with mlsys_data_ */ 2 13 2 14 /* Constants used internally by the Multics mail system */ 2 15 2 16 dcl mlsys_data_$max_opening_retries fixed binary external; /* maximum number of times to reopen a mailbox if it gets 2 17* damaged and salvaged while open */ 2 18 2 19 dcl mlsys_data_$max_lock_wait_retries fixed binary external; 2 20 /* maximum number of times to try to send a message while the 2 21* mailbox is locked (being salvaged?) */ 2 22 2 23 2 24 /* Allocation overhead factors: When allocating those structures with refer extents, insure that the variable portion of 2 25* the structure contains a multiple of the appropriate constant number of slots. These extra slots will be used for 2 26* later additions to the structure; when a new element must be added to a full structure, add this many new slots (rather 2 27* than a single new slot) 2 28* 2 29* The following expression should be used to determine the initial allocation: 2 30* 2 31* n_slots_to_allocate = n_slots_needed + CONSTANT - mod (n_slots_needed, CONSTANT); */ 2 32 2 33 dcl (mlsys_data_$mailbox_allocation, /* mailbox.messages */ 2 34 mlsys_data_$message_body_sections_allocation, /* message.body_sections */ 2 35 mlsys_data_$message_redistributions_list_allocation, /* message_redistributions_list.redistributions */ 2 36 mlsys_data_$message_user_fields_allocation, /* message_user_fields_list.user_fields */ 2 37 mlsys_data_$message_references_list_allocation, /* message_references_list.references */ 2 38 mlsys_data_$address_list_allocation) /* address_list.addresses */ 2 39 fixed binary external; 2 40 2 41 2 42 /* Static data user by the Multics mail system */ 2 43 2 44 dcl (mlsys_data_$forum_not_available, /* 1 => forum isn't available on the system or in this ring */ 2 45 mlsys_data_$ism_not_available, /* 1 => no inter-system mailer on this system */ 2 46 mlsys_data_$domains_available) /* 1 => domain name system software on this sytem */ 2 47 fixed binary (1) external; 2 48 2 49 dcl (mlsys_data_$subsystem_ring, /* ring in which the mail system is secured */ 2 50 mlsys_data_$highest_usable_ring, /* highest ring of execution which may use the mail system */ 2 51 mlsys_data_$lowest_forum_ring) /* lowest ring of execution with access to forum */ 2 52 fixed binary (3) external; 2 53 2 54 dcl mlsys_data_$temp_segment_list_ptr pointer external; /* -> list of all mail system temporary segments */ 2 55 2 56 dcl mlsys_data_$valid_segments (0:4095) bit (1) unaligned external; 2 57 /* indicates which segments have been used by the mail system 2 58* for the allocation of user-visible data in order to 2 59* validate that pointers passed from the user-ring are OK */ 2 60 2 61 dcl mlsys_area area based (mlsys_data_$subsystem_area_ptr);/* area used for all user-visible allocations ... */ 2 62 dcl mlsys_data_$subsystem_area_ptr pointer external; /* ... and the pointer on which it is based */ 2 63 2 64 dcl mlsys_data_$hash_tables_segment_ptr pointer external; /* -> hash tables used by the mail system */ 2 65 2 66 dcl mlsys_data_$transmit_cache_ptr pointer external; /* -> cache of recently used mailboxes for mlsys_transmit_ */ 2 67 2 68 dcl mlsys_data_$user_is_anonymous bit (1) aligned external;/* ON => the user is an anonymous user */ 2 69 2 70 dcl mlsys_data_$person_id character (24) varying external; /* the user's Person_id */ 2 71 dcl mlsys_data_$project_id character (12) varying external;/* the user's Project_id */ 2 72 dcl mlsys_data_$user_id character (32) varying external; /* the user's User_id (Person_id.Project_id) */ 2 73 2 74 /* END INCLUDE FILE ... mlsys_internal_data.incl.pl1 */ 349 350 3 1 /* BEGIN INCLUDE FILE ... mlsys_field_types.incl.pl1 */ 3 2 /* Created: July 1983 by G. Palter */ 3 3 3 4 /* Defined field types */ 3 5 3 6 dcl (USER_DEFINED_FIELD initial ( 0), /* user-defined field */ 3 7 ACCESS_CLASS_FIELD initial (16), ACKNOWLEDGE_TO_FIELD initial ( 7), 3 8 BCC_FIELD initial (14), CC_FIELD initial (13), 3 9 DATE_FIELD initial ( 8), DELIVERY_DATE_FIELD initial ( 5), 3 10 POSTED_DATE_FIELD initial ( 1), DELIVERY_BY_FIELD initial ( 6), 3 11 FROM_FIELD initial ( 9), ROUTE_FIELD initial ( 3), 3 12 MESSAGE_ID_FIELD initial (18), RELAYED_FIELD initial ( 4), 3 13 IN_REPLY_TO_FIELD initial (15), REPLY_TO_FIELD initial (11), 3 14 SENDER_FIELD initial ( 2), SUBJECT_FIELD initial (10), 3 15 TO_FIELD initial (12), COMMENT_FIELD initial (17), 3 16 3 17 N_ORDINARY_FIELDS initial (18)) /* # of defined field types */ 3 18 fixed binary static options (constant); 3 19 3 20 3 21 /* Defined classes of header fields */ 3 22 3 23 dcl (ORDINARY_FIELDS_BASE initial ( 0), 3 24 REDISTRIBUTED_FIELDS_BASE initial (100), /* fields in a redistribution */ 3 25 COMMENT_FIELDS_BASE initial (200)) /* fields in a comment */ 3 26 fixed binary static options (constant); 3 27 3 28 /* END INCLUDE FILE ... mlsys_field_types.incl.pl1 */ 351 352 353 end mlsys_field_id_mgr_; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 06/30/86 1343.8 mlsys_field_id_mgr_.pl1 >spec>install>1080>mlsys_field_id_mgr_.pl1 347 1 10/27/83 2104.2 mlsys_hash_tables_seg.incl.pl1 >ldd>include>mlsys_hash_tables_seg.incl.pl1 349 2 06/30/86 1338.7 mlsys_internal_data.incl.pl1 >spec>install>1080>mlsys_internal_data.incl.pl1 351 3 10/27/83 2104.2 mlsys_field_types.incl.pl1 >ldd>include>mlsys_field_types.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. COMMENT_FIELD constant fixed bin(17,0) initial dcl 3-6 ref 277 COMMENT_FIELDS_BASE constant fixed bin(17,0) initial dcl 3-23 ref 277 FIELD_TYPES_BASE_MULTIPLIER constant fixed bin(17,0) initial dcl 81 ref 269 FIELD_TYPE_BASES 000427 constant fixed bin(17,0) initial array dcl 90 ref 254 HTSP constant char(2) initial unaligned dcl 62 ref 303 303 309 319 HYPHEN 003167 constant char(1) initial unaligned dcl 61 ref 316 326 LOWERCASE 000511 constant char(26) initial unaligned dcl 65 ref 330 333 ORDINARY_FIELDS_BASE constant fixed bin(17,0) initial dcl 3-23 ref 245 248 P_canonical_field_name parameter varying char dcl 30 set ref 152 194* 196 205 221 222* P_code parameter fixed bin(35,0) dcl 35 set ref 128 131* 134 135 143* 152 161* 162 165* 196* 198* 205 212* 223* 225* P_field_id parameter bit(36) dcl 27 set ref 152 192* 205 208 P_field_name parameter char unaligned dcl 24 set ref 128 131 139 141* 152 157 159* P_field_type parameter fixed bin(17,0) dcl 33 set ref 128 131* 135 143* RECOGNIZED_PREFIXES 000434 constant varying char(32) initial array dcl 87 ref 248 248 250 250 250 253 SORTED_FIELD_NAMES 000031 constant char(32) initial array unaligned dcl 110 ref 258 259 264 265 SORTED_FIELD_TYPES 000000 constant fixed bin(17,0) initial array dcl 117 ref 264 SUPPORTED_FIELDS 000341 constant bit(1) initial array dcl 96 ref 269 UPPERCASE 000520 constant char(26) initial unaligned dcl 65 ref 330 333 USER_DEFINED_FIELD constant fixed bin(17,0) initial dcl 3-6 ref 135 164 260 262 269 bucket_idx 000101 automatic fixed bin(18,0) level 2 packed unsigned unaligned dcl 45 set ref 169* 175 187 210 210 218 buckets based pointer array level 3 dcl 1-6 set ref 169 169 175 187* 210 210 218 canonical_field_name 000100 automatic varying char dcl 157 in begin block on line 155 set ref 159* 161* 169 177 183 185 194 196 canonical_field_name 000100 automatic varying char dcl 301 in begin block on line 298 set ref 305* 311* 311 315* 315 316* 316 325 326 327 330* 330 333* 333 340 canonical_field_name 000100 automatic varying char dcl 139 in begin block on line 137 set ref 141* 143* dimension builtin function dcl 76 ref 169 169 divide builtin function dcl 76 ref 263 encoded_field_id 000101 automatic structure level 1 dcl 45 set ref 192 208* error_table_$smallarg 000012 external static fixed bin(35,0) dcl 69 ref 196 225 field_name 000100 automatic varying char dcl 300 in begin block on line 298 set ref 303* 308 309 311 312 315 319 field_name 3 based char level 2 in structure "field_name_slot" dcl 49 in procedure "mlsys_field_id_mgr_" set ref 177 185* 222 field_name_hash_table based structure level 2 dcl 1-6 field_name_lth 2 based fixed bin(21,0) level 2 dcl 49 set ref 177 184* 185 221 222 field_name_slot based structure level 1 dcl 49 set ref 184 field_name_slot_field_name_lth 000106 automatic fixed bin(21,0) dcl 54 set ref 183* 184 184 field_name_slot_ptr 000102 automatic pointer dcl 53 set ref 175* 175* 177 179* 180 184* 185 186 187 189 218* 218* 221 222* 229 field_type 000101 automatic fixed bin(17,0) dcl 243 in procedure "lookup_field_name" set ref 260* 262 264* 269 269 269* 269 277 277* 277 279 field_type 000100 automatic fixed bin(17,0) dcl 40 in procedure "mlsys_field_id_mgr_" set ref 161* 164 field_type_base 000100 automatic fixed bin(17,0) dcl 243 set ref 245* 248 254* 269 269 hash_area 4000 based area(1024) level 2 dcl 1-6 ref 184 hash_tables_segment based structure level 1 dcl 1-6 hb 000104 automatic fixed bin(17,0) dcl 243 set ref 259* 262 263 266* hbound builtin function dcl 76 ref 210 248 259 idx 000105 automatic fixed bin(17,0) dcl 243 in procedure "lookup_field_name" set ref 248* 250 250 250 253 254* idx 000102 automatic fixed bin(21,0) dcl 296 in procedure "canonicalize_field_name" set ref 309* 310 315 318 319* 320 320 326* 327 329 index builtin function dcl 76 ref 326 last_field_name_slot_ptr 000104 automatic pointer dcl 53 set ref 174* 179* 187 189 lb 000103 automatic fixed bin(17,0) dcl 243 set ref 258* 262 263 265* lbound builtin function dcl 76 ref 210 248 258 length builtin function dcl 76 ref 139 157 183 196 242 250 250 250 253 300 308 312 325 327 ltrim builtin function dcl 76 ref 303 maxlength builtin function dcl 76 ref 196 221 301 mlsys_data_$hash_tables_segment_ptr 000024 external static pointer dcl 2-64 ref 169 169 175 184 187 210 210 218 mlsys_et_$reserved_field_name 000014 external static fixed bin(35,0) dcl 69 ref 165 mlsys_et_$unknown_user_field_id 000016 external static fixed bin(35,0) dcl 69 ref 212 mlsys_et_$unsupported_reserved_field_name 000020 external static fixed bin(35,0) dcl 69 ref 134 273 mlsys_hash_$hash 000022 constant entry external dcl 74 ref 169 n_real_steps 000107 automatic fixed bin(17,0) dcl 59 set ref 217* 220 228* 228 n_steps 0(18) 000101 automatic fixed bin(18,0) level 2 packed unsigned unaligned dcl 45 set ref 172* 178* 178 220 name_idx 000102 automatic fixed bin(17,0) dcl 243 set ref 263* 264 264 265 265 266 next_slot_ptr based pointer level 2 dcl 49 set ref 180 186* 189* 229 null builtin function dcl 76 ref 174 175 186 187 218 p_canonical_field_name parameter varying char dcl 294 in procedure "canonicalize_field_name" set ref 290 301 340* p_canonical_field_name parameter varying char dcl 238 in procedure "lookup_field_name" ref 235 242 246 p_code parameter fixed bin(35,0) dcl 240 set ref 235 273* 280* p_field_name parameter char unaligned dcl 293 ref 290 300 303 p_field_type parameter fixed bin(17,0) dcl 239 set ref 235 279* prefixless_field_name 000100 automatic varying char dcl 242 set ref 246* 250 250 253* 253 264 265 rtrim builtin function dcl 76 ref 303 search builtin function dcl 76 ref 309 start 000100 automatic fixed bin(21,0) dcl 296 set ref 307* 308 309 311 312* 315 318* 318 319 320* 320 324* 325 326 327 330 330 333 333 337* 337 substr builtin function dcl 76 set ref 250 253 309 311 315 319 326 330* 330 333* 333 token_lth 000101 automatic fixed bin(21,0) dcl 296 set ref 327* 329* 330 333 333 333 337 translate builtin function dcl 76 ref 330 333 unspec builtin function dcl 76 set ref 192* 192 208* 208 verify builtin function dcl 76 ref 319 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ACCESS_CLASS_FIELD internal static fixed bin(17,0) initial dcl 3-6 ACKNOWLEDGE_TO_FIELD internal static fixed bin(17,0) initial dcl 3-6 BCC_FIELD internal static fixed bin(17,0) initial dcl 3-6 CC_FIELD internal static fixed bin(17,0) initial dcl 3-6 DATE_FIELD internal static fixed bin(17,0) initial dcl 3-6 DELIVERY_BY_FIELD internal static fixed bin(17,0) initial dcl 3-6 DELIVERY_DATE_FIELD internal static fixed bin(17,0) initial dcl 3-6 FROM_FIELD internal static fixed bin(17,0) initial dcl 3-6 IN_REPLY_TO_FIELD internal static fixed bin(17,0) initial dcl 3-6 MESSAGE_ID_FIELD internal static fixed bin(17,0) initial dcl 3-6 N_ORDINARY_FIELDS internal static fixed bin(17,0) initial dcl 3-6 POSTED_DATE_FIELD internal static fixed bin(17,0) initial dcl 3-6 REDISTRIBUTED_FIELDS_BASE internal static fixed bin(17,0) initial dcl 3-23 RELAYED_FIELD internal static fixed bin(17,0) initial dcl 3-6 REPLY_TO_FIELD internal static fixed bin(17,0) initial dcl 3-6 ROUTE_FIELD internal static fixed bin(17,0) initial dcl 3-6 SENDER_FIELD internal static fixed bin(17,0) initial dcl 3-6 SUBJECT_FIELD internal static fixed bin(17,0) initial dcl 3-6 TO_FIELD internal static fixed bin(17,0) initial dcl 3-6 mlsys_area based area(1024) dcl 2-61 mlsys_data_$address_list_allocation external static fixed bin(17,0) dcl 2-33 mlsys_data_$domains_available external static fixed bin(1,0) dcl 2-44 mlsys_data_$forum_not_available external static fixed bin(1,0) dcl 2-44 mlsys_data_$highest_usable_ring external static fixed bin(3,0) dcl 2-49 mlsys_data_$ism_not_available external static fixed bin(1,0) dcl 2-44 mlsys_data_$lowest_forum_ring external static fixed bin(3,0) dcl 2-49 mlsys_data_$mailbox_allocation external static fixed bin(17,0) dcl 2-33 mlsys_data_$max_lock_wait_retries external static fixed bin(17,0) dcl 2-19 mlsys_data_$max_opening_retries external static fixed bin(17,0) dcl 2-16 mlsys_data_$message_body_sections_allocation external static fixed bin(17,0) dcl 2-33 mlsys_data_$message_redistributions_list_allocation external static fixed bin(17,0) dcl 2-33 mlsys_data_$message_references_list_allocation external static fixed bin(17,0) dcl 2-33 mlsys_data_$message_user_fields_allocation external static fixed bin(17,0) dcl 2-33 mlsys_data_$person_id external static varying char(24) dcl 2-70 mlsys_data_$project_id external static varying char(12) dcl 2-71 mlsys_data_$subsystem_area_ptr external static pointer dcl 2-62 mlsys_data_$subsystem_ring external static fixed bin(3,0) dcl 2-49 mlsys_data_$temp_segment_list_ptr external static pointer dcl 2-54 mlsys_data_$transmit_cache_ptr external static pointer dcl 2-66 mlsys_data_$user_id external static varying char(32) dcl 2-72 mlsys_data_$user_is_anonymous external static bit(1) dcl 2-68 mlsys_data_$valid_segments external static bit(1) array unaligned dcl 2-56 NAMES DECLARED BY EXPLICIT CONTEXT. HAVE_ENCODED_FIELD_ID 001240 constant label dcl 192 ref 177 UNKNOWN_FIELD_ID 001325 constant label dcl 212 ref 231 canonicalize_field_name 001614 constant entry internal dcl 290 ref 141 159 get_system_field_type 000553 constant entry external dcl 128 get_user_field_id 000734 constant entry external dcl 152 get_user_field_name 001276 constant entry external dcl 205 lookup_field_name 001406 constant entry internal dcl 235 ref 131 143 161 mlsys_field_id_mgr_ 000541 constant entry external dcl 16 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3400 3426 3170 3410 Length 3702 3170 26 240 210 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME mlsys_field_id_mgr_ 100 external procedure is an external procedure. begin block on line 137 98 begin block uses auto adjustable storage. begin block on line 155 103 begin block uses auto adjustable storage. lookup_field_name 76 internal procedure uses auto adjustable storage, and is called during a stack extension. canonicalize_field_name 69 internal procedure is called by several nonquick procedures. begin block on line 298 74 begin block uses auto adjustable storage. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME begin block on line 137 000100 canonical_field_name begin block on line 137 begin block on line 155 000100 canonical_field_name begin block on line 155 begin block on line 298 000100 canonical_field_name begin block on line 298 000100 field_name begin block on line 298 canonicalize_field_name 000100 start canonicalize_field_name 000101 token_lth canonicalize_field_name 000102 idx canonicalize_field_name lookup_field_name 000100 prefixless_field_name lookup_field_name 000100 field_type_base lookup_field_name 000101 field_type lookup_field_name 000102 name_idx lookup_field_name 000103 lb lookup_field_name 000104 hb lookup_field_name 000105 idx lookup_field_name mlsys_field_id_mgr_ 000100 field_type mlsys_field_id_mgr_ 000101 encoded_field_id mlsys_field_id_mgr_ 000102 field_name_slot_ptr mlsys_field_id_mgr_ 000104 last_field_name_slot_ptr mlsys_field_id_mgr_ 000106 field_name_slot_field_name_lth mlsys_field_id_mgr_ 000107 n_real_steps mlsys_field_id_mgr_ THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs enter_begin leave_begin call_ext_out_desc call_ext_out call_int_this_desc call_int_other_desc begin_return return alloc_auto_adj shorten_stack ext_entry ext_entry_desc int_entry_desc THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. mlsys_hash_$hash mlsys_storage_mgr_$allocate THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$smallarg mlsys_data_$hash_tables_segment_ptr mlsys_et_$reserved_field_name mlsys_et_$unknown_user_field_id mlsys_et_$unsupported_reserved_field_name LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 16 000540 19 000546 128 000547 131 000571 134 000622 135 000627 137 000634 139 000637 141 000654 143 000657 141 000662 143 000701 144 000725 146 000726 152 000727 155 000760 157 000763 159 001000 161 001003 159 001006 161 001025 162 001050 164 001055 165 001057 166 001062 169 001064 172 001123 174 001126 175 001130 177 001145 178 001155 179 001161 180 001162 183 001165 184 001167 185 001216 186 001223 187 001225 189 001237 192 001240 194 001242 196 001260 198 001267 199 001270 201 001271 205 001272 208 001315 210 001317 212 001325 214 001330 217 001331 218 001332 220 001344 221 001350 222 001360 223 001371 224 001372 225 001373 226 001376 228 001377 229 001400 231 001404 235 001405 242 001421 245 001433 246 001435 248 001445 250 001455 253 001473 254 001505 256 001510 258 001512 259 001514 260 001516 262 001520 263 001525 264 001530 265 001545 266 001553 267 001556 269 001557 273 001575 274 001601 277 001602 279 001606 280 001611 282 001612 290 001613 298 001634 300 001637 301 001654 303 001667 305 001726 307 001727 308 001731 309 001736 310 001757 311 001760 312 001776 313 002001 315 002002 316 002022 318 002031 319 002033 320 002053 322 002060 324 002061 325 002063 326 002070 327 002107 329 002115 330 002117 333 002130 337 002144 338 002151 340 002152 341 002165 343 002166 ----------------------------------------------------------- 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