Include charset.h and category.h.

(Vsyntax_code_object): New variable.
(Fmodify_syntax_entry): Handle multibyte characters.  A multibyte
character in matching parenthesis is also handled correctly.  Use
shared object in the vector Vsyntax_code_object for an ASCII
character.
(describe_syntax): Handle a multibyte character in matching
parenthesis.
(describe_syntax_1): Describe also parent syntax tables.
(scan_words, Fforward_comment): Handle multibyte characters.
(scan_lists, char_quoted, Fbackward_prefix_chars): Likewise.
(scan_sexps_forward): Likewise.
(init_syntax_once): Initialize Vsyntax_code_object.
Initialize Vstandard_syntax_table by share objects in
Vsyntax_code_object.
(syms_of_syntax): Staticpro Vsyntax_code_object.

1 files changed, 226 insertions, 122 deletions

diff --git a/src/syntax.c b/src/syntax.c
index 1404bfab249..b5d9c9a5b01 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -24,7 +24,9 @@ Boston, MA 02111-1307, USA.  */
 #include "lisp.h"
 #include "commands.h"
 #include "buffer.h"
+#include "charset.h"
 #include "syntax.h"
+#include "category.h"
 
 Lisp_Object Qsyntax_table_p, Qsyntax_table, Qscan_error;
 
@@ -222,6 +224,14 @@ char syntax_code_spec[14] =
   {
     ' ', '.', 'w', '_', '(', ')', '\'', '\"', '$', '\\', '/', '<', '>', '@'
   };
+
+/* Indexed by syntax code, give the object (cons of syntax code and
+   nil) to be stored in syntax table.  Since these objects can be
+   shared among syntax tables, we generate them in advance.  By
+   sharing objects, the function `describe-syntax' can give a more
+   compact listing.  */
+static Lisp_Object Vsyntax_code_object;
+
 
 /* Look up the value for CHARACTER in syntax table TABLE's parent
    and its parents.  SYNTAX_ENTRY calls this, when TABLE itself has nil
@@ -351,9 +361,13 @@ DEFUN ("modify-syntax-entry", Fmodify_syntax_entry, Smodify_syntax_entry, 2, 3,
 
   if (*p)
     {
-      XSETINT (match, *p++);
+      int len;
+      int character = STRING_CHAR_AND_LENGTH (p, XSTRING (newentry)->size - 1,
+					      len);
+      XSETINT (match, character);
       if (XFASTINT (match) == ' ')
 	match = Qnil;
+      p += len;
     }
   else
     match = Qnil;
@@ -387,8 +401,13 @@ DEFUN ("modify-syntax-entry", Fmodify_syntax_entry, Smodify_syntax_entry, 2, 3,
 	break;
       }
 	
-  SET_RAW_SYNTAX_ENTRY (syntax_table, c,
-			Fcons (make_number (val), match));
+  if (val < XVECTOR (Vsyntax_code_object)->size && NILP (match))
+    newentry = XVECTOR (Vsyntax_code_object)->contents[val];
+  else
+    /* Since we can't use a shared object, let's make a new one.  */
+    newentry = Fcons (make_number (val), match);
+    
+  SET_RAW_SYNTAX_ENTRY (syntax_table, c, newentry);
 
   return Qnil;
 }
@@ -408,13 +427,13 @@ describe_syntax (value)
 
   if (NILP (value))
     {
-      insert_string ("inherit");
+      insert_string ("default\n");
       return;
     }
 
   if (!CONSP (value))
     {
-      insert_string ("invalid");
+      insert_string ("invalid\n");
       return;
     }
 
@@ -423,7 +442,7 @@ describe_syntax (value)
 
   if (!INTEGERP (first) || !(NILP (match_lisp) || INTEGERP (match_lisp)))
     {
-      insert_string ("invalid");
+      insert_string ("invalid\n");
       return;
     }
 
@@ -445,8 +464,10 @@ describe_syntax (value)
   str[0] = desc, str[1] = 0;
   insert (str, 1);
 
-  str[0] = !NILP (match_lisp) ? XINT (match_lisp) : ' ';
-  insert (str, 1);
+  if (NILP (match_lisp))
+    insert (" ", 1);
+  else
+    insert_char (XINT (match_lisp));
 
   if (start1)
     insert ("1", 1);
@@ -529,6 +550,13 @@ describe_syntax_1 (vector)
   struct buffer *old = current_buffer;
   set_buffer_internal (XBUFFER (Vstandard_output));
   describe_vector (vector, Qnil, describe_syntax, 0, Qnil, Qnil);
+  while (! NILP (XCHAR_TABLE (vector)->parent))
+    {
+      vector = XCHAR_TABLE (vector)->parent;
+      insert_string ("\nThe parent syntax table is:");
+      describe_vector (vector, Qnil, describe_syntax, 0, Qnil, Qnil);
+    }
+	
   call0 (intern ("help-mode"));
   set_buffer_internal (old);
   return Qnil;
@@ -554,8 +582,9 @@ scan_words (from, count)
 {
   register int beg = BEGV;
   register int end = ZV;
-  register int code;
-  int charcode;
+  register enum syntaxcode code;
+  int ch0, ch1;
+  int temp_pos;
 
   immediate_quit = 1;
   QUIT;
@@ -569,25 +598,28 @@ scan_words (from, count)
 	      immediate_quit = 0;
 	      return 0;
 	    }
-	  charcode = FETCH_CHAR (from);
-	  code = SYNTAX (charcode);
+	  ch0 = FETCH_CHAR (from);
+	  code = SYNTAX (ch0);
+	  INC_POS (from);
 	  if (words_include_escapes
 	      && (code == Sescape || code == Scharquote))
 	    break;
 	  if (code == Sword)
 	    break;
-	  from++;
 	}
+      /* Now CH0 is a character which begins a word and FROM is the
+         position of the next character.  */
       while (1)
 	{
 	  if (from == end) break;
-	  charcode = FETCH_CHAR (from);
-	  code = SYNTAX (charcode);
+	  ch1 = FETCH_CHAR (from);
+	  code = SYNTAX (ch1);
 	  if (!(words_include_escapes
 		&& (code == Sescape || code == Scharquote)))
-	    if (code != Sword)
+	    if (code != Sword || WORD_BOUNDARY_P (ch0, ch1))
 	      break;
-	  from++;
+	  INC_POS (from);
+	  ch0 = ch1;
 	}
       count--;
     }
@@ -600,25 +632,30 @@ scan_words (from, count)
 	      immediate_quit = 0;
 	      return 0;
 	    }
-	  charcode = FETCH_CHAR (from - 1);
-	  code = SYNTAX (charcode);
+	  DEC_POS (from);
+	  ch1 = FETCH_CHAR (from);
+	  code = SYNTAX (ch1);
 	  if (words_include_escapes
 	      && (code == Sescape || code == Scharquote))
 	    break;
 	  if (code == Sword)
 	    break;
-	  from--;
 	}
+      /* Now CH1 is a character which ends a word and FROM is the
+         position of it.  */
       while (1)
 	{
 	  if (from == beg) break;
-	  charcode = FETCH_CHAR (from - 1);
-	  code = SYNTAX (charcode);
+	  temp_pos = from;
+	  DEC_POS (temp_pos);
+	  ch0 = FETCH_CHAR (temp_pos);
+	  code = SYNTAX (ch0);
 	  if (!(words_include_escapes
 		&& (code == Sescape || code == Scharquote)))
-	    if (code != Sword)
+	    if (code != Sword || WORD_BOUNDARY_P (ch0, ch1))
 	      break;
-	  from--;
+	  from = temp_pos;
+	  ch1 = ch0;
 	}
       count++;
     }
@@ -664,6 +701,7 @@ between them, return t; otherwise return nil.")
   int comstyle = 0;	    /* style of comment encountered */
   int found;
   int count1;
+  int temp_pos;
 
   CHECK_NUMBER (count, 0);
   count1 = XINT (count);
@@ -686,7 +724,7 @@ between them, return t; otherwise return nil.")
 	    }
 	  c = FETCH_CHAR (from);
 	  code = SYNTAX (c);
-	  from++;
+	  INC_POS (from);
 	  comstyle = 0;
 	  if (from < stop && SYNTAX_COMSTART_FIRST (c)
 	      && (c1 = FETCH_CHAR (from),
@@ -699,14 +737,15 @@ between them, return t; otherwise return nil.")
 		 the comment section.  */
 	      code = Scomment;
 	      comstyle = SYNTAX_COMMENT_STYLE (c1);
-	      from++;
+	      INC_POS (from);
 	    }
 	}
       while (code == Swhitespace || code == Sendcomment);
       if (code != Scomment)
 	{
 	  immediate_quit = 0;
-	  SET_PT (from - 1);
+	  DEC_POS (from);
+	  SET_PT (from);
 	  return Qnil;
 	}
       /* We're at the start of a comment.  */
@@ -719,7 +758,7 @@ between them, return t; otherwise return nil.")
 	      return Qnil;
 	    }
 	  c = FETCH_CHAR (from);
-	  from++;
+	  INC_POS (from);
 	  if (SYNTAX (c) == Sendcomment
 	      && SYNTAX_COMMENT_STYLE (c) == comstyle)
 	    /* we have encountered a comment end of the same style
@@ -733,7 +772,7 @@ between them, return t; otherwise return nil.")
 	    /* we have encountered a comment end of the same style
 	       as the comment sequence which began this comment
 	       section */
-	    { from++; break; }
+	    { INC_POS (from); break; }
 	}
       /* We have skipped one comment.  */
       count1--;
@@ -746,26 +785,28 @@ between them, return t; otherwise return nil.")
 	{
 	  int quoted;
 
-	  from--;
+	  DEC_POS (from);
 	  quoted = char_quoted (from);
 	  if (quoted)
-	    from--;
+	    DEC_POS (from);
 	  c = FETCH_CHAR (from);
 	  code = SYNTAX (c);
 	  comstyle = 0;
 	  if (code == Sendcomment)
 	    comstyle = SYNTAX_COMMENT_STYLE (c);
+	  temp_pos = from;
+	  DEC_POS (temp_pos);
 	  if (from > stop && SYNTAX_COMEND_SECOND (c)
-	      && (c1 = FETCH_CHAR (from - 1),
+	      && (c1 = FETCH_CHAR (temp_pos),
 		  SYNTAX_COMEND_FIRST (c1))
-	      && !char_quoted (from - 1))
+	      && !char_quoted (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--;
+	      from = temp_pos;
 	    }
 
 	  if (code == Sendcomment && !quoted)
@@ -775,7 +816,7 @@ between them, return t; otherwise return nil.")
 		/* For a two-char comment ender, we can assume
 		   it does end a comment.  So scan back in a simple way.  */
 		{
-		  if (from != stop) from--;
+		  if (from != stop) DEC_POS (from);
 		  while (1)
 		    {
 		      if ((c = FETCH_CHAR (from),
@@ -788,7 +829,7 @@ between them, return t; otherwise return nil.")
 			  SET_PT (from);
 			  return Qnil;
 			}
-		      from--;
+		      DEC_POS (from);
 		      if (SYNTAX_COMSTART_SECOND (c)
 			  && (c1 = FETCH_CHAR (from),
 			      SYNTAX_COMSTART_FIRST (c1))
@@ -816,33 +857,40 @@ between them, return t; otherwise return nil.")
 		int comment_end = from;
 		int comstart_pos = 0;
 		int comstart_parity = 0;
-		int scanstart = from - 1;
+		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.  */
-		    from--;
+		    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)
-			&& SYNTAX_COMEND_FIRST (FETCH_CHAR (from - 1)))
+			&& (c1 = FETCH_CHAR (temp_pos),
+			    SYNTAX_COMEND_FIRST (c1)))
 		      {
 			code = Sendcomment;
-			from--;
-		        c = FETCH_CHAR (from);
+			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)
-			&& SYNTAX_COMSTART_SECOND (FETCH_CHAR (from + 1))
-			&& comstyle == SYNTAX_COMMENT_STYLE (FETCH_CHAR (from + 1)))
+			&& (c1 = FETCH_CHAR (temp_pos),
+			    SYNTAX_COMSTART_SECOND (c1))
+			&& comstyle == SYNTAX_COMMENT_STYLE (c1))
 		      code = Scomment;
 
 		    /* Ignore escaped characters.  */
@@ -878,7 +926,7 @@ between them, return t; otherwise return nil.")
 
 		    /* Assume a defun-start point is outside of strings.  */
 		    if (code == Sopen
-			&& (from == stop || FETCH_CHAR (from - 1) == '\n'))
+			&& (from == stop || FETCH_BYTE (from - 1) == '\n'))
 		      break;
 		  }
 
@@ -914,7 +962,8 @@ between them, return t; otherwise return nil.")
 	  else if ((code != Swhitespace && code != Scomment) || quoted)
 	    {
 	      immediate_quit = 0;
-	      SET_PT (from + 1);
+	      INC_POS (from);
+	      SET_PT (from);
 	      return Qnil;
 	    }
 	}
@@ -936,13 +985,14 @@ scan_lists (from, count, depth, sexpflag)
 {
   Lisp_Object val;
   register int stop;
-  register int c;
-  unsigned char stringterm;
+  register int c, c1;
+  int stringterm;
   int quoted;
   int mathexit = 0;
-  register enum syntaxcode code;
+  register enum syntaxcode code, temp_code;
   int min_depth = depth;    /* Err out if depth gets less than this. */
   int comstyle = 0;	    /* style of comment encountered */
+  int temp_pos;
   int last_good = from;
 
   if (depth > 0) min_depth = 0;
@@ -959,7 +1009,7 @@ scan_lists (from, count, depth, sexpflag)
 	  code = SYNTAX (c);
 	  if (depth == min_depth)
 	    last_good = from;
-	  from++;
+	  INC_POS (from);
 	  if (from < stop && SYNTAX_COMSTART_FIRST (c)
 	      && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from))
 	      && parse_sexp_ignore_comments)
@@ -971,7 +1021,7 @@ scan_lists (from, count, depth, sexpflag)
 		 the comment section */
 	      code = Scomment;
 	      comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from));
-	      from++;
+	      INC_POS (from);
 	    }
 	  
 	  if (SYNTAX_PREFIX (c))
@@ -982,7 +1032,7 @@ scan_lists (from, count, depth, sexpflag)
 	    case Sescape:
 	    case Scharquote:
 	      if (from == stop) goto lose;
-	      from++;
+	      INC_POS (from);
 	      /* treat following character as a word constituent */
 	    case Sword:
 	    case Ssymbol:
@@ -994,7 +1044,7 @@ scan_lists (from, count, depth, sexpflag)
 		    {
 		    case Scharquote:
 		    case Sescape:
-		      from++;
+		      INC_POS (from);
 		      if (from == stop) goto lose;
 		      break;
 		    case Sword:
@@ -1004,7 +1054,7 @@ scan_lists (from, count, depth, sexpflag)
 		    default:
 		      goto done;
 		    }
-		  from++;
+		  INC_POS (from);
 		}
 	      goto done;
 
@@ -1025,14 +1075,14 @@ scan_lists (from, count, depth, sexpflag)
 		       as the comment sequence which began this comment
 		       section */
 		    break;
-		  from++;
+		  INC_POS (from);
 		  if (from < stop && SYNTAX_COMEND_FIRST (c)
 		      && SYNTAX_COMEND_SECOND (FETCH_CHAR (from))
 		      && SYNTAX_COMMENT_STYLE (c) == comstyle)
 		    /* we have encountered a comment end of the same style
 		       as the comment sequence which began this comment
 		       section */
-		    { from++; break; }
+		    { INC_POS (from); break; }
 		}
 	      break;
 
@@ -1040,7 +1090,7 @@ scan_lists (from, count, depth, sexpflag)
 	      if (!sexpflag)
 		break;
 	      if (from != stop && c == FETCH_CHAR (from))
-		from++;
+		INC_POS (from);
 	      if (mathexit)
 		{
 		  mathexit = 0;
@@ -1063,7 +1113,9 @@ scan_lists (from, count, depth, sexpflag)
 	      break;
 
 	    case Sstring:
-	      stringterm = FETCH_CHAR (from - 1);
+	      temp_pos = from;
+	      DEC_POS (temp_pos);
+	      stringterm = FETCH_CHAR (temp_pos);
 	      while (1)
 		{
 		  if (from >= stop) goto lose;
@@ -1072,11 +1124,11 @@ scan_lists (from, count, depth, sexpflag)
 		    {
 		    case Scharquote:
 		    case Sescape:
-		      from++;
+		      INC_POS (from);
 		    }
-		  from++;
+		  INC_POS (from);
 		}
-	      from++;
+	      INC_POS (from);
 	      if (!depth && sexpflag) goto done;
 	      break;
 	    }
@@ -1098,9 +1150,9 @@ scan_lists (from, count, depth, sexpflag)
       stop = BEGV;
       while (from > stop)
 	{
-	  from--;
+	  DEC_POS (from);
 	  if (quoted = char_quoted (from))
-	    from--;
+	    DEC_POS (from);
 	  c = FETCH_CHAR (from);
 	  code = SYNTAX (c);
 	  if (depth == min_depth)
@@ -1108,17 +1160,19 @@ scan_lists (from, count, depth, sexpflag)
 	  comstyle = 0;
 	  if (code == Sendcomment)
 	    comstyle = SYNTAX_COMMENT_STYLE (c);
+	  temp_pos = from;
+	  DEC_POS (temp_pos);
 	  if (from > stop && SYNTAX_COMEND_SECOND (c)
-	      && SYNTAX_COMEND_FIRST (FETCH_CHAR (from - 1))
-	      && !char_quoted (from - 1)
+	      && (c1 = FETCH_CHAR (temp_pos), SYNTAX_COMEND_FIRST (c1))
+	      && !char_quoted (temp_pos)
 	      && parse_sexp_ignore_comments)
 	    {
 	      /* 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 (FETCH_CHAR (from - 1));
-	      from--;
+	      comstyle = SYNTAX_COMMENT_STYLE (c1);
+	      from = temp_pos;
 	    }
 	  
 	  if (SYNTAX_PREFIX (c))
@@ -1132,22 +1186,31 @@ scan_lists (from, count, depth, sexpflag)
 	      /* This word counts as a sexp; count object finished after passing it. */
 	      while (from > stop)
 		{
-		  quoted = char_quoted (from - 1);
+		  temp_pos = from;
+		  DEC_POS (temp_pos);
+		  quoted = char_quoted (temp_pos);
 		  if (quoted)
-		    from--;
-		  if (! (quoted || SYNTAX (FETCH_CHAR (from - 1)) == Sword
-			 || SYNTAX (FETCH_CHAR (from - 1)) == Ssymbol
-			 || SYNTAX (FETCH_CHAR (from - 1)) == Squote))
+		    {
+		      from = temp_pos;
+		      DEC_POS (temp_pos);
+		    }
+		  c1 = FETCH_CHAR (temp_pos);
+		  temp_code = SYNTAX (c1);
+		  if (! (quoted || temp_code == Sword
+			 || temp_code == Ssymbol
+			 || temp_code == Squote))
             	    goto done2;
-		  from--;
+		  from = temp_pos;
 		}
 	      goto done2;
 
 	    case Smath:
 	      if (!sexpflag)
 		break;
-	      if (from != stop && c == FETCH_CHAR (from - 1))
-		from--;
+	      temp_pos = from;
+	      DEC_POS (temp_pos);
+	      if (from != stop && c == FETCH_CHAR (temp_pos))
+		from = temp_pos;
 	      if (mathexit)
 		{
 		  mathexit = 0;
@@ -1177,7 +1240,7 @@ scan_lists (from, count, depth, sexpflag)
 		/* For a two-char comment ender, we can assume
 		   it does end a comment.  So scan back in a simple way.  */
 		{
-		  if (from != stop) from--;
+		  if (from != stop) DEC_POS (from);
 		  while (1)
 		    {
 		      if (SYNTAX (c = FETCH_CHAR (from)) == Scomment
@@ -1189,7 +1252,7 @@ scan_lists (from, count, depth, sexpflag)
 			    goto done2;
 			  goto lose;
 			}
-		      from--;
+		      DEC_POS (from);
 		      if (SYNTAX_COMSTART_SECOND (c)
 			  && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from))
 			  && SYNTAX_COMMENT_STYLE (c) == comstyle
@@ -1216,33 +1279,41 @@ scan_lists (from, count, depth, sexpflag)
 		int comment_end = from;
 		int comstart_pos = 0;
 		int comstart_parity = 0;
-		int scanstart = from - 1;
+		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.  */
-		    from--;
+		    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)
-			&& SYNTAX_COMEND_FIRST (FETCH_CHAR (from - 1)))
+			&& (c1 = FETCH_CHAR (temp_pos),
+			    SYNTAX_COMEND_FIRST (c1)))
 		      {
 			code = Sendcomment;
-			from--;
-		        c = FETCH_CHAR (from);
+			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)
-			&& SYNTAX_COMSTART_SECOND (FETCH_CHAR (from + 1))
-			&& comstyle == SYNTAX_COMMENT_STYLE (FETCH_CHAR (from + 1)))
+			&& (c1 = FETCH_CHAR (temp_pos),
+			    SYNTAX_COMSTART_SECOND (c1))
+			&& comstyle == SYNTAX_COMMENT_STYLE (c1))
 		      code = Scomment;
 
 		    /* Ignore escaped characters.  */
@@ -1278,7 +1349,7 @@ scan_lists (from, count, depth, sexpflag)
 
 		    /* Assume a defun-start point is outside of strings.  */
 		    if (code == Sopen
-			&& (from == stop || FETCH_CHAR (from - 1) == '\n'))
+			&& (from == stop || FETCH_BYTE (from - 1) == '\n'))
 		      break;
 		  }
 
@@ -1315,12 +1386,14 @@ scan_lists (from, count, depth, sexpflag)
 	      while (1)
 		{
 		  if (from == stop) goto lose;
-		  if (!char_quoted (from - 1)
-		      && stringterm == FETCH_CHAR (from - 1))
+		  temp_pos = from;
+		  DEC_POS (temp_pos);
+		  if (!char_quoted (temp_pos)
+		      && stringterm == FETCH_CHAR (temp_pos))
 		    break;
-		  from--;
+		  from = temp_pos;
 		}
-	      from--;
+	      DEC_POS (from);
 	      if (!depth && sexpflag) goto done2;
 	      break;
 	    }
@@ -1357,11 +1430,17 @@ char_quoted (pos)
   register enum syntaxcode code;
   register int beg = BEGV;
   register int quoted = 0;
+  int temp_pos = pos;
 
+  DEC_POS (temp_pos);
   while (pos > beg
-	 && ((code = SYNTAX (FETCH_CHAR (pos - 1))) == Scharquote
+	 && ((code = SYNTAX (FETCH_CHAR (temp_pos))) == Scharquote
 	     || code == Sescape))
-    pos--, quoted = !quoted;
+    {
+      pos = temp_pos;
+      quoted = !quoted;
+      DEC_POS (temp_pos);
+    }
   return quoted;
 }
 
@@ -1417,11 +1496,18 @@ This includes chars with \"quote\" or \"prefix\" syntax (' or p).")
 {
   int beg = BEGV;
   int pos = PT;
+  int c;
+  int temp_pos = pos;
+
+  DEC_POS (temp_pos);
 
-  while (pos > beg && !char_quoted (pos - 1)
-	 && (SYNTAX (FETCH_CHAR (pos - 1)) == Squote
-	     || SYNTAX_PREFIX (FETCH_CHAR (pos - 1))))
-    pos--;
+  while (pos > beg && !char_quoted (temp_pos)
+	 && ((c = FETCH_CHAR (temp_pos), SYNTAX (c) == Squote)
+	     || SYNTAX_PREFIX (c)))
+    {
+      pos = temp_pos;
+      DEC_POS (temp_pos);
+    }
 
   SET_PT (pos);
 
@@ -1450,13 +1536,20 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
   struct level levelstart[100];
   register struct level *curlevel = levelstart;
   struct level *endlevel = levelstart + 100;
-  char prev;
+  int prev;
   register int depth;	/* Paren depth of current scanning location.
 			   level - levelstart equals this except
 			   when the depth becomes negative.  */
   int mindepth;		/* Lowest DEPTH value seen.  */
   int start_quoted = 0;		/* Nonzero means starting after a char quote */
   Lisp_Object tem;
+  int prev_from;		/* Keep one character before FROM.  */
+
+  prev_from = from;
+  DEC_POS (prev_from);
+
+  /* Use this macro instead of `from++'.  */
+#define INC_FROM do { prev_from = from; INC_POS (from); } while (0)
 
   immediate_quit = 1;
   QUIT;
@@ -1516,11 +1609,11 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
   while (from < end)
     {
       code = SYNTAX (FETCH_CHAR (from));
-      from++;
+      INC_FROM;
       if (code == Scomment)
-	state.comstart = from-1;
+	state.comstart = prev_from;
       
-      else if (from < end && SYNTAX_COMSTART_FIRST (FETCH_CHAR (from - 1))
+      else if (from < end && SYNTAX_COMSTART_FIRST (FETCH_CHAR (prev_from))
 	       && SYNTAX_COMSTART_SECOND (FETCH_CHAR (from)))
 	{
 	  /* Record the comment style we have entered so that only
@@ -1528,27 +1621,27 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
 	     terminates the comment section.  */
 	  code = Scomment;
 	  state.comstyle = SYNTAX_COMMENT_STYLE (FETCH_CHAR (from));
-	  state.comstart = from-1;
-	  from++;
+	  state.comstart = prev_from;
+	  INC_FROM;
 	}
 
-      if (SYNTAX_PREFIX (FETCH_CHAR (from - 1)))
+      if (SYNTAX_PREFIX (FETCH_CHAR (prev_from)))
 	continue;
       switch (SWITCH_ENUM_CAST (code))
 	{
 	case Sescape:
 	case Scharquote:
 	  if (stopbefore) goto stop;  /* this arg means stop at sexp start */
-	  curlevel->last = from - 1;
+	  curlevel->last = prev_from;
 	startquoted:
 	  if (from == end) goto endquoted;
-	  from++;
+	  INC_FROM;
 	  goto symstarted;
 	  /* treat following character as a word constituent */
 	case Sword:
 	case Ssymbol:
 	  if (stopbefore) goto stop;  /* this arg means stop at sexp start */
-	  curlevel->last = from - 1;
+	  curlevel->last = prev_from;
 	symstarted:
 	  while (from < end)
 	    {
@@ -1556,7 +1649,7 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
 		{
 		case Scharquote:
 		case Sescape:
-		  from++;
+		  INC_FROM;
 		  if (from == end) goto endquoted;
 		  break;
 		case Sword:
@@ -1566,7 +1659,7 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
 		default:
 		  goto symdone;
 		}
-	      from++;
+	      INC_FROM;
 	    }
 	symdone:
 	  curlevel->prev = curlevel->last;
@@ -1579,7 +1672,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 (from - 1);
+	      prev = FETCH_CHAR (prev_from);
 	      goto startincomment_1;
 	    }
 	  /* At beginning of buffer, enter the loop the ordinary way.  */
@@ -1598,7 +1691,7 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
 		   of the same style as the start sequence has been
 		   encountered.  */
 		break;
-	      from++;
+	      INC_FROM;
 	    startincomment_1:
 	      if (from < end && SYNTAX_COMEND_FIRST (prev)
 		  && SYNTAX_COMEND_SECOND (FETCH_CHAR (from))
@@ -1606,7 +1699,7 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
 		/* Only terminate the comment section if the end-comment
 		   sequence of the same style as the start sequence has
 		   been encountered.  */
-		{ from++; break; }
+		{ INC_FROM; break; }
 	    }
 	  state.incomment = 0;
 	  state.comstyle = 0;	/* reset the comment style */
@@ -1616,7 +1709,7 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
 	  if (stopbefore) goto stop;  /* this arg means stop at sexp start */
 	  depth++;
 	  /* curlevel++->last ran into compiler bug on Apollo */
-	  curlevel->last = from - 1;
+	  curlevel->last = prev_from;
 	  if (++curlevel == endlevel)
 	    error ("Nesting too deep for parser");
 	  curlevel->prev = -1;
@@ -1636,26 +1729,29 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
 
 	case Sstring:
 	  if (stopbefore) goto stop;  /* this arg means stop at sexp start */
-	  curlevel->last = from - 1;
-	  state.instring = FETCH_CHAR (from - 1);
+	  curlevel->last = prev_from;
+	  state.instring = FETCH_CHAR (prev_from);
 	startinstring:
 	  while (1)
 	    {
+	      int c;
+
 	      if (from >= end) goto done;
-	      if (FETCH_CHAR (from) == state.instring) break;
-	      switch (SWITCH_ENUM_CAST (SYNTAX (FETCH_CHAR (from))))
+	      c = FETCH_CHAR (from);
+	      if (c == state.instring) break;
+	      switch (SWITCH_ENUM_CAST (SYNTAX (c)))
 		{
 		case Scharquote:
 		case Sescape:
-		  from++;
+		  INC_FROM;
 		startquotedinstring:
 		  if (from >= end) goto endquoted;
 		}
-	      from++;
+	      INC_FROM;
 	    }
 	  state.instring = -1;
 	  curlevel->prev = curlevel->last;
-	  from++;
+	  INC_FROM;
 	  break;
 
 	case Smath:
@@ -1665,7 +1761,7 @@ scan_sexps_forward (stateptr, from, end, targetdepth,
   goto done;
 
  stop:   /* Here if stopping before start of sexp. */
-  from--;    /* We have just fetched the char that starts it; */
+  from = prev_from;    /* We have just fetched the char that starts it; */
   goto done; /* but return the position before it. */
 
  endquoted:
@@ -1761,15 +1857,21 @@ init_syntax_once ()
      But don't staticpro it here--that is done in alloc.c.  */
   Qchar_table_extra_slots = intern ("char-table-extra-slots");
 
+  /* Create objects which can be shared among syntax tables.  */
+  Vsyntax_code_object = Fmake_vector (13, Qnil);
+  for (i = 0; i < XVECTOR (Vsyntax_code_object)->size; i++)
+    XVECTOR (Vsyntax_code_object)->contents[i]
+      = Fcons (make_number (i), Qnil);
+
   /* Now we are ready to set up this property, so we can
      create syntax tables.  */
   Fput (Qsyntax_table, Qchar_table_extra_slots, make_number (0));
 
-  temp = Fcons (make_number ((int) Swhitespace), Qnil);
+  temp = XVECTOR (Vsyntax_code_object)->contents[(int) Swhitespace];
 
   Vstandard_syntax_table = Fmake_char_table (Qsyntax_table, temp);
 
-  temp = Fcons (make_number ((int) Sword), Qnil);
+  temp = XVECTOR (Vsyntax_code_object)->contents[(int) Sword];
   for (i = 'a'; i <= 'z'; i++)
     SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, i, temp);
   for (i = 'A'; i <= 'Z'; i++)
@@ -1797,11 +1899,11 @@ init_syntax_once ()
   SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, '\\',
 			Fcons (make_number ((int) Sescape), Qnil));
 
-  temp = Fcons (make_number ((int) Ssymbol), Qnil);
+  temp = XVECTOR (Vsyntax_code_object)->contents[(int) Ssymbol];
   for (i = 0; i < 10; i++)
     SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, "_-+*/&|<>="[i], temp);
 
-  temp = Fcons (make_number ((int) Spunct), Qnil);
+  temp = XVECTOR (Vsyntax_code_object)->contents[(int) Spunct];
   for (i = 0; i < 12; i++)
     SET_RAW_SYNTAX_ENTRY (Vstandard_syntax_table, ".,;:?!#@~^'`"[i], temp);
 }
@@ -1811,6 +1913,8 @@ syms_of_syntax ()
   Qsyntax_table_p = intern ("syntax-table-p");
   staticpro (&Qsyntax_table_p);
 
+  staticpro (&Vsyntax_code_object);
+
   Qscan_error = intern ("scan-error");
   staticpro (&Qscan_error);
   Fput (Qscan_error, Qerror_conditions,