COMPILATION LISTING OF SEGMENT linus_lila_block Compiled by: Multics PL/I Compiler, Release 28e, of February 14, 1985 Compiled at: Honeywell Multics Op. - System M Compiled on: 07/29/86 0953.0 mst Tue Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1981 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 12 /****^ HISTORY COMMENTS: 13* 1) change(86-01-13,Dupuis), approve(86-01-13,MCR7188), audit(86-07-23,GWMay), 14* install(86-07-29,MR12.0-1106): 15* 84-12-28 Matthew Pierret: Changed to use linus_lila_tokens_ external 16* variables instead of hard-coding reserved words into the code. 17* END HISTORY COMMENTS */ 18 19 20 linus_lila_block: 21 proc (lcb_ptr, lsh_ptr, td_ptr, mblk_ptr, code); 22 23 /* DESCRIPTION: 24* 25* This procedure is the top level procedure for the translation of a LILA 26* block. It calls linus_lila_from, linus_lila_select, and linus_lila_where 27* to process the from, select, and where clauses respectively. Then, if 28* invoked to process an outer block, it combines the translated clauses to 29* form one mrds selection expression for the LILA block. 30* 31* 32* 33* HISTORY: 34* 35* 77-01-01 J. A. Weeldreyer: Initially written. 36* 37* 78-02-01 J. A. Weeldreyer: Modified to properly locate from clause. 38* 39* 78-08-01 J. A. Weeldreyer: Modified to properly handle row desig. scope. 40* 41* 80-04-13 Rickie E. Brinegar: Modified to use a work area defined on 42* lcb.lila_area_ptr instead of getting system free area. 43* 44* 80-12-03 Rickie E. Brinegar: sel_offset changed from ms_len_init + 3 to 45* ms_len_init + 2. 46* 47* 81-06-29 Rickie E. Brinegar: Modified to properly identify the from tokens 48* correct place. This is in response to TR10068. 49* 50* 81-07-15 Rickie E. Brinegar: Removed useless cleanup condition handler. 51* 52* 83-06-06 Bertley G. Moberg: Added support for print_search_order and no_optimize 53* 54**/ 55 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 */ 56 57 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 */ 58 59 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 */ 60 61 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 */ 62 63 7 1 /* BEGIN INCLUDE FILE linus_source.incl.pl1 -- jaw 7/12/77 */ 7 2 7 3 dcl source_str char (lcb.lila_chars) based (ls_header.src_ptr); 7 4 dcl source_array (lcb.lila_chars) char (1) based (ls_header.src_ptr); 7 5 7 6 /* END INCLUDE FILE linus_source.incl.pl1 */ 64 65 8 1 /* BEGIN INCLUDE FILE linus_token_data.incl.pl1 -- jaw 8/7/78 */ 8 2 8 3 dcl 1 token_data aligned based (td_ptr), /* data for lila tokens */ 8 4 2 key fixed bin (17) unal, /* key of token */ 8 5 2 must_free bit (1) unal, /* on if value must be freed */ 8 6 2 temp_tab bit (1) unal, /* on if temporary table */ 8 7 2 reserved bit (16) unal, 8 8 2 mvar char (32) var, /* mrds variable if identifier */ 8 9 2 lvar char (32) var, /* linus variable if identifier */ 8 10 2 length fixed bin (35), /* char length of token value */ 8 11 2 t_ptr ptr; /* points to token value */ 8 12 8 13 dcl ((NULL init (0)), 8 14 (RP init (1)), 8 15 (COL_SPEC init (2)), 8 16 (LINUS_VAR init (3)), 8 17 (CONST init (4)), 8 18 (SET_FN init (5)), 8 19 (SCAL_FN init (6)), 8 20 (LP init (7)), 8 21 (STAR init (8)), 8 22 (DIV init (9)), 8 23 (PLUS init (10)), 8 24 (MINUS init (11)), 8 25 (TAB_NAME init (12)), 8 26 (ROW_TAB_PAIR init (13)), 8 27 (UNION init (14)), 8 28 (INTER init (15)), 8 29 (DIFFER init (16)), 8 30 (ROW_DES init (17)), 8 31 (LB init (18)), 8 32 (RB init (19)), 8 33 (SELECT init (20)), 8 34 (NOT init (21)), 8 35 (AND init (22)), 8 36 (OR init (23)), 8 37 (EQ init (24)), 8 38 (NE init (25)), 8 39 (GT init (26)), 8 40 (GE init (27)), 8 41 (LT init (28)), 8 42 (LE init (29)), 8 43 (FROM init (30)), 8 44 (WHERE init (31)), 8 45 (DUP init (32)), 8 46 (UNIQUE init (33)), 8 47 (COMMA init (34))) fixed bin int static options (constant); 8 48 8 49 dcl td_ptr ptr; 8 50 8 51 /* END INCLUDE FILE linus_token_data.incl.pl1 */ 66 67 68 dcl ( 69 code, /* Output: status code */ 70 icode, /* internal status code */ 71 cur_pos, /* string index for from */ 72 sel_offset, 73 sel_length, 74 sel_cur_pos, 75 where_cur_pos, /* save index */ 76 i, /* internal string indexes */ 77 j 78 ) fixed bin (35); /* length of error source line */ 79 80 dcl hold_dflt_ri fixed bin; /* save area for prev. default range item */ 81 82 dcl rs_ptr ptr; 83 84 dcl temp_thd ptr; 85 86 dcl ( 87 b_cnt, /* bracket level count */ 88 rs_len_init, /* length of range string */ 89 rs_nargs_init, /* no. temp rels in range string */ 90 ind, /* internal indexes */ 91 arg_ind 92 ) fixed bin; 93 94 dcl ( 95 found, /* on if from found */ 96 inner 97 ) bit (1); /* on if this is for inner block */ 98 99 dcl work_area area (sys_info$max_seg_size) based (lcb.lila_area_ptr); 100 101 dcl 1 sel_tok_data aligned like token_data; 102 103 dcl 1 where_tok_data aligned like token_data; 104 105 dcl 1 range_string aligned based (rs_ptr), /* temp holding area for inner block ranges */ 106 2 str_len fixed bin, 107 2 nargs fixed bin, 108 2 string char (rs_len_init refer (range_string.str_len)) var, 109 2 arg_ptr (rs_nargs_init refer (range_string.nargs)) ptr, 110 2 desc_ptr (rs_nargs_init refer (range_string.nargs)) ptr, 111 2 thread ptr; 112 113 dcl BLOCK fixed bin int static options (constant) init (4); 114 dcl DELIMS char (7) int static options (constant) init ("{}() 115 "); 116 117 dcl ( 118 linus_data_$max_pred_stack_size, 119 linus_data_$max_range_items, 120 linus_error_$no_from, 121 mrds_data_$max_select_items, 122 mrds_data_$max_token_size, 123 sys_info$max_seg_size 124 ) fixed bin (35) ext; 125 dcl ( 126 linus_lila_tokens_$differ, 127 linus_lila_tokens_$from, 128 linus_lila_tokens_$inter, 129 linus_lila_tokens_$union, 130 linus_lila_tokens_$where 131 ) char (32) varying ext; 132 133 dcl (addr, fixed, null, index, length, rel, search, substr) builtin; 134 135 dcl linus_lila_error entry (ptr, ptr, fixed bin (35), char (*)); 136 dcl linus_lila_from entry (ptr, ptr, ptr, fixed bin (35)); 137 dcl linus_lila_select entry (ptr, ptr, bit (1), ptr, fixed bin (35)); 138 dcl linus_lila_where entry (ptr, ptr, bit (1), ptr, fixed bin (35)); 139 140 inner = "0"b; /* initialize */ 141 lsb_ptr, mblk_ptr = null; 142 143 if ls_header.cur_ptr -> ls_block.type = BLOCK then do; /* this is inner block */ 144 lsb_ptr = ls_header.cur_ptr; /* point to block stack frame */ 145 inner = "1"b; /* remember is inner block */ 146 hold_dflt_ri = ls_block.dflt_ritem; /* save prev. default */ 147 ls_block.ib_level = ls_block.ib_level + 1; 148 end; /* if inner */ 149 150 else do; /* is outer, must setup block stack frame */ 151 allocate ls_block in (work_area); 152 ls_block.nritems, /* initialize */ 153 ls_block.ib_level, ls_block.nrs_chars, ls_block.nselects, 154 ls_block.pred_pcnt, ls_block.nterms, ls_block.nrange_args, 155 ls_block.dflt_ritem, ls_block.nprops, ls_block.term_op, 156 ls_block.nterms = 0; 157 ls_block.type = BLOCK; 158 ls_block.leaf_ptr (1), ls_block.leaf_ptr (2), ls_block.fwd_ptr, 159 ls_block.rs_hd_ptr, ls_block.term_hd_ptr = null; 160 ls_block.tup_var, ls_block.mrds_var, ls_block.rel_name, 161 ls_block.sel_items = ""; 162 ls_block.back_ptr = ls_header.cur_ptr; /* thread into lila stack */ 163 ls_header.cur_ptr -> ls_block.fwd_ptr = lsb_ptr; 164 ls_header.cur_ptr = lsb_ptr; 165 end; /* if outer block */ 166 167 sel_tok_data = token_data; /* save for select clause processing */ 168 token_data.key = NULL; 169 sel_cur_pos, cur_pos = ls_header.cur_pos; /* init for from search */ 170 found = "0"b; 171 172 do while (^found & cur_pos < lcb.lila_chars); /* search for "from" */ 173 i = search (substr (source_str, cur_pos), "{}"); /* scan for brackets */ 174 if i > 0 then /* if found */ 175 if source_array (cur_pos + i - 1) = "{" then do; 176 /* if start of lower level */ 177 j = scan_from (cur_pos, i); /* look for from before { */ 178 if j > 0 then do; /* found it */ 179 found = "1"b; 180 cur_pos = cur_pos + j - 1; /* position to "f" */ 181 end; /* if found before { */ 182 else do; /* if not found before { */ 183 b_cnt = 1; /* init. bracket level count */ 184 do while (b_cnt > 0 & lcb.lila_chars > cur_pos); 185 /* search for end of lower level */ 186 cur_pos = cur_pos + i; /* first beyond { */ 187 i = search (substr (source_str, cur_pos), "{}"); 188 /* look for brackets */ 189 if i > 0 then do; /* if bracket found */ 190 if source_array (cur_pos + i + 1) = "{" then 191 b_cnt = b_cnt + 1; 192 else b_cnt = b_cnt - 1; /* adjust bracket count */ 193 cur_pos = cur_pos + i; /* first beyond bracket */ 194 end; /* if bracket found */ 195 else cur_pos = lcb.lila_chars; /* bracket not found, set to end of source */ 196 end; /* scan past inner blocks */ 197 end; /* if not found before { */ 198 end; /* if found { */ 199 else call final_scan (i); /* if found }, must find from before */ 200 else do; /* found no bracket, look through rest of string for from */ 201 i = lcb.lila_chars - cur_pos + 1; 202 call final_scan (i); 203 end; /* no brackets */ 204 end; /* search loop */ 205 206 if ^found then /* didnt find from */ 207 call linus_lila_error (lcb_ptr, lsh_ptr, linus_error_$no_from, ""); 208 else do; /* from was found, process from clause */ 209 ls_header.cur_pos = cur_pos; 210 call linus_lila_from (lcb_ptr, lsh_ptr, td_ptr, icode); 211 if icode ^= 0 then 212 call linus_lila_error (lcb_ptr, lsh_ptr, icode, ""); 213 where_tok_data = token_data; /* save for start of where */ 214 where_cur_pos = ls_header.cur_pos; 215 end; /* if from found */ 216 217 token_data = sel_tok_data; /* set for processing select clause */ 218 ls_header.cur_pos = sel_cur_pos; 219 call linus_lila_select (lcb_ptr, lsh_ptr, inner, td_ptr, icode); 220 if icode ^= 0 then 221 call linus_lila_error (lcb_ptr, lsh_ptr, icode, ""); 222 223 if found then do; /* if we proc. from clause, load tok. data for where */ 224 token_data = where_tok_data; 225 ls_header.cur_pos = where_cur_pos; 226 end; /* if had from clause */ 227 if token_data.key = WHERE then do; /* if have where clause */ 228 call linus_lila_where (lcb_ptr, lsh_ptr, inner, td_ptr, icode); 229 if icode ^= 0 then 230 call linus_lila_error (lcb_ptr, lsh_ptr, icode, ""); 231 end; /* if where clause exists */ 232 233 rs_nargs_init, /* init. for stringing range for current block */ 234 rs_len_init = 0; 235 do i = ls_block.nritems by -1 to 1 236 while (ls_block.range_items.level (i) >= ls_block.ib_level); 237 /* only for current block */ 238 rs_len_init = 239 rs_len_init + 4 + length (ls_block.range_items.mrds_var (i)) 240 + length (ls_block.range_items.rel_name (i)); 241 if ls_block.range_items.arg_ptr (i) ^= null then 242 rs_nargs_init = rs_nargs_init + 1; 243 end; 244 if ls_block.ib_level = 0 then 245 ind = 1; 246 else ind = i + 1; 247 248 allocate range_string in (work_area); /* bild the range string */ 249 range_string.thread = ls_block.rs_hd_ptr; /* thread it in */ 250 ls_block.rs_hd_ptr = rs_ptr; 251 range_string.string = ""; 252 arg_ind = 0; 253 do i = ind to ls_block.nritems; /* add each item to stirng */ 254 range_string.string = 255 range_string.string || "(" || ls_block.range_items.mrds_var (i) 256 || " " || ls_block.range_items.rel_name (i) || ") "; 257 if ls_block.range_items.arg_ptr (i) ^= null then do; 258 /* if temp rel */ 259 arg_ind = arg_ind + 1; 260 range_string.arg_ptr (arg_ind) = ls_block.range_items.arg_ptr (i); 261 range_string.desc_ptr (arg_ind) = ls_block.range_items.desc_ptr (i); 262 end; 263 end; /* adding items to string */ 264 265 ls_block.nritems = ind - 1; /* reset counters */ 266 ls_block.nrs_chars = ls_block.nrs_chars + rs_len_init; 267 ls_block.ib_level = ls_block.ib_level - 1; 268 269 if ^inner then do; /* if outer block, put together mrds block */ 270 ms_len_init = ls_block.nrs_chars + 7; /* calc. length of full mrds block */ 271 if lcb.pso_flag then ms_len_init = ms_len_init + 5; /* for "-pso " */ 272 if lcb.no_ot_flag then ms_len_init = ms_len_init + 7; /* for "-no_ot " */ 273 ms_len_init = ms_len_init + 12; /* for -select and opt. -dup */ 274 sel_offset = ms_len_init + 2; /* char index of first select term */ 275 do i = 1 to ls_block.nselects; /* calc len. of select clause */ 276 ms_len_init = ms_len_init + length (ls_block.sel_items (i)) + 2; 277 end; 278 sel_length = ms_len_init - sel_offset + 2; 279 if ls_block.nterms = 1 then do; /* if have pred. */ 280 ms_len_init = 281 ms_len_init + 8 282 + length (ls_block.term_hd_ptr -> mrds_block.mrds_string); 283 nval_args_init = 284 ls_block.nrange_args 285 + ls_block.term_hd_ptr -> mrds_block.nval_args; 286 end; 287 else nval_args_init = ls_block.nrange_args; 288 289 allocate mrds_block in (work_area); /* space for full mrds block */ 290 arg_ind = 0; 291 mrds_block.fwd_ptr = null; 292 mrds_block.sel_offset = sel_offset; 293 mrds_block.sel_length = sel_length; 294 mrds_block.mrds_string = "-range "; /* build the whole block */ 295 if lcb.pso_flag then mrds_block.mrds_string = mrds_block.mrds_string || "-pso "; 296 if lcb.no_ot_flag then mrds_block.mrds_string = mrds_block.mrds_string || "-no_ot "; 297 do rs_ptr = ls_block.rs_hd_ptr repeat temp_thd while (rs_ptr ^= null); 298 /* pick up range strings */ 299 do i = 1 to range_string.nargs; 300 mrds_block.val_args.arg_ptr (i + arg_ind) = 301 range_string.arg_ptr (i); 302 mrds_block.val_args.desc_ptr (i + arg_ind) = 303 range_string.desc_ptr (i); 304 end; 305 arg_ind = arg_ind + range_string.nargs; 306 mrds_block.mrds_string = 307 mrds_block.mrds_string || range_string.string; 308 temp_thd = range_string.thread; 309 rs_ptr = null; 310 end; /* adding range */ 311 mrds_block.mrds_string = mrds_block.mrds_string || "-select "; 312 do i = 1 to ls_block.nselects; 313 mrds_block.mrds_string = 314 mrds_block.mrds_string || " " || ls_block.sel_items (i) || " "; 315 end; 316 if ls_block.nterms = 1 then do; /* if have pred */ 317 i = ls_block.nrange_args; 318 mrds_block.mrds_string = 319 mrds_block.mrds_string || " -where " 320 || ls_block.term_hd_ptr -> mrds_block.mrds_string; 321 do j = i + 1 to ls_block.term_hd_ptr -> mrds_block.nval_args + i; 322 mrds_block.val_args.arg_ptr (j) = 323 ls_block.term_hd_ptr -> mrds_block.val_args.arg_ptr (j - i); 324 mrds_block.val_args.desc_ptr (j) = 325 ls_block.term_hd_ptr -> mrds_block.val_args.desc_ptr (j - i); 326 end; 327 ls_block.term_hd_ptr = null; /* don't need this mrds_block */ 328 end; /* if had pred */ 329 ls_block.back_ptr -> ls_block.fwd_ptr = null; /* unthread and free block stack frame */ 330 ls_header.cur_ptr = ls_block.back_ptr; 331 lsb_ptr = null; 332 end; /* if outer block */ 333 else ls_block.dflt_ritem = hold_dflt_ri; /* restore prev. default if inner block */ 334 335 code = 0; /* made it */ 336 337 exit: 338 return; 339 340 scan_from: 341 proc (start, len) returns (fixed bin (35)); 342 343 /* Procedure to dcan for from which precedes select and where in given sub string */ 344 345 dcl (from_pos, i, start, len) fixed bin (35); 346 347 from_pos = scan_kwd (linus_lila_tokens_$from); /* look for a from */ 348 if from_pos > 0 then do; /* if found */ 349 i = scan_kwd (linus_lila_tokens_$where); /* look for where */ 350 if i > 0 then 351 if from_pos > i then 352 from_pos = 0; /* from must precede where */ 353 i = scan_kwd (linus_lila_tokens_$inter); 354 if i > 0 then 355 if from_pos > i then 356 from_pos = 0; /* must also precede inter */ 357 i = scan_kwd (linus_lila_tokens_$differ); 358 if i > 0 then 359 if from_pos > i then 360 from_pos = 0; /* must also precede differ */ 361 i = scan_kwd (linus_lila_tokens_$union); 362 if i > 0 then 363 if from_pos > i then 364 from_pos = 0; /* must also precede union */ 365 end; /* if from found */ 366 367 return (from_pos); 368 369 scan_kwd: 370 proc (kwd) returns (fixed bin (35)); 371 372 /* Procedure to find isolated occurence of specified string */ 373 374 dcl kwd char (*) varying; 375 dcl (i, j, klen) fixed bin (35); 376 377 found = "0"b; /* init */ 378 klen = length (kwd); 379 i = start; 380 381 do while (i < start + len - 1 & ^found); 382 j = index (substr (source_str, i, start + len - i), kwd); 383 /* look for kwd */ 384 if j > 0 then /* if key word string found */ 385 if index (DELIMS, source_array (i + j - 2)) ^= 0 386 /* must be prec. and followed by delimiters */ 387 & index (DELIMS, source_array (i + j + klen - 1)) ^= 0 then do; 388 if i ^= start then 389 j = i - start + j; 390 found = "1"b; 391 end; 392 else i = i + j; /* keep looking */ 393 else i = start + len; /* not there, get out of loop */ 394 end; /* search loop */ 395 if ^found then 396 j = 0; 397 398 return (j); 399 400 end scan_kwd; 401 402 end scan_from; 403 404 final_scan: 405 proc (len); 406 407 /* Procedure to scan final part of string */ 408 409 dcl (len, i) fixed bin (35); 410 411 i = scan_from (cur_pos, len); 412 if i <= 0 then 413 cur_pos = lcb.lila_chars; /* get out of loop */ 414 else do; /* found it */ 415 cur_pos = cur_pos + i - 1; 416 found = "1"b; 417 end; 418 419 end final_scan; 420 421 end linus_lila_block; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 07/29/86 0936.9 linus_lila_block.pl1 >special_ldd>install>MR12.0-1106>linus_lila_block.pl1 56 1 07/29/86 0937.8 linus_lcb.incl.pl1 >special_ldd>install>MR12.0-1106>linus_lcb.incl.pl1 58 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 60 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 62 6 03/27/82 0434.5 linus_mrds_block.incl.pl1 >ldd>include>linus_mrds_block.incl.pl1 64 7 03/27/82 0434.5 linus_source.incl.pl1 >ldd>include>linus_source.incl.pl1 66 8 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. BLOCK constant fixed bin(17,0) initial dcl 113 ref 143 157 DELIMS 000000 constant char(7) initial unaligned dcl 114 ref 384 384 NULL constant fixed bin(17,0) initial dcl 8-13 ref 168 WHERE constant fixed bin(17,0) initial dcl 8-13 ref 227 arg_ind 000126 automatic fixed bin(17,0) dcl 86 set ref 252* 259* 259 260 261 290* 300 302 305* 305 arg_ptr 50 based pointer array level 3 in structure "ls_block" dcl 2-3 in procedure "linus_lila_block" ref 241 257 260 arg_ptr 6 based pointer array level 3 in structure "mrds_block" dcl 6-3 in procedure "linus_lila_block" set ref 300* 322* 322 arg_ptr based pointer array level 2 in structure "range_string" dcl 105 in procedure "linus_lila_block" set ref 260* 300 b_cnt 000122 automatic fixed bin(17,0) dcl 86 set ref 183* 184 190* 190 192* 192 back_ptr 2 based pointer level 2 dcl 2-3 set ref 162* 329 330 code parameter fixed bin(35,0) dcl 68 set ref 20 335* cur_pos 13 based fixed bin(35,0) level 2 in structure "ls_header" dcl 4-3 in procedure "linus_lila_block" set ref 169 209* 214 218* 225* cur_pos 000105 automatic fixed bin(35,0) dcl 68 in procedure "linus_lila_block" set ref 169* 172 173 174 177* 180* 180 184 186* 186 187 190 193* 193 195* 201 209 411* 412* 415* 415 cur_ptr 6 based pointer level 2 dcl 4-3 set ref 143 144 162 163 164* 330* desc_ptr based pointer array level 2 in structure "range_string" dcl 105 in procedure "linus_lila_block" set ref 261* 302 desc_ptr 10 based pointer array level 3 in structure "mrds_block" dcl 6-3 in procedure "linus_lila_block" set ref 302* 324* 324 desc_ptr 52 based pointer array level 3 in structure "ls_block" dcl 2-3 in procedure "linus_lila_block" ref 261 dflt_ritem based fixed bin(17,0) level 2 dcl 2-3 set ref 146 152* 333* found 000127 automatic bit(1) unaligned dcl 94 set ref 170* 172 179* 206 223 377* 381 390* 395 416* from_pos 000224 automatic fixed bin(35,0) dcl 345 set ref 347* 348 350 350* 354 354* 358 358* 362 362* 367 fwd_ptr 4 based pointer level 2 in structure "ls_block" dcl 2-3 in procedure "linus_lila_block" set ref 158* 163* 329* fwd_ptr based pointer level 2 in structure "mrds_block" dcl 6-3 in procedure "linus_lila_block" set ref 291* hold_dflt_ri 000114 automatic fixed bin(17,0) dcl 80 set ref 146* 333 i 000234 automatic fixed bin(35,0) dcl 375 in procedure "scan_kwd" set ref 379* 381 382 382 384 384 388 388 392* 392 393* i 000246 automatic fixed bin(35,0) dcl 409 in procedure "final_scan" set ref 411* 412 415 i 000112 automatic fixed bin(35,0) dcl 68 in procedure "linus_lila_block" set ref 173* 174 174 177* 186 187* 189 190 193 199* 201* 202* 235* 235* 238 238 241* 246 253* 254 254 257 260 261* 275* 276* 299* 300 300 302 302* 312* 313* 317* 321 321 322 324 i 000225 automatic fixed bin(35,0) dcl 345 in procedure "scan_from" set ref 349* 350 350 353* 354 354 357* 358 358 361* 362 362 ib_level 7 based fixed bin(17,0) level 2 dcl 2-3 set ref 147* 147 152* 235 244 267* 267 icode 000104 automatic fixed bin(35,0) dcl 68 set ref 210* 211 211* 219* 220 220* 228* 229 229* ind 000125 automatic fixed bin(17,0) dcl 86 set ref 244* 246* 253 265 index builtin function dcl 133 ref 382 384 384 inner 000130 automatic bit(1) unaligned dcl 94 set ref 140* 145* 219* 228* 269 j 000113 automatic fixed bin(35,0) dcl 68 in procedure "linus_lila_block" set ref 177* 178 180 321* 322 322 324 324* j 000235 automatic fixed bin(35,0) dcl 375 in procedure "scan_kwd" set ref 382* 384 384 384 388* 388 392 395* 398 key based fixed bin(17,0) level 2 packed unaligned dcl 8-3 set ref 168* 227 klen 000236 automatic fixed bin(35,0) dcl 375 set ref 378* 384 kwd parameter varying char dcl 374 ref 369 378 382 lcb based structure level 1 dcl 1-53 lcb_ptr parameter pointer dcl 1-121 set ref 20 151 172 173 184 187 195 201 206* 210* 211* 219* 220* 228* 229* 248 271 272 289 295 296 382 412 leaf_ptr based pointer array level 2 dcl 2-3 set ref 158* 158* len parameter fixed bin(35,0) dcl 409 in procedure "final_scan" set ref 404 411* len parameter fixed bin(35,0) dcl 345 in procedure "scan_from" ref 340 381 382 393 length builtin function dcl 133 ref 238 238 276 280 378 level 46 based fixed bin(17,0) array level 3 dcl 2-3 ref 235 lila_area_ptr 62 based pointer level 2 dcl 1-53 ref 151 248 289 lila_chars 3 based fixed bin(35,0) level 2 dcl 1-53 ref 172 173 184 187 195 201 382 412 linus_data_$max_pred_stack_size 000010 external static fixed bin(35,0) dcl 117 ref 146 151 152 152 152 152 152 152 158 158 158 158 249 250 279 280 283 283 287 297 316 317 318 321 322 324 327 333 linus_data_$max_range_items 000012 external static fixed bin(35,0) dcl 117 ref 146 151 152 152 152 152 152 152 152 152 158 158 158 158 160 160 160 160 160 249 250 275 276 279 280 283 283 287 297 312 313 316 317 318 321 322 324 327 333 linus_error_$no_from 000014 external static fixed bin(35,0) dcl 117 set ref 206* linus_lila_error 000034 constant entry external dcl 135 ref 206 211 220 229 linus_lila_from 000036 constant entry external dcl 136 ref 210 linus_lila_select 000040 constant entry external dcl 137 ref 219 linus_lila_tokens_$differ 000022 external static varying char(32) dcl 125 set ref 357* linus_lila_tokens_$from 000024 external static varying char(32) dcl 125 set ref 347* linus_lila_tokens_$inter 000026 external static varying char(32) dcl 125 set ref 353* linus_lila_tokens_$union 000030 external static varying char(32) dcl 125 set ref 361* linus_lila_tokens_$where 000032 external static varying char(32) dcl 125 set ref 349* linus_lila_where 000042 constant entry external dcl 138 ref 228 ls_block based structure level 1 dcl 2-3 set ref 151 ls_header based structure level 1 dcl 4-3 lsb_ptr 000100 automatic pointer dcl 2-32 set ref 141* 144* 146 147 147 151* 152 152 152 152 152 152 152 152 152 152 152 157 158 158 158 158 158 160 160 160 160 162 163 164 235 235 235 238 238 241 244 249 250 253 254 254 257 260 261 265 266 266 267 267 270 275 276 279 280 283 283 287 297 312 313 316 317 318 321 322 324 327 329 330 331* 333 lsh_ptr parameter pointer dcl 4-15 set ref 20 143 144 162 163 164 169 173 174 187 190 206* 209 210* 211* 214 218 219* 220* 225 228* 229* 330 382 384 384 mblk_ptr parameter pointer dcl 6-16 set ref 20 141* 289* 291 292 293 294 295 295 296 296 300 302 306 306 311 311 313 313 318 318 322 324 mrds_block based structure level 1 dcl 6-3 set ref 289 mrds_data_$max_select_items 000016 external static fixed bin(35,0) dcl 117 ref 146 151 152 152 152 152 152 152 152 158 158 158 158 160 249 250 279 280 283 283 287 297 316 317 318 321 322 324 327 333 mrds_data_$max_token_size 000020 external static fixed bin(35,0) dcl 117 ref 146 151 152 152 152 152 152 152 152 158 158 158 158 160 160 160 249 250 276 276 279 280 283 283 287 297 313 313 316 317 318 321 322 324 327 333 mrds_string based varying char level 2 dcl 6-3 set ref 280 294* 295* 295 296* 296 306* 306 311* 311 313* 313 318* 318 318 mrds_var 23 based varying char(32) array level 3 dcl 2-3 set ref 160* 238 254 ms_len based fixed bin(35,0) level 2 dcl 6-3 set ref 289* 294 295 296 306 311 313 318 ms_len_init 000103 automatic fixed bin(35,0) dcl 6-15 set ref 270* 271* 271 272* 272 273* 273 274 276* 276 278 280* 280 289 289 nargs 1 based fixed bin(17,0) level 2 dcl 105 set ref 248* 249 249 261 299 302 305 308 308 no_ot_flag 15(08) based bit(1) level 2 packed unaligned dcl 1-53 ref 272 296 nprops based fixed bin(17,0) level 2 dcl 2-3 set ref 152* nrange_args based fixed bin(17,0) level 2 dcl 2-3 set ref 152* 283 287 317 nritems 11 based fixed bin(17,0) level 2 dcl 2-3 set ref 152* 235 253 265* nrs_chars 10 based fixed bin(17,0) level 2 dcl 2-3 set ref 152* 266* 266 270 nselects based fixed bin(17,0) level 2 dcl 2-3 set ref 152* 275 312 nterms based fixed bin(17,0) level 2 dcl 2-3 set ref 152* 152* 279 316 null builtin function dcl 133 ref 141 158 241 257 291 297 309 327 329 331 nval_args 4 based fixed bin(17,0) level 2 dcl 6-3 set ref 280 283 289* 289 294 294 295 295 295 296 296 296 306 306 306 311 311 311 313 313 313 318 318 318 318 321 nval_args_init 000102 automatic fixed bin(17,0) dcl 6-14 set ref 283* 287* 289 289 pred_pcnt based fixed bin(17,0) level 2 dcl 2-3 set ref 152* pso_flag 15(07) based bit(1) level 2 packed unaligned dcl 1-53 ref 271 295 range_items 12 based structure array level 2 dcl 2-3 range_string based structure level 1 dcl 105 set ref 248 rel_name 34 based varying char(32) array level 3 dcl 2-3 set ref 160* 238 254 rs_hd_ptr based pointer level 2 dcl 2-3 set ref 158* 249 250* 297 rs_len_init 000123 automatic fixed bin(17,0) dcl 86 set ref 233* 238* 238 248 248 266 rs_nargs_init 000124 automatic fixed bin(17,0) dcl 86 set ref 233* 241* 241 248 248 248 rs_ptr 000116 automatic pointer dcl 82 set ref 248* 249 250 251 254 254 260 261 297* 297* 299 300 302 305 306 308 309* search builtin function dcl 133 ref 173 187 sel_cur_pos 000110 automatic fixed bin(35,0) dcl 68 set ref 169* 218 sel_items based varying char array level 2 dcl 2-3 set ref 160* 276 313 sel_length 000107 automatic fixed bin(35,0) dcl 68 in procedure "linus_lila_block" set ref 278* 293 sel_length 3 based fixed bin(35,0) level 2 in structure "mrds_block" dcl 6-3 in procedure "linus_lila_block" set ref 293* sel_offset 2 based fixed bin(35,0) level 2 in structure "mrds_block" dcl 6-3 in procedure "linus_lila_block" set ref 292* sel_offset 000106 automatic fixed bin(35,0) dcl 68 in procedure "linus_lila_block" set ref 274* 278 292 sel_tok_data 000132 automatic structure level 1 dcl 101 set ref 167* 217 source_array based char(1) array unaligned dcl 7-4 ref 174 190 384 384 source_str based char unaligned dcl 7-3 ref 173 187 382 src_ptr 10 based pointer level 2 dcl 4-3 ref 173 174 187 190 382 384 384 start parameter fixed bin(35,0) dcl 345 ref 340 379 381 382 388 388 393 str_len based fixed bin(17,0) level 2 dcl 105 set ref 248* 249 251 254 260 261 300 302 308 string 2 based varying char level 2 dcl 105 set ref 251* 254* 254 306 substr builtin function dcl 133 ref 173 187 382 td_ptr parameter pointer dcl 8-49 set ref 20 167 168 210* 213 217 219* 224 227 228* temp_thd 000120 automatic pointer dcl 84 set ref 308* 310 term_hd_ptr based pointer level 2 dcl 2-3 set ref 158* 280 283 318 321 322 324 327* term_op based fixed bin(17,0) level 2 dcl 2-3 set ref 152* thread based pointer level 2 dcl 105 set ref 249* 308 token_data based structure level 1 dcl 8-3 set ref 167 213 217* 224* tup_var 12 based varying char(32) array level 3 dcl 2-3 set ref 160* type based fixed bin(17,0) level 2 dcl 2-3 set ref 143 157* val_args 6 based structure array level 2 dcl 6-3 where_cur_pos 000111 automatic fixed bin(35,0) dcl 68 set ref 214* 225 where_tok_data 000160 automatic structure level 1 dcl 103 set ref 213* 224 work_area based area dcl 99 ref 151 248 289 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. AND internal static fixed bin(17,0) initial dcl 8-13 COL_SPEC internal static fixed bin(17,0) initial dcl 8-13 COMMA internal static fixed bin(17,0) initial dcl 8-13 CONST internal static fixed bin(17,0) initial dcl 8-13 DIFFER internal static fixed bin(17,0) initial dcl 8-13 DIV internal static fixed bin(17,0) initial dcl 8-13 DUP internal static fixed bin(17,0) initial dcl 8-13 EQ internal static fixed bin(17,0) initial dcl 8-13 FROM internal static fixed bin(17,0) initial dcl 8-13 GE internal static fixed bin(17,0) initial dcl 8-13 GT internal static fixed bin(17,0) initial dcl 8-13 INTER internal static fixed bin(17,0) initial dcl 8-13 LB internal static fixed bin(17,0) initial dcl 8-13 LE internal static fixed bin(17,0) initial dcl 8-13 LINUS_VAR internal static fixed bin(17,0) initial dcl 8-13 LP internal static fixed bin(17,0) initial dcl 8-13 LT internal static fixed bin(17,0) initial dcl 8-13 MINUS internal static fixed bin(17,0) initial dcl 8-13 NE internal static fixed bin(17,0) initial dcl 8-13 NOT internal static fixed bin(17,0) initial dcl 8-13 OR internal static fixed bin(17,0) initial dcl 8-13 PLUS internal static fixed bin(17,0) initial dcl 8-13 RB internal static fixed bin(17,0) initial dcl 8-13 ROW_DES internal static fixed bin(17,0) initial dcl 8-13 ROW_TAB_PAIR internal static fixed bin(17,0) initial dcl 8-13 RP internal static fixed bin(17,0) initial dcl 8-13 SCAL_FN internal static fixed bin(17,0) initial dcl 8-13 SELECT internal static fixed bin(17,0) initial dcl 8-13 SET_FN internal static fixed bin(17,0) initial dcl 8-13 STAR internal static fixed bin(17,0) initial dcl 8-13 TAB_NAME internal static fixed bin(17,0) initial dcl 8-13 UNION internal static fixed bin(17,0) initial dcl 8-13 UNIQUE internal static fixed bin(17,0) initial dcl 8-13 addr builtin function dcl 133 fixed builtin function dcl 133 rel builtin function dcl 133 sys_info$max_seg_size external static fixed bin(35,0) dcl 117 NAMES DECLARED BY EXPLICIT CONTEXT. exit 002475 constant label dcl 337 final_scan 003013 constant entry internal dcl 404 ref 199 202 linus_lila_block 000032 constant entry external dcl 20 scan_from 002476 constant entry internal dcl 340 ref 177 411 scan_kwd 002640 constant entry internal dcl 369 ref 347 349 353 357 361 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 3474 3540 3273 3504 Length 4150 3273 44 373 200 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME linus_lila_block 222 external procedure is an external procedure. scan_from internal procedure shares stack frame of external procedure linus_lila_block. scan_kwd internal procedure shares stack frame of external procedure linus_lila_block. final_scan internal procedure shares stack frame of external procedure linus_lila_block. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME linus_lila_block 000100 lsb_ptr linus_lila_block 000102 nval_args_init linus_lila_block 000103 ms_len_init linus_lila_block 000104 icode linus_lila_block 000105 cur_pos linus_lila_block 000106 sel_offset linus_lila_block 000107 sel_length linus_lila_block 000110 sel_cur_pos linus_lila_block 000111 where_cur_pos linus_lila_block 000112 i linus_lila_block 000113 j linus_lila_block 000114 hold_dflt_ri linus_lila_block 000116 rs_ptr linus_lila_block 000120 temp_thd linus_lila_block 000122 b_cnt linus_lila_block 000123 rs_len_init linus_lila_block 000124 rs_nargs_init linus_lila_block 000125 ind linus_lila_block 000126 arg_ind linus_lila_block 000127 found linus_lila_block 000130 inner linus_lila_block 000132 sel_tok_data linus_lila_block 000160 where_tok_data linus_lila_block 000224 from_pos scan_from 000225 i scan_from 000234 i scan_kwd 000235 j scan_kwd 000236 klen scan_kwd 000246 i final_scan 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 set_cs_eis index_cs_eis alloc_based THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. linus_lila_error linus_lila_from linus_lila_select linus_lila_where THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. linus_data_$max_pred_stack_size linus_data_$max_range_items linus_error_$no_from linus_lila_tokens_$differ linus_lila_tokens_$from linus_lila_tokens_$inter linus_lila_tokens_$union linus_lila_tokens_$where mrds_data_$max_select_items mrds_data_$max_token_size LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 20 000025 140 000037 141 000040 143 000044 144 000051 145 000053 146 000055 147 000073 148 000074 151 000075 152 000132 157 000166 158 000170 160 000220 162 000310 163 000316 164 000322 167 000325 168 000333 169 000335 170 000342 172 000343 173 000356 174 000405 177 000413 178 000415 179 000417 180 000421 181 000430 183 000431 184 000433 186 000444 187 000450 189 000477 190 000500 192 000507 193 000511 194 000515 195 000516 196 000520 198 000521 199 000522 201 000525 202 000534 204 000536 206 000537 209 000567 210 000574 211 000611 213 000640 214 000646 217 000652 218 000660 219 000664 220 000703 223 000732 224 000734 225 000742 227 000746 228 000754 229 000773 233 001022 235 001024 238 001041 241 001047 243 001054 244 001061 246 001067 248 001073 249 001122 250 001165 251 001166 252 001167 253 001170 254 001201 257 001274 259 001302 260 001303 261 001320 263 001326 265 001333 266 001337 267 001341 269 001343 270 001346 271 001351 272 001363 273 001372 274 001376 275 001402 276 001415 277 001440 278 001445 279 001454 280 001477 283 001533 286 001537 287 001540 289 001543 290 001572 291 001573 292 001575 293 001601 294 001603 295 001617 296 001640 297 001656 299 001712 300 001723 302 001747 304 001760 305 001765 306 001770 308 002011 309 002026 310 002030 311 002032 312 002053 313 002067 315 002163 316 002171 317 002214 318 002217 321 002313 322 002332 324 002375 326 002403 327 002410 329 002441 330 002444 331 002451 332 002452 333 002453 335 002473 337 002475 340 002476 347 002500 348 002516 349 002520 350 002536 353 002543 354 002561 357 002566 358 002604 361 002611 362 002627 367 002634 369 002640 377 002651 378 002652 379 002656 381 002661 382 002705 384 002727 388 002756 390 002771 391 002773 392 002774 393 003001 394 003003 395 003004 398 003007 404 003013 411 003015 412 003030 415 003040 416 003047 419 003051 ----------------------------------------------------------- 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