(scan_sexps_forward): Additional arg FROM_BYTE. Calls changed.

(find_defun_start): Additional arg POS_BYTE.
Save final byte pos in find_start_value_byte.
(find_start_value_byte): New variable.

(Fforward_comment): Scan by bytes and chars.
(Fbackward_prefix_chars): Scan by bytes and chars.
(scan_words, scan_sexps_forward): Scan bytes as well as chars.
(skip_chars, scan_lists): Scan by bytes and chars.  Now static.

(char_quoted): Take charpos and bytepos as args.
(back_comment): Likewise.
(update_syntax_table): Arg renamed.
(inc_bytepos, dec_bytepos): New functions.

1 files changed, 325 insertions, 494 deletions

diff --git a/src/syntax.c b/src/syntax.c
index d5b4d9407ff..97e8591ba15 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -42,9 +42,6 @@ Boston, MA 02111-1307, USA.  */
 
 Lisp_Object Qsyntax_table_p, Qsyntax_table, Qscan_error;
 
-static void scan_sexps_forward ();
-static int char_quoted ();
-
 int words_include_escapes;
 int parse_sexp_lookup_properties;
 
@@ -72,15 +69,27 @@ struct lisp_parse_state
 /* These variables are a cache for finding the start of a defun.
    find_start_pos is the place for which the defun start was found.
    find_start_value is the defun start position found for it.
+   find_start_value_byte is the corresponding byte position.
    find_start_buffer is the buffer it was found in.
    find_start_begv is the BEGV value when it was found.
    find_start_modiff is the value of MODIFF when it was found.  */
 
 static int find_start_pos;
 static int find_start_value;
+static int find_start_value_byte;
 static struct buffer *find_start_buffer;
 static int find_start_begv;
 static int find_start_modiff;
+
+
+static int find_defun_start P_ ((int, int));
+static int back_comment P_ ((int, int, int, int, int *, int *));
+static int char_quoted P_ ((int, int));
+static Lisp_Object skip_chars P_ ((int, int, Lisp_Object, Lisp_Object));
+static Lisp_Object scan_lists P_ ((int, int, int, int));
+static void scan_sexps_forward P_ ((struct lisp_parse_state *,
+                                    int, int, int, int,
+                                    int, Lisp_Object, int));
 
 
 struct gl_state_s gl_state;             /* Global state of syntax parser.  */
@@ -89,23 +98,22 @@ INTERVAL interval_of ();
 #define INTERVALS_AT_ONCE 10            /* 1 + max-number of intervals
                                            to scan to property-change.  */
 
-/* 
-   Update gl_state to an appropriate interval which contains POS.  The
-   sign of COUNT give the relative position of POS wrt the previously
+/* Update gl_state to an appropriate interval which contains CHARPOS.  The
+   sign of COUNT give the relative position of CHARPOS wrt the previously
    valid interval.  If INIT, only [be]_property fields of gl_state are
-   valid at start, the  rest is filled basing on OBJECT.
+   valid at start, the rest is filled basing on OBJECT.
 
-   `gl_state.*_i' are the intervals, and pos is further in the search
+   `gl_state.*_i' are the intervals, and CHARPOS is further in the search
    direction than the intervals - or in an interval.  We update the
    current syntax-table basing on the property of this interval, and
-   update the interval to start further than POS - or be
+   update the interval to start further than CHARPOS - or be
    NULL_INTERVAL.  We also update lim_property to be the next value of
-   pos to call this subroutine again - or be before/after the
+   charpos to call this subroutine again - or be before/after the
    start/end of OBJECT.  */
 
 void
-update_syntax_table (pos, count, init, object)
-     int pos, count, init;
+update_syntax_table (charpos, count, init, object)
+     int charpos, count, init;
      Lisp_Object object;
 {
   Lisp_Object tmp_table;
@@ -116,7 +124,7 @@ update_syntax_table (pos, count, init, object)
     {
       gl_state.start = gl_state.b_property;
       gl_state.stop = gl_state.e_property;
-      gl_state.forward_i = interval_of (pos, object);
+      gl_state.forward_i = interval_of (charpos, object);
       i = gl_state.backward_i = gl_state.forward_i;
       gl_state.left_ok = gl_state.right_ok = 1;
       invalidate = 0;
@@ -128,15 +136,16 @@ update_syntax_table (pos, count, init, object)
     }
   oldi = i = count > 0 ? gl_state.forward_i : gl_state.backward_i;
 
-  /* We are guarantied to be called with pos either in i, of further off.  */
+  /* We are guarantied to be called with CHARPOS either in i,
+     or further off.  */
   if (NULL_INTERVAL_P (i))
     error ("Error in syntax_table logic for to-the-end intervals");
-  else if (pos < i->position)           /* Move left.  */
+  else if (charpos < i->position)               /* Move left.  */
     {
       if (count > 0)
         error ("Error in syntax_table logic for intervals <-.");
       /* Update the interval.  */
-      i = update_interval (i, pos);
+      i = update_interval (i, charpos);
       if (oldi->position != INTERVAL_LAST_POS (i))
         {
           invalidate = 0;
@@ -145,12 +154,12 @@ update_syntax_table (pos, count, init, object)
           gl_state.e_property = INTERVAL_LAST_POS (i);
         }
     } 
-  else if (pos >= INTERVAL_LAST_POS (i)) /* Move right.  */
+  else if (charpos >= INTERVAL_LAST_POS (i)) /* Move right.  */
     {
       if (count < 0)
         error ("Error in syntax_table logic for intervals ->.");
       /* Update the interval.  */
-      i = update_interval (i, pos);
+      i = update_interval (i, charpos);
       if (i->position != INTERVAL_LAST_POS (oldi))
         {
           invalidate = 0;
@@ -248,30 +257,57 @@ update_syntax_table (pos, count, init, object)
     }    
 }
 
-/* Returns TRUE if char at POS is quoted.
-   Global syntax-table data should be set up already to be good at pos
-   or after.  On return global syntax data is good for lookup at POS. */
+/* Returns TRUE if char at CHARPOS is quoted.
+   Global syntax-table data should be set up already to be good at CHARPOS
+   or after.  On return global syntax data is good for lookup at CHARPOS. */
 
 static int
-char_quoted (pos)
-     register int pos;
+char_quoted (charpos, bytepos)
+     register int charpos, bytepos;
 {
   register enum syntaxcode code;
   register int beg = BEGV;
   register int quoted = 0;
-  int temp_pos = pos;
+  int orig = charpos;
+
+  DEC_BOTH (charpos, bytepos);
 
-  DEC_POS (temp_pos);
-  while (temp_pos >= beg
-         && ( UPDATE_SYNTAX_TABLE_BACKWARD (temp_pos), 1)
-         && ((code = SYNTAX (FETCH_CHAR (temp_pos))) == Scharquote
-             || code == Sescape))
+  while (bytepos >= beg)
     {
-      temp_pos--, quoted = !quoted;
+      UPDATE_SYNTAX_TABLE_BACKWARD (charpos);
+      code = SYNTAX (FETCH_CHAR (bytepos));
+      if (! (code == Scharquote || code == Sescape))
+        break;
+
+      DEC_BOTH (charpos, bytepos);
+      quoted = !quoted;
     }
-  UPDATE_SYNTAX_TABLE (pos);
+
+  UPDATE_SYNTAX_TABLE (orig);
   return quoted;
 }
+
+/* Return the bytepos one character after BYTEPOS.
+   We assume that BYTEPOS is not at the end of the buffer.  */
+
+INLINE int
+inc_bytepos (bytepos)
+     int bytepos;
+{
+  INC_POS (bytepos);
+  return bytepos;
+}
+
+/* Return the bytepos one character before BYTEPOS.
+   We assume that BYTEPOS is not at the start of the buffer.  */
+
+INLINE int
+dec_bytepos (bytepos)
+     int bytepos;
+{
+  DEC_POS (bytepos);
+  return bytepos;
+}
 
 /* Find a defun-start that is the last one before POS (or nearly the last).
    We record what we find, so that another call in the same area
@@ -282,11 +318,12 @@ char_quoted (pos)
    update the global data.  */
 
 static int
-find_defun_start (pos)
-     int pos;
+find_defun_start (pos, pos_byte)
+     int pos, pos_byte;
 {
   int tem;
   int shortage;
+  int opoint = PT, opoint_byte = PT_BYTE;
 
   /* Use previous finding, if it's valid and applies to this inquiry.  */
   if (current_buffer == find_start_buffer
@@ -300,50 +337,60 @@ find_defun_start (pos)
     return find_start_value;
 
   /* Back up to start of line.  */
-  tem = scan_buffer ('\n', pos, BEGV, -1, &shortage, 1);
+  scan_newline (pos, pos_byte, BEGV, BEGV_BYTE, -1, 1);
 
   /* We optimize syntax-table lookup for rare updates.  Thus we accept
      only those `^\s(' which are good in global _and_ text-property
      syntax-tables.  */
   gl_state.current_syntax_table = current_buffer->syntax_table;
   gl_state.use_global = 0;
-  while (tem > BEGV)
+  while (PT > BEGV)
     {
       /* Open-paren at start of line means we found our defun-start.  */
-      if (SYNTAX (FETCH_CHAR (tem)) == Sopen)
+      if (SYNTAX (FETCH_CHAR (PT_BYTE)) == Sopen)
         {
-          SETUP_SYNTAX_TABLE (tem + 1, -1);     /* Try again... */
-          if (SYNTAX (FETCH_CHAR (tem)) == Sopen)
+          SETUP_SYNTAX_TABLE (PT + 1, -1);      /* Try again... */
+          if (SYNTAX (FETCH_CHAR (PT_BYTE)) == Sopen)
             break;
           /* Now fallback to the default value.  */
           gl_state.current_syntax_table = current_buffer->syntax_table;
           gl_state.use_global = 0;
         }
       /* Move to beg of previous line.  */
-      tem = scan_buffer ('\n', tem, BEGV, -2, &shortage, 1);
+      scan_newline (PT, PT_BYTE, BEGV, BEGV_BYTE, -2, 1);
     }
 
   /* Record what we found, for the next try.  */
-  find_start_value = tem;
+  find_start_value = PT;
+  find_start_value_byte = PT_BYTE;
   find_start_buffer = current_buffer;
   find_start_modiff = MODIFF;
   find_start_begv = BEGV;
   find_start_pos = pos;
 
+  TEMP_SET_PT_BOTH (opoint, opoint_byte);
+
   return find_start_value;
 }
 
-/* Checks whether FROM is at the end of a comment;
-   and if so, returns position of the start of the comment.
-   But does not move back before STOP.
-   Returns -1 if there is no comment ending at FROM.
+/* Checks whether charpos FROM is at the end of a comment.
+   FROM_BYTE is the bytepos corresponding to FROM.
+   Do not move back before STOP.
+
+   Return a positive value if we find a comment ending at FROM/FROM_BYTE;
+   return -1 otherwise.
+
+   If successful, store the charpos of the comment's beginning
+   into *CHARPOS_PTR, and the bytepos into *BYTEPOS_PTR.
 
    Global syntax data remains valid for backward search starting at
    the returned value (or at FROM, if the search was not successful).  */
 
 static int
-back_comment (from, stop, comstyle)
-     int from, stop, comstyle;
+back_comment (from, from_byte, stop, comstyle, charpos_ptr, bytepos_ptr)
+     int from, from_byte, stop;
+     int comstyle;
+     int *charpos_ptr, *bytepos_ptr;
 {
   /* Look back, counting the parity of string-quotes,
      and recording the comment-starters seen.
@@ -358,8 +405,10 @@ back_comment (from, stop, comstyle)
   int my_stringend = 0;
   int string_lossage = 0;
   int comment_end = from;
+  int comment_end_byte = from_byte;
   int comstart_pos = 0;
   int comstart_parity = 0;
+  int comstart_byte;
   int scanstart = from - 1;
   register enum syntaxcode code;
   int c;
@@ -368,34 +417,38 @@ back_comment (from, stop, comstyle)
      that determines quote parity to the comment-end.  */
   while (from != stop)
     {
+      int temp_byte;
+
       /* Move back and examine a character.  */
-      DEC_POS (from);
+      DEC_BOTH (from, from_byte);
       UPDATE_SYNTAX_TABLE_BACKWARD (from);
 
-      c = FETCH_CHAR (from);
+      c = FETCH_CHAR (from_byte);
       code = SYNTAX (c);
 
       /* If this char is the second of a 2-char comment end sequence,
          back up and give the pair the appropriate syntax.  */
       if (from > stop && SYNTAX_COMEND_SECOND (c)
-          && SYNTAX_COMEND_FIRST (FETCH_CHAR (from - 1)))
+          && (temp_byte = dec_bytepos (from_byte),
+              SYNTAX_COMEND_FIRST (FETCH_CHAR (temp_byte))))
         {
           code = Sendcomment;
-          DEC_POS (from);
+          DEC_BOTH (from, from_byte);
           /* This is apparently the best we can do: */
           UPDATE_SYNTAX_TABLE_BACKWARD (from);
-          c = FETCH_CHAR (from);
+          c = FETCH_CHAR (from_byte);
         }
                         
       /* If this char starts a 2-char comment start sequence,
          treat it like a 1-char comment starter.  */
       if (from < scanstart && SYNTAX_COMSTART_FIRST (c)
-          && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from + 1))
-          && comstyle == SYNTAX_COMMENT_STYLE (FETCH_CHAR (from + 1)))
+          && (temp_byte = inc_bytepos (from_byte),
+              (SYNTAX_COMSTART_SECOND (FETCH_CHAR (temp_byte))
+               && comstyle == SYNTAX_COMMENT_STYLE (FETCH_CHAR (temp_byte)))))
         code = Scomment;
 
       /* Ignore escaped characters.  */
-      if (char_quoted (from))
+      if (char_quoted (from, from_byte))
         continue;
 
       /* Track parity of quotes.  */
@@ -414,8 +467,8 @@ back_comment (from, stop, comstyle)
         {
           parity ^= 1;
           if (my_stringend == 0)
-            my_stringend = 
-                code == Sstring_fence ? ST_STRING_STYLE : ST_COMMENT_STYLE;
+            my_stringend
+              = code == Sstring_fence ? ST_STRING_STYLE : ST_COMMENT_STYLE;
           /* If we have two kinds of string delimiters.
              There's no way to grok this scanning backwards.  */
           else if (my_stringend != (code == Sstring_fence 
@@ -429,24 +482,28 @@ back_comment (from, stop, comstyle)
         {
           comstart_parity = parity;
           comstart_pos = from;
+          comstart_byte = from_byte;
         }
 
       /* If we find another earlier comment-ender,
          any comment-starts earlier than that don't count
          (because they go with the earlier comment-ender).  */
       if (code == Sendcomment
-          && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from)) == comstyle)
+          && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte)) == comstyle)
         break;
 
       /* Assume a defun-start point is outside of strings.  */
       if (code == Sopen
-          && (from == stop || FETCH_CHAR (from - 1) == '\n'))
+          && (from == stop
+              || (temp_byte = dec_bytepos (from_byte),
+                  FETCH_CHAR (temp_byte) == '\n')))
         break;
     }
 
   if (comstart_pos == 0)
     {
       from = comment_end;
+      from_byte = comment_end_byte;
       UPDATE_SYNTAX_TABLE_FORWARD (comment_end - 1);
     }
   /* If the earliest comment starter
@@ -457,6 +514,7 @@ back_comment (from, stop, comstyle)
   else if (comstart_parity == 0 && !string_lossage) 
     {
       from = comstart_pos;
+      from_byte = comstart_byte;
       /* Globals are correct now.  */
     }
   else
@@ -467,7 +525,9 @@ back_comment (from, stop, comstyle)
          to the one in question; this records where we
          last passed a comment starter.  */
       struct lisp_parse_state state;
-      scan_sexps_forward (&state, find_defun_start (comment_end),
+      scan_sexps_forward (&state,
+                          find_defun_start (comment_end, comment_end_byte),
+                          find_start_value_byte,
                           comment_end - 1, -10000, 0, Qnil, 0);
       if (state.incomment)
         {
@@ -480,9 +540,13 @@ back_comment (from, stop, comstyle)
         {
           from = comment_end;     
         }
+      from_byte = CHAR_TO_BYTE (from);
       UPDATE_SYNTAX_TABLE_FORWARD (from - 1);
     }
     
+  *charpos_ptr = from;
+  *bytepos_ptr = from_byte;
+
   return from;
 }
 
@@ -970,9 +1034,9 @@ scan_words (from, count)
 {
   register int beg = BEGV;
   register int end = ZV;
+  register int from_byte = CHAR_TO_BYTE (from);
   register enum syntaxcode code;
   int ch0, ch1;
-  int temp_pos;
 
   immediate_quit = 1;
   QUIT;
@@ -989,9 +1053,9 @@ scan_words (from, count)
               return 0;
             }
           UPDATE_SYNTAX_TABLE_FORWARD (from);
-          ch0 = FETCH_CHAR (from);
+          ch0 = FETCH_CHAR (from_byte);
           code = SYNTAX (ch0);
-          INC_POS (from);
+          INC_BOTH (from, from_byte);
           if (words_include_escapes
               && (code == Sescape || code == Scharquote))
             break;
@@ -1004,13 +1068,13 @@ scan_words (from, count)
         {
           if (from == end) break;
           UPDATE_SYNTAX_TABLE_FORWARD (from);
-          ch1 = FETCH_CHAR (from);
+          ch1 = FETCH_CHAR (from_byte);
           code = SYNTAX (ch1);
           if (!(words_include_escapes
                 && (code == Sescape || code == Scharquote)))
             if (code != Sword || WORD_BOUNDARY_P (ch0, ch1))
               break;
-          INC_POS (from);
+          INC_BOTH (from, from_byte);
           ch0 = ch1;
         }
       count--;
@@ -1024,9 +1088,9 @@ scan_words (from, count)
               immediate_quit = 0;
               return 0;
             }
-          DEC_POS (from);
+          DEC_BOTH (from, from_byte);
           UPDATE_SYNTAX_TABLE_BACKWARD (from);
-          ch1 = FETCH_CHAR (from);
+          ch1 = FETCH_CHAR (from_byte);
           code = SYNTAX (ch1);
           if (words_include_escapes
               && (code == Sescape || code == Scharquote))
@@ -1038,17 +1102,19 @@ scan_words (from, count)
          position of it.  */
       while (1)
         {
-          if (from == beg) break;
-          temp_pos = from;
-          DEC_POS (temp_pos);
+          int temp_byte;
+
+          if (from == beg)
+            break;
+          temp_byte = dec_bytepos (from_byte);
           UPDATE_SYNTAX_TABLE_BACKWARD (from);
-          ch0 = FETCH_CHAR (temp_pos);
+          ch0 = FETCH_CHAR (temp_byte);
           code = SYNTAX (ch0);
           if (!(words_include_escapes
                 && (code == Sescape || code == Scharquote)))
             if (code != Sword || WORD_BOUNDARY_P (ch0, ch1))
               break;
-          from = temp_pos;
+          DEC_BOTH (from, from_byte);
           ch1 = ch0;
         }
       count++;
@@ -1128,7 +1194,7 @@ This function returns the distance traveled, either zero or negative.")
   return skip_chars (0, 1, syntax, lim);
 }
 
-Lisp_Object
+static Lisp_Object
 skip_chars (forwardp, syntaxp, string, lim)
      int forwardp, syntaxp;
      Lisp_Object string, lim;
@@ -1156,12 +1222,9 @@ skip_chars (forwardp, syntaxp, string, lim)
   if (NILP (lim))
     XSETINT (lim, forwardp ? ZV : BEGV);
   else
-    CHECK_NUMBER_COERCE_MARKER (lim, 1);
+    CHECK_NUMBER_COERCE_MARKER (lim, 0);
 
   /* In any case, don't allow scan outside bounds of buffer.  */
-  /* jla turned this off, for no known reason.
-     bfox turned the ZV part on, and rms turned the
-     BEGV part back on.  */
   if (XINT (lim) > ZV)
     XSETFASTINT (lim, ZV);
   if (XINT (lim) < BEGV)
@@ -1253,6 +1316,7 @@ skip_chars (forwardp, syntaxp, string, lim)
   {
     int start_point = PT;
     int pos = PT;
+    int pos_byte = PT_BYTE;
 
     immediate_quit = 1;
     if (syntaxp)
@@ -1263,9 +1327,9 @@ skip_chars (forwardp, syntaxp, string, lim)
             if (multibyte)
               {
                 while (pos < XINT (lim)
-                       && fastmap[(int) SYNTAX (FETCH_CHAR (pos))])
+                       && fastmap[(int) SYNTAX (FETCH_CHAR (pos_byte))])
                   {
-                    INC_POS (pos);
+                    INC_BOTH (pos, pos_byte);
                     UPDATE_SYNTAX_TABLE_FORWARD (pos);
                   }
               }
@@ -1285,12 +1349,13 @@ skip_chars (forwardp, syntaxp, string, lim)
               {
                 while (pos > XINT (lim))
                   {
-                    int savepos = pos;
-                    DEC_POS (pos);
+                    int savepos = pos_byte;
+                    DEC_BOTH (pos, pos_byte);
                     UPDATE_SYNTAX_TABLE_BACKWARD (pos);
-                    if (!fastmap[(int) SYNTAX (FETCH_CHAR (pos))])
+                    if (!fastmap[(int) SYNTAX (FETCH_CHAR (pos_byte))])
                       {
-                        pos = savepos;
+                        pos++;
+                        pos_byte = savepos;
                         break;
                       }
                   }
@@ -1315,27 +1380,27 @@ skip_chars (forwardp, syntaxp, string, lim)
         if (forwardp)
           {
             if (multibyte)
-              while (pos < XINT (lim) && fastmap[(c = FETCH_BYTE (pos))])
+              while (pos < XINT (lim) && fastmap[(c = FETCH_BYTE (pos_byte))])
                 {
                   if (!BASE_LEADING_CODE_P (c))
-                    pos++;
+                    INC_BOTH (pos, pos_byte);
                   else if (n_char_ranges)
                     {
                       /* We much check CHAR_RANGES for a multibyte
                          character.  */
-                      ch = FETCH_MULTIBYTE_CHAR (pos);
+                      ch = FETCH_MULTIBYTE_CHAR (pos_byte);
                       for (i = 0; i < n_char_ranges; i += 2)
                         if ((ch >= char_ranges[i] && ch <= char_ranges[i + 1]))
                           break;
                       if (!(negate ^ (i < n_char_ranges)))
                         break;
 
-                      INC_POS (pos);
+                      INC_BOTH (pos, pos_byte);
                     }
                   else
                     {
                       if (!negate) break;
-                      INC_POS (pos);
+                      INC_BOTH (pos, pos_byte);
                     }
                 }
             else
@@ -1347,9 +1412,9 @@ skip_chars (forwardp, syntaxp, string, lim)
             if (multibyte)
               while (pos > XINT (lim))
                 {
-                  int savepos = pos;
-                  DEC_POS (pos);
-                  if (fastmap[(c = FETCH_BYTE (pos))])
+                  int savepos = pos_byte;
+                  DEC_BOTH (pos, pos_byte);
+                  if (fastmap[(c = FETCH_BYTE (pos_byte))])
                     {
                       if (!BASE_LEADING_CODE_P (c))
                         ;
@@ -1357,26 +1422,29 @@ skip_chars (forwardp, syntaxp, string, lim)
                         {
                           /* We much check CHAR_RANGES for a multibyte
                              character.  */
-                          ch = FETCH_MULTIBYTE_CHAR (pos);
+                          ch = FETCH_MULTIBYTE_CHAR (pos_byte);
                           for (i = 0; i < n_char_ranges; i += 2)
                             if (ch >= char_ranges[i] && ch <= char_ranges[i + 1])
                               break;
                           if (!(negate ^ (i < n_char_ranges)))
                             {
-                              pos = savepos;
+                              pos++;
+                              pos_byte = savepos;
                               break;
                             }
                         }
                       else
                         if (!negate)
                           {
-                            pos = savepos;
+                            pos++;
+                            pos_byte = savepos;
                             break;
                           }
                     }
                   else
                     {
-                      pos = savepos;
+                      pos++;
+                      pos_byte = savepos;
                       break;
                     }
                 }
@@ -1386,12 +1454,18 @@ skip_chars (forwardp, syntaxp, string, lim)
           }
       }
 
+#if 0 /* Not needed now that a position in mid-character
+         cannot be specified in Lisp.  */
     if (multibyte
         /* INC_POS or DEC_POS might have moved POS over LIM.  */
         && (forwardp ? (pos > XINT (lim)) : (pos < XINT (lim))))
       pos = XINT (lim);
+#endif
 
-    SET_PT (pos);
+    if (! multibyte)
+      pos_byte = pos;
+
+    SET_PT_BOTH (pos, pos_byte);
     immediate_quit = 0;
 
     return make_number (PT - start_point);
@@ -1408,6 +1482,7 @@ between them, return t; otherwise return nil.")
      Lisp_Object count;
 {
   register int from;
+  int from_byte;
   register int stop;
   register int c, c1;
   register enum syntaxcode code;
@@ -1415,6 +1490,7 @@ between them, return t; otherwise return nil.")
   int found;
   int count1;
   int temp_pos;
+  int out_charpos, out_bytepos;
 
   CHECK_NUMBER (count, 0);
   count1 = XINT (count);
@@ -1424,6 +1500,7 @@ between them, return t; otherwise return nil.")
   QUIT;
 
   from = PT;
+  from_byte = PT_BYTE;
 
   SETUP_SYNTAX_TABLE (from, count1);
   while (count1 > 0)
@@ -1432,17 +1509,20 @@ between them, return t; otherwise return nil.")
         {
           if (from == stop)
             {
-              SET_PT (from);
+              if (! NILP (current_buffer->enable_multibyte_characters))
+                SET_PT_BOTH (from, from_byte);
+              else
+                SET_PT_BOTH (from_byte, from_byte);
               immediate_quit = 0;
               return Qnil;
             }
           UPDATE_SYNTAX_TABLE_FORWARD (from);
-          c = FETCH_CHAR (from);
+          c = FETCH_CHAR (from_byte);
           code = SYNTAX (c);
-          INC_POS (from);
+          INC_BOTH (from, from_byte);
           comstyle = 0;
           if (from < stop && SYNTAX_COMSTART_FIRST (c)
-              && (c1 = FETCH_CHAR (from),
+              && (c1 = FETCH_CHAR (from_byte),
                   SYNTAX_COMSTART_SECOND (c1)))
             {
               /* We have encountered a comment start sequence and we 
@@ -1452,15 +1532,19 @@ between them, return t; otherwise return nil.")
                  the comment section.  */
               code = Scomment;
               comstyle = SYNTAX_COMMENT_STYLE (c1);
-              INC_POS (from);
+              INC_BOTH (from, from_byte);
             }
         }
       while (code == Swhitespace || code == Sendcomment);
+
       if (code != Scomment && code != Scomment_fence)
         {
           immediate_quit = 0;
-          DEC_POS (from);
-          SET_PT (from);
+          DEC_BOTH (from, from_byte);
+          if (! NILP (current_buffer->enable_multibyte_characters))
+            SET_PT_BOTH (from, from_byte);
+          else
+            SET_PT_BOTH (from_byte, from_byte);
           return Qnil;
         }
       /* We're at the start of a comment.  */
@@ -1469,12 +1553,15 @@ between them, return t; otherwise return nil.")
           if (from == stop)
             {
               immediate_quit = 0;
-              SET_PT (from);
+              if (! NILP (current_buffer->enable_multibyte_characters))
+                SET_PT_BOTH (from, from_byte);
+              else
+                SET_PT_BOTH (from_byte, from_byte);
               return Qnil;
             }
           UPDATE_SYNTAX_TABLE_FORWARD (from);
-          c = FETCH_CHAR (from);
-          INC_POS (from);
+          c = FETCH_CHAR (from_byte);
+          INC_BOTH (from, from_byte);
           if (SYNTAX (c) == Sendcomment
               && SYNTAX_COMMENT_STYLE (c) == comstyle)
             /* we have encountered a comment end of the same style
@@ -1488,13 +1575,16 @@ between them, return t; otherwise return nil.")
                section.  */
             break;
           if (from < stop && SYNTAX_COMEND_FIRST (c)
-              && (c1 = FETCH_CHAR (from),
+              && (c1 = FETCH_CHAR (from_byte),
                   SYNTAX_COMEND_SECOND (c1))
               && SYNTAX_COMMENT_STYLE (c) == comstyle)
             /* we have encountered a comment end of the same style
                as the comment sequence which began this comment
                section */
-            { INC_POS (from); break; }
+            {
+              INC_BOTH (from, from_byte);
+              break;
+            }
         }
       /* We have skipped one comment.  */
       count1--;
@@ -1507,60 +1597,64 @@ between them, return t; otherwise return nil.")
           int quoted;
           if (from <= stop)
             {
-              SET_PT (stop);
+              SET_PT_BOTH (BEGV, BEGV_BYTE);
               immediate_quit = 0;
               return Qnil;
             }
 
-          DEC_POS (from);
-          quoted = char_quoted (from);
+          DEC_BOTH (from, from_byte);
+          quoted = char_quoted (from, from_byte);
           if (quoted)
             {
-              DEC_POS (from);
-              goto leave;               /* ????? XXXXX */
+              DEC_BOTH (from, from_byte);
+              goto leave;
             }
           UPDATE_SYNTAX_TABLE_BACKWARD (from);
-          c = FETCH_CHAR (from);
+          c = FETCH_CHAR (from_byte);
           code = SYNTAX (c);
           comstyle = 0;
           if (code == Sendcomment)
             comstyle = SYNTAX_COMMENT_STYLE (c);
-          temp_pos = from;
+          temp_pos = from_byte;
           DEC_POS (temp_pos);
           if (from > stop && SYNTAX_COMEND_SECOND (c)
               && (c1 = FETCH_CHAR (temp_pos),
                   SYNTAX_COMEND_FIRST (c1))
-              && !char_quoted (temp_pos))
+              && !char_quoted (from - 1, temp_pos))
             {
               /* We must record the comment style encountered so that
                  later, we can match only the proper comment begin
                  sequence of the same style.  */
               code = Sendcomment;
               comstyle = SYNTAX_COMMENT_STYLE (c1);
-              from = temp_pos;
+              DEC_BOTH (from, from_byte);
             }
           if (from > stop && SYNTAX_COMSTART_SECOND (c)
               && (c1 = FETCH_CHAR (temp_pos),
                   SYNTAX_COMSTART_FIRST (c1))
-              && !char_quoted (temp_pos))
+              && !char_quoted (from - 1, temp_pos))
             {
               /* We must record the comment style encountered so that
                  later, we can match only the proper comment begin
                  sequence of the same style.  */
               code = Scomment;
-              from = temp_pos;
+              DEC_BOTH (from, from_byte);
             }
 
           if (code == Scomment_fence)
             {
               /* Skip until first preceding unquoted comment_fence.  */
-              int found = 0, ini = from;
+              int found = 0, ini = from, ini_byte = from_byte;
               
-              while (--from != stop)
+              while (1)
                 {
+                  DEC_BOTH (from, from_byte);
+                  if (from == stop)
+                    break;
                   UPDATE_SYNTAX_TABLE_BACKWARD (from);
-                  c = FETCH_CHAR (from);
-                  if (SYNTAX (c) == Scomment_fence && !char_quoted (from)) 
+                  c = FETCH_CHAR (from_byte);
+                  if (SYNTAX (c) == Scomment_fence
+                      && !char_quoted (from, from_byte)) 
                     {
                       found = 1; 
                       break;
@@ -1569,160 +1663,16 @@ between them, return t; otherwise return nil.")
               if (found == 0)
                 {
                   from = ini;           /* Set point to ini + 1.  */
+                  from_byte = ini_byte;
                   goto leave;
                 }
             }
           else if (code == Sendcomment)
             {
-#if 0
-              if (code != SYNTAX (c))
-                /* For a two-char comment ender, we can assume
-                   it does end a comment.  So scan back in a simple way.  */
-                {
-                  if (from != stop) DEC_POS (from);
-                  while (1)
-                    {
-                      if ((c = FETCH_CHAR (from),
-                           SYNTAX (c) == Scomment)
-                          && SYNTAX_COMMENT_STYLE (c) == comstyle)
-                        break;
-                      if (from == stop)
-                        {
-                          immediate_quit = 0;
-                          SET_PT (from);
-                          return Qnil;
-                        }
-                      DEC_POS (from);
-                      if (SYNTAX_COMSTART_SECOND (c)
-                          && (c1 = FETCH_CHAR (from),
-                              SYNTAX_COMSTART_FIRST (c1))
-                          && SYNTAX_COMMENT_STYLE (c) == comstyle
-                          && !char_quoted (from))
-                        break;
-                    }
-                  break;
-                }
-#endif /* 0 */
-              found = back_comment (from, stop, comstyle);
-              if (found != -1) from = found;
-#if 0
-              /* Look back, counting the parity of string-quotes,
-                 and recording the comment-starters seen.
-                 When we reach a safe place, assume that's not in a string;
-                 then step the main scan to the earliest comment-starter seen
-                 an even number of string quotes away from the safe place.
-
-                 OFROM[I] is position of the earliest comment-starter seen
-                 which is I+2X quotes from the comment-end.
-                 PARITY is current parity of quotes from the comment end.  */
-              {
-                int parity = 0;
-                char my_stringend = 0;
-                int string_lossage = 0;
-                int comment_end = from;
-                int comstart_pos = 0;
-                int comstart_parity = 0;
-                int scanstart = from;
-
-                DEC_POS (scanstart);
-                /* At beginning of range to scan, we're outside of strings;
-                   that determines quote parity to the comment-end.  */
-                while (from != stop)
-                  {
-                    /* Move back and examine a character.  */
-                    DEC_POS (from);
-
-                    UPDATE_SYNTAX_TABLE_BACKWARD (from);
-                    c = FETCH_CHAR (from);
-                    code = SYNTAX (c);
-
-                    /* If this char is the second of a 2-char comment sequence,
-                       back up and give the pair the appropriate syntax.  */
-                    temp_pos = from;
-                    DEC_POS (temp_pos);
-                    if (from > stop && SYNTAX_COMEND_SECOND (c)
-                        && (c1 = FETCH_CHAR (temp_pos),
-                            SYNTAX_COMEND_FIRST (c1)))
-                      {
-                        code = Sendcomment;
-                        from = temp_pos;
-                        c = c1;
-                      }
-                        
-                    temp_pos = from;
-                    INC_POS (temp_pos);
-                    /* If this char starts a 2-char comment start sequence,
-                       treat it like a 1-char comment starter.  */
-                    if (from < scanstart && SYNTAX_COMSTART_FIRST (c)
-                        && (c1 = FETCH_CHAR (temp_pos),
-                            SYNTAX_COMSTART_SECOND (c1))
-                        && comstyle == SYNTAX_COMMENT_STYLE (c1))
-                      code = Scomment;
-
-                    /* Ignore escaped characters.  */
-                    if (char_quoted (from))
-                      continue;
-
-                    /* Track parity of quotes.  */
-                    if (code == Sstring)
-                      {
-                        parity ^= 1;
-                        if (my_stringend == 0)
-                          my_stringend = c;
-                        /* If we have two kinds of string delimiters.
-                           There's no way to grok this scanning backwards.  */
-                        else if (my_stringend != c)
-                          string_lossage = 1;
-                      }
-
-                    /* Record comment-starters according to that
-                       quote-parity to the comment-end.  */
-                    if (code == Scomment)
-                      {
-                        comstart_parity = parity;
-                        comstart_pos = from;
-                      }
-
-                    /* If we find another earlier comment-ender,
-                       any comment-starts earlier than that don't count
-                       (because they go with the earlier comment-ender).  */
-                    if (code == Sendcomment
-                        && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from)) == comstyle)
-                      break;
-
-                    /* Assume a defun-start point is outside of strings.  */
-                    if (code == Sopen
-                        && (from == stop || FETCH_BYTE (from - 1) == '\n'))
-                      break;
-                  }
-
-                if (comstart_pos == 0)
-                  from = comment_end;
-                /* If the earliest comment starter
-                   is followed by uniform paired string quotes or none,
-                   we know it can't be inside a string
-                   since if it were then the comment ender would be inside one.
-                   So it does start a comment.  Skip back to it.  */
-                else if (comstart_parity == 0 && !string_lossage)
-                  from = comstart_pos;
-                else
-                  {
-                    /* We had two kinds of string delimiters mixed up
-                       together.  Decode this going forwards.
-                       Scan fwd from the previous comment ender
-                       to the one in question; this records where we
-                       last passed a comment starter.  */
-                    struct lisp_parse_state state;
-                    scan_sexps_forward (&state, find_defun_start (comment_end),
-                                        comment_end - 1, -10000, 0, Qnil, 0);
-                    if (state.incomment)
-                      from = state.comstr_start;
-                    else
-                      /* We can't grok this as a comment; scan it normally.  */
-                      from = comment_end;
-                  }
-              }
-#endif /* 0 */
+              found = back_comment (from, from_byte, stop, comstyle,
+                                    &out_charpos, &out_bytepos);
+              if (found != -1)
+                from = out_charpos, from_byte = out_bytepos;
               /* We have skipped one comment.  */
               break;
             }
@@ -1730,8 +1680,11 @@ between them, return t; otherwise return nil.")
             {
             leave:
               immediate_quit = 0;
-              INC_POS (from);
-              SET_PT (from);
+              INC_BOTH (from, from_byte);
+              if (! NILP (current_buffer->enable_multibyte_characters))
+                SET_PT_BOTH (from, from_byte);
+              else
+                SET_PT_BOTH (from_byte, from_byte);
               return Qnil;
             }
         }
@@ -1739,12 +1692,15 @@ between them, return t; otherwise return nil.")
       count1++;
     }
 
-  SET_PT (from);
+  if (! NILP (current_buffer->enable_multibyte_characters))
+    SET_PT_BOTH (from, from_byte);
+  else
+    SET_PT_BOTH (from_byte, from_byte);
   immediate_quit = 0;
   return Qt;
 }
 
-Lisp_Object
+static Lisp_Object
 scan_lists (from, count, depth, sexpflag)
      register int from;
      int count, depth, sexpflag;
@@ -1761,6 +1717,8 @@ scan_lists (from, count, depth, sexpflag)
   int temp_pos;
   int last_good = from;
   int found;
+  int from_byte = CHAR_TO_BYTE (from);
+  int out_bytepos, out_charpos;
 
   if (depth > 0) min_depth = 0;
 
@@ -1773,14 +1731,14 @@ scan_lists (from, count, depth, sexpflag)
       while (from < stop)
         {
           UPDATE_SYNTAX_TABLE_FORWARD (from);
-          c = FETCH_CHAR (from);
+          c = FETCH_CHAR (from_byte);
           code = SYNTAX (c);
           if (depth == min_depth)
             last_good = from;
-          INC_POS (from);
+          INC_BOTH (from, from_byte);
           UPDATE_SYNTAX_TABLE_FORWARD (from);
           if (from < stop && SYNTAX_COMSTART_FIRST (c)
-              && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from))
+              && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from_byte))
               && parse_sexp_ignore_comments)
             {
               /* we have encountered a comment start sequence and we 
@@ -1789,8 +1747,8 @@ scan_lists (from, count, depth, sexpflag)
                  only a comment end of the same style actually ends
                  the comment section */
               code = Scomment;
-              comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from));
-              INC_POS (from);
+              comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte));
+              INC_BOTH (from, from_byte);
             }
           
           UPDATE_SYNTAX_TABLE_FORWARD (from);
@@ -1802,7 +1760,7 @@ scan_lists (from, count, depth, sexpflag)
             case Sescape:
             case Scharquote:
               if (from == stop) goto lose;
-              INC_POS (from);
+              INC_BOTH (from, from_byte);
               /* treat following character as a word constituent */
             case Sword:
             case Ssymbol:
@@ -1811,11 +1769,11 @@ scan_lists (from, count, depth, sexpflag)
               while (from < stop)
                 {
                   UPDATE_SYNTAX_TABLE_FORWARD (from);
-                  switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from))))
+                  switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from_byte))))
                     {
                     case Scharquote:
                     case Sescape:
-                      INC_POS (from);
+                      INC_BOTH (from, from_byte);
                       if (from == stop) goto lose;
                       break;
                     case Sword:
@@ -1825,7 +1783,7 @@ scan_lists (from, count, depth, sexpflag)
                     default:
                       goto done;
                     }
-                  INC_POS (from);
+                  INC_BOTH (from, from_byte);
                 }
               goto done;
 
@@ -1841,7 +1799,7 @@ scan_lists (from, count, depth, sexpflag)
                       goto lose;
                     }
                   UPDATE_SYNTAX_TABLE_FORWARD (from);
-                  c = FETCH_CHAR (from);
+                  c = FETCH_CHAR (from_byte);
                   if (code == Scomment 
                       ? (SYNTAX (c) == Sendcomment
                          && SYNTAX_COMMENT_STYLE (c) == comstyle)
@@ -1850,23 +1808,28 @@ scan_lists (from, count, depth, sexpflag)
                        as the comment sequence which began this comment
                        section */
                     break;
-                  INC_POS (from);
+                  INC_BOTH (from, from_byte);
                   if (from < stop && SYNTAX_COMEND_FIRST (c)
-                      && SYNTAX_COMEND_SECOND (FETCH_CHAR (from))
+                      && SYNTAX_COMEND_SECOND (FETCH_CHAR (from_byte))
                       && SYNTAX_COMMENT_STYLE (c) == comstyle
                       && code == Scomment)
                     /* we have encountered a comment end of the same style
                        as the comment sequence which began this comment
                        section */
-                    { INC_POS (from); break; }
+                    {
+                      INC_BOTH (from, from_byte);
+                      break;
+                    }
                 }
               break;
 
             case Smath:
               if (!sexpflag)
                 break;
-              if (from != stop && c == FETCH_CHAR (from))
-                INC_POS (from);
+              if (from != stop && c == FETCH_CHAR (from_byte))
+                {
+                  INC_BOTH (from, from_byte);
+                }
               if (mathexit)
                 {
                   mathexit = 0;
@@ -1890,7 +1853,7 @@ scan_lists (from, count, depth, sexpflag)
 
             case Sstring:
             case Sstring_fence:
-              temp_pos = from;
+              temp_pos = from_byte;
               DEC_POS (temp_pos);
               stringterm = FETCH_CHAR (temp_pos);
               while (1)
@@ -1898,18 +1861,18 @@ scan_lists (from, count, depth, sexpflag)
                   if (from >= stop) goto lose;
                   UPDATE_SYNTAX_TABLE_FORWARD (from);
                   if (code == Sstring 
-                      ? (FETCH_CHAR (from) == stringterm)
-                      : SYNTAX (FETCH_CHAR (from)) == Sstring_fence) 
+                      ? (FETCH_CHAR (from_byte) == stringterm)
+                      : SYNTAX (FETCH_CHAR (from_byte)) == Sstring_fence) 
                     break;
-                  switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from))))
+                  switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from_byte))))
                     {
                     case Scharquote:
                     case Sescape:
-                      INC_POS (from);
+                      INC_BOTH (from, from_byte);
                     }
-                  INC_POS (from);
+                  INC_BOTH (from, from_byte);
                 }
-              INC_POS (from);
+              INC_BOTH (from, from_byte);
               if (!depth && sexpflag) goto done;
               break;
             }
@@ -1930,25 +1893,25 @@ scan_lists (from, count, depth, sexpflag)
     {
       while (from > stop)
         {
-          DEC_POS (from);
+          DEC_BOTH (from, from_byte);
           UPDATE_SYNTAX_TABLE_BACKWARD (from);
-          if (quoted = char_quoted (from))
+          if (quoted = char_quoted (from, from_byte))
             {
-              DEC_POS (from);
+              DEC_BOTH (from, from_byte);
               UPDATE_SYNTAX_TABLE_BACKWARD (from);
             }
-          c = FETCH_CHAR (from);
+          c = FETCH_CHAR (from_byte);
           code = SYNTAX (c);
           if (depth == min_depth)
             last_good = from;
           comstyle = 0;
           if (code == Sendcomment)
             comstyle = SYNTAX_COMMENT_STYLE (c);
-          temp_pos = from;
+          temp_pos = from_byte;
           DEC_POS (temp_pos);
           if (from > stop && SYNTAX_COMEND_SECOND (c)
               && (c1 = FETCH_CHAR (temp_pos), SYNTAX_COMEND_FIRST (c1))
-              && !char_quoted (temp_pos)
+              && !char_quoted (from - 1, temp_pos)
               && parse_sexp_ignore_comments)
             {
               /* we must record the comment style encountered so that
@@ -1956,7 +1919,7 @@ scan_lists (from, count, depth, sexpflag)
                  sequence of the same style */
               code = Sendcomment;
               comstyle = SYNTAX_COMMENT_STYLE (c1);
-              from = temp_pos;
+              DEC_BOTH (from, from_byte);
             }
           
           if (SYNTAX_PREFIX (c))
@@ -1971,15 +1934,15 @@ scan_lists (from, count, depth, sexpflag)
                  after passing it.  */
               while (from > stop)
                 {
-                  temp_pos = from;
+                  temp_pos = from_byte;
                   DEC_POS (temp_pos);
-                  UPDATE_SYNTAX_TABLE_BACKWARD (temp_pos);
-                  quoted = char_quoted (temp_pos);
+                  UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
+                  quoted = char_quoted (from - 1, temp_pos);
                   if (quoted)
                     {
-                      from = temp_pos;
+                      DEC_BOTH (from, from_byte);
                       DEC_POS (temp_pos);
-                      UPDATE_SYNTAX_TABLE_BACKWARD (temp_pos);
+                      UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
                     }
                   c1 = FETCH_CHAR (temp_pos);
                   temp_code = SYNTAX (c1);
@@ -1987,18 +1950,18 @@ scan_lists (from, count, depth, sexpflag)
                          || temp_code == Ssymbol
                          || temp_code == Squote))
                     goto done2;
-                  from = temp_pos;
+                  DEC_BOTH (from, from_byte);
                 }
               goto done2;
 
             case Smath:
               if (!sexpflag)
                 break;
-              temp_pos = from;
+              temp_pos = from_byte;
               DEC_POS (temp_pos);
-              UPDATE_SYNTAX_TABLE_BACKWARD (temp_pos);
+              UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
               if (from != stop && c == FETCH_CHAR (temp_pos))
-                from = temp_pos;
+                DEC_BOTH (from, from_byte);
               if (mathexit)
                 {
                   mathexit = 0;
@@ -2023,183 +1986,40 @@ scan_lists (from, count, depth, sexpflag)
             case Sendcomment:
               if (!parse_sexp_ignore_comments)
                 break;
-#if 0
-              if (code != SYNTAX (c))
-                /* For a two-char comment ender, we can assume
-                   it does end a comment.  So scan back in a simple way.  */
-                {
-                  if (from != stop) DEC_POS (from);
-                  while (1)
-                    {
-                      if (SYNTAX (c = FETCH_CHAR (from)) == Scomment
-                          && SYNTAX_COMMENT_STYLE (c) == comstyle)
-                        break;
-                      if (from == stop)
-                        {
-                          if (depth == 0)
-                            goto done2;
-                          goto lose;
-                        }
-                      DEC_POS (from);
-                      if (SYNTAX_COMSTART_SECOND (c)
-                          && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from))
-                          && SYNTAX_COMMENT_STYLE (c) == comstyle
-                          && !char_quoted (from))
-                        break;
-                    }
-                  break;
-                }
-#endif /* 0 */
-              found = back_comment (from, stop, comstyle);
-              if (found != -1) from = found;
-#if 0
-              /* Look back, counting the parity of string-quotes,
-                 and recording the comment-starters seen.
-                 When we reach a safe place, assume that's not in a string;
-                 then step the main scan to the earliest comment-starter seen
-                 an even number of string quotes away from the safe place.
-
-                 OFROM[I] is position of the earliest comment-starter seen
-                 which is I+2X quotes from the comment-end.
-                 PARITY is current parity of quotes from the comment end.  */
-              {
-                int parity = 0;
-                char my_stringend = 0;
-                int string_lossage = 0;
-                int comment_end = from;
-                int comstart_pos = 0;
-                int comstart_parity = 0;
-                int scanstart = from;
-
-                DEC_POS (scanstart);
-
-                /* At beginning of range to scan, we're outside of strings;
-                   that determines quote parity to the comment-end.  */
-                while (from != stop)
-                  {
-                    /* Move back and examine a character.  */
-                    DEC_POS (from);
-
-                    c = FETCH_CHAR (from);
-                    code = SYNTAX (c);
-
-                    /* If this char is the second of a 2-char comment sequence,
-                       back up and give the pair the appropriate syntax.  */
-                    temp_pos = from;
-                    DEC_POS (temp_pos);
-                    if (from > stop && SYNTAX_COMEND_SECOND (c)
-                        && (c1 = FETCH_CHAR (temp_pos),
-                            SYNTAX_COMEND_FIRST (c1)))
-                      {
-                        code = Sendcomment;
-                        from = temp_pos;
-                        c = c1;
-                      }
-                        
-                    /* If this char starts a 2-char comment start sequence,
-                       treat it like a 1-char comment starter.  */
-                    temp_pos = from;
-                    INC_POS (temp_pos);
-                    if (from < scanstart && SYNTAX_COMSTART_FIRST (c)
-                        && (c1 = FETCH_CHAR (temp_pos),
-                            SYNTAX_COMSTART_SECOND (c1))
-                        && comstyle == SYNTAX_COMMENT_STYLE (c1))
-                      code = Scomment;
-
-                    /* Ignore escaped characters.  */
-                    if (char_quoted (from))
-                      continue;
-
-                    /* Track parity of quotes.  */
-                    if (code == Sstring)
-                      {
-                        parity ^= 1;
-                        if (my_stringend == 0)
-                          my_stringend = c;
-                        /* If we have two kinds of string delimiters.
-                           There's no way to grok this scanning backwards.  */
-                        else if (my_stringend != c)
-                          string_lossage = 1;
-                      }
-
-                    /* Record comment-starters according to that
-                       quote-parity to the comment-end.  */
-                    if (code == Scomment)
-                      {
-                        comstart_parity = parity;
-                        comstart_pos = from;
-                      }
-
-                    /* If we find another earlier comment-ender,
-                       any comment-starts earlier than that don't count
-                       (because they go with the earlier comment-ender).  */
-                    if (code == Sendcomment
-                        && SYNTAX_COMMENT_STYLE (FETCH_CHAR (from)) == comstyle)
-                      break;
-
-                    /* Assume a defun-start point is outside of strings.  */
-                    if (code == Sopen
-                        && (from == stop || FETCH_BYTE (from - 1) == '\n'))
-                      break;
-                  }
-
-                if (comstart_pos == 0)
-                  from = comment_end;
-                /* If the earliest comment starter
-                   is followed by uniform paired string quotes or none,
-                   we know it can't be inside a string
-                   since if it were then the comment ender would be inside one.
-                   So it does start a comment.  Skip back to it.  */
-                else if (comstart_parity == 0 && !string_lossage)
-                  from = comstart_pos;
-                else
-                  {
-                    /* We had two kinds of string delimiters mixed up
-                       together.  Decode this going forwards.
-                       Scan fwd from the previous comment ender
-                       to the one in question; this records where we
-                       last passed a comment starter.  */
-                    struct lisp_parse_state state;
-                    scan_sexps_forward (&state, find_defun_start (comment_end),
-                                        comment_end - 1, -10000, 0, Qnil, 0);
-                    if (state.incomment)
-                      from = state.comstr_start;
-                    else
-                      /* We can't grok this as a comment; scan it normally.  */
-                      from = comment_end;
-                  }
-              }
-#endif /* 0 */
+              found = back_comment (from, from_byte, stop, comstyle,
+                                    &out_charpos, &out_bytepos);
+              if (found != -1)
+                from = out_charpos, from_byte = out_bytepos;
               break;
 
             case Scomment_fence:
             case Sstring_fence:
               while (1)
                 {
-                  DEC_POS (from);
+                  DEC_BOTH (from, from_byte);
                   if (from == stop) goto lose;
                   UPDATE_SYNTAX_TABLE_BACKWARD (from);
-                  if (!char_quoted (from) 
-                      && SYNTAX (FETCH_CHAR (from)) == code)
+                  if (!char_quoted (from, from_byte) 
+                      && SYNTAX (FETCH_CHAR (from_byte)) == code)
                     break;
                 }
               if (code == Sstring_fence && !depth && sexpflag) goto done2;
               break;
               
             case Sstring:
-              stringterm = FETCH_CHAR (from);
+              stringterm = FETCH_CHAR (from_byte);
               while (1)
                 {
                   if (from == stop) goto lose;
-                  temp_pos = from;
+                  temp_pos = from_byte;
                   DEC_POS (temp_pos);
-                  UPDATE_SYNTAX_TABLE_BACKWARD (temp_pos);
-                  if (!char_quoted (temp_pos)
+                  UPDATE_SYNTAX_TABLE_BACKWARD (from - 1);
+                  if (!char_quoted (from - 1, temp_pos)
                       && stringterm == FETCH_CHAR (temp_pos))
                     break;
-                  from = temp_pos;
+                  DEC_BOTH (from, from_byte);
                 }
-              DEC_POS (from);
+              DEC_BOTH (from, from_byte);
               if (!depth && sexpflag) goto done2;
               break;
             }
@@ -2280,31 +2100,33 @@ This includes chars with \"quote\" or \"prefix\" syntax (' or p).")
   ()
 {
   int beg = BEGV;
+  int opoint = PT;
+  int opoint_byte = PT_BYTE;
   int pos = PT;
+  int pos_byte = PT_BYTE;
   int c;
-  int temp_pos = pos;
 
   if (pos > beg) 
     {
       SETUP_SYNTAX_TABLE (pos, -1);
     }
-  DEC_POS (temp_pos);
 
-  while (pos > beg && !char_quoted (temp_pos)
+  DEC_BOTH (pos, pos_byte);
+
+  while (pos + 1 > beg && !char_quoted (pos, pos_byte)
          /* Previous statement updates syntax table.  */
-         && ((c = FETCH_CHAR (temp_pos), SYNTAX (c) == Squote)
+         && ((c = FETCH_CHAR (pos_byte), SYNTAX (c) == Squote)
              || SYNTAX_PREFIX (c)))
     {
-      pos = temp_pos;
-      DEC_POS (temp_pos);
+      DEC_BOTH (pos, pos_byte);
     }
 
-  SET_PT (pos);
+  SET_PT_BOTH (opoint, opoint_byte);
 
   return Qnil;
 }
 
-/* Parse forward from FROM to END,
+/* Parse forward from FROM / FROM_BYTE to END,
    assuming that FROM has state OLDSTATE (nil means FROM is start of function),
    and return a description of the state of the parse at END.
    If STOPBEFORE is nonzero, stop at the start of an atom.
@@ -2313,7 +2135,7 @@ This includes chars with \"quote\" or \"prefix\" syntax (' or p).")
    after the beginning of a string, or after the end of a string.  */
 
 static void
-scan_sexps_forward (stateptr, from, end, targetdepth,
+scan_sexps_forward (stateptr, from, from_byte, end, targetdepth,
                     stopbefore, oldstate, commentstop)
      struct lisp_parse_state *stateptr;
      register int from;
@@ -2336,14 +2158,22 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
   int start_quoted = 0;         /* Nonzero means starting after a char quote */
   Lisp_Object tem;
   int prev_from;                /* Keep one character before FROM.  */
+  int prev_from_byte;
   int boundary_stop = commentstop == -1;
   int nofence;
 
   prev_from = from;
-  DEC_POS (prev_from);
+  prev_from_byte = from_byte;
+  if (from != BEGV)
+    DEC_BOTH (prev_from, prev_from_byte);
 
   /* Use this macro instead of `from++'.  */
-#define INC_FROM do { prev_from = from; INC_POS (from); } while (0)
+#define INC_FROM                                \
+do { prev_from = from;                          \
+     prev_from_byte = from_byte;                \
+     from++;                                    \
+     INC_POS (from_byte);                       \
+  } while (0)
 
   immediate_quit = 1;
   QUIT;
@@ -2415,7 +2245,7 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
   while (from < end)
     {
       UPDATE_SYNTAX_TABLE_FORWARD (from);
-      code = SYNTAX (FETCH_CHAR (from));
+      code = SYNTAX (FETCH_CHAR (from_byte));
       INC_FROM;
 
       if (code == Scomment)
@@ -2427,14 +2257,14 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
              terminates the comment section.  */
           state.comstyle = ( code == Scomment_fence 
                              ? ST_COMMENT_STYLE 
-                             : SYNTAX_COMMENT_STYLE (FETCH_CHAR (from)));
+                             : SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte)));
           state.comstr_start = prev_from;
           if (code != Scomment_fence) INC_FROM;
           code = Scomment;
         }
      else if (from < end)
-        if (SYNTAX_COMSTART_FIRST (FETCH_CHAR (prev_from)))
-          if (SYNTAX_COMSTART_SECOND (FETCH_CHAR (from)))
+        if (SYNTAX_COMSTART_FIRST (FETCH_CHAR (prev_from_byte)))
+          if (SYNTAX_COMSTART_SECOND (FETCH_CHAR (from_byte)))
             /* Duplicate code to avoid a very complex if-expression
                which causes trouble for the SGI compiler.  */
             {
@@ -2443,13 +2273,13 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
                  terminates the comment section.  */
               state.comstyle = ( code == Scomment_fence 
                                  ? ST_COMMENT_STYLE 
-                                 : SYNTAX_COMMENT_STYLE (FETCH_CHAR (from)));
+                                 : SYNTAX_COMMENT_STYLE (FETCH_CHAR (from_byte)));
               state.comstr_start = prev_from;
               if (code != Scomment_fence) INC_FROM;
               code = Scomment;
             }
 
-      if (SYNTAX_PREFIX (FETCH_CHAR (prev_from)))
+      if (SYNTAX_PREFIX (FETCH_CHAR (prev_from_byte)))
         continue;
       switch (SWITCH_ENUM_CAST (code))
         {
@@ -2470,7 +2300,7 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
           while (from < end)
             {
               UPDATE_SYNTAX_TABLE_FORWARD (from);
-              switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from))))
+              switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from_byte))))
                 {
                 case Scharquote:
                 case Sescape:
@@ -2497,7 +2327,7 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
             {
               /* Enter the loop in the middle so that we find
                  a 2-char comment ender if we start in the middle of it.  */
-              prev = FETCH_CHAR (prev_from);
+              prev = FETCH_CHAR (prev_from_byte);
               goto startincomment_1;
             }
           /* At beginning of buffer, enter the loop the ordinary way.  */
@@ -2512,7 +2342,7 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
             {
               if (from == end) goto done;
               UPDATE_SYNTAX_TABLE_FORWARD (from);
-              prev = FETCH_CHAR (from);
+              prev = FETCH_CHAR (from_byte);
               if (SYNTAX (prev) == Sendcomment
                   && SYNTAX_COMMENT_STYLE (prev) == state.comstyle)
                 /* Only terminate the comment section if the endcomment
@@ -2525,12 +2355,12 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
               INC_FROM;
             startincomment_1:
               if (from < end && SYNTAX_COMEND_FIRST (prev)
-                  && SYNTAX_COMEND_SECOND (FETCH_CHAR (from))
+                  && SYNTAX_COMEND_SECOND (FETCH_CHAR (from_byte))
                   && SYNTAX_COMMENT_STYLE (prev) == state.comstyle)
                 /* Only terminate the comment section if the end-comment
                    sequence of the same style as the start sequence has
                    been encountered.  */
-                { break; }
+                break;
             }
           INC_FROM; 
           state.incomment = 0;
@@ -2566,7 +2396,7 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
           if (stopbefore) goto stop;  /* this arg means stop at sexp start */
           curlevel->last = prev_from;
           state.instring = (code == Sstring 
-                            ? (FETCH_CHAR (prev_from))
+                            ? (FETCH_CHAR (prev_from_byte))
                             : ST_STRING_STYLE);
           if (boundary_stop) goto done;
         startinstring:
@@ -2578,7 +2408,7 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
                 int c;
 
                 if (from >= end) goto done;
-                c = FETCH_CHAR (from);
+                c = FETCH_CHAR (from_byte);
                 if (nofence && c == state.instring) break;
                 UPDATE_SYNTAX_TABLE_FORWARD (from);
                 switch (SWITCH_ENUM_CAST (SYNTAX (c)))
@@ -2679,7 +2509,8 @@ DEFUN ("parse-partial-sexp", Fparse_partial_sexp, Sparse_partial_sexp, 2, 6, 0,
     target = -100000;           /* We won't reach this depth */
 
   validate_region (&from, &to);
-  scan_sexps_forward (&state, XINT (from), XINT (to),
+  scan_sexps_forward (&state, XINT (from), CHAR_TO_BYTE (XINT (from)),
+                      XINT (to),
                       target, !NILP (stopbefore), oldstate,
                       (NILP (commentstop) 
                        ? 0 : (EQ (commentstop, Qsyntax_table) ? -1 : 1)));