Change all references from point to PT.

diff --git a/src/abbrev.c b/src/abbrev.c
index 6d88dad7716129e7947a6b3312491b3cceb1f937..d6acfe289ba18816383cbe3419766fb7c2e21f35 100644 (file)
--- a/src/abbrev.c
+++ b/src/abbrev.c
@@ -246,7 +246,7 @@ Returns t if expansion took place.")
        del_range (wordstart, wordstart + 1);
     }
   if (!wordstart)
-    wordstart = scan_words (point, -1);
+    wordstart = scan_words (PT, -1);
 
   if (!wordstart)
     return value;
@@ -255,9 +255,9 @@ Returns t if expansion took place.")
   if (!wordend)
     return value;
 
-  if (wordend > point)
-    wordend = point;
-  whitecnt = point - wordend;
+  if (wordend > PT)
+    wordend = PT;
+  whitecnt = PT - wordend;
   if (wordend <= wordstart)
     return value;
 
@@ -304,7 +304,7 @@ Returns t if expansion took place.")
 
   expansion = XSYMBOL (sym)->value;
   insert_from_string (expansion, 0, XSTRING (expansion)->size, 1);
-  SET_PT (point + whitecnt);
+  SET_PT (PT + whitecnt);
 
   if (uccount && !lccount)
     {
@@ -313,14 +313,14 @@ Returns t if expansion took place.")
       /* This used to be if (!... && ... >= ...) Fcapitalize; else Fupcase
         but Megatest 68000 compiler can't handle that */
       if (!abbrev_all_caps)
-       if (scan_words (point, -1) > scan_words (wordstart, 1))
+       if (scan_words (PT, -1) > scan_words (wordstart, 1))
          {
            Fupcase_initials_region (make_number (wordstart),
-                                    make_number (point));
+                                    make_number (PT));
            goto caped;
          }
       /* If expansion is one word, or if user says so, upcase it all. */
-      Fupcase_region (make_number (wordstart), make_number (point));
+      Fupcase_region (make_number (wordstart), make_number (PT));
     caped: ;
     }
   else if (uccount)
@@ -329,7 +329,7 @@ Returns t if expansion took place.")
       int pos = wordstart;
 
       /* Find the initial.  */
-      while (pos < point
+      while (pos < PT
             && SYNTAX (*BUF_CHAR_ADDRESS (current_buffer, pos)) != Sword)
        pos++;
 
@@ -350,7 +350,7 @@ This differs from ordinary undo in that other editing done since then\n\
 is not undone.")
   ()
 {
-  int opoint = point;
+  int opoint = PT;
   int adjust = 0;
   if (last_abbrev_point < BEGV
       || last_abbrev_point > ZV)
@@ -365,7 +365,7 @@ is not undone.")
       if (!STRINGP (val))
        error ("value of abbrev-symbol must be a string");
       adjust = XSTRING (val)->size;
-      del_range (point, point + adjust);
+      del_range (PT, PT + adjust);
       /* Don't inherit properties here; just copy from old contents.  */
       insert_from_string (Vlast_abbrev_text, 0,
                          XSTRING (Vlast_abbrev_text)->size, 0);

diff --git a/src/bytecode.c b/src/bytecode.c
index 4fb6d86bb6999f7abf48ee9bf0ed58946418b179..646ada96aa199091615ea4e4fd3335550bd59316 100644 (file)
--- a/src/bytecode.c
+++ b/src/bytecode.c
@@ -841,7 +841,7 @@ If the third argument is incorrect, Emacs may crash.")
          break;
 
        case Bpoint:
-         XSETFASTINT (v1, point);
+         XSETFASTINT (v1, PT);
          PUSH (v1);
          break;
 

diff --git a/src/callint.c b/src/callint.c
index 14f34f3b5f604d5f64a5d284c2dd01f7125e5858..3741a0930d1f383d1da35ae41cfd9f59a5ba768b 100644 (file)
--- a/src/callint.c
+++ b/src/callint.c
@@ -606,9 +606,9 @@ Otherwise, this is done only if an arg is read using the minibuffer.")
          /* visargs[i+1] = Qnil; */
          foo = marker_position (current_buffer->mark);
          /* visargs[i] = Qnil; */
-         args[i] = point < foo ? point_marker : current_buffer->mark;
+         args[i] = PT < foo ? point_marker : current_buffer->mark;
          varies[i] = 3;
-         args[++i] = point > foo ? point_marker : current_buffer->mark;
+         args[++i] = PT > foo ? point_marker : current_buffer->mark;
          varies[i] = 4;
          break;
 

diff --git a/src/casefiddle.c b/src/casefiddle.c
index 1e3856100a076bb4ba8188f913c5affc7057e070..f44008147788ac7e16000ea094ec12e95d918b2c 100644 (file)
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -227,11 +227,11 @@ operate_on_word (arg, newpoint)
 
   CHECK_NUMBER (arg, 0);
   iarg = XINT (arg);
-  farend = scan_words (point, iarg);
+  farend = scan_words (PT, iarg);
   if (!farend)
     farend = iarg > 0 ? ZV : BEGV;
 
-  *newpoint = point > farend ? point : farend;
+  *newpoint = PT > farend ? PT : farend;
   XSETFASTINT (val, farend);
 
   return val;
@@ -246,7 +246,7 @@ See also `capitalize-word'.")
 {
   Lisp_Object beg, end;
   int newpoint;
-  XSETFASTINT (beg, point);
+  XSETFASTINT (beg, PT);
   end = operate_on_word (arg, &newpoint);
   casify_region (CASE_UP, beg, end);
   SET_PT (newpoint);
@@ -261,7 +261,7 @@ With negative argument, convert previous words but do not move.")
 {
   Lisp_Object beg, end;
   int newpoint;
-  XSETFASTINT (beg, point);
+  XSETFASTINT (beg, PT);
   end = operate_on_word (arg, &newpoint);
   casify_region (CASE_DOWN, beg, end);
   SET_PT (newpoint);
@@ -278,7 +278,7 @@ With negative argument, capitalize previous words but do not move.")
 {
   Lisp_Object beg, end;
   int newpoint;
-  XSETFASTINT (beg, point);
+  XSETFASTINT (beg, PT);
   end = operate_on_word (arg, &newpoint);
   casify_region (CASE_CAPITALIZE, beg, end);
   SET_PT (newpoint);

diff --git a/src/cmds.c b/src/cmds.c
index 9c29982cc80f1558dbcee8789419e315e5b94f9d..1d835d8554f6cd410d08faaaa51c47b5a6829247 100644 (file)
--- a/src/cmds.c
+++ b/src/cmds.c
@@ -57,7 +57,7 @@ On reaching end of buffer, stop and signal error.")
      hooks, etcetera), that's not a good approach.  So we validate the
      proposed position, then set point.  */
   {
-    int new_point = point + XINT (n);
+    int new_point = PT + XINT (n);
 
     if (new_point < BEGV)
       {
@@ -102,7 +102,7 @@ With positive N, a non-empty line at the end counts as one line\n\
   (n)
      Lisp_Object n;
 {
-  int pos2 = point;
+  int pos2 = PT;
   int pos;
   int count, shortage, negp;
 
@@ -178,17 +178,17 @@ N was explicitly specified.")
     {
       if (XINT (n) < 0)
        {
-         if (point + XINT (n) < BEGV)
+         if (PT + XINT (n) < BEGV)
            Fsignal (Qbeginning_of_buffer, Qnil);
          else
-           del_range (point + XINT (n), point);
+           del_range (PT + XINT (n), PT);
        }
       else
        {
-         if (point + XINT (n) > ZV)
+         if (PT + XINT (n) > ZV)
            Fsignal (Qend_of_buffer, Qnil);
          else
-           del_range (point, point + XINT (n));
+           del_range (PT, PT + XINT (n));
        }
     }
   else
@@ -216,9 +216,9 @@ N was explicitly specified.")
   /* See if we are about to delete a tab or newline backwards.  */
   for (i = 1; i <= XINT (n); i++)
     {
-      if (point - i < BEGV)
+      if (PT - i < BEGV)
        break;
-      if (FETCH_CHAR (point - i) == '\t' || FETCH_CHAR (point - i) == '\n')
+      if (FETCH_CHAR (PT - i) == '\t' || FETCH_CHAR (PT - i) == '\n')
        {
          deleted_special = 1;
          break;
@@ -232,10 +232,10 @@ N was explicitly specified.")
   if (XINT (n) > 0
       && ! NILP (current_buffer->overwrite_mode)
       && ! deleted_special
-      && ! (point == ZV || FETCH_CHAR (point) == '\n'))
+      && ! (PT == ZV || FETCH_CHAR (PT) == '\n'))
     {
       Finsert_char (make_number (' '), XINT (n));
-      SET_PT (point - XINT (n));
+      SET_PT (PT - XINT (n));
     }
 
   return value;
@@ -302,22 +302,22 @@ internal_self_insert (c1, noautofill)
     hairy = 1;
 
   if (!NILP (overwrite)
-      && point < ZV
+      && PT < ZV
       && (EQ (overwrite, Qoverwrite_mode_binary)
-         || (c != '\n' && FETCH_CHAR (point) != '\n'))
+         || (c != '\n' && FETCH_CHAR (PT) != '\n'))
       && (EQ (overwrite, Qoverwrite_mode_binary)
-         || FETCH_CHAR (point) != '\t'
+         || FETCH_CHAR (PT) != '\t'
          || XINT (current_buffer->tab_width) <= 0
          || XFASTINT (current_buffer->tab_width) > 20
          || !((current_column () + 1) % XFASTINT (current_buffer->tab_width))))
     {
-      del_range (point, point + 1);
+      del_range (PT, PT + 1);
       hairy = 2;
     }
   if (!NILP (current_buffer->abbrev_mode)
       && SYNTAX (c) != Sword
       && NILP (current_buffer->read_only)
-      && point > BEGV && SYNTAX (FETCH_CHAR (point - 1)) == Sword)
+      && PT > BEGV && SYNTAX (FETCH_CHAR (PT - 1)) == Sword)
     {
       int modiff = MODIFF;
       Fexpand_abbrev ();
@@ -338,10 +338,10 @@ internal_self_insert (c1, noautofill)
        /* After inserting a newline, move to previous line and fill */
        /* that.  Must have the newline in place already so filling and */
        /* justification, if any, know where the end is going to be. */
-       SET_PT (point - 1);
+       SET_PT (PT - 1);
       tem = call0 (current_buffer->auto_fill_function);
       if (c1 == '\n')
-       SET_PT (point + 1);
+       SET_PT (PT + 1);
       if (!NILP (tem))
        hairy = 2;
     }

diff --git a/src/dispnew.c b/src/dispnew.c
index 96d513b8e59d5f0d4dcc299cf53f53b992ead8a0..4c14f0a972bf608ae07216bd8b0fd11cd1ef4e55 100644 (file)
--- a/src/dispnew.c
+++ b/src/dispnew.c
@@ -1104,7 +1104,7 @@ direct_output_for_insert (g)
      At the moment we only lose at end of line or end of buffer
      and only with faces that have some background */
   /* Instead of wasting time, give up if character has any text properties */
-      || ! NILP (Ftext_properties_at (make_number (point - 1), Qnil))
+      || ! NILP (Ftext_properties_at (make_number (PT - 1), Qnil))
 #endif
 
   /* Give up if w is minibuffer and a message is being displayed there */
@@ -1117,17 +1117,17 @@ direct_output_for_insert (g)
     int dummy;
 
     if (FRAME_WINDOW_P (frame) || FRAME_MSDOS_P (frame))
-      face = compute_char_face (frame, w, point - 1, -1, -1, &dummy, point, 0);
+      face = compute_char_face (frame, w, PT - 1, -1, -1, &dummy, PT, 0);
 #endif
     current_frame->glyphs[vpos][hpos] = MAKE_GLYPH (frame, g, face);
-    current_frame->charstarts[vpos][hpos] = point - 1;
+    current_frame->charstarts[vpos][hpos] = PT - 1;
     /* Record the entry for after the newly inserted character.  */
-    current_frame->charstarts[vpos][hpos + 1] = point;
+    current_frame->charstarts[vpos][hpos + 1] = PT;
     adjust_window_charstarts (w, vpos, 1);
   }
   unchanged_modified = MODIFF;
   beg_unchanged = GPT - BEG;
-  XSETFASTINT (w->last_point, point);
+  XSETFASTINT (w->last_point, PT);
   XSETFASTINT (w->last_point_x, hpos);
   XSETFASTINT (w->last_modified, MODIFF);
 
@@ -1179,14 +1179,14 @@ direct_output_forward_char (n)
   /* Don't use direct output next to an invisible character
      since we might need to do something special.  */
 
-  XSETFASTINT (position, point);
+  XSETFASTINT (position, PT);
   if (XFASTINT (position) < ZV
       && ! NILP (Fget_char_property (position,
                                     Qinvisible,
                                     selected_window)))
     return 0;
 
-  XSETFASTINT (position, point - 1);
+  XSETFASTINT (position, PT - 1);
   if (XFASTINT (position) >= BEGV
       && ! NILP (Fget_char_property (position,
                                     Qinvisible,
@@ -1196,7 +1196,7 @@ direct_output_forward_char (n)
 
   FRAME_CURSOR_X (frame) += n;
   XSETFASTINT (w->last_point_x, FRAME_CURSOR_X (frame));
-  XSETFASTINT (w->last_point, point);
+  XSETFASTINT (w->last_point, PT);
   cursor_to (FRAME_CURSOR_Y (frame), FRAME_CURSOR_X (frame));
   fflush (stdout);
 

diff --git a/src/editfns.c b/src/editfns.c
index 88d8841a06d84f02048b27528b2b8e70ff1f0092..6870ae11b4aa8a0fbaa1df24d50b86be44bced3e 100644 (file)
--- a/src/editfns.c
+++ b/src/editfns.c
@@ -178,7 +178,7 @@ Beginning of buffer is position (point-min)")
   ()
 {
   Lisp_Object temp;
-  XSETFASTINT (temp, point);
+  XSETFASTINT (temp, PT);
   return temp;
 }
 
@@ -186,7 +186,7 @@ DEFUN ("point-marker", Fpoint_marker, Spoint_marker, 0, 0, 0,
    "Return value of point, as a marker object.")
   ()
 {
-  return buildmark (point);
+  return buildmark (PT);
 }
 
 int
@@ -224,8 +224,8 @@ region_limit (beginningp)
     Fsignal (Qmark_inactive, Qnil);
   m = Fmarker_position (current_buffer->mark);
   if (NILP (m)) error ("There is no region now");
-  if ((point < XFASTINT (m)) == beginningp)
-    return (make_number (point));
+  if ((PT < XFASTINT (m)) == beginningp)
+    return (make_number (PT));
   else
     return (m);
 }
@@ -393,10 +393,10 @@ At the end of the buffer or accessible region, return 0.")
   ()
 {
   Lisp_Object temp;
-  if (point >= ZV)
+  if (PT >= ZV)
     XSETFASTINT (temp, 0);
   else
-    XSETFASTINT (temp, FETCH_CHAR (point));
+    XSETFASTINT (temp, FETCH_CHAR (PT));
   return temp;
 }
 
@@ -406,10 +406,10 @@ At the beginning of the buffer or accessible region, return 0.")
   ()
 {
   Lisp_Object temp;
-  if (point <= BEGV)
+  if (PT <= BEGV)
     XSETFASTINT (temp, 0);
   else
-    XSETFASTINT (temp, FETCH_CHAR (point - 1));
+    XSETFASTINT (temp, FETCH_CHAR (PT - 1));
   return temp;
 }
 
@@ -418,7 +418,7 @@ DEFUN ("bobp", Fbobp, Sbobp, 0, 0, 0,
 If the buffer is narrowed, this means the beginning of the narrowed part.")
   ()
 {
-  if (point == BEGV)
+  if (PT == BEGV)
     return Qt;
   return Qnil;
 }
@@ -428,7 +428,7 @@ DEFUN ("eobp", Feobp, Seobp, 0, 0, 0,
 If the buffer is narrowed, this means the end of the narrowed part.")
   ()
 {
-  if (point == ZV)
+  if (PT == ZV)
     return Qt;
   return Qnil;
 }
@@ -437,7 +437,7 @@ DEFUN ("bolp", Fbolp, Sbolp, 0, 0, 0,
   "Return T if point is at the beginning of a line.")
   ()
 {
-  if (point == BEGV || FETCH_CHAR (point - 1) == '\n')
+  if (PT == BEGV || FETCH_CHAR (PT - 1) == '\n')
     return Qt;
   return Qnil;
 }
@@ -447,7 +447,7 @@ DEFUN ("eolp", Feolp, Seolp, 0, 0, 0,
 `End of a line' includes point being at the end of the buffer.")
   ()
 {
-  if (point == ZV || FETCH_CHAR (point) == '\n')
+  if (PT == ZV || FETCH_CHAR (PT) == '\n')
     return Qt;
   return Qnil;
 }
@@ -1703,9 +1703,9 @@ or markers) bounding the text that should remain visible.")
 
   BEGV = XFASTINT (start);
   SET_BUF_ZV (current_buffer, XFASTINT (end));
-  if (point < XFASTINT (start))
+  if (PT < XFASTINT (start))
     SET_PT (XFASTINT (start));
-  if (point > XFASTINT (end))
+  if (PT > XFASTINT (end))
     SET_PT (XFASTINT (end));
   current_buffer->clip_changed = 1;
   /* Changing the buffer bounds invalidates any recorded current column.  */

diff --git a/src/indent.c b/src/indent.c
index 503038b54011918ce4374b464f9abd46fe230252..2a05a3d4a65b97b1e5af9367bfb320835359a1ea 100644 (file)
--- a/src/indent.c
+++ b/src/indent.c
@@ -283,7 +283,7 @@ current_column ()
   register struct Lisp_Char_Table *dp = buffer_display_table ();
   int stopchar;
 
-  if (point == last_known_column_point
+  if (PT == last_known_column_point
       && MODIFF == last_known_column_modified)
     return last_known_column;
 
@@ -292,18 +292,18 @@ current_column ()
   if (BUF_INTERVALS (current_buffer)
       || !NILP (current_buffer->overlays_before)
       || !NILP (current_buffer->overlays_after))
-    return current_column_1 (point);
+    return current_column_1 (PT);
 
   /* Scan backwards from point to the previous newline,
      counting width.  Tab characters are the only complicated case.  */
 
   /* Make a pointer for decrementing through the chars before point.  */
-  ptr = &FETCH_CHAR (point - 1) + 1;
+  ptr = &FETCH_CHAR (PT - 1) + 1;
   /* Make a pointer to where consecutive chars leave off,
      going backwards from point.  */
-  if (point == BEGV)
+  if (PT == BEGV)
     stop = ptr;
-  else if (point <= GPT || BEGV > GPT)
+  else if (PT <= GPT || BEGV > GPT)
     stop = BEGV_ADDR;
   else
     stop = GAP_END_ADDR;
@@ -356,7 +356,7 @@ current_column ()
     }
 
   last_known_column = col;
-  last_known_column_point = point;
+  last_known_column_point = PT;
   last_known_column_modified = MODIFF;
 
   return col;
@@ -425,7 +425,7 @@ current_column_1 (pos)
  endloop:
 
   last_known_column = col;
-  last_known_column_point = point;
+  last_known_column_point = PT;
   last_known_column_modified = MODIFF;
 
   return col;
@@ -550,7 +550,7 @@ even if that goes past COLUMN; by default, MININUM is zero.")
   Finsert_char (make_number (' '), column, Qt);
 
   last_known_column = mincol;
-  last_known_column_point = point;
+  last_known_column_point = PT;
   last_known_column_modified = MODIFF;
 
   XSETINT (column, mincol);
@@ -567,7 +567,7 @@ following any initial whitespace.")
 {
   Lisp_Object val;
 
-  XSETFASTINT (val, position_indentation (find_next_newline (point, -1)));
+  XSETFASTINT (val, position_indentation (find_next_newline (PT, -1)));
   return val;
 }
 
@@ -680,7 +680,7 @@ The return value is the current column.")
   CHECK_NATNUM (column, 0);
   goal = XINT (column);
 
-  pos = point;
+  pos = PT;
   end = ZV;
   next_boundary = pos;
 
@@ -743,9 +743,9 @@ The return value is the current column.")
     {
       int old_point;
 
-      del_range (point - 1, point);
+      del_range (PT - 1, PT);
       Findent_to (make_number (goal), Qnil);
-      old_point = point;
+      old_point = PT;
       Findent_to (make_number (col), Qnil);
       SET_PT (old_point);
       /* Set the last_known... vars consistently.  */
@@ -757,7 +757,7 @@ The return value is the current column.")
     Findent_to (make_number (col = goal), Qnil);
 
   last_known_column = col;
-  last_known_column_point = point;
+  last_known_column_point = PT;
   last_known_column_modified = MODIFF;
 
   XSETFASTINT (val, col);
@@ -1409,7 +1409,7 @@ whether or not it is currently displayed in some window.")
   else
     window = selected_window;
 
-  pos = *vmotion (point, (int) XINT (lines), XWINDOW (window));
+  pos = *vmotion (PT, (int) XINT (lines), XWINDOW (window));
 
   SET_PT (pos.bufpos);
   return make_number (pos.vpos);

diff --git a/src/lread.c b/src/lread.c
index f9b95acc170808f41af6c61a0ae50ed5cbd69f2c..21f32863f98e15bcab7365d1f705d766c84e5013 100644 (file)
--- a/src/lread.c
+++ b/src/lread.c
@@ -219,7 +219,7 @@ unreadchar (readcharfun, c)
   else if (BUFFERP (readcharfun))
     {
       if (XBUFFER (readcharfun) == current_buffer)
-       SET_PT (point - 1);
+       SET_PT (PT - 1);
       else
        SET_BUF_PT (XBUFFER (readcharfun), BUF_PT (XBUFFER (readcharfun)) - 1);
     }

diff --git a/src/print.c b/src/print.c
index b6a12e7228d26e48a174d91e4b7046bec8c93fcb..b34adbf98148b180c5ef8e0b66cd8c1a2c5a392c 100644 (file)
--- a/src/print.c
+++ b/src/print.c
@@ -173,9 +173,9 @@ glyph_to_str_cpy (glyphs, str)
          error ("Marker does not point anywhere");             \
        if (XMARKER (original)->buffer != current_buffer)       \
          set_buffer_internal (XMARKER (original)->buffer);     \
-       old_point = point;                                      \
+       old_point = PT;                                         \
        SET_PT (marker_position (printcharfun));                        \
-       start_point = point;                                    \
+       start_point = PT;                                       \
        printcharfun = Qnil;}                                   \
    if (NILP (printcharfun))                                    \
      {                                                         \
@@ -191,10 +191,10 @@ glyph_to_str_cpy (glyphs, str)
      insert (print_buffer, print_buffer_pos);          \
    if (print_buffer) free (print_buffer);              \
    if (MARKERP (original))                             \
-     Fset_marker (original, make_number (point), Qnil);        \
+     Fset_marker (original, make_number (PT), Qnil);   \
    if (old_point >= 0)                                 \
      SET_PT (old_point + (old_point >= start_point     \
-                         ? point - start_point : 0));  \
+                         ? PT - start_point : 0));     \
    if (old != current_buffer)                          \
      set_buffer_internal (old)
 

diff --git a/src/process.c b/src/process.c
index af82f560860dfe1f102a2913e1a107bd66a0efdc..eac1f839f9924570ad98fbbbebeaffff9e24c5a9 100644 (file)
--- a/src/process.c
+++ b/src/process.c
@@ -2554,7 +2554,7 @@ read_process_output (proc, channel)
       odeactivate = Vdeactivate_mark;
 
       Fset_buffer (p->buffer);
-      opoint = point;
+      opoint = PT;
       old_read_only = current_buffer->read_only;
       XSETFASTINT (old_begv, BEGV);
       XSETFASTINT (old_zv, ZV);
@@ -2571,24 +2571,24 @@ read_process_output (proc, channel)
 
       /* If the output marker is outside of the visible region, save
         the restriction and widen.  */
-      if (! (BEGV <= point && point <= ZV))
+      if (! (BEGV <= PT && PT <= ZV))
        Fwiden ();
 
       /* Make sure opoint floats ahead of any new text, just as point
         would.  */
-      if (point <= opoint)
+      if (PT <= opoint)
        opoint += nchars;
 
       /* Insert after old_begv, but before old_zv.  */
-      if (point < XFASTINT (old_begv))
+      if (PT < XFASTINT (old_begv))
        XSETFASTINT (old_begv, XFASTINT (old_begv) + nchars);
-      if (point <= XFASTINT (old_zv))
+      if (PT <= XFASTINT (old_zv))
        XSETFASTINT (old_zv, XFASTINT (old_zv) + nchars);
 
       /* Insert before markers in case we are inserting where
         the buffer's mark is, and the user's next command is Meta-y.  */
       insert_before_markers (chars, nchars);
-      Fset_marker (p->mark, make_number (point), p->buffer);
+      Fset_marker (p->mark, make_number (PT), p->buffer);
 
       update_mode_lines++;
 
@@ -3620,7 +3620,7 @@ status_notify ()
              if (NILP (XBUFFER (buffer)->name))
                continue;
              Fset_buffer (buffer);
-             opoint = point;
+             opoint = PT;
              /* Insert new output into buffer
                 at the current end-of-output marker,
                 thus preserving logical ordering of input and output.  */
@@ -3628,7 +3628,7 @@ status_notify ()
                SET_PT (marker_position (p->mark));
              else
                SET_PT (ZV);
-             if (point <= opoint)
+             if (PT <= opoint)
                opoint += XSTRING (msg)->size + XSTRING (p->name)->size + 10;
 
              tem = current_buffer->read_only;
@@ -3638,7 +3638,7 @@ status_notify ()
              insert_string (" ");
              Finsert (1, &msg);
              current_buffer->read_only = tem;
-             Fset_marker (p->mark, make_number (point), p->buffer);
+             Fset_marker (p->mark, make_number (PT), p->buffer);
 
              SET_PT (opoint);
              set_buffer_internal (old);

diff --git a/src/search.c b/src/search.c
index 53187c2c48566653dc3291770c20297c70bb2664..bfc5add20d7705049c4adb6b3efd1a67712636ea 100644 (file)
--- a/src/search.c
+++ b/src/search.c
@@ -238,7 +238,7 @@ looking_at_1 (string, posix)
     }
   
   i = re_match_2 (bufp, (char *) p1, s1, (char *) p2, s2,
-                 point - BEGV, &search_regs,
+                 PT - BEGV, &search_regs,
                  ZV - BEGV);
   if (i == -2)
     matcher_overflow ();
@@ -762,7 +762,7 @@ skip_chars (forwardp, syntaxp, string, lim)
       fastmap[i] ^= 1;
 
   {
-    int start_point = point;
+    int start_point = PT;
 
     immediate_quit = 1;
     if (syntaxp)
@@ -770,33 +770,33 @@ skip_chars (forwardp, syntaxp, string, lim)
 
        if (forwardp)
          {
-           while (point < XINT (lim)
-                  && fastmap[(unsigned char) syntax_code_spec[(int) SYNTAX (FETCH_CHAR (point))]])
-             SET_PT (point + 1);
+           while (PT < XINT (lim)
+                  && fastmap[(unsigned char) syntax_code_spec[(int) SYNTAX (FETCH_CHAR (PT))]])
+             SET_PT (PT + 1);
          }
        else
          {
-           while (point > XINT (lim)
-                  && fastmap[(unsigned char) syntax_code_spec[(int) SYNTAX (FETCH_CHAR (point - 1))]])
-             SET_PT (point - 1);
+           while (PT > XINT (lim)
+                  && fastmap[(unsigned char) syntax_code_spec[(int) SYNTAX (FETCH_CHAR (PT - 1))]])
+             SET_PT (PT - 1);
          }
       }
     else
       {
        if (forwardp)
          {
-           while (point < XINT (lim) && fastmap[FETCH_CHAR (point)])
-             SET_PT (point + 1);
+           while (PT < XINT (lim) && fastmap[FETCH_CHAR (PT)])
+             SET_PT (PT + 1);
          }
        else
          {
-           while (point > XINT (lim) && fastmap[FETCH_CHAR (point - 1)])
-             SET_PT (point - 1);
+           while (PT > XINT (lim) && fastmap[FETCH_CHAR (PT - 1)])
+             SET_PT (PT - 1);
          }
       }
     immediate_quit = 0;
 
-    return make_number (point - start_point);
+    return make_number (PT - start_point);
   }
 }
 \f
@@ -826,7 +826,7 @@ search_command (string, bound, noerror, count, direction, RE, posix)
     {
       CHECK_NUMBER_COERCE_MARKER (bound, 1);
       lim = XINT (bound);
-      if (n > 0 ? lim < point : lim > point)
+      if (n > 0 ? lim < PT : lim > PT)
        error ("Invalid search bound (wrong side of point)");
       if (lim > ZV)
        lim = ZV;
@@ -834,7 +834,7 @@ search_command (string, bound, noerror, count, direction, RE, posix)
        lim = BEGV;
     }
 
-  np = search_buffer (string, point, lim, n, RE,
+  np = search_buffer (string, PT, lim, n, RE,
                      (!NILP (current_buffer->case_fold_search)
                       ? XCHAR_TABLE (current_buffer->case_canon_table)->contents
                       : 0),
@@ -1745,7 +1745,7 @@ since only regular expressions have distinguished subexpressions.")
 
       for (pos = 0; pos < XSTRING (newtext)->size; pos++)
        {
-         int offset = point - search_regs.start[sub];
+         int offset = PT - search_regs.start[sub];
 
          c = XSTRING (newtext)->data[pos];
          if (c == '\\')
@@ -1773,13 +1773,13 @@ since only regular expressions have distinguished subexpressions.")
       UNGCPRO;
     }
 
-  inslen = point - (search_regs.start[sub]);
+  inslen = PT - (search_regs.start[sub]);
   del_range (search_regs.start[sub] + inslen, search_regs.end[sub] + inslen);
 
   if (case_action == all_caps)
-    Fupcase_region (make_number (point - inslen), make_number (point));
+    Fupcase_region (make_number (PT - inslen), make_number (PT));
   else if (case_action == cap_initial)
-    Fupcase_initials_region (make_number (point - inslen), make_number (point));
+    Fupcase_initials_region (make_number (PT - inslen), make_number (PT));
   return Qnil;
 }
 \f

diff --git a/src/syntax.c b/src/syntax.c
index 8c08aa56a1038b2427c9e8319af45cb916e1170d..22339930b2be21054e49ad6c3c74e32ee6253802 100644 (file)
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -639,7 +639,7 @@ and nil is returned.")
   int val;
   CHECK_NUMBER (count, 0);
 
-  if (!(val = scan_words (point, XINT (count))))
+  if (!(val = scan_words (PT, XINT (count))))
     {
       SET_PT (XINT (count) > 0 ? ZV : BEGV);
       return Qnil;
@@ -1401,7 +1401,7 @@ This includes chars with \"quote\" or \"prefix\" syntax (' or p).")
   ()
 {
   int beg = BEGV;
-  int pos = point;
+  int pos = PT;
 
   while (pos > beg && !char_quoted (pos - 1)
         && (SYNTAX (FETCH_CHAR (pos - 1)) == Squote

diff --git a/src/undo.c b/src/undo.c
index d2cc1d2dcd4537cdfe516f6dac18fda87a2e3a78..9a1394569276264c6e8e71019b016475dd385d99 100644 (file)
--- a/src/undo.c
+++ b/src/undo.c
@@ -108,7 +108,7 @@ record_delete (beg, length)
   if (MODIFF <= SAVE_MODIFF)
     record_first_change ();
 
-  if (point == beg + length)
+  if (PT == beg + length)
     XSETINT (sbeg, -beg);
   else
     XSETFASTINT (sbeg, beg);

diff --git a/src/window.c b/src/window.c
index c27991154bad8f7c61fb5204218137fbfb010d58..19fd3802e8217c4b7e91af0c8afde0c8fdd5a30e 100644 (file)
--- a/src/window.c
+++ b/src/window.c
@@ -2935,7 +2935,7 @@ redraws with point in the center of the current window.")
   if (XINT (arg) < 0)
     XSETINT (arg, XINT (arg) + ht);
 
-  pos = *vmotion (point, - XINT (arg), w);
+  pos = *vmotion (PT, - XINT (arg), w);
 
   Fset_marker (w->start, make_number (pos.bufpos), w->buffer);
   w->start_at_line_beg = ((pos.bufpos == BEGV