COMPILATION LISTING OF SEGMENT tc_screen Compiled by: Multics PL/I Compiler, Release 29, of July 28, 1986 Compiled at: Honeywell Bull, Phx. Az., Sys-M Compiled on: 08/13/87 1329.1 mst Thu Options: optimize map 1 /****^ *********************************************************** 2* * * 3* * Copyright, (C) Honeywell Bull Inc., 1987 * 4* * * 5* * Copyright, (C) Honeywell Information Systems Inc., 1981 * 6* * * 7* * Copyright (c) 1972 by Massachusetts Institute of * 8* * Technology and Honeywell Information Systems, Inc. * 9* * * 10* *********************************************************** */ 11 12 13 /* Terminal Control Screen Image Management */ 14 /* format: style2,linecom,^indnoniterdo,indcomtxt,^inditerdo,dclind5,idind25 */ 15 tc_screen: 16 procedure; 17 return; 18 19 /* Coded June 1981 by, Benson I. Margulies, because I had no choice. */ 20 21 declare ( 22 Screen_data_ptr pointer, 23 Operation fixed bin, 24 Op_row fixed bin, 25 Op_col fixed bin, 26 Op_count fixed bin, 27 Text character (*), 28 Insert bit (1) aligned, 29 Rows fixed bin, 30 Columns fixed bin 31 ) parameter; 32 33 34 /* a virtual video terminal, more or less. Insert mode 35* is replaced with extra entrypoints to simplify things. */ 36 37 1 1 /* BEGIN INCLUDE FILE... tty_video_tables.incl.pl1 */ 1 2 /* Created: 3 June 1979 by Bernard S. Greenberg */ 1 3 /* Modified: 9 June 1981 by G. Palter to switch to line/column orientation */ 1 4 1 5 /* Definition of the video operations supported by a terminal */ 1 6 1 7 dcl tty_video_tables_version_1 fixed binary static options (constant) initial (1); 1 8 1 9 dcl ttyvtblp pointer; 1 10 dcl tty_video_table_video_chars_len fixed binary (21); 1 11 1 12 dcl 1 tty_video_table aligned based (ttyvtblp), 1 13 2 version fixed binary initial (tty_video_tables_version_1), 1 14 2 screen_height fixed binary, /* # of lines on screen */ 1 15 2 screen_line_length fixed binary, /* # of characters on a line */ 1 16 2 scroll_count fixed binary, /* # of lines scrolled by LF at bottom */ 1 17 2 flags, 1 18 3 overstrike_available bit (1) unaligned, /* ON => overstrike works */ 1 19 3 automatic_crlf bit (1) unaligned, /* ON => automatically goes to next line from last column */ 1 20 3 simulate_eol bit (1) unaligned, /* ON => program must simulate clear-to-end-of-line */ 1 21 3 pad bit (33) unaligned, 1 22 2 video_chars_len fixed binary (21), /* combined length of all sequences used */ 1 23 2 pad (2) bit (36), 1 24 2 nseq fixed binary, /* # of video sequences defined */ 1 25 2 sequences (N_VIDEO_SEQUENCES refer (tty_video_table.nseq)) like tty_video_seq aligned, 1 26 /* the control sequences */ 1 27 2 video_chars character (tty_video_table_video_chars_len refer (tty_video_table.video_chars_len)) unaligned; 1 28 1 29 dcl video_chars_ptr pointer; /* -> tty_video_table.video_chars */ 1 30 dcl video_chars character (tty_video_table.video_chars_len) based (video_chars_ptr); 1 31 1 32 1 33 /* A single video sequence: it may contain encoded screen coordinates or a repeat counter */ 1 34 1 35 dcl ttyvseqp pointer; 1 36 1 37 dcl 1 tty_video_seq based (ttyvseqp) aligned, 1 38 2 flags unaligned, /* first 2 characters */ 1 39 3 present bit (1) unaligned, /* ON => this feature is present */ 1 40 3 interpret bit (1) unaligned, /* ON => sequence contains encoded coordinates/repeat count */ 1 41 3 able_to_repeat bit (1) unaligned, /* ON => sequence contains a repeat count */ 1 42 3 cpad_present bit (1) unaligned, /* ON => this operation must be padded */ 1 43 3 cpad_in_chars bit (1) unaligned, /* ON => pad expressed in characters */ 1 44 3 pad bit (7) unaligned, 1 45 3 general bit (6) unaligned, /* reserved for per-operation flags */ 1 46 2 cpad fixed binary (18) unsigned unaligned, /* padding in characters of .1 millisecond units */ 1 47 2 pad bit (15) unal, 1 48 2 len fixed binary (9) unsigned unaligned, /* # of valid characters in sequence */ 1 49 2 seq_index fixed binary (12) unsigned unaligned; /* start of string in character data */ 1 50 1 51 1 52 /* Available operations */ 1 53 1 54 dcl (ABS_POS initial (1), CLEAR_SCREEN initial (2), 1 55 CLEAR_TO_EOS initial (3), HOME initial (4), 1 56 CLEAR_TO_EOL initial (5), CURSOR_UP initial (6), 1 57 CURSOR_RIGHT initial (7), CURSOR_DOWN initial (8), 1 58 CURSOR_LEFT initial (9), INSERT_CHARS initial (10), 1 59 END_INSERT_CHARS /* if not present, insert-chars opens up N spaces */ 1 60 initial (11), DELETE_CHARS initial (12), 1 61 INSERT_LINES initial (13), DELETE_LINES initial (14)) 1 62 fixed binary static options (constant); 1 63 1 64 dcl N_VIDEO_SEQUENCES fixed binary static options (constant) initial (14); 1 65 1 66 1 67 /* Encoding of special values (eg: coordinates or the repeat count) */ 1 68 1 69 dcl 1 tty_numeric_encoding based unaligned, 1 70 2 flags, 1 71 3 must_be_on bit (1) unaligned, /* ON => an encoding; not a character */ 1 72 3 express_in_decimal bit (1) unaligned, /* ON => express it as decimal digits */ 1 73 3 express_in_octal bit (1) unaligned, /* ON => express it as octal digits; both OFF => in binary */ 1 74 1 75 3 offset_is_0 bit (1) unaligned, /* ON => offset is not stored as it's zero */ 1 76 2 l_c_or_n fixed binary (2) unsigned unaligned, /* 0 = line, 1= column, 2 = repeat-count */ 1 77 2 num_digits fixed bin (2) unsigned unaligned, /* # of digits for decimal/octal; 0 => as many as needed */ 1 78 2 pad bit (1) unaligned, 1 79 2 offset fixed bin (8) unaligned; /* offset to add to the number */ 1 80 1 81 /* END INCLUDE FILE tty_video_tables.incl.pl1 */ 38 39 2 1 /* Begin include file tc_screen_image.incl.pl1 BIM Sept 81 */ 2 2 /* format: style3 */ 2 3 2 4 declare 1 screen aligned based (screen_ptr), 2 5 2 n_lines fixed bin, 2 6 2 n_columns fixed bin, 2 7 2 is_clear bit (1) aligned, /* opt */ 2 8 2 lines (screen_n_lines refer (screen.n_lines)) 2 9 character (screen_n_columns refer (screen.n_columns)) unaligned; 2 10 2 11 2 12 declare screen_ptr pointer; 2 13 declare (screen_n_lines, screen_n_columns) 2 14 fixed bin; 2 15 2 16 /* End include file tc_screen_image.incl.pl1 */ 40 41 42 declare (length, string, substr) builtin; 43 declare discovered_clear_screen bit (1) aligned; 44 declare line fixed bin; 45 46 47 init: 48 entry (Screen_data_ptr, Rows, Columns); 49 50 screen_n_lines = Rows; 51 screen_n_columns = Columns; 52 allocate screen; 53 54 string (screen.lines (*)) = ""; 55 screen.is_clear = "1"b; 56 Screen_data_ptr = screen_ptr; 57 58 return; 59 60 61 shut: 62 entry (Screen_data_ptr); 63 64 free Screen_data_ptr -> screen; 65 return; 66 67 68 operation: 69 entry (Screen_data_ptr, Operation, Op_row, Op_col, Op_count); 70 71 screen_ptr = Screen_data_ptr; 72 73 go to OPERATION (Operation); 74 75 OPERATION (0): /* ERROR */ 76 OPERATION (1): /* POSITION CURSOR */ 77 OPERATION (4): /* HOME */ 78 OPERATION (10): /* INSERT_CHARS */ 79 OPERATION (11): /* END INSERT CHARS */ 80 OPERATION (6): /* UP, down, etc. */ 81 OPERATION (7): 82 OPERATION (8): 83 OPERATION (9): 84 return; 85 86 87 OPERATION (2): /* Clear screen */ 88 string (screen.lines (*)) = ""; 89 screen.is_clear = "1"b; 90 return; 91 92 OPERATION (3): /* clear to EOS */ 93 /* too hard to check for is_clear */ 94 substr (screen.lines (Op_row), Op_col) = ""; 95 if Op_row < screen.n_lines 96 then begin; 97 declare lines (screen.n_lines - Op_row) character (screen.n_columns) 98 defined (screen.lines (Op_row + 1)); 99 lines (*) = ""; 100 end; 101 return; 102 103 OPERATION (12): /* DELETE CHARS */ 104 if screen.is_clear 105 then return; 106 substr (screen.lines (Op_row), Op_col) = substr (screen.lines (Op_row), Op_col + Op_count); 107 return; 108 109 OPERATION (13): /* INSERT LINES */ 110 if screen.is_clear 111 then return; 112 begin; 113 declare new_home (screen.n_lines - Op_row + 1 - Op_count) 114 character (screen.n_columns) defined (screen.lines (Op_row + Op_count)); 115 declare old_stuff (screen.n_lines - Op_row + 1 - Op_count) 116 character (screen.n_columns) defined (screen.lines (Op_row)); 117 declare to_blank (Op_count) character (screen.n_columns) defined (screen.lines (Op_row)); 118 119 120 new_home = old_stuff; 121 to_blank = ""; 122 123 124 end; 125 return; 126 127 OPERATION (14): /* DELETE LINES */ 128 if screen.is_clear 129 then return; 130 begin; 131 declare old_stuff (screen.n_lines - Op_row + 1 - Op_count) 132 character (screen.n_columns) defined (screen.lines (Op_row + Op_count)); 133 declare new_home (screen.n_lines - Op_row + 1 - Op_count) 134 character (screen.n_columns) defined (screen.lines (Op_row)); 135 declare to_blank (Op_count) character (screen.n_columns) 136 defined (screen.lines (screen.n_lines - Op_count + 1)); 137 138 139 new_home = old_stuff; 140 to_blank = ""; 141 142 end; 143 return; 144 145 OPERATION (5): /* EOL */ 146 if screen.is_clear 147 then return; 148 if Op_row <= screen.n_lines 149 then substr (screen.lines (Op_row), Op_col) = ""; 150 else signal SCREEN_ERROR_; 151 declare SCREEN_ERROR_ condition; 152 return; 153 154 text: 155 entry (Screen_data_ptr, Op_row, Op_col, Insert, Text); 156 157 screen_ptr = Screen_data_ptr; 158 if length (Text) = 0 159 then return; 160 if Text ^= "" 161 then screen.is_clear = "0"b; 162 163 begin; 164 declare line character (screen.n_columns) defined (screen.lines (Op_row)); 165 if ^Insert 166 then substr (line, Op_col, length (Text)) = Text; 167 else do; 168 (nostringsize): /* whatever the prefix */ 169 substr (line, Op_col + length (Text)) = substr (line, Op_col); 170 /* would take stringsize */ 171 substr (line, Op_col, length (Text)) = Text; 172 end; 173 end; 174 return; 175 176 clear_in_line: 177 entry (Screen_data_ptr, Op_row, Op_col, Op_count); 178 179 screen_ptr = Screen_data_ptr; 180 if screen.is_clear 181 then return; 182 183 substr (screen.lines (Op_row), Op_col, Op_count) = ""; 184 return; 185 186 get_in_line: 187 entry (Screen_data_ptr, Op_row, Op_col, Text); 188 189 screen_ptr = Screen_data_ptr; 190 if screen.is_clear 191 then Text = ""; 192 else Text = substr (screen.lines (Op_row), Op_col); 193 return; 194 195 may_echo_negotiate: 196 entry (Screen_data_ptr, Op_row, Op_col) returns (bit (1) aligned); 197 198 screen_ptr = Screen_data_ptr; 199 200 if screen.is_clear 201 then return ("1"b); 202 203 return (substr (screen.lines (Op_row), Op_col + 1) = ""); 204 205 is_region_clear: 206 entry (Screen_data_ptr, Op_row, Op_col, Rows, Columns) returns (bit (1) aligned); 207 208 screen_ptr = Screen_data_ptr; 209 if screen.is_clear 210 then return ("1"b); 211 212 /* Case statement for efficiency */ 213 /* though Isub defining could probably do it in one nasty dcl */ 214 215 if Op_col = 1 /* start at origin */ 216 & Op_row = 1 /* ditto */ 217 & Rows = screen.n_lines /* all the way down */ 218 & Columns = screen.n_columns /* and across */ 219 then return (is_the_screen_clear ()); 220 221 if Rows > 4 /* just a heuristic for cost */ 222 then if is_the_screen_clear () /* perhaps the screen is empty? */ 223 then return ("1"b); 224 225 /* we have to look at a region */ 226 227 do line = Op_row to Op_row + Rows - 1; 228 if substr (screen.lines (line), Op_col, Columns) ^= "" 229 then return ("0"b); 230 end; 231 return ("1"b); 232 233 is_the_screen_clear: /* interrogate screen.is_clear FIRST */ 234 procedure returns (bit (1) aligned); 235 236 if string (screen.lines (*)) = "" 237 then do; 238 screen.is_clear = "1"b; 239 return ("1"b); 240 end; 241 else return ("0"b); 242 end is_the_screen_clear; 243 244 end tc_screen; SOURCE FILES USED IN THIS COMPILATION. LINE NUMBER DATE MODIFIED NAME PATHNAME 0 08/13/87 1323.6 tc_screen.pl1 >special_ldd>install>MR12.1-1086>tc_screen.pl1 38 1 08/11/81 1106.2 tty_video_tables.incl.pl1 >ldd>include>tty_video_tables.incl.pl1 40 2 03/27/82 0424.8 tc_screen_image.incl.pl1 >ldd>include>tc_screen_image.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. Columns parameter fixed bin(17,0) dcl 21 ref 47 51 205 215 228 Insert parameter bit(1) dcl 21 ref 154 165 Op_col parameter fixed bin(17,0) dcl 21 ref 68 92 106 106 148 154 165 168 168 171 176 183 186 192 195 203 205 215 228 Op_count parameter fixed bin(17,0) dcl 21 ref 68 106 113 115 117 120 131 133 135 139 140 176 183 Op_row parameter fixed bin(17,0) dcl 21 ref 68 92 95 97 99 106 106 113 115 120 120 121 131 133 139 139 148 148 154 165 168 168 171 176 183 186 192 195 203 205 215 227 227 Operation parameter fixed bin(17,0) dcl 21 ref 68 73 Rows parameter fixed bin(17,0) dcl 21 ref 47 50 205 215 221 227 SCREEN_ERROR_ 000106 stack reference condition dcl 151 ref 150 Screen_data_ptr parameter pointer dcl 21 set ref 47 56* 61 64 68 71 154 157 176 179 186 189 195 198 205 208 Text parameter char unaligned dcl 21 set ref 154 158 160 165 165 168 171 171 186 190* 192* is_clear 2 based bit(1) level 2 dcl 2-4 set ref 55* 89* 103 109 127 145 160* 180 190 200 209 238* length builtin function dcl 42 ref 158 165 168 171 line defined char unaligned dcl 164 in begin block on line 163 set ref 165* 168* 168 171* line 000104 automatic fixed bin(17,0) dcl 44 in procedure "tc_screen" set ref 227* 228* lines 3 based char array level 2 in structure "screen" packed unaligned dcl 2-4 in procedure "tc_screen" set ref 54* 87* 92* 99 99 106* 106 120 120 120 120 121 121 139 139 139 139 140 140 148* 165 165 168 168 168 168 171 171 183* 192 203 228 236 lines defined char array unaligned dcl 97 in begin block on line 95 set ref 99* n_columns 1 based fixed bin(17,0) level 2 dcl 2-4 set ref 52* 54 64 87 92 92 92 97 99 99 99 106 106 106 106 106 106 113 115 117 120 120 120 120 120 120 121 121 121 131 133 135 139 139 139 139 139 139 140 140 140 148 148 148 164 165 165 165 168 168 168 168 168 168 171 171 171 183 183 183 192 192 192 203 203 203 215 228 228 228 236 n_lines based fixed bin(17,0) level 2 dcl 2-4 set ref 52* 54 64 87 95 97 113 115 131 133 140 148 215 236 new_home defined char array unaligned dcl 133 in begin block on line 130 set ref 139* new_home defined char array unaligned dcl 113 in begin block on line 112 set ref 120* old_stuff defined char array unaligned dcl 131 in begin block on line 130 ref 139 old_stuff defined char array unaligned dcl 115 in begin block on line 112 ref 120 screen based structure level 1 dcl 2-4 set ref 52 64 screen_n_columns 000103 automatic fixed bin(17,0) dcl 2-13 set ref 51* 52 52 screen_n_lines 000102 automatic fixed bin(17,0) dcl 2-13 set ref 50* 52 52 screen_ptr 000100 automatic pointer dcl 2-12 set ref 52* 54 55 56 71* 87 89 92 95 97 97 99 103 106 106 109 113 113 115 115 117 120 120 121 127 131 131 133 133 135 139 139 140 140 145 148 148 157* 160 164 165 168 168 171 179* 180 183 189* 190 192 198* 200 203 208* 209 215 215 228 236 238 string builtin function dcl 42 set ref 54* 87* 236 substr builtin function dcl 42 set ref 92* 106* 106 148* 165* 168* 168 171* 183* 192 203 228 to_blank defined char array unaligned dcl 117 in begin block on line 112 set ref 121* to_blank defined char array unaligned dcl 135 in begin block on line 130 set ref 140* tty_video_seq based structure level 1 dcl 1-37 NAMES DECLARED BY DECLARE STATEMENT AND NEVER REFERENCED. ABS_POS internal static fixed bin(17,0) initial dcl 1-54 CLEAR_SCREEN internal static fixed bin(17,0) initial dcl 1-54 CLEAR_TO_EOL internal static fixed bin(17,0) initial dcl 1-54 CLEAR_TO_EOS internal static fixed bin(17,0) initial dcl 1-54 CURSOR_DOWN internal static fixed bin(17,0) initial dcl 1-54 CURSOR_LEFT internal static fixed bin(17,0) initial dcl 1-54 CURSOR_RIGHT internal static fixed bin(17,0) initial dcl 1-54 CURSOR_UP internal static fixed bin(17,0) initial dcl 1-54 DELETE_CHARS internal static fixed bin(17,0) initial dcl 1-54 DELETE_LINES internal static fixed bin(17,0) initial dcl 1-54 END_INSERT_CHARS internal static fixed bin(17,0) initial dcl 1-54 HOME internal static fixed bin(17,0) initial dcl 1-54 INSERT_CHARS internal static fixed bin(17,0) initial dcl 1-54 INSERT_LINES internal static fixed bin(17,0) initial dcl 1-54 N_VIDEO_SEQUENCES internal static fixed bin(17,0) initial dcl 1-64 discovered_clear_screen automatic bit(1) dcl 43 tty_numeric_encoding based structure level 1 packed unaligned dcl 1-69 tty_video_table based structure level 1 dcl 1-12 tty_video_table_video_chars_len automatic fixed bin(21,0) dcl 1-10 tty_video_tables_version_1 internal static fixed bin(17,0) initial dcl 1-7 ttyvseqp automatic pointer dcl 1-35 ttyvtblp automatic pointer dcl 1-9 video_chars based char unaligned dcl 1-30 video_chars_ptr automatic pointer dcl 1-29 NAMES DECLARED BY EXPLICIT CONTEXT. OPERATION 000000 constant label array(0:14) dcl 75 set ref 73 clear_in_line 001253 constant entry external dcl 176 get_in_line 001335 constant entry external dcl 186 init 000057 constant entry external dcl 47 is_region_clear 001527 constant entry external dcl 205 is_the_screen_clear 001711 constant entry internal dcl 233 ref 215 221 may_echo_negotiate 001440 constant entry external dcl 195 operation 000201 constant entry external dcl 68 shut 000142 constant entry external dcl 61 tc_screen 000036 constant entry external dcl 15 text 001064 constant entry external dcl 154 THERE WERE NO NAMES DECLARED BY CONTEXT OR IMPLICATION. STORAGE REQUIREMENTS FOR THIS PROGRAM. Object Text Link Symbol Defs Static Start 0 0 2046 2056 1740 2056 Length 2276 1740 10 204 105 0 BLOCK NAME STACK SIZE TYPE WHY NONQUICK/WHO SHARES STACK FRAME tc_screen 140 external procedure is an external procedure. begin block on line 95 begin block shares stack frame of external procedure tc_screen. begin block on line 112 begin block shares stack frame of external procedure tc_screen. begin block on line 130 begin block shares stack frame of external procedure tc_screen. begin block on line 163 begin block shares stack frame of external procedure tc_screen. is_the_screen_clear internal procedure shares stack frame of external procedure tc_screen. STORAGE FOR AUTOMATIC VARIABLES. STACK FRAME LOC IDENTIFIER BLOCK NAME tc_screen 000100 screen_ptr tc_screen 000102 screen_n_lines tc_screen 000103 screen_n_columns tc_screen 000104 line tc_screen THE FOLLOWING EXTERNAL OPERATORS ARE USED BY THIS PROGRAM. r_e_as alloc_temp return_mac bound_ck_signal signal_op shorten_stack ext_entry ext_entry_desc alloc_storage op_freen_ NO EXTERNAL ENTRIES ARE CALLED BY THIS PROGRAM. NO EXTERNAL VARIABLES ARE USED BY THIS PROGRAM. LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC LINE LOC 15 000035 17 000045 47 000053 50 000073 51 000075 52 000077 54 000115 55 000124 56 000126 58 000130 61 000137 64 000151 65 000165 68 000174 71 000217 73 000223 75 000225 87 000234 89 000244 90 000246 92 000255 95 000273 97 000276 99 000304 101 000326 103 000335 106 000346 107 000405 109 000414 113 000425 115 000436 117 000443 120 000447 121 000557 125 000603 127 000612 131 000623 133 000634 135 000641 139 000645 140 000756 143 001003 145 001012 148 001023 150 001045 152 001050 154 001057 157 001105 158 001111 160 001126 164 001134 165 001137 168 001165 171 001231 174 001237 176 001246 179 001271 180 001275 183 001306 184 001321 186 001330 189 001356 190 001362 192 001375 193 001424 195 001433 198 001455 200 001461 203 001474 205 001521 208 001550 209 001554 215 001567 221 001617 227 001640 228 001651 230 001676 231 001700 233 001711 236 001713 238 001725 239 001727 241 001731 ----------------------------------------------------------- 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