Remove spurious semicolons.

[bpt/emacs.git] / src / cm.c

diff --git a/src/cm.c b/src/cm.c
index da984f0..563a488 100644 (file)
--- a/src/cm.c
+++ b/src/cm.c
@@ -1,14 +1,14 @@
 /* Cursor motion subroutines for GNU Emacs.
    Copyright (C) 1985, 1995, 2001, 2002, 2003, 2004,
 /* Cursor motion subroutines for GNU Emacs.
    Copyright (C) 1985, 1995, 2001, 2002, 2003, 2004,

-                 2005, 2006, 2007  Free Software Foundation, Inc.
+                 2005, 2006, 2007, 2008, 2009  Free Software Foundation, Inc.

     based primarily on public domain code written by Chris Torek
 
 This file is part of GNU Emacs.
 
     based primarily on public domain code written by Chris Torek
 
 This file is part of GNU Emacs.
 

-GNU Emacs is free software; you can redistribute it and/or modify
+GNU Emacs is free software: you can redistribute it and/or modify

 it under the terms of the GNU General Public License as published by
 it under the terms of the GNU General Public License as published by

-the Free Software Foundation; either version 2, or (at your option)
-any later version.
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.

 
 GNU Emacs is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 
 GNU Emacs is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of


@@ -16,15 +16,18 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License

-along with GNU Emacs; see the file COPYING.  If not, write to
-the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-Boston, MA 02110-1301, USA.  */
+along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */

 
 
 #include <config.h>
 #include <stdio.h>
 
 
 #include <config.h>
 #include <stdio.h>

+
+#include "lisp.h"
+#include "frame.h"

 #include "cm.h"
 #include "termhooks.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
 
 /* 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 +56,16 @@ evalcost (c)
   return c;
 }
 
   return c;
 }
 

+/* The terminal to use for low-level output. */
+struct tty_display_info *current_tty;
+

 int
 cmputc (c)
      char c;
 {
 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;
 }
 
   return c;
 }
 


@@ -72,9 +78,9 @@ cmputc (c)
  */
 
 static
  */
 
 static

-at (row, col) {
-    curY = row;
-    curX = col;
+at (tty, row, col) {
+  curY (tty) = row;
+  curX (tty)  = col;

 }
 
 /*
 }
 
 /*


@@ -82,8 +88,8 @@ at (row, col) {
  */
 
 static
  */
 
 static

-addcol (n) {
-    curX += n;
+addcol (tty, n) {
+  curX (tty) += n;

 
     /*
      * If cursor hit edge of screen, what happened?
 
     /*
      * If cursor hit edge of screen, what happened?


@@ -93,21 +99,21 @@ addcol (n) {
      * of the last line.
      */
 
      * 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.
         */
 
        /*
         * 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" */
            ;                   /* "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
        }
        else

-           curX--;
+          curX (tty)--;

     }
 }
 #endif
     }
 }
 #endif


@@ -123,20 +129,20 @@ addcol (n) {
  * after we reach the last column; this takes us to a known state.
  */
 void
  * 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 ();
        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 +154,21 @@ cmcheckmagic ()
  */
 
 void
  */
 
 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)))
 
 {
     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
 
     /*
      * These last three are actually minimum costs.  When (if) they are


@@ -173,9 +179,9 @@ cmcostinit ()
      * cursor motion seem to take straight numeric values.  --ACT)
      */
 
      * 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
 
 #undef CMCOST
 #undef COST


@@ -188,8 +194,8 @@ cmcostinit ()
  */
 
 static int
  */
 
 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,
 {
     register int    deltay,
                     deltax,


@@ -206,16 +212,16 @@ calccost (srcy, srcx, dsty, dstx, doit)
        don't believe the cursor position: give up here
        and force use of absolute positioning.  */
 
        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)
       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
     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");
     if (c == BIG) {            /* caint get thar from here */
        if (doit)
            printf ("OOPS");


@@ -224,16 +230,16 @@ calccost (srcy, srcx, dsty, dstx, doit)
     totalcost = c * deltay;
     if (doit)
        while (--deltay >= 0)
     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) {
 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) */
        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! */
 
     /*
        goto olddelta;          /* forget it! */
 
     /*


@@ -244,12 +250,12 @@ x:
      * we will put into tabx (for ntabs) and tab2x (for n2tabs)).
      */
 
      * 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;
     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;
 
     /*
        n2tabs = 0;
 
     /*


@@ -257,12 +263,12 @@ x:
      * for using n2tabs, then pick the minimum.
      */
 
      * 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;
 
                    : 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 */
                : BIG;
 
     if (c < tabcost)           /* then cheaper to overshoot & back up */


@@ -275,11 +281,11 @@ x:
      * See if tabcost is less than just moving right
      */
 
      * 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)
        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;
     }
 
        srcx = tabx;
     }
 


@@ -292,9 +298,9 @@ newdelta:
        goto done;
 olddelta:
     if (deltax > 0)
        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
     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 */
 
 dodelta:
     if (c == BIG) {            /* caint get thar from here */


@@ -306,7 +312,7 @@ fail:
     totalcost += c * deltax;
     if (doit)
        while (--deltax >= 0)
     totalcost += c * deltax;
     if (doit)
        while (--deltax >= 0)

-           tputs (p, 1, cmputc);
+          emacs_tputs (tty, p, 1, cmputc);

 done:
     return totalcost;
 }
 done:
     return totalcost;
 }


@@ -324,7 +330,8 @@ losecursor ()
 #define        USECR   3
 
 void
 #define        USECR   3
 
 void

-cmgoto (row, col)
+cmgoto (tty, row, col)
+     struct tty_display_info *tty;

      int row, col;
 {
     int     homecost,
      int row, col;
 {
     int     homecost,


@@ -337,47 +344,47 @@ cmgoto (row, col)
            *dcm;
 
   /* First the degenerate case */
            *dcm;
 
   /* First the degenerate case */

-  if (row == curY && col == curX) /* already there */
+    if (row == curY (tty) && col == curX (tty)) /* already there */

     return;
 
     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.
        */
 
     {
       /* 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;
       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)
       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)
       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
              else

-                 crcost += calccost (curY + 1, 0, row, col, 0);
+                crcost += calccost (tty, curY (tty) + 1, 0, row, col, 0);

          else
          else

-             crcost += calccost (curY, 0, row, col, 0);
+            crcost += calccost (tty, curY (tty), 0, row, col, 0);

       }
       if (crcost < relcost)
          relcost = crcost, use = USECR;
       }
       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;
     }
   else
     {
       directcost = 0, relcost = 100000;

-      dcm = Wcm.cm_abs;
+      dcm = tty->Wcm->cm_abs;

     }
 
   /*
     }
 
   /*


@@ -388,13 +395,14 @@ cmgoto (row, col)
     {
       /* compute REAL direct cost */
       cost = 0;
     {
       /* 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 */
       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;
        }
     }
          return;
        }
     }


@@ -402,25 +410,25 @@ cmgoto (row, col)
   switch (use)
     {
     case USEHOME:
   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:
       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:
       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;
     }
 
       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.
 }
 
 /* Clear out all terminal info.


@@ -428,9 +436,9 @@ cmgoto (row, col)
  */
 
 void
  */
 
 void

-Wcm_clear ()
+Wcm_clear (struct tty_display_info *tty)

 {
 {

-  bzero (&Wcm, sizeof Wcm);
+  bzero (tty->Wcm, sizeof (struct cm));

   UP = 0;
   BC = 0;
 }
   UP = 0;
   BC = 0;
 }


@@ -443,21 +451,21 @@ Wcm_clear ()
  */
 
 int
  */
 
 int

-Wcm_init ()
+Wcm_init (struct tty_display_info *tty)

 {
 #if 0
 {
 #if 0

-  if (Wcm.cm_abs && !Wcm.cm_ds)
+  if (tty->Wcm->cm_abs && !tty->Wcm->cm_ds)

     return 0;
 #endif
     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 */
     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;
     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.... */
     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;
 }
     return - 2;
   return 0;
 }