--- rxvt-unicode/src/screen.C	2011/11/24 18:09:54	1.410
+++ rxvt-unicode/src/screen.C	2012/05/28 14:25:16	1.415
@@ -100,9 +100,9 @@
 void
 rxvt_term::scr_blank_line (line_t &l, unsigned int col, unsigned int width, rend_t efs) const NOTHROW
 {
-  if (!l.t)
+  if (!l.valid ())
     {
-      lalloc (l);
+      l.alloc ();
       col = 0;
       width = ncol;
     }
@@ -159,6 +159,40 @@
  * ------------------------------------------------------------------------- */
 
 void
+rxvt_term::scr_alloc ()
+{
+  int tsize = sizeof (text_t) * ncol;
+  int rsize = sizeof (rend_t) * ncol;
+
+  // we assume that rend_t size is a sufficient alignment
+  // factor for tetx_t and line_t values, and we only
+  // need to adjust tsize.
+  tsize = (tsize + sizeof (rend_t) - 1);
+  tsize -= tsize % sizeof (rend_t);
+
+  int all_rows = total_rows + nrow + nrow;
+
+  chunk_size = (sizeof (line_t) + rsize + tsize) * all_rows;
+  chunk = rxvt_malloc (chunk_size);
+
+  char *base = (char *)chunk + sizeof (line_t) * all_rows;
+
+  for (int row = 0; row < all_rows; ++row)
+    {
+      line_t &l = ((line_t *)chunk) [row];
+
+      l.t = (text_t *)base; base += tsize;
+      l.r = (rend_t *)base; base += rsize;
+      l.l = -1;
+      l.f = 0;
+    }
+
+  drawn_buf = (line_t *)chunk;
+  swap_buf  = drawn_buf + nrow;
+  row_buf   = swap_buf  + nrow;
+}
+
+void
 rxvt_term::scr_reset ()
 {
 #if ENABLE_OVERLAY
@@ -194,7 +228,16 @@
   screen.tscroll = 0;
   screen.bscroll = nrow - 1;
 
-  if (!row_buf)
+  void *prev_chunk = chunk;
+  line_t *prev_drawn_buf = drawn_buf;
+  line_t *prev_swap_buf  = swap_buf;
+  line_t *prev_row_buf   = row_buf;
+
+  int common_col = min (prev_ncol, ncol);
+
+  scr_alloc ();
+
+  if (!prev_row_buf)
     {
       /*
        * first time called so just malloc everything: don't rely on realloc
@@ -202,20 +245,6 @@
       top_row    = 0;
       term_start = 0;
 
-      talloc = new rxvt_salloc (ncol * sizeof (text_t));
-      ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
-
-      row_buf   = (line_t *)rxvt_calloc (total_rows       , sizeof (line_t));
-      drawn_buf = (line_t *)rxvt_calloc (nrow             , sizeof (line_t));
-      swap_buf  = (line_t *)rxvt_calloc (nrow             , sizeof (line_t));
-
-      for (int row = nrow; row--; )
-        {
-          scr_blank_screen_mem (ROW (row), DEFAULT_RSTYLE);
-          scr_blank_screen_mem (swap_buf [row], DEFAULT_RSTYLE);
-          scr_blank_screen_mem (drawn_buf[row], DEFAULT_RSTYLE);
-        }
-
       memset (charsets, 'B', sizeof (charsets));
       rstyle = DEFAULT_RSTYLE;
       screen.flags = Screen_DefaultFlags;
@@ -247,38 +276,17 @@
        * add or delete rows as appropriate
        */
 
-      rxvt_salloc *old_ta = talloc; talloc = new rxvt_salloc (ncol * sizeof (text_t));
-      rxvt_salloc *old_ra = ralloc; ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
-
-#if 0
-      if (nrow < prev_nrow)
-        {
-          for (int row = nrow; row < prev_nrow; row++)
-            {
-              lfree (swap_buf [row]);
-              lfree (drawn_buf[row]);
-            }
-        }
-#endif
-
-      drawn_buf = (line_t *)rxvt_realloc (drawn_buf, nrow * sizeof (line_t));
-      swap_buf  = (line_t *)rxvt_realloc (swap_buf , nrow * sizeof (line_t));
-
       for (int row = min (nrow, prev_nrow); row--; )
         {
-          lresize (drawn_buf[row]);
-          lresize (swap_buf [row]);
-        }
+          scr_blank_screen_mem (drawn_buf [row], DEFAULT_RSTYLE);
+          scr_blank_screen_mem (swap_buf  [row], DEFAULT_RSTYLE);
 
-      for (int row = prev_nrow; row < nrow; row++)
-        {
-          swap_buf [row].clear (); scr_blank_screen_mem (swap_buf [row], DEFAULT_RSTYLE);
-          drawn_buf[row].clear (); scr_blank_screen_mem (drawn_buf[row], DEFAULT_RSTYLE);
+          memcpy (drawn_buf [row].t, prev_drawn_buf [row].t, sizeof (text_t) * common_col);
+          memcpy (drawn_buf [row].r, prev_drawn_buf [row].r, sizeof (rend_t) * common_col);
+          memcpy (swap_buf  [row].t, prev_swap_buf  [row].t, sizeof (text_t) * common_col);
+          memcpy (swap_buf  [row].r, prev_swap_buf  [row].r, sizeof (rend_t) * common_col);
         }
 
-      line_t *old_buf = row_buf;
-      row_buf = (line_t *)rxvt_calloc (total_rows, sizeof (line_t));
-
       int p    = MOD (term_start + prev_nrow, prev_total_rows);  // previous row
       int pend = MOD (term_start + top_row  , prev_total_rows);
       int q    = total_rows; // rewrapped row
@@ -295,11 +303,11 @@
           do
             {
               p = MOD (p - 1, prev_total_rows);
-              assert (old_buf [MOD (p, prev_total_rows)].t);
+              assert (prev_row_buf [MOD (p, prev_total_rows)].t);
               int plines = 1;
-              int llen = old_buf [MOD (p, prev_total_rows)].l;
+              int llen = prev_row_buf [MOD (p, prev_total_rows)].l;
 
-              while (p != pend && old_buf [MOD (p - 1, prev_total_rows)].is_longer ())
+              while (p != pend && prev_row_buf [MOD (p - 1, prev_total_rows)].is_longer ())
                 {
                   p = MOD (p - 1, prev_total_rows);
 
@@ -322,7 +330,7 @@
               for (int qrow = q; qlines--; qrow++)
                 {
                   qline = row_buf + qrow;
-                  lalloc (*qline);
+                  qline->alloc (); // redundant with next line
                   qline->l = ncol;
                   qline->is_longer (1);
 
@@ -347,7 +355,7 @@
                       if (prow == ocur.row)
                         screen.cur.row = q - (total_rows - nrow);
 
-                      line_t &pline = old_buf [prow];
+                      line_t &pline = prev_row_buf [prow];
 
                       int len = min (min (prev_ncol - pcol, ncol - qcol), llen - lofs);
 
@@ -378,29 +386,34 @@
 
           for (int row = min (nrow, prev_nrow); row--; )
             {
-              line_t &pline = old_buf [MOD (term_start + row, prev_total_rows)];
-              line_t &qline = row_buf [row];
+              line_t &src = prev_row_buf [MOD (term_start + row, prev_total_rows)];
+              line_t &dst = row_buf [row];
+
+              scr_blank_screen_mem (dst, DEFAULT_RSTYLE);
 
-              qline = pline;
-              lresize (qline);
+              memcpy (dst.t, src.t, sizeof (text_t) * common_col);
+              memcpy (dst.r, src.r, sizeof (rend_t) * common_col);
             }
 
           for (int row = prev_nrow; row < nrow; row++)
-            {
-              row_buf [row].clear (); scr_blank_screen_mem (row_buf [row], DEFAULT_RSTYLE);
-            }
+            scr_blank_screen_mem (row_buf [row], DEFAULT_RSTYLE);
 
           term_start = 0;
         }
 
-      free (old_buf);
-      delete old_ta;
-      delete old_ra;
-
       clamp_it (screen.cur.row, 0, nrow - 1);
       clamp_it (screen.cur.col, 0, ncol - 1);
     }
 
+  for (int row = nrow; row--; )
+    {
+      if (!ROW       (row).valid ()) scr_blank_screen_mem (ROW       (row), DEFAULT_RSTYLE);
+      if (!swap_buf  [row].valid ()) scr_blank_screen_mem (swap_buf  [row], DEFAULT_RSTYLE);
+      if (!drawn_buf [row].valid ()) scr_blank_screen_mem (drawn_buf [row], DEFAULT_RSTYLE);
+    }
+
+  free (prev_chunk);
+
   free (tabs);
   tabs = (char *)rxvt_malloc (ncol);
 
@@ -424,19 +437,8 @@
 void
 rxvt_term::scr_release () NOTHROW
 {
-  if (row_buf)
-    {
-      delete talloc; talloc = 0;
-      delete ralloc; ralloc = 0;
-
-      free (row_buf);
-      free (swap_buf);
-      free (drawn_buf);
-      row_buf = 0; // signal that we freed all the arrays above
-
-      free (tabs);
-      tabs = 0;
-    }
+  free (chunk);
+  free (tabs);
 }
 
 /* ------------------------------------------------------------------------- */
@@ -447,6 +449,9 @@
 rxvt_term::scr_poweron ()
 {
   scr_release ();
+
+  row_buf = 0;
+  tabs = 0;
   prev_nrow = prev_ncol = 0;
   rvideo_mode = false;
   scr_soft_reset ();
@@ -457,7 +462,7 @@
 }
 
 void
-rxvt_term::scr_soft_reset ()
+rxvt_term::scr_soft_reset () NOTHROW
 {
   /* only affects modes, nothing drastic such as clearing the screen */
 #if ENABLE_OVERLAY
@@ -522,7 +527,7 @@
 }
 
 void
-rxvt_term::scr_swap_screen ()
+rxvt_term::scr_swap_screen () NOTHROW
 {
   if (!option (Opt_secondaryScreen))
     return;
@@ -1369,7 +1374,7 @@
 
       if (mapped)
         XClearArea (dpy, vt, 0,
-                    Row2Pixel (row - view_start), (unsigned int)width,
+                    Row2Pixel (row - view_start), (unsigned int)vt_width,
                     (unsigned int)Height2Pixel (num), False);
     }
   else
@@ -1382,7 +1387,7 @@
           XChangeGC (dpy, gc, GCForeground, &gcvalue);
           XFillRectangle (dpy, vt, gc,
                           0, Row2Pixel (row - view_start),
-                          (unsigned int)width,
+                          (unsigned int)vt_width,
                           (unsigned int)Height2Pixel (num));
           gcvalue.foreground = pix_colors[Color_fg];
           XChangeGC (dpy, gc, GCForeground, &gcvalue);
@@ -1878,7 +1883,7 @@
 void
 rxvt_term::scr_touch (bool refresh) NOTHROW
 {
-  scr_expose (0, 0, width, height, refresh);
+  scr_expose (0, 0, vt_width, vt_height, refresh);
 }
 
 /* ------------------------------------------------------------------------- */
@@ -2483,7 +2488,7 @@
                           Col2Pixel (col),
                           Row2Pixel (oldcursor.row),
                           (unsigned int) (Width2Pixel (cursorwidth) - 1),
-                          (unsigned int) (Height2Pixel (1) - lineSpace - 1));
+                          (unsigned int) (Height2Pixel (1) - 1));
         }
     }
 
@@ -2505,7 +2510,7 @@
 void
 rxvt_term::scr_remap_chars (line_t &l) NOTHROW
 {
-  if (!l.t)
+  if (!l.valid ())
     return;
 
   l.touch (); // maybe a bit of an overkill, but it's not performance-relevant
@@ -2706,12 +2711,12 @@
       data[i] = C0_CR;
 
   if (priv_modes & PrivMode_BracketPaste)
-    tt_printf ("\e[200~");
+    tt_printf ("\x1b[200~");
 
   tt_write (data, len);
 
   if (priv_modes & PrivMode_BracketPaste)
-    tt_printf ("\e[201~");
+    tt_printf ("\x1b[201~");
 }
 
 void