COMPILATION LISTING OF SEGMENT discard_output Compiled by: Multics PL/I Compiler, Release 27d, of October 11, 1982 Compiled at: Honeywell LISD Phoenix, System M Compiled on: 11/04/82 1837.8 mst Thu Options: optimize map 1 /* *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Information Systems Inc., 1982 * 4* * * 5* * Copyright (c) 1972 by Massachusetts Institute of * 6* * Technology and Honeywell Information Systems, Inc. * 7* * * 8* *********************************************************** */ 9 10 11 discard_output: 12 dco: 13 procedure options (variable); 14 15 /* This module implements the discard_output command, which discards the 16* output from specified I/O switches for the duration of a command line. 17* 18* Usage: 19* discard_output {-osw switch_name}... command_line 20* 21* */ 22 23 /* Steve Herbst 4/19/77 */ 24 25 26 dcl arg char (arg_len) based (arg_ptr); 27 dcl command_line char (cl_len) aligned based (cl_ptr); 28 dcl old_command_line char (old_cl_len) aligned based (old_cl_ptr); 29 dcl cl_space char (512) aligned init (""); 30 31 dcl command char (14) int static options (constant) init ("discard_output"); 32 dcl NL char (1) int static options (constant) init (" 33 "); 34 35 dcl area area based (area_ptr); 36 37 dcl cl_allocated bit (1); 38 39 dcl (area_ptr, discard_ptr) ptr init (null ()); 40 dcl (arg_list_ptr, arg_ptr, cl_ptr, iocb_ptr, old_cl_ptr) ptr; 41 42 dcl (arg_len, cl_len, command_len, old_cl_len) fixed bin (21); 43 dcl (arg_count, arg_index, iocb_limit, iocb_count, n_saved_iocbs, i) fixed bin; 44 dcl (code, cp_code) fixed bin (35); 45 46 dcl switch_name char (32); 47 dcl syn_attach_desc char (37); 48 49 dcl error_table_$badopt fixed bin (35) ext static; 50 dcl error_table_$not_attached fixed bin (35) ext static; 51 52 dcl com_err_ entry options (variable); 53 dcl cu_$arg_count entry (fixed bin); 54 dcl cu_$arg_list_ptr entry (ptr); 55 dcl cu_$arg_ptr_rel entry (fixed bin, ptr, fixed bin (21), fixed bin (35), ptr); 56 dcl cu_$cp entry (ptr, fixed bin (21), fixed bin (35)); 57 dcl get_system_free_area_ entry returns (ptr); 58 dcl iox_$attach_name entry (char (*), ptr, char (*), ptr, fixed bin (35)); 59 dcl iox_$attach_ptr entry (ptr, char (*), ptr, fixed bin (35)); 60 dcl iox_$close entry (ptr, fixed bin (35)); 61 dcl iox_$detach_iocb entry (ptr, fixed bin (35)); 62 dcl iox_$destroy_iocb entry (ptr, fixed bin (35)); 63 dcl iox_$error_output ptr ext; 64 dcl iox_$find_iocb entry (char (*), ptr, fixed bin (35)); 65 dcl iox_$look_iocb entry (char (*), ptr, fixed bin (35)); 66 dcl iox_$move_attach entry (ptr, ptr, fixed bin (35)); 67 dcl iox_$open entry (ptr, fixed bin, bit (1), fixed bin (35)); 68 dcl iox_$user_output ptr ext; 69 dcl unique_chars_ entry (bit (*)) returns (char (15)); 70 71 dcl (addr, divide, length, null, substr) builtin; 72 73 dcl cleanup condition; 74 1 1 /* Begin include file ..... iox_modes.incl.pl1 */ 1 2 1 3 /* Written by C. D. Tavares, 03/17/75 */ 1 4 /* Updated 10/31/77 by CDT to include short iox mode strings */ 1 5 1 6 dcl iox_modes (13) char (24) int static options (constant) aligned initial 1 7 ("stream_input", "stream_output", "stream_input_output", 1 8 "sequential_input", "sequential_output", "sequential_input_output", "sequential_update", 1 9 "keyed_sequential_input", "keyed_sequential_output", "keyed_sequential_update", 1 10 "direct_input", "direct_output", "direct_update"); 1 11 1 12 dcl short_iox_modes (13) char (4) int static options (constant) aligned initial 1 13 ("si", "so", "sio", "sqi", "sqo", "sqio", "squ", "ksqi", "ksqo", "ksqu", "di", "do", "du"); 1 14 1 15 dcl (Stream_input initial (1), 1 16 Stream_output initial (2), 1 17 Stream_input_output initial (3), 1 18 Sequential_input initial (4), 1 19 Sequential_output initial (5), 1 20 Sequential_input_output initial (6), 1 21 Sequential_update initial (7), 1 22 Keyed_sequential_input initial (8), 1 23 Keyed_sequential_output initial (9), 1 24 Keyed_sequential_update initial (10), 1 25 Direct_input initial (11), 1 26 Direct_output initial (12), 1 27 Direct_update initial (13)) fixed bin int static options (constant); 1 28 1 29 /* End include file ..... iox_modes.incl.pl1 */ 75 76 77 call cu_$arg_count (arg_count); 78 if arg_count = 0 then do; 79 USAGE: call com_err_ (0, command, 80 "Usage: discard_output {-osw switchname}... command_line"); 81 return; 82 end; 83 84 iocb_count, command_len = 0; 85 iocb_limit = divide (arg_count, 2, 17, 0)+1; 86 cl_ptr = addr (cl_space); 87 cl_len = length (cl_space); 88 cl_allocated = "0"b; 89 call cu_$arg_list_ptr (arg_list_ptr); 90 arg_index = 1; 91 92 begin; 93 94 dcl iocbp (iocb_limit) pointer; /* IOCB's to discard */ 95 dcl iocb_name (iocb_limit) char (32); /* names of the switches */ 96 dcl saved_iocb (iocb_limit) pointer; /* IOCB's of saved attachments */ 97 dcl was_detached (iocb_limit) bit (1) aligned; /* ON if switch was not attached to begin with */ 98 99 100 n_saved_iocbs = 0; /* haven't saved anything yet */ 101 on condition (cleanup) call clean_up; 102 103 NEXT_OS: call cu_$arg_ptr_rel (arg_index, arg_ptr, arg_len, code, arg_list_ptr); 104 if code ^= 0 then go to USAGE; 105 if substr (arg, 1, 1) = "-" then 106 if arg = "-osw" | arg = "-output_switch" then do; 107 call cu_$arg_ptr_rel (arg_index+1, arg_ptr, arg_len, code, arg_list_ptr); 108 if code ^= 0 then go to USAGE; 109 call iox_$look_iocb (arg, iocb_ptr, code); 110 if iocb_ptr = null () then do; 111 call com_err_ (code, command, "^a", arg); 112 return; 113 end; 114 iocb_count = iocb_count+1; 115 iocbp (iocb_count) = iocb_ptr; 116 iocb_name (iocb_count) = arg; 117 arg_index = arg_index+2; 118 go to NEXT_OS; 119 end; 120 else do; /* no other control args allowed */ 121 call com_err_ (error_table_$badopt, command, "^a", arg); 122 return; 123 end; 124 else call grow_command_line (); /* start of command line arguments */ 125 126 do arg_index = arg_index+1 to arg_count; /* pick up rest of command line */ 127 call cu_$arg_ptr_rel (arg_index, arg_ptr, arg_len, code, arg_list_ptr); 128 call grow_command_line (); 129 end; 130 131 if iocb_count = 0 then do; 132 iocb_count = 1; 133 iocbp (iocb_count) = iox_$user_output; /* default I/O switch */ 134 iocb_name (iocb_count) = "user_output"; 135 end; 136 137 138 /* Create a switch to use to discard output of specified switches */ 139 140 switch_name = "dco_" || unique_chars_ ("0"b); /* create name of switch */ 141 syn_attach_desc = "syn_ " || switch_name; /* and attach description for discarded switches */ 142 143 call iox_$attach_name (switch_name, discard_ptr, "discard_", null (), code); /* attempt to attach it */ 144 if code ^= 0 then do; 145 call com_err_ (code, command, "Attempting to attach ^a.", switch_name); 146 call clean_up; 147 return; 148 end; 149 150 call iox_$open (discard_ptr, Stream_output, "0"b, code); 151 if code ^= 0 then do; 152 call com_err_ (code, command, "Attempting to open ^a.", switch_name); 153 call clean_up (); 154 return; 155 end; 156 157 158 /* Save attachments of switches to be discarded and attach them to discard_ 159* switch */ 160 161 do i = 1 to iocb_count; 162 switch_name = "dco_save_" || unique_chars_ ("0"b); 163 call iox_$find_iocb (switch_name, saved_iocb (i), code); 164 if code ^= 0 then do; 165 call clean_up (); /* insure error_output is alright */ 166 call com_err_ (code, command, "^a", switch_name); 167 return; 168 end; 169 call iox_$move_attach (iocbp (i), saved_iocb (i), code); 170 if code = 0 171 then was_detached (i) = "0"b; /* have saved something */ 172 else if code = error_table_$not_attached 173 then was_detached (i) = "1"b; /* not attached */ 174 else do; 175 call clean_up (); 176 call com_err_ (code, command, "Saving attachment of ^a.", iocb_name (i)); 177 return; 178 end; 179 n_saved_iocbs = n_saved_iocbs + 1; /* have now saved the attachment */ 180 call iox_$attach_ptr (iocbp (i), syn_attach_desc, null (), code); /* attach to discard_ */ 181 if code ^= 0 then do; 182 call clean_up (); 183 call com_err_ (code, command, "Attaching ^a.", switch_name); 184 return; 185 end; 186 end; 187 188 189 /* Call the command processor */ 190 191 substr (command_line, command_len, 1) = NL; 192 193 call cu_$cp (addr (command_line), command_len, cp_code); 194 195 call clean_up (); 196 revert cleanup; 197 198 if (cp_code ^= 0) & (cp_code ^= 100) then do; /* have to print message? */ 199 do i = iocb_count by -1 to 1 while (iocbp (i) ^= iox_$error_output); end; 200 if i ^= 0 then call com_err_ (cp_code, command, "Returned by command_processor_."); 201 end; 202 203 204 grow_command_line: 205 procedure (); 206 207 /* This internal procedure adds arg to the end of command_line */ 208 209 if command_len + arg_len + 1 > cl_len then do; /* need more space */ 210 old_cl_ptr = cl_ptr; 211 old_cl_len = cl_len; 212 cl_len = 2 * cl_len; 213 if area_ptr = null () then area_ptr = get_system_free_area_ (); 214 allocate command_line in (area) set (cl_ptr); 215 command_line = old_command_line; 216 if cl_allocated then free old_cl_ptr -> command_line in (area); 217 else cl_allocated = "1"b; 218 end; 219 220 substr (command_line, command_len + 1) = arg; 221 command_len = command_len + arg_len + 1; 222 223 end grow_command_line; 224 225 226 clean_up: 227 procedure (); 228 229 /* This internal procedure restores attachments to their previous state */ 230 231 do i = 1 to n_saved_iocbs; /* restore each saved attachment */ 232 call iox_$detach_iocb (iocbp (i), code); /* detach it from discard_ */ 233 if was_detached (i) then; /* it was detached to start with */ 234 else call iox_$move_attach (saved_iocb (i), iocbp (i), code); 235 call iox_$destroy_iocb (saved_iocb (i), code); /* get rid of temp IOCB */ 236 end; 237 238 if discard_ptr ^= null () then do; /* get rid of discard_ IOCB */ 239 call iox_$close (discard_ptr, code); 240 call iox_$detach_iocb (discard_ptr, code); 241 call iox_$destroy_iocb (discard_ptr, code); 242 end; 243 244 if cl_allocated /* free copy of command line */ 245 then free command_line in (area); 246 247 end clean_up; 248 249 end; /* of begin block */ 250 251 end discard_output; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 11/04/82 1631.3 discard_output.pl1 >dumps>old>recomp>discard_output.pl1 75 1 02/02/78 1229.7 iox_modes.incl.pl1 >ldd>include>iox_modes.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. NL constant char(1) initial unaligned dcl 32 ref 191 Stream_output 000021 constant fixed bin(17,0) initial dcl 1-15 set ref 150* addr builtin function dcl 71 ref 86 193 193 area based area(1024) dcl 35 ref 214 216 244 area_ptr 000302 automatic pointer initial dcl 39 set ref 39* 213 213* 214 216 244 arg based char unaligned dcl 26 set ref 105 105 105 109* 111* 116 121* 220 arg_count 000324 automatic fixed bin(17,0) dcl 43 set ref 77* 78 85 126 arg_index 000325 automatic fixed bin(17,0) dcl 43 set ref 90* 103* 107 117* 117 126* 126* 127* arg_len 000320 automatic fixed bin(21,0) dcl 42 set ref 103* 105 105 105 107* 109 109 111 111 116 121 121 127* 209 220 221 arg_list_ptr 000306 automatic pointer dcl 40 set ref 89* 103* 107* 127* arg_ptr 000310 automatic pointer dcl 40 set ref 103* 105 105 105 107* 109 111 116 121 127* 220 cl_allocated 000300 automatic bit(1) unaligned dcl 37 set ref 88* 216 217* 244 cl_len 000321 automatic fixed bin(21,0) dcl 42 set ref 87* 191 193 193 209 211 212* 212 214 214 215 216 216 220 244 244 cl_ptr 000312 automatic pointer dcl 40 set ref 86* 191 193 193 210 214* 215 220 244 cl_space 000100 automatic char(512) initial dcl 29 set ref 29* 86 87 cleanup 000000 stack reference condition dcl 73 ref 101 196 code 000332 automatic fixed bin(35,0) dcl 44 set ref 103* 104 107* 108 109* 111* 127* 143* 144 145* 150* 151 152* 163* 164 166* 169* 170 172 176* 180* 181 183* 232* 234* 235* 239* 240* 241* com_err_ 000014 constant entry external dcl 52 ref 79 111 121 145 152 166 176 183 200 command 000000 constant char(14) initial unaligned dcl 31 set ref 79* 111* 121* 145* 152* 166* 176* 183* 200* command_len 000322 automatic fixed bin(21,0) dcl 42 set ref 84* 191 193* 209 220 221* 221 command_line based char dcl 27 set ref 191* 193 193 214 215* 216 220* 244 cp_code 000333 automatic fixed bin(35,0) dcl 44 set ref 193* 198 198 200* cu_$arg_count 000016 constant entry external dcl 53 ref 77 cu_$arg_list_ptr 000020 constant entry external dcl 54 ref 89 cu_$arg_ptr_rel 000022 constant entry external dcl 55 ref 103 107 127 cu_$cp 000024 constant entry external dcl 56 ref 193 discard_ptr 000304 automatic pointer initial dcl 39 set ref 39* 143* 150* 238 239* 240* 241* divide builtin function dcl 71 ref 85 error_table_$badopt 000010 external static fixed bin(35,0) dcl 49 set ref 121* error_table_$not_attached 000012 external static fixed bin(35,0) dcl 50 ref 172 get_system_free_area_ 000026 constant entry external dcl 57 ref 213 i 000331 automatic fixed bin(17,0) dcl 43 set ref 161* 163 169 169 170 172 176 180* 199* 199* 200 231* 232 233 234 234 235* iocb_count 000327 automatic fixed bin(17,0) dcl 43 set ref 84* 114* 114 115 116 131 132* 133 134 161 199 iocb_limit 000326 automatic fixed bin(17,0) dcl 43 set ref 85* 94 95 96 97 iocb_name 000100 automatic char(32) array unaligned dcl 95 set ref 116* 134* 176* iocb_ptr 000314 automatic pointer dcl 40 set ref 109* 110 115 iocbp 000100 automatic pointer array dcl 94 set ref 115* 133* 169* 180* 199 232* 234* iox_$attach_name 000030 constant entry external dcl 58 ref 143 iox_$attach_ptr 000032 constant entry external dcl 59 ref 180 iox_$close 000034 constant entry external dcl 60 ref 239 iox_$destroy_iocb 000040 constant entry external dcl 62 ref 235 241 iox_$detach_iocb 000036 constant entry external dcl 61 ref 232 240 iox_$error_output 000042 external static pointer dcl 63 ref 199 iox_$find_iocb 000044 constant entry external dcl 64 ref 163 iox_$look_iocb 000046 constant entry external dcl 65 ref 109 iox_$move_attach 000050 constant entry external dcl 66 ref 169 234 iox_$open 000052 constant entry external dcl 67 ref 150 iox_$user_output 000054 external static pointer dcl 68 ref 133 length builtin function dcl 71 ref 87 n_saved_iocbs 000330 automatic fixed bin(17,0) dcl 43 set ref 100* 179* 179 231 null builtin function dcl 71 ref 39 39 110 143 143 180 180 213 238 old_cl_len 000323 automatic fixed bin(21,0) dcl 42 set ref 211* 215 old_cl_ptr 000316 automatic pointer dcl 40 set ref 210* 215 216 old_command_line based char dcl 28 ref 215 saved_iocb 000100 automatic pointer array dcl 96 set ref 163* 169* 234* 235* substr builtin function dcl 71 set ref 105 191* 220* switch_name 000334 automatic char(32) unaligned dcl 46 set ref 140* 141 143* 145* 152* 162* 163* 166* 183* syn_attach_desc 000344 automatic char(37) unaligned dcl 47 set ref 141* 180* unique_chars_ 000056 constant entry external dcl 69 ref 140 162 was_detached 000100 automatic bit(1) array dcl 97 set ref 170* 172* 233 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. Direct_input internal static fixed bin(17,0) initial dcl 1-15 Direct_output internal static fixed bin(17,0) initial dcl 1-15 Direct_update internal static fixed bin(17,0) initial dcl 1-15 Keyed_sequential_input internal static fixed bin(17,0) initial dcl 1-15 Keyed_sequential_output internal static fixed bin(17,0) initial dcl 1-15 Keyed_sequential_update internal static fixed bin(17,0) initial dcl 1-15 Sequential_input internal static fixed bin(17,0) initial dcl 1-15 Sequential_input_output internal static fixed bin(17,0) initial dcl 1-15 Sequential_output internal static fixed bin(17,0) initial dcl 1-15 Sequential_update internal static fixed bin(17,0) initial dcl 1-15 Stream_input internal static fixed bin(17,0) initial dcl 1-15 Stream_input_output internal static fixed bin(17,0) initial dcl 1-15 iox_modes internal static char(24) initial array dcl 1-6 short_iox_modes internal static char(4) initial array dcl 1-12 NAMES DECLARED BY EXPLICIT CONTEXT. NEXT_OS 000323 constant label dcl 103 ref 118 USAGE 000167 constant label dcl 79 ref 104 108 clean_up 001637 constant entry internal dcl 226 ref 101 146 153 165 175 182 195 dco 000140 constant entry external dcl 11 discard_output 000150 constant entry external dcl 11 grow_command_line 001534 constant entry internal dcl 204 ref 124 128 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2274 2354 2024 2304 Length 2604 2024 60 214 247 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME dco 272 external procedure is an external procedure. begin block on line 92 174 begin block uses auto adjustable storage, and enables or reverts conditions. on unit on line 101 64 on unit grow_command_line internal procedure shares stack frame of begin block on line 92. clean_up 80 internal procedure is called by several nonquick procedures. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME begin block on line 92 000100 was_detached begin block on line 92 000100 iocb_name begin block on line 92 000100 saved_iocb begin block on line 92 000100 iocbp begin block on line 92 dco 000100 cl_space dco 000300 cl_allocated dco 000302 area_ptr dco 000304 discard_ptr dco 000306 arg_list_ptr dco 000310 arg_ptr dco 000312 cl_ptr dco 000314 iocb_ptr dco 000316 old_cl_ptr dco 000320 arg_len dco 000321 cl_len dco 000322 command_len dco 000323 old_cl_len dco 000324 arg_count dco 000325 arg_index dco 000326 iocb_limit dco 000327 iocb_count dco 000330 n_saved_iocbs dco 000331 i dco 000332 code dco 000333 cp_code dco 000334 switch_name dco 000344 syn_attach_desc dco 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 call_int_other begin_return return tra_ext alloc_auto_adj enable shorten_stack ext_entry int_entry alloc_based free_based THE FOLLOWING EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. com_err_ cu_$arg_count cu_$arg_list_ptr cu_$arg_ptr_rel cu_$cp get_system_free_area_ iox_$attach_name iox_$attach_ptr iox_$close iox_$destroy_iocb iox_$detach_iocb iox_$find_iocb iox_$look_iocb iox_$move_attach iox_$open unique_chars_ THE FOLLOWING EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. error_table_$badopt error_table_$not_attached iox_$error_output iox_$user_output LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 29 000127 39 000132 11 000137 77 000156 78 000165 79 000167 81 000214 84 000215 85 000217 86 000222 87 000224 88 000226 89 000227 90 000236 92 000240 94 000243 95 000252 96 000260 97 000266 163 000272 176 000274 180 000276 100 000300 101 000301 103 000323 104 000343 105 000351 107 000370 108 000412 109 000420 110 000445 111 000452 112 000504 114 000506 115 000507 116 000514 117 000525 118 000527 121 000530 122 000562 124 000564 126 000565 127 000575 128 000614 129 000615 131 000620 132 000622 133 000624 134 000632 140 000641 141 000674 143 000710 144 000745 145 000750 146 001003 147 001007 150 001011 151 001030 152 001033 153 001066 154 001072 161 001074 162 001104 163 001137 164 001164 165 001167 166 001173 167 001223 169 001225 170 001244 172 001253 175 001263 176 001267 177 001326 179 001330 180 001331 181 001363 182 001366 183 001372 184 001424 186 001426 191 001430 193 001435 195 001452 196 001456 198 001457 199 001464 199 001501 200 001504 249 001532 204 001534 209 001535 210 001543 211 001545 212 001547 213 001551 214 001564 215 001575 216 001603 217 001613 220 001615 221 001631 223 001635 226 001636 231 001644 232 001657 233 001673 234 001703 235 001722 236 001741 238 001745 239 001751 240 001762 241 001775 244 002010 247 002021 251 002022 ----------------------------------------------------------- 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