1 files changed, 113 insertions, 103 deletions

diff --git a/src/cm.c b/src/cm.c
index da984f0b82d..d520e740eb3 100644
--- a/src/cm.c
+++ b/src/cm.c
@@ -23,8 +23,13 @@ Boston, MA 02110-1301, USA.  */
 
 #include <config.h>
 #include <stdio.h>
+
+#include "lisp.h"
+#include "frame.h"
 #include "cm.h"
 #include "termhooks.h"
+#include "termchar.h"
+
 
 /* For now, don't try to include termcap.h.  On some systems,
    configure finds a non-standard termcap.h that the main build
@@ -53,13 +58,16 @@ evalcost (c)
   return c;
 }
 
+/* The terminal to use for low-level output. */
+struct tty_display_info *current_tty;
+
 int
 cmputc (c)
      char c;
 {
-  if (termscript)
-    fputc (c & 0177, termscript);
-  putchar (c & 0177);
+  if (current_tty->termscript)
+    putc (c & 0177, current_tty->termscript);
+  putc (c & 0177, current_tty->output);
   return c;
 }
 
@@ -72,9 +80,9 @@ cmputc (c)
  */
 
 static
-at (row, col) {
-    curY = row;
-    curX = col;
+at (tty, row, col) {
+  curY (tty) = row;
+  curX (tty)  = col;
 }
 
 /*
@@ -82,8 +90,8 @@ at (row, col) {
  */
 
 static
-addcol (n) {
-    curX += n;
+addcol (tty, n) {
+  curX (tty) += n;
 
     /*
      * If cursor hit edge of screen, what happened?
@@ -93,21 +101,21 @@ addcol (n) {
      * of the last line.
      */
 
-    if (curX == Wcm.cm_cols) {
+  if (curX (tty) == tty->Wcm->cm_cols) {
         /*
          * Well, if magicwrap, still there, past the edge of the
          * screen (!).  If autowrap, on the col 0 of the next line.
          * Otherwise on last column.
          */
 
-        if (Wcm.cm_magicwrap)
+        if (tty->Wcm->cm_magicwrap)
             ;                   /* "limbo" */
-        else if (Wcm.cm_autowrap) {
-            curX = 0;
-            curY++;             /* Beware end of screen! */
+        else if (tty->Wcm->cm_autowrap) {
+          curX (tty) = 0;
+          curY (tty) ++;                /* Beware end of screen! */
         }
         else
-            curX--;
+          curX (tty)--;
     }
 }
 #endif
@@ -123,20 +131,20 @@ addcol (n) {
  * after we reach the last column; this takes us to a known state.
  */
 void
-cmcheckmagic ()
+cmcheckmagic (struct tty_display_info *tty)
 {
-  if (curX == FrameCols)
+  if (curX (tty) == FrameCols (tty))
     {
-      if (!MagicWrap || curY >= FrameRows - 1)
+      if (!MagicWrap (tty) || curY (tty) >= FrameRows (tty) - 1)
         abort ();
-      if (termscript)
-        putc ('\r', termscript);
-      putchar ('\r');
-      if (termscript)
-        putc ('\n', termscript);
-      putchar ('\n');
-      curX = 0;
-      curY++;
+      if (tty->termscript)
+        putc ('\r', tty->termscript);
+      putc ('\r', tty->output);
+      if (tty->termscript)
+        putc ('\n', tty->termscript);
+      putc ('\n', tty->output);
+      curX (tty) = 0;
+      curY (tty)++;
     }
 }
 
@@ -148,21 +156,21 @@ cmcheckmagic ()
  */
 
 void
-cmcostinit ()
+cmcostinit (struct tty_display_info *tty)
 {
     char *p;
 
 #define COST(x,e)       (x ? (cost = 0, tputs (x, 1, e), cost) : BIG)
 #define CMCOST(x,e)     ((x == 0) ? BIG : (p = tgoto(x, 0, 0), COST(p ,e)))
 
-    Wcm.cc_up =         COST (Wcm.cm_up, evalcost);
-    Wcm.cc_down =       COST (Wcm.cm_down, evalcost);
-    Wcm.cc_left =       COST (Wcm.cm_left, evalcost);
-    Wcm.cc_right =      COST (Wcm.cm_right, evalcost);
-    Wcm.cc_home =       COST (Wcm.cm_home, evalcost);
-    Wcm.cc_cr =         COST (Wcm.cm_cr, evalcost);
-    Wcm.cc_ll =         COST (Wcm.cm_ll, evalcost);
-    Wcm.cc_tab =        Wcm.cm_tabwidth ? COST (Wcm.cm_tab, evalcost) : BIG;
+    tty->Wcm->cc_up =    COST (tty->Wcm->cm_up, evalcost);
+    tty->Wcm->cc_down =  COST (tty->Wcm->cm_down, evalcost);
+    tty->Wcm->cc_left =  COST (tty->Wcm->cm_left, evalcost);
+    tty->Wcm->cc_right = COST (tty->Wcm->cm_right, evalcost);
+    tty->Wcm->cc_home =  COST (tty->Wcm->cm_home, evalcost);
+    tty->Wcm->cc_cr =    COST (tty->Wcm->cm_cr, evalcost);
+    tty->Wcm->cc_ll =    COST (tty->Wcm->cm_ll, evalcost);
+    tty->Wcm->cc_tab =   tty->Wcm->cm_tabwidth ? COST (tty->Wcm->cm_tab, evalcost) : BIG;
 
     /*
      * These last three are actually minimum costs.  When (if) they are
@@ -173,9 +181,9 @@ cmcostinit ()
      * cursor motion seem to take straight numeric values.  --ACT)
      */
 
-    Wcm.cc_abs =  CMCOST (Wcm.cm_abs, evalcost);
-    Wcm.cc_habs = CMCOST (Wcm.cm_habs, evalcost);
-    Wcm.cc_vabs = CMCOST (Wcm.cm_vabs, evalcost);
+    tty->Wcm->cc_abs =  CMCOST (tty->Wcm->cm_abs, evalcost);
+    tty->Wcm->cc_habs = CMCOST (tty->Wcm->cm_habs, evalcost);
+    tty->Wcm->cc_vabs = CMCOST (tty->Wcm->cm_vabs, evalcost);
 
 #undef CMCOST
 #undef COST
@@ -188,8 +196,8 @@ cmcostinit ()
  */
 
 static int
-calccost (srcy, srcx, dsty, dstx, doit)
-     int srcy, srcx, dsty, dstx, doit;
+calccost (struct tty_display_info *tty,
+          int srcy, int srcx, int dsty, int dstx, int doit)
 {
     register int    deltay,
                     deltax,
@@ -206,16 +214,16 @@ calccost (srcy, srcx, dsty, dstx, doit)
        don't believe the cursor position: give up here
        and force use of absolute positioning.  */
 
-    if (curX == Wcm.cm_cols)
+    if (curX (tty) == tty->Wcm->cm_cols)
       goto fail;
 
     totalcost = 0;
     if ((deltay = dsty - srcy) == 0)
         goto x;
     if (deltay < 0)
-        p = Wcm.cm_up, c = Wcm.cc_up, deltay = -deltay;
+        p = tty->Wcm->cm_up, c = tty->Wcm->cc_up, deltay = -deltay;
     else
-        p = Wcm.cm_down, c = Wcm.cc_down;
+        p = tty->Wcm->cm_down, c = tty->Wcm->cc_down;
     if (c == BIG) {             /* caint get thar from here */
         if (doit)
             printf ("OOPS");
@@ -224,16 +232,16 @@ calccost (srcy, srcx, dsty, dstx, doit)
     totalcost = c * deltay;
     if (doit)
         while (--deltay >= 0)
-            tputs (p, 1, cmputc);
+          emacs_tputs (tty, p, 1, cmputc);
 x:
     if ((deltax = dstx - srcx) == 0)
         goto done;
     if (deltax < 0) {
-        p = Wcm.cm_left, c = Wcm.cc_left, deltax = -deltax;
+        p = tty->Wcm->cm_left, c = tty->Wcm->cc_left, deltax = -deltax;
         goto dodelta;           /* skip all the tab junk */
     }
     /* Tabs (the toughie) */
-    if (Wcm.cc_tab >= BIG || !Wcm.cm_usetabs)
+    if (tty->Wcm->cc_tab >= BIG || !tty->Wcm->cm_usetabs)
         goto olddelta;          /* forget it! */
 
     /*
@@ -244,12 +252,12 @@ x:
      * we will put into tabx (for ntabs) and tab2x (for n2tabs)).
      */
 
-    ntabs = (deltax + srcx % Wcm.cm_tabwidth) / Wcm.cm_tabwidth;
+    ntabs = (deltax + srcx % tty->Wcm->cm_tabwidth) / tty->Wcm->cm_tabwidth;
     n2tabs = ntabs + 1;
-    tabx = (srcx / Wcm.cm_tabwidth + ntabs) * Wcm.cm_tabwidth;
-    tab2x = tabx + Wcm.cm_tabwidth;
+    tabx = (srcx / tty->Wcm->cm_tabwidth + ntabs) * tty->Wcm->cm_tabwidth;
+    tab2x = tabx + tty->Wcm->cm_tabwidth;
 
-    if (tab2x >= Wcm.cm_cols)   /* too far (past edge) */
+    if (tab2x >= tty->Wcm->cm_cols)     /* too far (past edge) */
         n2tabs = 0;
 
     /*
@@ -257,12 +265,12 @@ x:
      * for using n2tabs, then pick the minimum.
      */
 
-                   /* cost for ntabs     +    cost for right motion */
-    tabcost = ntabs ? ntabs * Wcm.cc_tab + (dstx - tabx) * Wcm.cc_right
+                   /* cost for ntabs           +    cost for right motion */
+    tabcost = ntabs ? ntabs * tty->Wcm->cc_tab + (dstx - tabx) * tty->Wcm->cc_right
                     : BIG;
 
-                   /* cost for n2tabs    +    cost for left motion */
-    c = n2tabs  ?    n2tabs * Wcm.cc_tab + (tab2x - dstx) * Wcm.cc_left
+                   /* cost for n2tabs          +    cost for left motion */
+    c = n2tabs  ?    n2tabs * tty->Wcm->cc_tab + (tab2x - dstx) * tty->Wcm->cc_left
                 : BIG;
 
     if (c < tabcost)            /* then cheaper to overshoot & back up */
@@ -275,11 +283,11 @@ x:
      * See if tabcost is less than just moving right
      */
 
-    if (tabcost < (deltax * Wcm.cc_right)) {
+    if (tabcost < (deltax * tty->Wcm->cc_right)) {
         totalcost += tabcost;   /* use the tabs */
         if (doit)
             while (--ntabs >= 0)
-                tputs (Wcm.cm_tab, 1, cmputc);
+              emacs_tputs (tty, tty->Wcm->cm_tab, 1, cmputc);
         srcx = tabx;
     }
 
@@ -292,9 +300,9 @@ newdelta:
         goto done;
 olddelta:
     if (deltax > 0)
-        p = Wcm.cm_right, c = Wcm.cc_right;
+        p = tty->Wcm->cm_right, c = tty->Wcm->cc_right;
     else
-        p = Wcm.cm_left, c = Wcm.cc_left, deltax = -deltax;
+        p = tty->Wcm->cm_left, c = tty->Wcm->cc_left, deltax = -deltax;
 
 dodelta:
     if (c == BIG) {             /* caint get thar from here */
@@ -306,7 +314,7 @@ fail:
     totalcost += c * deltax;
     if (doit)
         while (--deltax >= 0)
-            tputs (p, 1, cmputc);
+          emacs_tputs (tty, p, 1, cmputc);
 done:
     return totalcost;
 }
@@ -324,7 +332,8 @@ losecursor ()
 #define USECR   3
 
 void
-cmgoto (row, col)
+cmgoto (tty, row, col)
+     struct tty_display_info *tty;
      int row, col;
 {
     int     homecost,
@@ -337,47 +346,47 @@ cmgoto (row, col)
            *dcm;
 
   /* First the degenerate case */
-  if (row == curY && col == curX) /* already there */
+    if (row == curY (tty) && col == curX (tty)) /* already there */
     return;
 
-  if (curY >= 0 && curX >= 0)
+    if (curY (tty) >= 0 && curX (tty) >= 0)
     {
       /* We may have quick ways to go to the upper-left, bottom-left,
        * start-of-line, or start-of-next-line.  Or it might be best to
        * start where we are.  Examine the options, and pick the cheapest.
        */
 
-      relcost = calccost (curY, curX, row, col, 0);
+      relcost = calccost (tty, curY (tty), curX (tty), row, col, 0);
       use = USEREL;
-      if ((homecost = Wcm.cc_home) < BIG)
-          homecost += calccost (0, 0, row, col, 0);
+      if ((homecost = tty->Wcm->cc_home) < BIG)
+          homecost += calccost (tty, 0, 0, row, col, 0);
       if (homecost < relcost)
-          relcost = homecost, use = USEHOME;
-      if ((llcost = Wcm.cc_ll) < BIG)
-          llcost += calccost (Wcm.cm_rows - 1, 0, row, col, 0);
+          relcost = homecost, use = USEHOME;
+      if ((llcost = tty->Wcm->cc_ll) < BIG)
+          llcost += calccost (tty, tty->Wcm->cm_rows - 1, 0, row, col, 0);
       if (llcost < relcost)
-          relcost = llcost, use = USELL;
-      if ((crcost = Wcm.cc_cr) < BIG) {
-          if (Wcm.cm_autolf)
-              if (curY + 1 >= Wcm.cm_rows)
-                  crcost = BIG;
+          relcost = llcost, use = USELL;
+      if ((crcost = tty->Wcm->cc_cr) < BIG) {
+          if (tty->Wcm->cm_autolf)
+            if (curY (tty) + 1 >= tty->Wcm->cm_rows)
+                crcost = BIG;
               else
-                  crcost += calccost (curY + 1, 0, row, col, 0);
+                crcost += calccost (tty, curY (tty) + 1, 0, row, col, 0);
           else
-              crcost += calccost (curY, 0, row, col, 0);
+            crcost += calccost (tty, curY (tty), 0, row, col, 0);
       }
       if (crcost < relcost)
           relcost = crcost, use = USECR;
-      directcost = Wcm.cc_abs, dcm = Wcm.cm_abs;
-      if (row == curY && Wcm.cc_habs < BIG)
-          directcost = Wcm.cc_habs, dcm = Wcm.cm_habs;
-      else if (col == curX && Wcm.cc_vabs < BIG)
-          directcost = Wcm.cc_vabs, dcm = Wcm.cm_vabs;
+      directcost = tty->Wcm->cc_abs, dcm = tty->Wcm->cm_abs;
+      if (row == curY (tty) && tty->Wcm->cc_habs < BIG)
+          directcost = tty->Wcm->cc_habs, dcm = tty->Wcm->cm_habs;
+      else if (col == curX (tty) && tty->Wcm->cc_vabs < BIG)
+          directcost = tty->Wcm->cc_vabs, dcm = tty->Wcm->cm_vabs;
     }
   else
     {
       directcost = 0, relcost = 100000;
-      dcm = Wcm.cm_abs;
+      dcm = tty->Wcm->cm_abs;
     }
 
   /*
@@ -388,13 +397,14 @@ cmgoto (row, col)
     {
       /* compute REAL direct cost */
       cost = 0;
-      p = dcm == Wcm.cm_habs ? tgoto (dcm, row, col) :
-                               tgoto (dcm, col, row);
-      tputs (p, 1, evalcost);
+      p = (dcm == tty->Wcm->cm_habs
+           ? tgoto (dcm, row, col)
+           : tgoto (dcm, col, row));
+      emacs_tputs (tty, p, 1, evalcost);
       if (cost <= relcost)
         {       /* really is cheaper */
-          tputs (p, 1, cmputc);
-          curY = row, curX = col;
+          emacs_tputs (tty, p, 1, cmputc);
+          curY (tty) = row, curX (tty) = col;
           return;
         }
     }
@@ -402,25 +412,25 @@ cmgoto (row, col)
   switch (use)
     {
     case USEHOME:
-      tputs (Wcm.cm_home, 1, cmputc);
-      curY = 0, curX = 0;
+      emacs_tputs (tty, tty->Wcm->cm_home, 1, cmputc);
+      curY (tty) = 0, curX (tty) = 0;
       break;
 
     case USELL:
-      tputs (Wcm.cm_ll, 1, cmputc);
-      curY = Wcm.cm_rows - 1, curX = 0;
+      emacs_tputs (tty, tty->Wcm->cm_ll, 1, cmputc);
+      curY (tty) = tty->Wcm->cm_rows - 1, curX (tty) = 0;
       break;
 
     case USECR:
-      tputs (Wcm.cm_cr, 1, cmputc);
-      if (Wcm.cm_autolf)
-        curY++;
-      curX = 0;
+      emacs_tputs (tty, tty->Wcm->cm_cr, 1, cmputc);
+      if (tty->Wcm->cm_autolf)
+        curY (tty)++;
+      curX (tty) = 0;
       break;
     }
 
-  (void) calccost (curY, curX, row, col, 1);
-  curY = row, curX = col;
+  (void) calccost (tty, curY (tty), curX (tty), row, col, 1);
+  curY (tty) = row, curX (tty) = col;
 }
 
 /* Clear out all terminal info.
@@ -428,9 +438,9 @@ cmgoto (row, col)
  */
 
 void
-Wcm_clear ()
+Wcm_clear (struct tty_display_info *tty)
 {
-  bzero (&Wcm, sizeof Wcm);
+  bzero (tty->Wcm, sizeof (struct cm));
   UP = 0;
   BC = 0;
 }
@@ -443,21 +453,21 @@ Wcm_clear ()
  */
 
 int
-Wcm_init ()
+Wcm_init (struct tty_display_info *tty)
 {
 #if 0
-  if (Wcm.cm_abs && !Wcm.cm_ds)
+  if (tty->Wcm->cm_abs && !tty->Wcm->cm_ds)
     return 0;
 #endif
-  if (Wcm.cm_abs)
+  if (tty->Wcm->cm_abs)
     return 0;
   /* Require up and left, and, if no absolute, down and right */
-  if (!Wcm.cm_up || !Wcm.cm_left)
+  if (!tty->Wcm->cm_up || !tty->Wcm->cm_left)
     return - 1;
-  if (!Wcm.cm_abs && (!Wcm.cm_down || !Wcm.cm_right))
+  if (!tty->Wcm->cm_abs && (!tty->Wcm->cm_down || !tty->Wcm->cm_right))
     return - 1;
   /* Check that we know the size of the screen.... */
-  if (Wcm.cm_rows <= 0 || Wcm.cm_cols <= 0)
+  if (tty->Wcm->cm_rows <= 0 || tty->Wcm->cm_cols <= 0)
     return - 2;
   return 0;
 }