Did another measurement, when 2 frames are open and xemacs goes into "hog"-mode. Process PID TID Total Kernel User Shared Other ======= === === ===== ====== ==== ====== ===== wait 8196 8197 72,43 72,43 0,00 0,00 0,00 usr/local/bin/xemacs 303342 696425 24,03 1,70 20,21 2,12 0,00 /usr/local/bin/gdb 274524 602237 2,20 0,59 1,16 0,45 0,00 /usr/local/bin/top 221352 631039 0,42 0,36 0,04 0,01 0,00 /usr/sbin/syncd 102464 163921 0,23 0,23 0,00 0,00 0,00 usr/local/bin/xemacs 286896 733359 0,17 0,16 0,01 0,00 0,00 usr/local/bin/xemacs 327716 688307 0,16 0,16 0,00 0,00 0,00 m-aix5.2.0.0/gnuserv 286896 733359 0,10 0,10 0,00 0,00 0,00 /usr/bin/bash 303342 696425 0,04 0,03 0,00 0,01 0,00 /usr/bin/tprof 258278 667747 0,03 0,00 0,00 0,03 0,00 /opt/freeware/bin/ls 327716 688307 0,03 0,03 0,00 0,00 0,00 /usr/sbin/aixmibd 168026 254085 0,01 0,01 0,00 0,00 0,00 /usr/sbin/syncd 102464 151633 0,01 0,01 0,00 0,00 0,00 /usr/sbin/syncd 102464 159823 0,01 0,01 0,00 0,00 0,00 /usr/bin/tprof 274524 602237 0,01 0,01 0,00 0,00 0,00 /usr/bin/trcstop 274526 602239 0,01 0,01 0,00 0,00 0,00 /usr/bin/tprof 274526 602239 0,01 0,01 0,00 0,00 0,00 PID-1 -1 598115 0,01 0,01 0,00 0,00 0,00 gil 40980 53275 0,01 0,01 0,00 0,00 0,00 j2pg 65570 110647 0,01 0,01 0,00 0,00 0,00 nfsd 204900 299155 0,01 0,01 0,00 0,00 0,00 rpc.lockd 213114 344233 0,01 0,01 0,00 0,00 0,00 ======= === === ===== ====== ==== ====== ===== Total 100,00 75,95 21,42 2,63 0,00 Total Samples = 6924 Total Elapsed Time = 69,26s Total % For All Processes (USER) = 21,42 User Process % ============= ====== /usr/local/bin/xemacs 20,22 /usr/local/bin/gdb 1,16 /usr/local/bin/top 0,04 Profile: /usr/local/bin/xemacs Total % For All Processes (/usr/local/bin/xemacs) = 20,22 Subroutine % Source ========== ====== ====== .add_ichar_rune_1 1,94 redisplay.c .create_text_block 1,00 redisplay.c .display_table_entry 0,94 glyphs.c .compare_runes 0,71 redisplay-output.c ======================================================================================== <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Total % for .add_ichar_rune_1 = 1,94 Line % Source 1079 0,04 { 1080 - struct rune rb, *crb; 1081 - int width, local; 1082 - 1083 0,06 if (data->start_col) 1084 - { 1085 - data->start_col--; 1086 - 1087 - if (data->start_col) 1088 - return NULL; 1089 - } 1090 - 1091 0,03 if (data->byte_start_col_enabled) 1092 - { 1093 - return add_hscroll_rune (data); 1094 - } 1095 - 1096 0,01 if (data->ch == '\n') 1097 - { 1098 - data->font_is_bogus = 0; 1099 - /* Cheesy end-of-line pseudo-character. */ 1100 - width = data->blank_width; 1101 - } 1102 - else 1103 - { 1104 - Lisp_Object charset = ichar_charset (data->ch); 1105 0,23 if (!EQ (charset, data->last_charset) || 1106 - data->findex != data->last_findex) 1107 - { 1108 - /* OK, we need to do things the hard way. */ 1109 - struct window *w = XWINDOW (data->window); 1110 - struct face_cachel *cachel = WINDOW_FACE_CACHEL (w, data->findex); 1111 0,01 Lisp_Object font_instance = 1112 - ensure_face_cachel_contains_charset (cachel, data->window, 1113 - charset); 1114 - Lisp_Font_Instance *fi; 1115 - 1116 - if (EQ (font_instance, Vthe_null_font_instance)) 1117 - { 1118 - font_instance = FACE_CACHEL_FONT (cachel, Vcharset_ascii); 1119 - data->font_is_bogus = 1; 1120 - } 1121 - else 1122 - data->font_is_bogus = 0; 1123 - 1124 - fi = XFONT_INSTANCE (font_instance); 1125 - if (!fi->proportional_p || data->font_is_bogus) 1126 - { 1127 - Ichar ch = data->font_is_bogus ? '~' : data->ch; 1128 - 1129 - data->last_char_width = 1130 - redisplay_text_width_ichar_string (XWINDOW (data->window), 1131 - data->findex, &ch, 1); 1132 - } 1133 - else 1134 - data->last_char_width = -1; 1135 - 1136 - if (!no_contribute_to_line_height) 1137 - { 1138 0,01 data->new_ascent = max (data->new_ascent, (int) fi->ascent); 1139 - data->new_descent = max (data->new_descent, (int) fi->descent); 1140 - } 1141 - 1142 - data->last_charset = charset; 1143 - data->last_findex = data->findex; 1144 - } 1145 - 1146 - width = data->last_char_width; 1147 0,10 if (width < 0) /* proportional fonts */ 1148 - width = redisplay_text_width_ichar_string (XWINDOW (data->window), 1149 - data->findex, 1150 - &data->ch, 1); 1151 - } 1152 - 1153 0,14 if (data->max_pixpos != -1 && (data->pixpos + width > data->max_pixpos)) 1154 - { 1155 - return ADD_FAILED; 1156 - } 1157 - 1158 0,10 if (Dynarr_length (data->db->runes) < Dynarr_largest (data->db->runes)) 1159 - { 1160 0,17 crb = Dynarr_atp (data->db->runes, Dynarr_length (data->db->runes)); 1161 0,01 local = 0; 1162 - } 1163 - else 1164 - { 1165 - crb = &rb; 1166 - local = 1; 1167 - } 1168 - 1169 0,06 crb->findex = data->findex; 1170 0,04 crb->xpos = data->pixpos; 1171 - crb->width = width; 1172 0,04 if (data->byte_charpos) 1173 - { 1174 0,04 if (NILP (data->string)) 1175 0,03 crb->charpos = 1176 - bytebpos_to_charbpos (XBUFFER (WINDOW_BUFFER 1177 - (XWINDOW (data->window))), 1178 - data->byte_charpos); 1179 - else 1180 - crb->charpos = 1181 - string_index_byte_to_char (data->string, data->byte_charpos); 1182 - } 1183 0,01 else if (data->is_modeline) 1184 0,01 crb->charpos = data->modeline_charpos; 1185 - else 1186 - /* Text but not in buffer */ 1187 - crb->charpos = 0; 1188 0,03 crb->type = RUNE_CHAR; 1189 0,17 crb->object.chr.ch = data->font_is_bogus ? '~' : data->ch; 1190 0,01 crb->endpos = 0; 1191 - 1192 0,10 if (data->cursor_type == CURSOR_ON) 1193 - { 1194 0,03 if (data->byte_charpos == data->byte_cursor_charpos) 1195 - { 1196 - crb->cursor_type = CURSOR_ON; 1197 - data->cursor_x = Dynarr_length (data->db->runes); 1198 - } 1199 - else 1200 0,03 crb->cursor_type = CURSOR_OFF; 1201 - } 1202 - else if (data->cursor_type == NEXT_CURSOR) 1203 - { 1204 - crb->cursor_type = CURSOR_ON; 1205 - data->cursor_x = Dynarr_length (data->db->runes); 1206 - data->cursor_type = NO_CURSOR; 1207 - } 1208 - else if (data->cursor_type == IGNORE_CURSOR) 1209 - crb->cursor_type = IGNORE_CURSOR; 1210 - else 1211 - crb->cursor_type = CURSOR_OFF; 1212 - 1213 - if (local) 1214 0,01 Dynarr_add (data->db->runes, *crb); 1215 - else 1216 0,12 Dynarr_increment (data->db->runes); 1217 - 1218 0,07 data->pixpos += width; 1219 - 1220 - return NULL; 1221 0,17 } <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Total % for .create_text_block = 1,00 Line % Source 2121 - { 2122 - struct frame *f = XFRAME (w->frame); 2123 - struct buffer *b = XBUFFER (w->buffer); 2124 - struct device *d = XDEVICE (f->device); 2125 - 2126 - pos_data data; 2127 - 2128 - /* Don't display anything in the minibuffer if this window is not on 2129 - a selected frame. We consider all other windows to be active 2130 - minibuffers as it simplifies the coding. */ 2131 - int active_minibuffer = (!MINI_WINDOW_P (w) || 2132 - (f == device_selected_frame (d)) || 2133 - is_surrogate_for_selected_frame (f)); 2134 - 2135 - int truncate_win = window_truncation_on (w); 2136 - 2137 - /* If the buffer's value of selective_display is an integer then 2138 - only lines that start with less than selective_display columns of 2139 - space will be displayed. If selective_display is t then all text 2140 - after a ^M is invisible. */ 2141 - int selective = (INTP (b->selective_display) 2142 - ? XINT (b->selective_display) 2143 - : (!NILP (b->selective_display) ? -1 : 0)); 2144 - 2145 - /* The variable ctl-arrow allows the user to specify what characters 2146 - can actually be displayed and which octal should be used for. 2147 - #### This variable should probably have some rethought done to 2148 - it. 2149 - 2150 - See also 2151 - 2152 - (Info-goto-node "(internals)Future Work -- Display Tables") 2153 - 2154 - */ 2155 - Ichar printable_min = (CHAR_OR_CHAR_INTP (b->ctl_arrow) 2156 - ? XCHAR_OR_CHAR_INT (b->ctl_arrow) 2157 - : ((EQ (b->ctl_arrow, Qt) || EQ (b->ctl_arrow, Qnil)) 2158 - ? 255 : 160)); 2159 - 2160 - Lisp_Object face_dt, window_dt; 2161 - 2162 - /* The text display block for this display line. */ 2163 - struct display_block *db = get_display_block_from_line (dl, TEXT); 2164 - 2165 - /* The first time through the main loop we need to force the glyph 2166 - data to be updated. */ 2167 - int initial = 1; 2168 - 2169 - /* Apparently the new extent_fragment_update returns an end position 2170 - equal to the position passed in if there are no more runs to be 2171 - displayed. */ 2172 - int no_more_frags = 0; 2173 - 2174 - Lisp_Object synch_minibuffers_value = 2175 - symbol_value_in_buffer (Qsynchronize_minibuffers, w->buffer); 2176 - 2177 - dl->used_prop_data = 0; 2178 - dl->num_chars = 0; 2179 - dl->line_continuation = 0; 2180 - 2181 - xzero (data); 2182 - data.ef = extent_fragment_new (w->buffer, f); 2183 - 2184 - /* These values are used by all of the rune addition routines. We add 2185 - them to this structure for ease of passing. */ 2186 - data.d = d; 2187 - data.window = wrap_window (w); 2188 - data.string = Qnil; 2189 - data.db = db; 2190 - data.dl = dl; 2191 - 2192 - data.byte_charpos = byte_start_pos; 2193 - data.pixpos = dl->bounds.left_in; 2194 - data.last_charset = Qunbound; 2195 - data.last_findex = DEFAULT_INDEX; 2196 - data.result_str = Qnil; 2197 - 2198 - /* Set the right boundary adjusting it to take into account any end 2199 - glyph. Save the width of the end glyph for later use. */ 2200 - data.max_pixpos = dl->bounds.right_in; 2201 - if (truncate_win) 2202 - data.end_glyph_width = GLYPH_CACHEL_WIDTH (w, TRUN_GLYPH_INDEX); 2203 - else 2204 - data.end_glyph_width = GLYPH_CACHEL_WIDTH (w, CONT_GLYPH_INDEX); 2205 0,01 data.max_pixpos -= data.end_glyph_width; 2206 - 2207 - if (cursor_in_echo_area && MINI_WINDOW_P (w) && echo_area_active (f)) 2208 - { 2209 - data.byte_cursor_charpos = BYTE_BUF_ZV (b); 2210 - data.cursor_type = CURSOR_ON; 2211 - } 2212 - else if (MINI_WINDOW_P (w) && !active_minibuffer) 2213 - data.cursor_type = NO_CURSOR; 2214 - else if (w == XWINDOW (FRAME_SELECTED_WINDOW (f)) && 2215 - EQ(DEVICE_CONSOLE(d), Vselected_console) && 2216 - d == XDEVICE(CONSOLE_SELECTED_DEVICE(XCONSOLE(DEVICE_CONSOLE(d))))&& 2217 - f == XFRAME(DEVICE_SELECTED_FRAME(d))) 2218 - { 2219 - data.byte_cursor_charpos = BYTE_BUF_PT (b); 2220 - data.cursor_type = CURSOR_ON; 2221 - } 2222 - else if (w == XWINDOW (FRAME_SELECTED_WINDOW (f))) 2223 - { 2224 - data.byte_cursor_charpos = byte_marker_position (w->pointm[type]); 2225 - data.cursor_type = CURSOR_ON; 2226 - } 2227 - else 2228 - data.cursor_type = NO_CURSOR; 2229 - data.cursor_x = -1; 2230 - 2231 - data.start_col = w->hscroll; 2232 - data.start_col_xoffset = w->left_xoffset; 2233 0,01 data.byte_start_col_enabled = (w->hscroll ? byte_start_pos: 0); 2234 - data.hscroll_glyph_width_adjust = 0; 2235 - 2236 - /* We regenerate the line from the very beginning. */ 2237 - Dynarr_reset (db->runes); 2238 - 2239 - /* Why is this less than or equal and not just less than? If the 2240 - starting position is already equal to the maximum we can't add 2241 - anything else, right? Wrong. We might still have a newline to 2242 - add. A newline can use the room allocated for an end glyph since 2243 - if we add it we know we aren't going to be adding any end 2244 - glyph. */ 2245 - 2246 - /* #### Chuck -- I think this condition should be while (1). 2247 - Otherwise if (e.g.) there is one begin-glyph and one end-glyph 2248 - and the begin-glyph ends exactly at the end of the window, the 2249 - end-glyph and text might not be displayed. while (1) ensures 2250 - that the loop terminates only when either (a) there is 2251 - propagation data or (b) the end-of-line or end-of-buffer is hit. 2252 - 2253 - #### Also I think you need to ensure that the operation 2254 - "add begin glyphs; add end glyphs; add text" is atomic and 2255 - can't get interrupted in the middle. If you run off the end 2256 - of the line during that operation, then you keep accumulating 2257 - propagation data until you're done. Otherwise, if the (e.g.) 2258 - there's a begin glyph at a particular position and attempting 2259 - to display that glyph results in window-end being hit and 2260 - propagation data being generated, then the character at that 2261 - position won't be displayed. 2262 - 2263 - #### See also the comment after the end of this loop, below. 2264 - */ 2265 0,04 while (data.pixpos <= data.max_pixpos 2266 - && (active_minibuffer || !NILP (synch_minibuffers_value))) 2267 - { 2268 - /* #### This check probably should not be necessary. */ 2269 0,07 if (data.byte_charpos > BYTE_BUF_ZV (b)) 2270 - { 2271 - /* #### urk! More of this lossage! */ 2272 - data.byte_charpos--; 2273 - goto done; 2274 - } 2275 - 2276 - /* If selective display was an integer and we aren't working on 2277 - a continuation line then find the next line we are actually 2278 - supposed to display. */ 2279 - if (selective > 0 2280 - && (data.byte_charpos == BYTE_BUF_BEGV (b) 2281 - || BUF_FETCH_CHAR (b, prev_bytebpos (b, data.byte_charpos)) == '\n')) 2282 - { 2283 - while (byte_spaces_at_point (b, data.byte_charpos) 2284 - { 2285 - data.byte_charpos = 2286 - byte_find_next_newline_no_quit (b, data.byte_charpos, 1); 2287 - if (data.byte_charpos >= BYTE_BUF_ZV (b)) 2288 - { 2289 - data.byte_charpos = BYTE_BUF_ZV (b); 2290 - goto done; 2291 - } 2292 - } 2293 - } 2294 - 2295 - /* Check for face changes. */ 2296 0,04 if (initial || (!no_more_frags && data.byte_charpos == data.ef->end)) 2297 - { 2298 0,01 Lisp_Object last_glyph = Qnil; 2299 - 2300 - /* Deal with glyphs that we have already displayed. The 2301 - theory is that if we end up with a PROP_GLYPH in the 2302 - propagation data then we are clipping the glyph and there 2303 - can be no propagation data before that point. The theory 2304 - works because we always recalculate the extent-fragments 2305 - for propagated data, we never actually propagate the 2306 - fragments that still need to be displayed. */ 2307 - if (*prop && Dynarr_atp (*prop, 0)->type == PROP_GLYPH) 2308 - { 2309 - last_glyph = Dynarr_atp (*prop, 0)->data.p_glyph.glyph; 2310 - Dynarr_free (*prop); 2311 - *prop = 0; 2312 - } 2313 - /* Now compute the face and begin/end-glyph information. */ 2314 0,01 data.findex = 2315 - /* Remember that the extent-fragment routines deal in Bytebpos's. */ 2316 - extent_fragment_update (w, data.ef, data.byte_charpos, last_glyph); 2317 - 2318 - get_display_tables (w, data.findex, &face_dt, &window_dt); 2319 - 2320 - if (data.byte_charpos == data.ef->end) 2321 - no_more_frags = 1; 2322 - } 2323 0,01 initial = 0; 2324 - 2325 - /* Determine what is next to be displayed. We first handle any 2326 - glyphs returned by glyphs_at_charbpos. If there are no glyphs to 2327 - display then we determine what to do based on the character at the 2328 - current buffer position. */ 2329 - 2330 - /* If the current position is covered by an invisible extent, do 2331 - nothing (except maybe add some ellipses). 2332 - 2333 - #### The behavior of begin and end-glyphs at the edge of an 2334 - invisible extent should be investigated further. This is 2335 - fairly low priority though. */ 2336 0,01 if (data.ef->invisible) 2337 - { 2338 - /* #### Chuck, perhaps you could look at this code? I don't 2339 - really know what I'm doing. */ 2340 - if (*prop) 2341 - { 2342 - Dynarr_free (*prop); 2343 - *prop = 0; 2344 - } 2345 - 2346 - /* The extent fragment code only sets this when we should 2347 - really display the ellipses. It makes sure the ellipses 2348 - don't get displayed more than once in a row. */ 2349 - if (data.ef->invisible_ellipses) 2350 - { 2351 - struct glyph_block gb; 2352 - 2353 - data.ef->invisible_ellipses_already_displayed = 1; 2354 - data.ef->invisible_ellipses = 0; 2355 - gb.extent = Qnil; 2356 - gb.glyph = Vinvisible_text_glyph; 2357 - *prop = add_glyph_rune (&data, &gb, BEGIN_GLYPHS, 0, 2358 - GLYPH_CACHEL (w, INVIS_GLYPH_INDEX)); 2359 - /* Perhaps they shouldn't propagate if the very next thing 2360 - is to display a newline (for compatibility with 2361 - selective-display-ellipses)? Maybe that's too 2362 - abstruse. */ 2363 - if (*prop) 2364 - goto done; 2365 - } 2366 - 2367 - /* If point is in an invisible region we place it on the 2368 - next visible character. */ 2369 - if (data.cursor_type == CURSOR_ON 2370 - && data.byte_charpos == data.byte_cursor_charpos) 2371 - { 2372 - data.cursor_type = NEXT_CURSOR; 2373 - } 2374 - 2375 - /* #### What if we we're dealing with a display table? */ 2376 - if (data.start_col) 2377 - data.start_col--; 2378 - 2379 - if (data.byte_charpos == BYTE_BUF_ZV (b)) 2380 - goto done; 2381 - else 2382 - INC_BYTEBPOS (b, data.byte_charpos); 2383 - } 2384 - 2385 - /* If there is propagation data, then it represents the current 2386 - buffer position being displayed. Add them and advance the 2387 - position counter. This might also add the minibuffer 2388 - prompt. */ 2389 - else if (*prop) 2390 - { 2391 - dl->used_prop_data = 1; 2392 - *prop = add_propagation_runes (prop, &data); 2393 - 2394 - if (*prop) 2395 - goto done; /* gee, a really narrow window */ 2396 - else if (data.byte_charpos == BYTE_BUF_ZV (b)) 2397 - goto done; 2398 - else if (data.byte_charpos < BYTE_BUF_BEGV (b)) 2399 - /* #### urk urk urk! Aborts are not very fun! Fix this please! */ 2400 - data.byte_charpos = BYTE_BUF_BEGV (b); 2401 - else 2402 - INC_BYTEBPOS (b, data.byte_charpos); 2403 - } 2404 - 2405 - /* If there are end glyphs, add them to the line. These are 2406 - the end glyphs for the previous run of text. We add them 2407 - here rather than doing them at the end of handling the 2408 - previous run so that glyphs at the beginning and end of 2409 - a line are handled correctly. */ 2410 0,07 else if (Dynarr_length (data.ef->end_glyphs) > 0 2411 - || Dynarr_length (data.ef->begin_glyphs) > 0) 2412 - { 2413 - glyph_block_dynarr* tmpglyphs = 0; 2414 - /* #### I think this is safe, but could be wrong. */ 2415 - data.ch = BYTE_BUF_FETCH_CHAR (b, data.byte_charpos); 2416 - 2417 - if (Dynarr_length (data.ef->end_glyphs) > 0) 2418 - { 2419 - *prop = add_glyph_runes (&data, END_GLYPHS); 2420 - tmpglyphs = data.ef->end_glyphs; 2421 - } 2422 - 2423 - /* If there are begin glyphs, add them to the line. */ 2424 - if (!*prop && Dynarr_length (data.ef->begin_glyphs) > 0) 2425 - { 2426 - *prop = add_glyph_runes (&data, BEGIN_GLYPHS); 2427 - tmpglyphs = data.ef->begin_glyphs; 2428 - } 2429 - 2430 - if (*prop) 2431 - { 2432 - /* If we just clipped a glyph and we are at the end of a 2433 - line and there are more glyphs to display then do 2434 - appropriate processing to not get a continuation 2435 - glyph. */ 2436 - if (*prop != ADD_FAILED 2437 - && Dynarr_atp (*prop, 0)->type == PROP_GLYPH 2438 - && data.ch == '\n') 2439 - { 2440 - /* If there are no more glyphs then do the normal 2441 - processing. 2442 - 2443 - #### This doesn't actually work if the same glyph is 2444 - present more than once in the block. To solve 2445 - this we would have to carry the index around 2446 - which might be problematic since the fragment is 2447 - recalculated for each line. */ 2448 - if (EQ (Dynarr_end (tmpglyphs)->glyph, 2449 - Dynarr_atp (*prop, 0)->data.p_glyph.glyph)) 2450 - { 2451 - Dynarr_free (*prop); 2452 - *prop = 0; 2453 - } 2454 - else { 2455 - data.blank_width = DEVMETH (d, eol_cursor_width, ()); 2456 - add_ichar_rune (&data); /* discard prop data. */ 2457 - goto done; 2458 - } 2459 - } 2460 - else 2461 - goto done; 2462 - } 2463 - } 2464 - 2465 - /* If at end-of-buffer, we've already processed begin and 2466 - end-glyphs at this point and there's no text to process, 2467 - so we're done. */ 2468 - else if (data.byte_charpos == BYTE_BUF_ZV (b)) 2469 - goto done; 2470 - 2471 - else 2472 - { 2473 0,04 Lisp_Object entry = Qnil; 2474 - /* Get the character at the current buffer position. */ 2475 0,09 data.ch = BYTE_BUF_FETCH_CHAR (b, data.byte_charpos); 2476 0,09 if (!NILP (face_dt) || !NILP (window_dt)) 2477 0,12 entry = display_table_entry (data.ch, face_dt, window_dt); 2478 - 2479 - /* If there is a display table entry for it, hand it off to 2480 - add_disp_table_entry_runes and let it worry about it. */ 2481 0,04 if (!NILP (entry) && !EQ (entry, make_char (data.ch))) 2482 - { 2483 - *prop = add_disp_table_entry_runes (&data, entry); 2484 - 2485 - if (*prop) 2486 - goto done; 2487 - } 2488 - 2489 - /* Check if we have hit a newline character. If so, add a marker 2490 - to the line and end this loop. */ 2491 0,03 else if (data.ch == '\n') 2492 - { 2493 - /* We aren't going to be adding an end glyph so give its 2494 - space back in order to make sure that the cursor can 2495 - fit. */ 2496 - data.max_pixpos += data.end_glyph_width; 2497 - 2498 - if (selective > 0 2499 - && (byte_spaces_at_point 2500 - (b, next_bytebpos (b, data.byte_charpos)) 2501 - >= selective)) 2502 - { 2503 - if (!NILP (b->selective_display_ellipses)) 2504 - { 2505 - struct glyph_block gb; 2506 - 2507 - gb.extent = Qnil; 2508 - gb.glyph = Vinvisible_text_glyph; 2509 - add_glyph_rune (&data, &gb, BEGIN_GLYPHS, 0, 2510 - GLYPH_CACHEL (w, INVIS_GLYPH_INDEX)); 2511 - } 2512 - else 2513 - { 2514 - /* Cheesy, cheesy, cheesy. We mark the end of the 2515 - line with a special "character rune" whose width 2516 - is the EOL cursor width and whose character is 2517 - the non-printing character '\n'. */ 2518 - data.blank_width = DEVMETH (d, eol_cursor_width, ()); 2519 - *prop = add_ichar_rune (&data); 2520 - } 2521 - 2522 - /* We need to set data.byte_charpos to the start of the 2523 - next visible region in order to make this line 2524 - appear to contain all of the invisible area. 2525 - Otherwise, the line cache won't work 2526 - correctly. */ 2527 - INC_BYTEBPOS (b, data.byte_charpos); 2528 - while (byte_spaces_at_point (b, data.byte_charpos) 2529 - { 2530 - data.byte_charpos = 2531 - byte_find_next_newline_no_quit (b, data.byte_charpos, 1); 2532 - if (data.byte_charpos >= BYTE_BUF_ZV (b)) 2533 - { 2534 - data.byte_charpos = BYTE_BUF_ZV (b); 2535 - break; 2536 - } 2537 - } 2538 - if (BYTE_BUF_FETCH_CHAR 2539 - (b, prev_bytebpos (b, data.byte_charpos)) == '\n') 2540 - DEC_BYTEBPOS (b, data.byte_charpos); 2541 - } 2542 - else 2543 - { 2544 - data.blank_width = DEVMETH (d, eol_cursor_width, ()); 2545 - *prop = add_ichar_rune (&data); 2546 - } 2547 - 2548 - goto done; 2549 - } 2550 - 2551 - /* If the current character is ^M, and selective display is 2552 - enabled, then add the invisible-text-glyph if 2553 - selective-display-ellipses is set. In any case, this 2554 - line is done. */ 2555 - else if (data.ch == (('M' & 037)) && selective == -1) 2556 - { 2557 - Bytebpos byte_next_charpos; 2558 - 2559 - /* Find the buffer position at the end of the line. */ 2560 - byte_next_charpos = 2561 - byte_find_next_newline_no_quit (b, data.byte_charpos, 1); 2562 - if (BYTE_BUF_FETCH_CHAR (b, prev_bytebpos (b, byte_next_charpos)) 2563 - == '\n') 2564 - DEC_BYTEBPOS (b, byte_next_charpos); 2565 - 2566 - /* If the cursor is somewhere in the elided text make 2567 - sure that the cursor gets drawn appropriately. */ 2568 - if (data.cursor_type == CURSOR_ON 2569 - && (data.byte_cursor_charpos >= data.byte_charpos && 2570 - data.byte_cursor_charpos < byte_next_charpos)) 2571 - { 2572 - data.cursor_type = NEXT_CURSOR; 2573 - } 2574 - 2575 - /* We won't be adding a truncation or continuation glyph 2576 - so give up the room allocated for them. */ 2577 - data.max_pixpos += data.end_glyph_width; 2578 - 2579 - if (!NILP (b->selective_display_ellipses)) 2580 - { 2581 - /* We don't propagate anything from the invisible 2582 - text glyph if it fails to fit. This is 2583 - intentional. */ 2584 - struct glyph_block gb; 2585 - 2586 - gb.extent = Qnil; 2587 - gb.glyph = Vinvisible_text_glyph; 2588 - add_glyph_rune (&data, &gb, BEGIN_GLYPHS, 1, 2589 - GLYPH_CACHEL (w, INVIS_GLYPH_INDEX)); 2590 - } 2591 - 2592 - /* Set the buffer position to the end of the line. We 2593 - need to do this before potentially adding a newline 2594 - so that the cursor flag will get set correctly (if 2595 - needed). */ 2596 - data.byte_charpos = byte_next_charpos; 2597 - 2598 - if (NILP (b->selective_display_ellipses) 2599 - || data.byte_cursor_charpos == byte_next_charpos) 2600 - { 2601 - /* We have to at least add a newline character so 2602 - that the cursor shows up properly. */ 2603 - data.ch = '\n'; 2604 - data.blank_width = DEVMETH (d, eol_cursor_width, ()); 2605 - data.findex = DEFAULT_INDEX; 2606 - data.start_col = 0; 2607 - data.start_col_xoffset = 0; 2608 - data.byte_start_col_enabled = 0; 2609 - 2610 - add_ichar_rune (&data); 2611 - } 2612 - 2613 - /* This had better be a newline but doing it this way 2614 - we'll see obvious incorrect results if it isn't. No 2615 - need to abort here. */ 2616 - data.ch = BYTE_BUF_FETCH_CHAR (b, data.byte_charpos); 2617 - 2618 - goto done; 2619 - } 2620 - 2621 - /* If the current character is considered to be printable, then 2622 - just add it. */ 2623 0,01 else if (data.ch >= printable_min) 2624 - { 2625 - *prop = add_ichar_rune (&data); 2626 - if (*prop) 2627 - goto done; 2628 - } 2629 - 2630 - /* If the current character is a tab, determine the next tab 2631 - starting position and add a blank rune which extends from the 2632 - current pixel position to that starting position. */ 2633 - else if (data.ch == '\t') 2634 - { 2635 - int tab_start_pixpos = data.pixpos; 2636 - int next_tab_start; 2637 - int char_tab_width; 2638 - int prop_width = 0; 2639 - 2640 - if (data.start_col > 1) 2641 - tab_start_pixpos -= (space_width (w) * (data.start_col - 1)) 2642 - + data.start_col_xoffset; 2643 - 2644 - next_tab_start = 2645 - next_tab_position (w, tab_start_pixpos, 2646 - dl->bounds.left_in + 2647 - data.hscroll_glyph_width_adjust); 2648 - if (next_tab_start > data.max_pixpos) 2649 - { 2650 - prop_width = next_tab_start - data.max_pixpos; 2651 - next_tab_start = data.max_pixpos; 2652 - } 2653 - data.blank_width = next_tab_start - data.pixpos; 2654 - char_tab_width = 2655 - (next_tab_start - tab_start_pixpos) / space_width (w); 2656 - 2657 - *prop = add_blank_rune (&data, w, char_tab_width); 2658 - 2659 - /* add_blank_rune is only supposed to be called with 2660 - sizes guaranteed to fit in the available space. */ 2661 - assert (!(*prop)); 2662 - 2663 - if (prop_width) 2664 - { 2665 - struct prop_block pb; 2666 - *prop = Dynarr_new (prop_block); 2667 - 2668 - pb.type = PROP_BLANK; 2669 - pb.data.p_blank.width = prop_width; 2670 - pb.data.p_blank.findex = data.findex; 2671 - Dynarr_add (*prop, pb); 2672 - 2673 - goto done; 2674 - } 2675 - } 2676 - 2677 - /* If character is a control character, pass it off to 2678 - add_control_char_runes. 2679 - 2680 - The is_*() routines have undefined results on 2681 - arguments outside of the range [-1, 255]. (This 2682 - often bites people who carelessly use `char' instead 2683 - of `unsigned char'.) 2684 - */ 2685 0,04 else if (data.ch < 0x100 && iscntrl ((Ibyte) data.ch)) 2686 - { 2687 - *prop = add_control_char_runes (&data, b); 2688 - 2689 - if (*prop) 2690 - goto done; 2691 - } 2692 - 2693 - /* If the character is above the ASCII range and we have not 2694 - already handled it, then print it as an octal number. */ 2695 - else if (data.ch >= 0200) 2696 - { 2697 - *prop = add_octal_runes (&data); 2698 - 2699 - if (*prop) 2700 - goto done; 2701 - } 2702 - 2703 - /* Assume the current character is considered to be printable, 2704 - then just add it. */ 2705 - else 2706 - { 2707 0,03 *prop = add_ichar_rune (&data); 2708 0,03 if (*prop) 2709 - goto done; 2710 - } 2711 - 2712 - INC_BYTEBPOS (b, data.byte_charpos); 2713 - } 2714 - } 2715 - 2716 - done: 2717 - 2718 - /* Determine the starting point of the next line if we did not hit the 2719 - end of the buffer. */ 2720 - if (data.byte_charpos < BYTE_BUF_ZV (b) 2721 - && (active_minibuffer || !NILP (synch_minibuffers_value))) 2722 - { 2723 - /* #### This check is not correct. If the line terminated 2724 - due to a begin-glyph or end-glyph hitting window-end, then 2725 - data.ch will not point to the character at data.byte_charpos. If 2726 - you make the two changes mentioned at the top of this loop, 2727 - you should be able to say '(if (*prop))'. That should also 2728 - make it possible to eliminate the data.byte_charpos < BYTE_BUF_ZV (b) 2729 - check. */ 2730 - 2731 - /* The common case is that the line ended because we hit a newline. 2732 - In that case, the next character is just the next buffer 2733 - position. */ 2734 - if (data.ch == '\n') 2735 - { 2736 - /* If data.start_col_enabled is still true, then the window is 2737 - scrolled far enough so that nothing on this line is visible. 2738 - We need to stick a truncation glyph at the beginning of the 2739 - line in that case unless the line is completely blank. */ 2740 - if (data.byte_start_col_enabled) 2741 - { 2742 - if (data.cursor_type == CURSOR_ON) 2743 - { 2744 - if (data.byte_cursor_charpos >= byte_start_pos 2745 - && data.byte_cursor_charpos <= data.byte_charpos) 2746 - data.byte_cursor_charpos = data.byte_charpos; 2747 - } 2748 - data.findex = DEFAULT_INDEX; 2749 - data.start_col = 0; 2750 - data.byte_start_col_enabled = 0; 2751 - 2752 - if (data.byte_charpos != byte_start_pos) 2753 - { 2754 - struct glyph_block gb; 2755 - 2756 - gb.extent = Qnil; 2757 - gb.glyph = Vhscroll_glyph; 2758 - add_glyph_rune (&data, &gb, BEGIN_GLYPHS, 0, 2759 - GLYPH_CACHEL (w, HSCROLL_GLYPH_INDEX)); 2760 - } 2761 - else 2762 - { 2763 - /* This duplicates code down below to add a newline to 2764 - the end of an otherwise empty line.*/ 2765 - data.ch = '\n'; 2766 - data.blank_width = DEVMETH (d, eol_cursor_width, ()); 2767 - 2768 - add_ichar_rune (&data); 2769 - } 2770 - } 2771 - 2772 - INC_BYTEBPOS (b, data.byte_charpos); 2773 - } 2774 - 2775 - /* Otherwise we have a buffer line which cannot fit on one display 2776 - line. */ 2777 - else 2778 - { 2779 - struct glyph_block gb; 2780 - struct glyph_cachel *cachel; 2781 - 2782 - /* If the line is to be truncated then we actually have to look 2783 - for the next newline. We also add the end-of-line glyph which 2784 - we know will fit because we adjusted the right border before 2785 - we starting laying out the line. */ 2786 - data.max_pixpos += data.end_glyph_width; 2787 - data.findex = DEFAULT_INDEX; 2788 - gb.extent = Qnil; 2789 - 2790 - if (truncate_win) 2791 - { 2792 - Bytebpos byte_pos; 2793 - 2794 - /* Now find the start of the next line. */ 2795 - byte_pos = byte_find_next_newline_no_quit (b, data.byte_charpos, 1); 2796 - 2797 - /* If the cursor is past the truncation line then we 2798 - make it appear on the truncation glyph. If we've hit 2799 - the end of the buffer then we also make the cursor 2800 - appear unless eob is immediately preceded by a 2801 - newline. In that case the cursor should actually 2802 - appear on the next line. */ 2803 - if (data.cursor_type == CURSOR_ON 2804 - && data.byte_cursor_charpos >= data.byte_charpos 2805 - && (data.byte_cursor_charpos < byte_pos || 2806 - (byte_pos == BYTE_BUF_ZV (b) 2807 - && (byte_pos == BYTE_BUF_BEGV (b) 2808 - || (BYTE_BUF_FETCH_CHAR (b, prev_bytebpos (b, byte_pos)) 2809 - != '\n'))))) 2810 - data.byte_cursor_charpos = byte_pos; 2811 - else 2812 - data.cursor_type = NO_CURSOR; 2813 - 2814 - data.byte_charpos = byte_pos; 2815 - gb.glyph = Vtruncation_glyph; 2816 - cachel = GLYPH_CACHEL (w, TRUN_GLYPH_INDEX); 2817 - } 2818 - else 2819 - { 2820 - /* The cursor can never be on the continuation glyph. */ 2821 - data.cursor_type = NO_CURSOR; 2822 - 2823 - /* data.byte_charpos is already at the start of the next line. */ 2824 - 2825 - dl->line_continuation = 1; 2826 - gb.glyph = Vcontinuation_glyph; 2827 - cachel = GLYPH_CACHEL (w, CONT_GLYPH_INDEX); 2828 - } 2829 - 2830 - add_glyph_rune (&data, &gb, BEGIN_GLYPHS, 0, cachel); 2831 - 2832 - if (truncate_win && data.byte_charpos == BYTE_BUF_ZV (b) 2833 - && BYTE_BUF_FETCH_CHAR (b, prev_bytebpos (b, BYTE_BUF_ZV (b))) != '\n') 2834 - /* #### Damn this losing shit. */ 2835 - data.byte_charpos++; 2836 - } 2837 - } 2838 - else if ((active_minibuffer || !NILP (synch_minibuffers_value)) 2839 - && (!echo_area_active (f) || data.byte_charpos == BYTE_BUF_ZV (b))) 2840 - { 2841 - /* We need to add a marker to the end of the line since there is no 2842 - newline character in order for the cursor to get drawn. We label 2843 - it as a newline so that it gets handled correctly by the 2844 - whitespace routines below. */ 2845 - 2846 - data.ch = '\n'; 2847 - data.blank_width = DEVMETH (d, eol_cursor_width, ()); 2848 - data.findex = DEFAULT_INDEX; 2849 - data.start_col = 0; 2850 - data.start_col_xoffset = 0; 2851 - data.byte_start_col_enabled = 0; 2852 - 2853 - data.max_pixpos += data.blank_width; 2854 - add_ichar_rune (&data); 2855 - data.max_pixpos -= data.blank_width; 2856 - 2857 - /* #### urk! Chuck, this shit is bad news. Going around 2858 - manipulating invalid positions is guaranteed to result in 2859 - trouble sooner or later. */ 2860 - data.byte_charpos = BYTE_BUF_ZV (b) + 1; 2861 - } 2862 - 2863 - /* Calculate left whitespace boundary. */ 2864 - { 2865 - int elt = 0; 2866 - 2867 - /* Whitespace past a newline is considered right whitespace. */ 2868 - while (elt < Dynarr_length (db->runes)) 2869 - { 2870 - struct rune *rb = Dynarr_atp (db->runes, elt); 2871 - 2872 - if ((rb->type == RUNE_CHAR && rb->object.chr.ch == ' ') 2873 - || rb->type == RUNE_BLANK) 2874 - { 2875 - dl->bounds.left_white += rb->width; 2876 - elt++; 2877 - } 2878 - else 2879 - elt = Dynarr_length (db->runes); 2880 - } 2881 - } 2882 - 2883 - /* Calculate right whitespace boundary. */ 2884 - { 2885 - int elt = Dynarr_length (db->runes) - 1; 2886 - int done = 0; 2887 - 2888 0,01 while (!done && elt >= 0) 2889 - { 2890 0,03 struct rune *rb = Dynarr_atp (db->runes, elt); 2891 - 2892 0,09 if (!(rb->type == RUNE_CHAR && rb->object.chr.ch < 0x100 2893 - && isspace (rb->object.chr.ch)) 2894 - && !rb->type == RUNE_BLANK) 2895 - { 2896 - dl->bounds.right_white = rb->xpos + rb->width; 2897 - done = 1; 2898 - } 2899 - 2900 0,01 elt--; 2901 - 2902 - } 2903 - 2904 - /* The line is blank so everything is considered to be right 2905 - whitespace. */ 2906 - if (!done) 2907 - dl->bounds.right_white = dl->bounds.left_in; 2908 - } 2909 - 2910 - /* Set the display blocks bounds. */ 2911 - db->start_pos = dl->bounds.left_in; 2912 - if (Dynarr_length (db->runes)) 2913 - { 2914 - struct rune *rb = Dynarr_atp (db->runes, Dynarr_length (db->runes) - 1); 2915 - 2916 - db->end_pos = rb->xpos + rb->width; 2917 - } 2918 - else 2919 - db->end_pos = dl->bounds.right_white; 2920 - 2921 - calculate_baseline (&data); 2922 - 2923 - dl->ascent = data.new_ascent; 2924 - dl->descent = data.new_descent; 2925 - 2926 - { 2927 - unsigned short ascent = (unsigned short) XINT (w->minimum_line_ascent); 2928 - 2929 - if (dl->ascent < ascent) 2930 - dl->ascent = ascent; 2931 - } 2932 - { 2933 - unsigned short descent = (unsigned short) XINT (w->minimum_line_descent); 2934 - 2935 0,01 if (dl->descent < descent) 2936 - dl->descent = descent; 2937 - } 2938 - 2939 - calculate_yoffset (dl, db); 2940 - 2941 - dl->cursor_elt = data.cursor_x; 2942 - /* #### lossage lossage lossage! Fix this shit! */ 2943 - if (data.byte_charpos > BYTE_BUF_ZV (b)) 2944 - dl->end_charpos = BUF_ZV (b); 2945 - else 2946 - dl->end_charpos = bytebpos_to_charbpos (b, data.byte_charpos) - 1; 2947 - if (truncate_win) 2948 - data.dl->num_chars = column_at_point (b, dl->end_charpos, 0); 2949 - else 2950 - /* This doesn't correctly take into account tabs and control 2951 - characters but if the window isn't being truncated then this 2952 - value isn't going to end up being used anyhow. */ 2953 - data.dl->num_chars = dl->end_charpos - dl->charpos; 2954 - 2955 - /* #### handle horizontally scrolled line with text none of which 2956 - was actually laid out. */ 2957 - 2958 - /* #### handle any remainder of overlay arrow */ 2959 - 2960 - if (*prop == ADD_FAILED) 2961 - *prop = NULL; 2962 - 2963 - if (truncate_win && *prop) 2964 - { 2965 - Dynarr_free (*prop); 2966 - *prop = NULL; 2967 - } 2968 - 2969 - extent_fragment_delete (data.ef); 2970 - 2971 - /* #### If we started at EOB, then make sure we return a value past 2972 - it so that regenerate_window will exit properly. This is bogus. 2973 - The main loop should get fixed so that it isn't necessary to call 2974 - this function if we are already at EOB. */ 2975 - 2976 - if (data.byte_charpos == BYTE_BUF_ZV (b) && byte_start_pos == BYTE_BUF_ZV (b)) 2977 - return data.byte_charpos + 1; /* Yuck! */ 2978 - else 2979 - return data.byte_charpos; 2980 - } <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Total % for .add_ichar_rune = 0,29 Line % Source 1225 0,10 { 1226 0,12 return add_ichar_rune_1 (data, 0); 1227 0,07 } <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Total % for .display_table_entry = 0,94 Line % Source 5022 0,01 { 5023 - Lisp_Object tail; 5024 - 5025 - /* Loop over FACE_TABLE, and then over WINDOW_TABLE. */ 5026 0,25 for (tail = face_table; 1; tail = XCDR (tail)) 5027 - { 5028 - Lisp_Object table; 5029 0,13 if (NILP (tail)) 5030 - { 5031 0,04 if (!NILP (window_table)) 5032 - { 5033 - tail = window_table; 5034 0,04 window_table = Qnil; 5035 - } 5036 - else 5037 0,03 return Qnil; 5038 - } 5039 0,10 table = XCAR (tail); 5040 - 5041 0,12 if (VECTORP (table)) 5042 - { 5043 0,03 if (ch < XVECTOR_LENGTH (table) && !NILP (XVECTOR_DATA (table)[ch])) 5044 - return XVECTOR_DATA (table)[ch]; 5045 - else 5046 - continue; 5047 - } 5048 - else if (CHAR_TABLEP (table) 5049 - && XCHAR_TABLE_TYPE (table) == CHAR_TABLE_TYPE_CHAR) 5050 - { 5051 - return get_char_table (ch, table); 5052 - } 5053 - else if (CHAR_TABLEP (table) 5054 - && XCHAR_TABLE_TYPE (table) == CHAR_TABLE_TYPE_GENERIC) 5055 - { 5056 - Lisp_Object gotit = get_char_table (ch, table); 5057 - if (!NILP (gotit)) 5058 - return gotit; 5059 - else 5060 - continue; 5061 - } 5062 - else if (RANGE_TABLEP (table)) 5063 - { 5064 - Lisp_Object gotit = Fget_range_table (make_char (ch), table, Qnil); 5065 - if (!NILP (gotit)) 5066 - return gotit; 5067 - else 5068 - continue; 5069 - } 5070 - else 5071 - ABORT (); 5072 - } 5073 0,19 } <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Total % for .compare_runes = 0,71 Line % Source 198 0,04 { 199 - /* Do not compare the values of charbpos and endpos. They do not 200 - affect the display characteristics. */ 201 - 202 - /* Note: (hanoi 6) spends 95% of its time in redisplay, and about 203 - 30% here. Not using bitfields for rune.type alone gives a redisplay 204 - speed up of 10%. 205 - 206 - #### In profile arcs run of a normal Gnus session this function 207 - is run 6.76 million times, only to return 1 in 6.73 million of 208 - those. 209 - 210 - In addition a quick look GCC sparc assembly shows that GCC is not 211 - doing a good job here. 212 - 1. The function is not inlined (too complicated?) 213 - 2. It seems to be reloading the crb and drb variables all the 214 - time. 215 - 3. It doesn't seem to notice that the second half of these if's 216 - are really a switch statement. 217 - 218 - So I (JV) conjecture 219 - 220 - #### It would really be worth it to arrange for this function to 221 - be (almost) a single call to memcmp. */ 222 - 223 0,23 if (crb->xpos != drb->xpos) 224 - return 0; 225 - else if (crb->width != drb->width) 226 - return 0; 227 0,07 else if (crb->cursor_type != drb->cursor_type) 228 - return 0; 229 0,03 else if (crb->type != drb->type) 230 - return 0; 231 0,03 else if (crb->type == RUNE_CHAR && 232 - (crb->object.chr.ch != drb->object.chr.ch)) 233 - return 0; 234 0,01 else if (crb->type == RUNE_HLINE && 235 - (crb->object.hline.thickness != drb->object.hline.thickness || 236 - crb->object.hline.yoffset != drb->object.hline.yoffset)) 237 - return 0; 238 0,01 else if (crb->type == RUNE_DGLYPH && 239 - (!EQ (crb->object.dglyph.glyph, drb->object.dglyph.glyph) || 240 - !EQ (crb->object.dglyph.extent, drb->object.dglyph.extent) || 241 - crb->object.dglyph.xoffset != drb->object.dglyph.xoffset || 242 - crb->object.dglyph.yoffset != drb->object.dglyph.yoffset || 243 - crb->object.dglyph.ascent != drb->object.dglyph.ascent || 244 - crb->object.dglyph.descent != drb->object.dglyph.descent)) 245 - return 0; 246 - /* Only check dirtiness if we know something has changed. */ 247 0,04 else if (crb->type == RUNE_DGLYPH && 248 - (XGLYPH_DIRTYP (crb->object.dglyph.glyph) || 249 - crb->findex != drb->findex)) 250 - { 251 - /* We need some way of telling redisplay_output_layout () that the 252 - only reason we are outputting it is because something has 253 - changed internally. That way we can optimize whether we need 254 - to clear the layout first and also only output the components 255 - that have changed. The image_instance dirty flag and 256 - display_hash are no good to us because these will invariably 257 - have been set anyway if the layout has changed. So it looks 258 - like we need yet another change flag that we can set here and 259 - then clear in redisplay_output_layout (). */ 260 - Lisp_Object window, image; 261 - Lisp_Image_Instance* ii; 262 - window = wrap_window (w); 263 - image = glyph_image_instance (crb->object.dglyph.glyph, 264 - window, ERROR_ME_DEBUG_WARN, 1); 265 - 266 - if (!IMAGE_INSTANCEP (image)) 267 - return 0; 268 - ii = XIMAGE_INSTANCE (image); 269 - 270 - if (TEXT_IMAGE_INSTANCEP (image) && 271 - (crb->findex != drb->findex || 272 - WINDOW_FACE_CACHEL_DIRTY (w, drb->findex))) 273 - return 0; 274 - 275 - /* It is quite common for the two glyphs to be EQ since in many 276 - cases they will actually be the same object. This does not 277 - mean, however, that nothing has changed. We therefore need to 278 - check the current hash of the glyph against the last recorded 279 - display hash and the pending display items. See 280 - update_subwindow (). */ 281 - if (image_instance_changed (image) || 282 - crb->findex != drb->findex || 283 - WINDOW_FACE_CACHEL_DIRTY (w, drb->findex)) 284 - { 285 - /* Now we are going to re-output the glyph, but since 286 - this is for some internal reason not related to geometry 287 - changes, send a hint to the output routines that they can 288 - take some short cuts. This is most useful for 289 - layouts. This flag should get reset by the output 290 - routines. 291 - 292 - #### It is possible for us to get here when the 293 - face_cachel is dirty. I do not know what the implications 294 - of this are.*/ 295 - IMAGE_INSTANCE_OPTIMIZE_OUTPUT (ii) = 1; 296 - return 0; 297 - } 298 - else 299 - return 1; 300 - } 301 - /* We now do this last so that glyph checks can do their own thing 302 - for face changes. Face changes quite often happen when we are 303 - trying to output something in the gutter, this would normally 304 - lead to a lot of flashing. The indices can quite often be 305 - different and yet the faces are the same, we do not want to 306 - re-output in this instance. */ 307 0,13 else if (crb->findex != drb->findex || 308 - WINDOW_FACE_CACHEL_DIRTY (w, drb->findex)) 309 - return 0; 310 - else 311 - return 1; 312 0,10 } <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<< Thomas Mittelstaedt schrieb: _______________________________________________ XEmacs-Beta mailing list XEmacs-Beta(a)xemacs.org http://calypso.tux.org/cgi-bin/mailman/listinfo/xemacs-beta