COMPILATION LISTING OF SEGMENT linus_lila_where Compiled by: Multics PL/I Compiler, Release 28e, of February 14, 1985 Compiled at: Honeywell Multics Op. - System M Compiled on: 07/29/86 1004.7 mst Tue Options: optimize map 1 /* *********************************************************** 2* * * 3* * * 4* * Copyright, (C) Honeywell Information Systems Inc., 1981 * 5* * * 6* * * 7* *********************************************************** */ 8 9 /* ****************************************************** 10* * * 11* * * 12* * Copyright (c) 1972 by Massachusetts Institute of * 13* * Technology and Honeywell Information Systems, Inc. * 14* * * 15* * * 16* ****************************************************** */ 17 18 linus_lila_where: 19 proc (lcb_ptr, lsh_ptr, inner, td_ptr, code); 20 21 /* DESCRIPTION: 22* 23* This procedure processes the LILA where clause, producing the qualifier 24* portion of a MRDS -where clause. 25* 26* 27* 28* HISTORY: 29* 30* 77-08-01 J. A. Weeldreyer: Initially written. 31* 32* 80-03-13 Rickie E. Brinegar: Modified to use a work area defined on 33* lcb.lila_area_ptr instead of getting system free area. 34* 35* 81-07-15 Rickie E. Brinegar: Removed useless cleanup condition handler. 36* 37* 81-09-17 Rickie E. Brinegar: Changed the two do loops in the reduce 38* procedure to use the bit variable done in the while clause instead of the 39* large boolean variables that are now done in the if statements just before 40* and inside of the do loops. This avoids subscript range conditions. 41* 42* 81-11-06 Rickie E. Brinegar: Added the declaration of the fixed builtin 43* and deleted the declaration of the unreferenced linus_data_$max_leaf_vals. 44* 45**/ 46 1 1 /* BEGIN INCLUDE FILE linus_lcb.incl.pl1 -- jaw 8/30/77 */ 1 2 1 3 1 4 1 5 /****^ HISTORY COMMENTS: 1 6* 1) change(86-04-23,Dupuis), approve(86-05-23,MCR7188), audit(86-07-23,GWMay), 1 7* install(86-07-29,MR12.0-1106): 1 8* Added general_work_area_ptr and renamed sfr_ptr to 1 9* force_retrieve_scope_ptr. 1 10* END HISTORY COMMENTS */ 1 11 1 12 1 13 /* HISTORY: 1 14* 1 15* 78-09-29 J. C. C. Jagernauth: Modified for MR7.0. 1 16* 1 17* 81-05-11 Rickie E. Brinegar: added security bit and andministrator bit as 1 18* a part of the attribute level control work. 1 19* 1 20* 81-06-17 Rickie E. Brinegar: deleted the sd_ptr as a part of removing the 1 21* scope_data structure from LINUS. LINUS now depends totally on MRDS for 1 22* scope information. 1 23* 1 24* 81-11-11 Rickie E. Brinegar: added the timing bit and three fields for 1 25* retaining various vcpu times to be collected when in timing mode. The 1 26* times to be collected are: LINUS parsing time, LINUS processing time, and 1 27* MRDS processing time. 1 28* 1 29* 82-01-15 DJ Schimke: Added the build_increment and build_start fields as 1 30* part of the line numbering implementation. This allows for possible later 1 31* LINUS control of the build defaults. 1 32* 1 33* 82-03-01 Paul W. Benjamin: Removed linus_prompt_chars_ptr, as that 1 34* information is now retained by ssu_. Removed parse_timer as no longer 1 35* meaningful. Added linus_version. Added iteration bit. Added 6 entry 1 36* variables for ssu_ replaceable procedures. Added actual_input_iocbp. 1 37* 1 38* 82-06-23 Al Dupuis: Added subsystem_control_info_ptr, 1 39* subsystem_invocation_level, and selection_expression_identifier. 1 40* 1 41* 82-08-26 DJ Schimke: Added report_control_info_ptr, and 1 42* table_control_info_ptr. 1 43* 1 44* 82-10-19 DJ Schimke: Added ssu_abort_line. 1 45* 1 46* 83-06-06 Bert Moberg: Added print_search_order (pso) and no_optimize (no_ot) 1 47* 1 48* 83-04-07 DJ Schimke: Added temp_seg_info_ptr. 1 49* 1 50* 83-08-26 Al Dupuis: Added query_temp_segment_ptr. 1 51**/ 1 52 1 53 dcl 1 lcb aligned based (lcb_ptr), /* LINUS control block */ 1 54 2 db_index fixed bin (35), /* index of open data base, or 0 */ 1 55 2 rb_len fixed bin (21), /* length of request buffer */ 1 56 2 lila_count fixed bin (35), /* number of LILA text lines */ 1 57 2 lila_chars fixed bin (35), /* number of LILA source test chars */ 1 58 2 trans_id fixed bin (35), /* used by checkpoint and rollback facilities (MR7.0) */ 1 59 2 lila_fn char (32) unal, /* entry name of lila data file */ 1 60 2 prompt_flag bit (1) unal, /* on if in prompt mode */ 1 61 2 test_flag bit (1) unal, /* on if in test mode */ 1 62 2 new_version bit (1) unal init (1), /* on for new version data base (MR7.0) */ 1 63 2 secured_db bit (1) unal, /* on if the db is in a secure state */ 1 64 2 administrator bit (1) unal, /* on if the user is a db administrator */ 1 65 2 timing_mode bit (1) unal, /* on if timing is to be done */ 1 66 2 iteration bit (1) unal, /* interpret parens as iteration sets */ 1 67 2 pso_flag bit (1) unal, /* add print_search_order to select */ 1 68 2 no_ot_flag bit (1) unal, /* add no_optimize to select */ 1 69 2 reserved bit (27) unal, 1 70 2 liocb_ptr ptr, /* iocb ptr for lila file */ 1 71 2 rb_ptr ptr, /* ptr to request buffer */ 1 72 2 is_ptr ptr, /* iocb ptr for currentinput stream switch */ 1 73 2 cal_ptr ptr, /* ptr to current arg list for invoke (or null) */ 1 74 2 ttn_ptr ptr, /* pointer to table info structure */ 1 75 2 force_retrieve_scope_info_ptr ptr, /* structure pointer to force retrieve scope operation */ 1 76 2 lv_ptr ptr, /* pointer linus variables */ 1 77 2 si_ptr ptr, /* pointer to select_info structure */ 1 78 2 setfi_ptr ptr, /* pointer to set function information */ 1 79 2 sclfi_ptr ptr, /* pointer to user declared scalar fun. names */ 1 80 2 ivs_ptr ptr, /* pointer to stack of invoke iocb pointers */ 1 81 2 lit_ptr ptr, /* pointer to literal pool */ 1 82 2 lvv_ptr ptr, /* pointer to linus variable alloc. pool */ 1 83 2 rd_ptr ptr, /* point to readied files mode information (MR7.0) */ 1 84 2 rt_ptr ptr, /* point to table of relation names and their readied modes 1 85* (MR7.0) */ 1 86 2 actual_input_iocbp ptr, /* ptr to input while in macros */ 1 87 2 lila_promp_chars_ptr ptr, /* pointer to the prompt characters for lila */ 1 88 2 linus_area_ptr ptr, /* LINUS temporary segment pointer */ 1 89 2 lila_area_ptr ptr, /* LILA temporary segment pointer */ 1 90 2 i_o_area_ptr ptr, /* temporary segment pointer used by write, print, create_list */ 1 91 2 rel_array_ptr ptr, /* ptr to array of names rslt info structure 1 92* for current lila expression */ 1 93 2 unused_timer float bin (63), /* future expansion */ 1 94 2 request_time float bin (63), /* How much request time was spent 1 95* in LINUS. (-1 = user has just enabled 1 96* timing, do not report) */ 1 97 2 mrds_time float bin (63), /* How much time was spent in MRDS */ 1 98 2 build_increment fixed bin, /* default increment for build mode */ 1 99 2 build_start fixed bin, /* default start count for build mode */ 1 100 2 linus_version char (4), /* current version of LINUS */ 1 101 2 subsystem_control_info_ptr ptr, /* the same ptr passed by ssu_ to each request procedure */ 1 102 2 subsystem_invocation_level fixed bin, /* identifies this invocation of LINUS */ 1 103 2 selection_expression_identifier fixed bin, /* identifies the current processed selection expression */ 1 104 2 report_control_info_ptr ptr, /* pointer to linus_report_control_info structure */ 1 105 2 table_control_info_ptr ptr, /* pointer to linus_table control structure */ 1 106 2 temp_seg_info_ptr ptr, /* pointer to linus_temp_seg_mgr control structure */ 1 107 2 query_temp_segment_ptr ptr, /* points to temp seg used for manipulating query */ 1 108 2 general_work_area_ptr ptr, /* a freeing area for general use */ 1 109 2 word_pad (6) bit (36) unal, 1 110 /* procedures that will be optionally */ 1 111 /* replaced by the user. Saved so they */ 1 112 /* can be reinstated if desired. */ 1 113 2 ssu_abort_line entry options (variable), 1 114 2 ssu_post_request_line variable entry (ptr), 1 115 2 ssu_pre_request_line variable entry (ptr), 1 116 1 117 2 curr_lit_offset fixed bin (35), /* index of first free bit in lit. pool */ 1 118 2 curr_lv_val_offset fixed bin (35), /* index of first free bit lv. val. pool */ 1 119 2 static_area area (sys_info$max_seg_size - fixed (rel (addr (lcb.static_area))) + 1); 1 120 1 121 dcl lcb_ptr ptr; 1 122 1 123 /* END INCLUDE FILE linus_lcb.incl.pl1 */ 47 48 2 1 /* BEGIN INCLUDE FILE linus_ls_block.incl.pl1 -- jaw 8/7/78 */ 2 2 2 3 dcl 1 ls_block aligned based (lsb_ptr), /* lila stack frame for outer lila block */ 3 1 /* BEGIN INCLUDE FILE linus_ls_common.incl.pl1 -- jaw 7/12/77 */ 3 2 3 3 2 type fixed bin, /* type of frame: 3 4* 1 => header, 3 5* 2 => set value, 3 6* 3 => lila set, 3 7* 4 => lila block */ 3 8 2 back_ptr ptr, /* pointer to previous frame */ 3 9 2 fwd_ptr ptr, /* pointer to next frame */ 3 10 3 11 /* END INCLUDE FILE linus_ls_common.incl.pl1 */ 2 4 2 5 2 reserved bit (36) unal, 2 6 2 ib_level fixed bin, /* current depth of inner blocks */ 2 7 2 nrs_chars fixed bin, /* total chars. in range strings */ 2 8 2 nritems fixed bin, /* current number of range items */ 2 9 2 range_items (linus_data_$max_range_items), 2 10 3 tup_var char (32) var, /* name of linus tuple variable */ 2 11 3 mrds_var char (32) var, /* name of mrds tuple variable */ 2 12 3 rel_name char (32) var, /* name of relation */ 2 13 3 rel_index fixed bin (35), /* rel. index if temp tab */ 2 14 3 level fixed bin, /* level of block generating item */ 2 15 3 arg_ptr ptr, 2 16 3 desc_ptr ptr, 2 17 2 nselects fixed bin, /* number of select items currently defined */ 2 18 2 sel_items (mrds_data_$max_select_items) char (mrds_data_$max_token_size) var, /* the mrds select items */ 2 19 2 nprops fixed bin, /* number of operators in pred stack */ 2 20 2 pred_op_stack (linus_data_$max_pred_stack_size), 2 21 3 key fixed bin (17) unal, 2 22 3 p_cnt fixed bin (17) unal, /* current paren count */ 2 23 2 pred_pcnt fixed bin, /* current paren. count in predicate */ 2 24 2 term_op fixed bin, /* rel. op. for current term */ 2 25 2 nterms fixed bin, /* no. of terms currently in term stack */ 2 26 2 dflt_ritem fixed bin, /* index of range item to be used for default */ 2 27 2 nrange_args fixed bin, /* no. of args for temp rel indexes */ 2 28 2 rs_hd_ptr ptr, /* pointer to head of range strings */ 2 29 2 term_hd_ptr ptr, /* pointer to top item in term stack */ 2 30 2 leaf_ptr (2) ptr; /* ptr to mrds block for each leaf of current term */ 2 31 2 32 dcl lsb_ptr ptr; 2 33 2 34 /* END INCLUDE FILE linus_ls_block.incl.pl1 */ 49 50 4 1 /* BEGIN INCLUDE FILE linus_ls_header.incl.pl1 -- jaw 7/28/77 */ 4 2 4 3 dcl 1 ls_header aligned based (lsh_ptr), /* header for LILA stack */ 5 1 /* BEGIN INCLUDE FILE linus_ls_common.incl.pl1 -- jaw 7/12/77 */ 5 2 5 3 2 type fixed bin, /* type of frame: 5 4* 1 => header, 5 5* 2 => set value, 5 6* 3 => lila set, 5 7* 4 => lila block */ 5 8 2 back_ptr ptr, /* pointer to previous frame */ 5 9 2 fwd_ptr ptr, /* pointer to next frame */ 5 10 5 11 /* END INCLUDE FILE linus_ls_common.incl.pl1 */ 4 4 4 5 2 cur_ptr ptr, /* pointer to current frame */ 4 6 2 src_ptr ptr, /* pointer to LILA source string */ 4 7 2 trans_failed bit (1) unal, /* on if translate failed */ 4 8 2 from_token bit (1) unal, /* on if the calling routine is linus_lila_from */ 4 9 2 reserved bit (34) unal, 4 10 2 cur_pos fixed bin (35), /* current position in source string */ 4 11 2 line_data (0 : lcb.lila_count), /* data for each source line */ 4 12 3 lno char (4), /* line number */ 4 13 3 last_char fixed bin (35); /* index of last char */ 4 14 4 15 dcl lsh_ptr ptr; 4 16 4 17 /* END INCLUDE FILE linus_ls_header.incl.pl1 */ 51 52 6 1 /* BEGIN INCLUDE FILE linus_mrds_block.incl.pl1 -- jaw 7/21/77 */ 6 2 6 3 dcl 1 mrds_block aligned based (mblk_ptr), /* partial mrds selection expr */ 6 4 2 fwd_ptr ptr, /* pointer to previous item in stack */ 6 5 2 sel_offset fixed bin (35), /* offset of first select item in mrds_string */ 6 6 2 sel_length fixed bin (35), /* length of first select list in mrds string */ 6 7 2 nval_args fixed bin, /* number of value args */ 6 8 2 val_args (nval_args_init refer (mrds_block.nval_args)), 6 9 3 arg_ptr ptr, 6 10 3 desc_ptr ptr, 6 11 2 ms_len fixed bin (35), /* length of the mrds string */ 6 12 2 mrds_string char (ms_len_init refer (mrds_block.ms_len)) var; 6 13 6 14 dcl nval_args_init fixed bin; 6 15 dcl ms_len_init fixed bin (35); 6 16 dcl mblk_ptr ptr; 6 17 6 18 /* END INCLUDE FILE linus_mrds_block.incl.pl1 */ 53 54 7 1 /* BEGIN INCLUDE FILE linus_token_data.incl.pl1 -- jaw 8/7/78 */ 7 2 7 3 dcl 1 token_data aligned based (td_ptr), /* data for lila tokens */ 7 4 2 key fixed bin (17) unal, /* key of token */ 7 5 2 must_free bit (1) unal, /* on if value must be freed */ 7 6 2 temp_tab bit (1) unal, /* on if temporary table */ 7 7 2 reserved bit (16) unal, 7 8 2 mvar char (32) var, /* mrds variable if identifier */ 7 9 2 lvar char (32) var, /* linus variable if identifier */ 7 10 2 length fixed bin (35), /* char length of token value */ 7 11 2 t_ptr ptr; /* points to token value */ 7 12 7 13 dcl ((NULL init (0)), 7 14 (RP init (1)), 7 15 (COL_SPEC init (2)), 7 16 (LINUS_VAR init (3)), 7 17 (CONST init (4)), 7 18 (SET_FN init (5)), 7 19 (SCAL_FN init (6)), 7 20 (LP init (7)), 7 21 (STAR init (8)), 7 22 (DIV init (9)), 7 23 (PLUS init (10)), 7 24 (MINUS init (11)), 7 25 (TAB_NAME init (12)), 7 26 (ROW_TAB_PAIR init (13)), 7 27 (UNION init (14)), 7 28 (INTER init (15)), 7 29 (DIFFER init (16)), 7 30 (ROW_DES init (17)), 7 31 (LB init (18)), 7 32 (RB init (19)), 7 33 (SELECT init (20)), 7 34 (NOT init (21)), 7 35 (AND init (22)), 7 36 (OR init (23)), 7 37 (EQ init (24)), 7 38 (NE init (25)), 7 39 (GT init (26)), 7 40 (GE init (27)), 7 41 (LT init (28)), 7 42 (LE init (29)), 7 43 (FROM init (30)), 7 44 (WHERE init (31)), 7 45 (DUP init (32)), 7 46 (UNIQUE init (33)), 7 47 (COMMA init (34))) fixed bin int static options (constant); 7 48 7 49 dcl td_ptr ptr; 7 50 7 51 /* END INCLUDE FILE linus_token_data.incl.pl1 */ 55 56 57 dcl ( 58 inner, /* Input: on if inner LILA block */ 59 where_flag, /* on if "where" OK */ 60 term_flag, /* on if term OK */ 61 not_flag, /* on if "^" OK */ 62 lp_flag, /* on if "(" OK */ 63 bop_flag, /* on if bool. op. OK */ 64 rp_flag, /* on if ")" OK */ 65 end_flag, /* on if end OK */ 66 done 67 ) bit (1) unal; /* internal completion flag */ 68 dcl ( 69 code, /* Output: status code */ 70 icode 71 ) fixed bin (35); 72 dcl i fixed bin; /* internal index */ 73 dcl work_area area (sys_info$max_seg_size) based (lcb.lila_area_ptr); 74 dcl token char (token_data.length) based (token_data.t_ptr); 75 76 dcl mrds_bop (22:23) char (5) int static options (constant) 77 init (") & (", ") | ("); 78 dcl bop_prec (22:23) fixed bin int static options (constant) init (2, 1); 79 dcl ( 80 END init (1), 81 PAREN init (2), 82 OP init (3) 83 ) fixed bin int static options (constant); 84 85 dcl ( 86 linus_error_$where_syntax, 87 linus_error_$where_ovfl, 88 linus_error_$incomplete_where, 89 linus_error_$unbal_parens, 90 linus_data_$max_pred_stack_size, 91 linus_data_$max_range_items, 92 mrds_data_$max_token_size, 93 mrds_data_$max_select_items, 94 sys_info$max_seg_size 95 ) fixed bin (35) ext; 96 97 dcl (addr, fixed, length, null, rel) builtin; 98 99 dcl linus_lila_get_token entry (ptr, ptr, fixed bin (35), ptr, fixed bin (35)); 100 dcl linus_lila_error entry (ptr, ptr, fixed bin (35), char (*)); 101 dcl linus_lila_term entry (ptr, ptr, ptr, fixed bin (35)); 102 103 mblk_ptr = null; 104 105 lsb_ptr = ls_header.cur_ptr; 106 107 if token_data.key = NULL then do; /* if need to get new token */ 108 call 109 linus_lila_get_token (lcb_ptr, lsh_ptr, ls_header.cur_pos, td_ptr, 110 icode); 111 if icode ^= 0 then 112 call linus_lila_error (lcb_ptr, lsh_ptr, icode, token); 113 end; 114 115 where_flag = "1"b; /* init. state flags */ 116 term_flag, not_flag, lp_flag, bop_flag, rp_flag, end_flag = "0"b; 117 118 done = "0"b; 119 120 do while (^done); /* main token processing loop */ 121 122 go to token_proc (token_data.key); 123 124 token_proc (0): /* null */ 125 token_proc (3): /* linus variable */ 126 token_proc (4): /* constant */ 127 token_proc (5): /* set function */ 128 token_proc (8): /* * */ 129 token_proc (9): /* / */ 130 token_proc (10): /* + */ 131 token_proc (11): /* - */ 132 token_proc (12): /* table name */ 133 token_proc (13): /* row table pair */ 134 token_proc (14): /* union */ 135 token_proc (15): /* inter */ 136 token_proc (16): /* differ */ 137 token_proc (17): /* row designator */ 138 token_proc (18): /* { */ 139 token_proc (19): /* } */ 140 token_proc (20): /* select */ 141 token_proc (24): /* = */ 142 token_proc (25): /* ^= */ 143 token_proc (26): /* > */ 144 token_proc (27): /* >= */ 145 token_proc (28): /* < */ 146 token_proc (29): /* <= */ 147 token_proc (30): /* from */ 148 token_proc (32): /* dup */ 149 token_proc (33): /* unique */ 150 token_proc (34): /* , */ 151 if ^end_flag then /* these tokens should not be here, try to treat as end */ 152 call 153 linus_lila_error (lcb_ptr, lsh_ptr, 154 linus_error_$incomplete_where, token); 155 156 if ^inner then do; /* if legit end for outer block */ 157 call reduce (END); /* perform final predicate retuction */ 158 if ls_block.nprops ^= 0 & ls_block.nterms ^= 1 then 159 /* didnt come out right */ 160 call 161 linus_lila_error (lcb_ptr, lsh_ptr, 162 linus_error_$where_syntax, ""); 163 end; /* if outer block */ 164 165 else do; /* if is legit end for inner block */ 166 do i = 1, 2 while (ls_block.pred_pcnt > 0); 167 call reduce (PAREN); /* reduce for 2 implied RP's at end of inner block */ 168 ls_block.pred_pcnt = ls_block.pred_pcnt - 1; 169 end; 170 end; /* if inner block */ 171 done = "1"b; /* set completion flag */ 172 go to next; 173 174 token_proc (1): /* ) */ 175 if ^rp_flag then /* if not expected */ 176 call 177 linus_lila_error (lcb_ptr, lsh_ptr, linus_error_$where_syntax, 178 token); 179 180 if ls_block.pred_pcnt <= 0 then /* if no matching ( */ 181 call 182 linus_lila_error (lcb_ptr, lsh_ptr, linus_error_$unbal_parens, 183 token); 184 185 call reduce (PAREN); /* perform any necessary reductions */ 186 ls_block.pred_pcnt = ls_block.pred_pcnt - 1; 187 188 token_data.key = NULL; /* force new token */ 189 go to next; 190 191 token_proc (2): /* column spec. */ 192 token_proc (6): /* scalar function */ 193 if ^term_flag then /* both tokens start terms, is one expected? */ 194 call 195 linus_lila_error (lcb_ptr, lsh_ptr, linus_error_$where_syntax, 196 token); 197 198 call linus_lila_term (lcb_ptr, lsh_ptr, td_ptr, icode); 199 /* go process the term */ 200 if icode ^= 0 then 201 call linus_lila_error (lcb_ptr, lsh_ptr, icode, token); 202 203 term_flag, /* set state flags */ 204 lp_flag, not_flag = "0"b; 205 bop_flag, rp_flag, end_flag = "1"b; 206 go to next; 207 208 token_proc (7): /* ( */ 209 if ^lp_flag then /* if not expected */ 210 call 211 linus_lila_error (lcb_ptr, lsh_ptr, linus_error_$where_syntax, 212 token); 213 ls_block.pred_pcnt = ls_block.pred_pcnt + 1; /* merely incr. par. count */ 214 term_flag, /* set state flags */ 215 not_flag = "1"b; 216 token_data.key = NULL; /* force new token */ 217 go to next; 218 219 token_proc (21): /* ^ */ 220 if ^not_flag then /* if not allowed here */ 221 call 222 linus_lila_error (lcb_ptr, lsh_ptr, linus_error_$where_syntax, 223 token); 224 if ls_block.nprops >= linus_data_$max_pred_stack_size then 225 /* if op stack ovfl. */ 226 call 227 linus_lila_error (lcb_ptr, lsh_ptr, linus_error_$where_ovfl, 228 ""); 229 ls_block.nprops = ls_block.nprops + 1; /* add ^ to op stack */ 230 ls_block.pred_op_stack.key (ls_block.nprops) = NOT; 231 ls_block.pred_op_stack.p_cnt (ls_block.nprops) = ls_block.pred_pcnt; 232 token_data.key = NULL; /* force new token */ 233 term_flag, /* set state flags */ 234 not_flag, rp_flag, bop_flag, end_flag = "0"b; 235 lp_flag = "1"b; 236 go to next; 237 238 token_proc (22): /* & */ 239 token_proc (23): /* | */ 240 if ^bop_flag then /* if bool. oper. not expected */ 241 call 242 linus_lila_error (lcb_ptr, lsh_ptr, linus_error_$where_syntax, 243 token); 244 if ls_block.nprops > 0 then /* if prev. op. */ 245 if ls_block.pred_op_stack.p_cnt (ls_block.nprops) 246 = ls_block.pred_pcnt then 247 if bop_prec (token_data.key) 248 <= bop_prec (ls_block.pred_op_stack.key (ls_block.nprops)) 249 then call reduce (OP); /* reduce for lower prec. oper. */ 250 if ls_block.nprops >= linus_data_$max_pred_stack_size then 251 /* if over flow */ 252 call 253 linus_lila_error (lcb_ptr, lsh_ptr, linus_error_$where_ovfl, 254 ""); 255 ls_block.nprops = ls_block.nprops + 1; /* add new op. to stack */ 256 ls_block.pred_op_stack.key (ls_block.nprops) = token_data.key; 257 ls_block.pred_op_stack.p_cnt (ls_block.nprops) = ls_block.pred_pcnt; 258 token_data.key = NULL; /* force new token */ 259 term_flag, /* set state flags */ 260 not_flag, lp_flag = "1"b; 261 bop_flag, rp_flag, end_flag = "0"b; 262 go to next; 263 264 token_proc (31): /* where */ 265 if ^where_flag then /* if not expected */ 266 call 267 linus_lila_error (lcb_ptr, lsh_ptr, linus_error_$where_syntax, 268 token); 269 270 if inner then do; /* if inner block, add implied & and ( */ 271 if ls_block.nprops >= linus_data_$max_pred_stack_size then 272 /* if will overfl. */ 273 call 274 linus_lila_error (lcb_ptr, lsh_ptr, linus_error_$where_ovfl, 275 ""); 276 ls_block.nprops = ls_block.nprops + 1; /* add & */ 277 ls_block.pred_op_stack.key (ls_block.nprops) = AND; 278 ls_block.pred_op_stack.p_cnt (ls_block.nprops) = ls_block.pred_pcnt; 279 ls_block.pred_pcnt = ls_block.pred_pcnt + 1; /* add ( */ 280 end; /* if inner block */ 281 282 where_flag = "0"b; /* set state flags */ 283 term_flag, not_flag, lp_flag = "1"b; 284 token_data.key = NULL; /* force new token */ 285 go to next; 286 287 next: 288 if token_data.key = NULL then do; /* if need new token */ 289 call 290 linus_lila_get_token (lcb_ptr, lsh_ptr, ls_header.cur_pos, 291 td_ptr, icode); 292 if icode ^= 0 then 293 call linus_lila_error (lcb_ptr, lsh_ptr, icode, token); 294 end; 295 296 end; /* main processing loop */ 297 298 code = 0; /* made it */ 299 return; 300 301 reduce: 302 proc (type); 303 304 /* Procedure to reduce items in pred stack. Three types of reduction are provided: 305* (a) for lower precedence operators, (b) for right parenthesis, and (c) final 306* reduction. */ 307 308 dcl type fixed bin; 309 dcl bp ptr; 310 dcl done bit (1); 311 312 if type = END then 313 do while (ls_block.nprops > 0 & ls_block.nterms > 1); 314 call combine; 315 end; /* final reduction */ 316 else if type = PAREN then do; /* paren reduction */ 317 318 done = "0"b; 319 if ls_block.nprops ^> 0 | ls_block.nterms ^> 1 then 320 done = "1"b; 321 else if ls_block.pred_op_stack.p_cnt (ls_block.nprops) 322 ^= ls_block.pred_pcnt then 323 done = "1"b; 324 do while (^done); 325 call combine; 326 if ls_block.nprops ^> 0 | ls_block.nterms ^> 1 then 327 done = "1"b; 328 else if ls_block.pred_op_stack.p_cnt (ls_block.nprops) 329 ^= ls_block.pred_pcnt then 330 done = "1"b; 331 end; /* combining all terms within paren */ 332 if ls_block.nprops > 0 & ls_block.nterms > 1 then /* check for preceding not */ 333 if ls_block.pred_op_stack.key (ls_block.nprops) = NOT 334 & ls_block.pred_op_stack.p_cnt (ls_block.nprops) 335 = ls_block.pred_pcnt - 1 then do; 336 bp = ls_block.term_hd_ptr; /* point to top term in stack */ 337 ms_len_init = 3 + length (bp -> mrds_block.mrds_string); 338 /* alloc. new block */ 339 nval_args_init = bp -> mrds_block.nval_args; 340 allocate mrds_block in (work_area); 341 mrds_block.fwd_ptr = bp -> mrds_block.fwd_ptr; 342 /* replace current top term */ 343 mrds_block.mrds_string = 344 "^(" || bp -> mrds_block.mrds_string || ")"; 345 mrds_block.val_args = bp -> mrds_block.val_args; 346 ls_block.nprops = ls_block.nprops - 1; 347 ls_block.term_hd_ptr = mblk_ptr; 348 bp = null; 349 mblk_ptr = null; 350 end; /* incorporating not */ 351 end; /* paren reduction */ 352 else do; 353 done = "0"b; 354 if ls_block.nprops ^> 0 | ls_block.nterms ^> 1 then 355 done = "1"b; 356 else if ls_block.pred_op_stack.p_cnt (ls_block.nprops) 357 ^= ls_block.pred_pcnt 358 | bop_prec (token_data.key) 359 > bop_prec (ls_block.pred_op_stack.key (ls_block.nprops)) then 360 done = "1"b; 361 do while (^done); 362 call combine; 363 if ls_block.nprops ^> 0 | ls_block.nterms ^> 1 then 364 done = "1"b; 365 else if ls_block.pred_op_stack.p_cnt (ls_block.nprops) 366 ^= ls_block.pred_pcnt 367 | bop_prec (token_data.key) 368 > bop_prec (ls_block.pred_op_stack.key (ls_block.nprops)) 369 then done = "1"b; 370 end; 371 end; /* operator reduction */ 372 373 combine: 374 proc; 375 376 /* Procedure to combine the top two string blocks and top operator into one 377* string block, and replace the items in the stack */ 378 379 dcl (b1p, b2p) ptr; 380 dcl i fixed bin; 381 382 b2p = ls_block.term_hd_ptr; /* point to top term */ 383 b1p = b2p -> mrds_block.fwd_ptr; /* and prec. term */ 384 385 ms_len_init = 386 7 + length (b1p -> mrds_block.mrds_string) 387 + length (b2p -> mrds_block.mrds_string); 388 nval_args_init = 389 b1p -> mrds_block.nval_args + b2p -> mrds_block.nval_args; 390 allocate mrds_block in (work_area); /* the combination block */ 391 392 mrds_block.fwd_ptr = b1p -> mrds_block.fwd_ptr; /* replace top two terms */ 393 mrds_block.mrds_string = 394 "(" || b1p -> mrds_block.mrds_string 395 || mrds_bop (ls_block.pred_op_stack.key (ls_block.nprops)) 396 || b2p -> mrds_block.mrds_string || ")"; 397 do i = 1 to b1p -> mrds_block.nval_args; 398 mrds_block.val_args.arg_ptr (i) = 399 b1p -> mrds_block.val_args.arg_ptr (i); 400 mrds_block.val_args.desc_ptr (i) = 401 b1p -> mrds_block.val_args.desc_ptr (i); 402 end; 403 do i = b1p -> mrds_block.nval_args + 1 to mrds_block.nval_args; 404 mrds_block.val_args.arg_ptr (i) = 405 b2p 406 -> mrds_block.val_args.arg_ptr (i - b1p -> mrds_block.nval_args); 407 mrds_block.val_args.desc_ptr (i) = 408 b2p 409 -> mrds_block.val_args.desc_ptr (i - b1p -> mrds_block.nval_args); 410 end; 411 ls_block.nprops = ls_block.nprops - 1; 412 ls_block.nterms = ls_block.nterms - 1; 413 ls_block.term_hd_ptr = mblk_ptr; 414 b1p = null; 415 b2p = null; 416 mblk_ptr = null; 417 418 end combine; 419 420 end reduce; 421 422 end linus_lila_where; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 07/29/86 0939.9 linus_lila_where.pl1 >special_ldd>install>MR12.0-1106>linus_lila_where.pl1 47 1 07/29/86 0937.8 linus_lcb.incl.pl1 >special_ldd>install>MR12.0-1106>linus_lcb.incl.pl1 49 2 03/27/82 0434.5 linus_ls_block.incl.pl1 >ldd>include>linus_ls_block.incl.pl1 2-4 3 03/27/82 0434.5 linus_ls_common.incl.pl1 >ldd>include>linus_ls_common.incl.pl1 51 4 11/23/82 1327.2 linus_ls_header.incl.pl1 >ldd>include>linus_ls_header.incl.pl1 4-4 5 03/27/82 0434.5 linus_ls_common.incl.pl1 >ldd>include>linus_ls_common.incl.pl1 53 6 03/27/82 0434.5 linus_mrds_block.incl.pl1 >ldd>include>linus_mrds_block.incl.pl1 55 7 03/27/82 0434.5 linus_token_data.incl.pl1 >ldd>include>linus_token_data.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. AND constant fixed bin(17,0) initial dcl 7-13 ref 277 END constant fixed bin(17,0) initial dcl 79 set ref 157* 312 NOT constant fixed bin(17,0) initial dcl 7-13 ref 230 332 NULL constant fixed bin(17,0) initial dcl 7-13 ref 107 188 216 232 258 284 287 OP constant fixed bin(17,0) initial dcl 79 set ref 244* PAREN constant fixed bin(17,0) initial dcl 79 set ref 167* 185* 316 arg_ptr 6 based pointer array level 3 dcl 6-3 set ref 398* 398 404* 404 b1p 000142 automatic pointer dcl 379 set ref 383* 385 388 392 393 397 398 400 403 404 407 414* b2p 000144 automatic pointer dcl 379 set ref 382* 383 385 388 393 404 407 415* bop_flag 000112 automatic bit(1) unaligned dcl 57 set ref 116* 205* 233* 238 261* bop_prec 000044 constant fixed bin(17,0) initial array dcl 78 ref 244 244 356 356 365 365 bp 000130 automatic pointer dcl 309 set ref 336* 337 339 341 343 345 348* code parameter fixed bin(35,0) dcl 68 set ref 18 298* cur_pos 13 based fixed bin(35,0) level 2 dcl 4-3 set ref 108* 289* cur_ptr 6 based pointer level 2 dcl 4-3 ref 105 desc_ptr 10 based pointer array level 3 dcl 6-3 set ref 400* 400 407* 407 done 000115 automatic bit(1) unaligned dcl 57 in procedure "linus_lila_where" set ref 118* 120 171* done 000132 automatic bit(1) unaligned dcl 310 in procedure "reduce" set ref 318* 319* 321* 324 326* 328* 353* 354* 356* 361 363* 365* end_flag 000114 automatic bit(1) unaligned dcl 57 set ref 116* 124 205* 233* 261* fwd_ptr based pointer level 2 dcl 6-3 set ref 341* 341 383 392* 392 i 000117 automatic fixed bin(17,0) dcl 72 in procedure "linus_lila_where" set ref 166* i 000146 automatic fixed bin(17,0) dcl 380 in procedure "combine" set ref 397* 398 398 400 400* 403* 404 404 407 407* icode 000116 automatic fixed bin(35,0) dcl 68 set ref 108* 111 111* 198* 200 200* 289* 292 292* inner parameter bit(1) unaligned dcl 57 ref 18 156 270 key based fixed bin(17,0) array level 3 in structure "ls_block" packed unaligned dcl 2-3 in procedure "linus_lila_where" set ref 230* 244 256* 277* 332 356 365 393 key based fixed bin(17,0) level 2 in structure "token_data" packed unaligned dcl 7-3 in procedure "linus_lila_where" set ref 107 122 188* 216* 232* 244 256 258* 284* 287 356 365 lcb based structure level 1 dcl 1-53 lcb_ptr parameter pointer dcl 1-121 set ref 18 108* 111* 124* 158* 174* 180* 191* 198* 200* 208* 219* 224* 238* 250* 264* 271* 289* 292* 340 390 length builtin function dcl 97 in procedure "linus_lila_where" ref 337 385 385 length 23 based fixed bin(35,0) level 2 in structure "token_data" dcl 7-3 in procedure "linus_lila_where" ref 111 111 124 124 174 174 180 180 191 191 200 200 208 208 219 219 238 238 264 264 292 292 lila_area_ptr 62 based pointer level 2 dcl 1-53 ref 340 390 linus_data_$max_pred_stack_size 000020 external static fixed bin(35,0) dcl 85 ref 158 168 168 169 180 186 186 213 213 224 231 244 250 257 271 278 279 279 312 319 321 326 328 332 332 336 347 354 356 363 365 382 412 412 413 linus_data_$max_range_items 000022 external static fixed bin(35,0) dcl 85 ref 158 158 168 168 169 180 186 186 213 213 224 229 229 230 230 231 231 231 244 244 244 244 244 244 250 255 255 256 256 257 257 257 271 276 276 277 277 278 278 278 279 279 312 312 319 319 321 321 321 326 326 328 328 328 332 332 332 332 332 332 332 336 346 346 347 354 354 356 356 356 356 356 363 363 365 365 365 365 365 382 393 393 411 411 412 412 413 linus_error_$incomplete_where 000014 external static fixed bin(35,0) dcl 85 set ref 124* linus_error_$unbal_parens 000016 external static fixed bin(35,0) dcl 85 set ref 180* linus_error_$where_ovfl 000012 external static fixed bin(35,0) dcl 85 set ref 224* 250* 271* linus_error_$where_syntax 000010 external static fixed bin(35,0) dcl 85 set ref 158* 174* 191* 208* 219* 238* 264* linus_lila_error 000032 constant entry external dcl 100 ref 111 124 158 174 180 191 200 208 219 224 238 250 264 271 292 linus_lila_get_token 000030 constant entry external dcl 99 ref 108 289 linus_lila_term 000034 constant entry external dcl 101 ref 198 lp_flag 000111 automatic bit(1) unaligned dcl 57 set ref 116* 203* 208 235* 259* 283* ls_block based structure level 1 dcl 2-3 ls_header based structure level 1 dcl 4-3 lsb_ptr 000100 automatic pointer dcl 2-32 set ref 105* 158 158 168 168 169 180 186 186 213 213 224 229 229 230 230 231 231 231 244 244 244 244 244 244 250 255 255 256 256 257 257 257 271 276 276 277 277 278 278 278 279 279 312 312 319 319 321 321 321 326 326 328 328 328 332 332 332 332 332 332 332 336 346 346 347 354 354 356 356 356 356 356 363 363 365 365 365 365 365 382 393 393 411 411 412 412 413 lsh_ptr parameter pointer dcl 4-15 set ref 18 105 108* 108 111* 124* 158* 174* 180* 191* 198* 200* 208* 219* 224* 238* 250* 264* 271* 289* 289 292* mblk_ptr 000104 automatic pointer dcl 6-16 set ref 103* 340* 341 343 345 347 349* 390* 392 393 398 400 403 404 407 413 416* mrds_block based structure level 1 dcl 6-3 set ref 340 390 mrds_bop 000046 constant char(5) initial array unaligned dcl 76 ref 393 mrds_data_$max_select_items 000026 external static fixed bin(35,0) dcl 85 ref 158 158 168 168 169 180 186 186 213 213 224 229 229 230 230 231 231 231 244 244 244 244 244 244 250 255 255 256 256 257 257 257 271 276 276 277 277 278 278 278 279 279 312 312 319 319 321 321 321 326 326 328 328 328 332 332 332 332 332 332 332 336 346 346 347 354 354 356 356 356 356 356 363 363 365 365 365 365 365 382 393 393 411 411 412 412 413 mrds_data_$max_token_size 000024 external static fixed bin(35,0) dcl 85 ref 158 158 168 168 169 180 186 186 213 213 224 229 229 230 230 231 231 231 244 244 244 244 244 244 250 255 255 256 256 257 257 257 271 276 276 277 277 278 278 278 279 279 312 312 319 319 321 321 321 326 326 328 328 328 332 332 332 332 332 332 332 336 346 346 347 354 354 356 356 356 356 356 363 363 365 365 365 365 365 382 393 393 411 411 412 412 413 mrds_string based varying char level 2 dcl 6-3 set ref 337 343* 343 385 385 393* 393 393 ms_len based fixed bin(35,0) level 2 dcl 6-3 set ref 340* 343 390* 393 ms_len_init 000103 automatic fixed bin(35,0) dcl 6-15 set ref 337* 340 340 385* 390 390 not_flag 000110 automatic bit(1) unaligned dcl 57 set ref 116* 203* 214* 219 233* 259* 283* nprops based fixed bin(17,0) level 2 dcl 2-3 set ref 158 224 229* 229 230 231 244 244 244 250 255* 255 256 257 271 276* 276 277 278 312 319 321 326 328 332 332 332 346* 346 354 356 356 363 365 365 393 411* 411 nterms based fixed bin(17,0) level 2 dcl 2-3 set ref 158 312 319 326 332 354 363 412* 412 null builtin function dcl 97 ref 103 348 349 414 415 416 nval_args 4 based fixed bin(17,0) level 2 dcl 6-3 set ref 337 339 340* 340 343 343 343 345 385 385 388 388 390* 390 393 393 393 393 397 403 403 404 407 nval_args_init 000102 automatic fixed bin(17,0) dcl 6-14 set ref 339* 340 340 388* 390 390 p_cnt based fixed bin(17,0) array level 3 packed unaligned dcl 2-3 set ref 231* 244 257* 278* 321 328 332 356 365 pred_op_stack based structure array level 2 dcl 2-3 pred_pcnt based fixed bin(17,0) level 2 dcl 2-3 set ref 168* 168 169 180 186* 186 213* 213 231 244 257 278 279* 279 321 328 332 356 365 rp_flag 000113 automatic bit(1) unaligned dcl 57 set ref 116* 174 205* 233* 261* t_ptr 24 based pointer level 2 dcl 7-3 ref 111 124 174 180 191 200 208 219 238 264 292 td_ptr parameter pointer dcl 7-49 set ref 18 107 108* 111 111 111 122 124 124 124 174 174 174 180 180 180 188 191 191 191 198* 200 200 200 208 208 208 216 219 219 219 232 238 238 238 244 256 258 264 264 264 284 287 289* 292 292 292 356 365 term_flag 000107 automatic bit(1) unaligned dcl 57 set ref 116* 191 203* 214* 233* 259* 283* term_hd_ptr based pointer level 2 dcl 2-3 set ref 336 347* 382 413* token based char unaligned dcl 74 set ref 111* 124* 174* 180* 191* 200* 208* 219* 238* 264* 292* token_data based structure level 1 dcl 7-3 type parameter fixed bin(17,0) dcl 308 ref 301 312 316 val_args 6 based structure array level 2 dcl 6-3 set ref 345* 345 where_flag 000106 automatic bit(1) unaligned dcl 57 set ref 115* 264 282* work_area based area dcl 73 ref 340 390 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. COL_SPEC internal static fixed bin(17,0) initial dcl 7-13 COMMA internal static fixed bin(17,0) initial dcl 7-13 CONST internal static fixed bin(17,0) initial dcl 7-13 DIFFER internal static fixed bin(17,0) initial dcl 7-13 DIV internal static fixed bin(17,0) initial dcl 7-13 DUP internal static fixed bin(17,0) initial dcl 7-13 EQ internal static fixed bin(17,0) initial dcl 7-13 FROM internal static fixed bin(17,0) initial dcl 7-13 GE internal static fixed bin(17,0) initial dcl 7-13 GT internal static fixed bin(17,0) initial dcl 7-13 INTER internal static fixed bin(17,0) initial dcl 7-13 LB internal static fixed bin(17,0) initial dcl 7-13 LE internal static fixed bin(17,0) initial dcl 7-13 LINUS_VAR internal static fixed bin(17,0) initial dcl 7-13 LP internal static fixed bin(17,0) initial dcl 7-13 LT internal static fixed bin(17,0) initial dcl 7-13 MINUS internal static fixed bin(17,0) initial dcl 7-13 NE internal static fixed bin(17,0) initial dcl 7-13 OR internal static fixed bin(17,0) initial dcl 7-13 PLUS internal static fixed bin(17,0) initial dcl 7-13 RB internal static fixed bin(17,0) initial dcl 7-13 ROW_DES internal static fixed bin(17,0) initial dcl 7-13 ROW_TAB_PAIR internal static fixed bin(17,0) initial dcl 7-13 RP internal static fixed bin(17,0) initial dcl 7-13 SCAL_FN internal static fixed bin(17,0) initial dcl 7-13 SELECT internal static fixed bin(17,0) initial dcl 7-13 SET_FN internal static fixed bin(17,0) initial dcl 7-13 STAR internal static fixed bin(17,0) initial dcl 7-13 TAB_NAME internal static fixed bin(17,0) initial dcl 7-13 UNION internal static fixed bin(17,0) initial dcl 7-13 UNIQUE internal static fixed bin(17,0) initial dcl 7-13 WHERE internal static fixed bin(17,0) initial dcl 7-13 addr builtin function dcl 97 fixed builtin function dcl 97 rel builtin function dcl 97 sys_info$max_seg_size external static fixed bin(35,0) dcl 85 NAMES DECLARED BY EXPLICIT CONTEXT. combine 002564 constant entry internal dcl 373 ref 314 325 362 linus_lila_where 000071 constant entry external dcl 18 next 001565 constant label dcl 287 ref 172 189 206 217 236 262 285 reduce 001653 constant entry internal dcl 301 ref 157 167 185 244 token_proc 000000 constant label array(0:34) dcl 124 ref 122 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3336 3374 3153 3346 Length 4024 3153 36 413 162 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME linus_lila_where 151 external procedure is an external procedure. reduce internal procedure shares stack frame of external procedure linus_lila_where. combine internal procedure shares stack frame of external procedure linus_lila_where. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME linus_lila_where 000100 lsb_ptr linus_lila_where 000102 nval_args_init linus_lila_where 000103 ms_len_init linus_lila_where 000104 mblk_ptr linus_lila_where 000106 where_flag linus_lila_where 000107 term_flag linus_lila_where 000110 not_flag linus_lila_where 000111 lp_flag linus_lila_where 000112 bop_flag linus_lila_where 000113 rp_flag linus_lila_where 000114 end_flag linus_lila_where 000115 done linus_lila_where 000116 icode linus_lila_where 000117 i linus_lila_where 000130 bp reduce 000132 done reduce 000142 b1p combine 000144 b2p combine 000146 i combine THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. alloc_cs cat_realloc_cs call_ext_out_desc call_ext_out return shorten_stack ext_entry alloc_based THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. linus_lila_error linus_lila_get_token linus_lila_term THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. linus_data_$max_pred_stack_size linus_data_$max_range_items linus_error_$incomplete_where linus_error_$unbal_parens linus_error_$where_ovfl linus_error_$where_syntax mrds_data_$max_select_items mrds_data_$max_token_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 18 000064 103 000076 105 000100 107 000105 108 000111 111 000127 115 000163 116 000165 118 000173 120 000174 122 000176 124 000202 156 000234 157 000242 158 000244 163 000315 166 000316 167 000322 168 000324 169 000344 171 000371 172 000373 174 000374 180 000426 185 000476 186 000500 188 000520 189 000525 191 000526 198 000560 200 000576 203 000632 205 000635 206 000641 208 000642 213 000674 214 000712 216 000715 217 000722 219 000723 224 000755 229 001017 230 001034 231 001044 232 001075 233 001102 235 001107 236 001111 238 001112 244 001144 250 001234 255 001276 256 001313 257 001325 258 001356 259 001361 261 001365 262 001370 264 001371 270 001423 271 001431 276 001472 277 001507 278 001517 279 001551 282 001552 283 001553 284 001557 285 001564 287 001565 289 001572 292 001613 296 001647 298 001650 299 001652 301 001653 312 001655 314 001705 315 001706 316 001710 318 001712 319 001713 321 001746 324 001776 325 002000 326 002001 328 002034 331 002064 332 002065 336 002160 337 002203 339 002211 340 002213 341 002241 343 002244 345 002305 346 002314 347 002333 348 002357 349 002361 351 002362 353 002363 354 002364 356 002420 361 002461 362 002464 363 002465 365 002521 370 002562 420 002563 373 002564 382 002565 383 002615 385 002617 388 002631 390 002634 392 002662 393 002665 397 002777 398 003011 400 003016 402 003021 403 003023 404 003035 407 003047 410 003052 411 003054 412 003073 413 003103 414 003127 415 003131 416 003132 418 003133 ----------------------------------------------------------- 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