Introduce a new comment style "c" flag.

* src/syntax.c (SYNTAX_FLAGS_COMMENT_STYLEB)
(SYNTAX_FLAGS_COMMENT_STYLEC): New macros.
(SYNTAX_FLAGS_COMMENT_STYLE): Use them, add an argument.
(syntax_prefix_flag_p): New function.
(Fstring_to_syntax): Understand new "c" flag.
(Finternal_describe_syntax_value): Recognize new flag; use the
SYNTAX_FLAGS_* macros.
(scan_sexps_forward, Fparse_partial_sexp): Change representation of
comment style to accomodate the new styles.
(back_comment, forw_comment, Fforward_comment, scan_lists)
(scan_sexps_forward): Update code to obey the new comment style flag.
* src/syntax.h: Move SYNTAX_FLAGS_FOO() macros to syntax.c.
* src/casefiddle.c (casify_region): Use the new syntax_prefix_flag_p.
* lisp/progmodes/octave-mod.el (octave-mode-syntax-table): Use the new "c"
comment style.
* lisp/progmodes/scheme.el (scheme-mode-syntax-table):
* lisp/emacs-lisp/lisp-mode.el (lisp-mode-syntax-table): Remove spurious
"b" flag in "14b" syntax.

Fixes: debbugs:6834

9 files changed, 213 insertions, 136 deletions

diff --git a/etc/NEWS b/etc/NEWS
index a8908379ce4..6a66b1b8f37 100644
--- a/etc/NEWS
+++ b/etc/NEWS
@@ -424,6 +424,7 @@ has now been removed.
 
 * Lisp changes in Emacs 24.1
 
+** Syntax tables support a new "comment style c" additionally to style b.
 ** frame-local variables cannot be let-bound any more.
 ** prog-mode is a new major-mode meant to be the parent of programming mode.
 ** define-minor-mode accepts a new keyword :variable.
diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 018da138dde..868d9822b85 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,5 +1,11 @@
 2010-08-12  Stefan Monnier  <monnier@iro.umontreal.ca>
 
+        * progmodes/octave-mod.el (octave-mode-syntax-table): Use the new "c"
+        comment style (bug#6834).
+        * progmodes/scheme.el (scheme-mode-syntax-table):
+        * emacs-lisp/lisp-mode.el (lisp-mode-syntax-table): Remove spurious
+        "b" flag in "' 14b" syntax.
+
         * progmodes/octave-mod.el (octave-mode-map): Remove special bindings
         for (un)commenting the region and performing completion.
         (octave-mode-menu): Use standard commands for help and completion.
diff --git a/lisp/emacs-lisp/lisp-mode.el b/lisp/emacs-lisp/lisp-mode.el
index 02477baf74f..21a9f80fa90 100644
--- a/lisp/emacs-lisp/lisp-mode.el
+++ b/lisp/emacs-lisp/lisp-mode.el
@@ -85,7 +85,7 @@
   (let ((table (copy-syntax-table emacs-lisp-mode-syntax-table)))
     (modify-syntax-entry ?\[ "_   " table)
     (modify-syntax-entry ?\] "_   " table)
-    (modify-syntax-entry ?# "' 14b" table)
+    (modify-syntax-entry ?# "' 14" table)
     (modify-syntax-entry ?| "\" 23bn" table)
     table)
   "Syntax table used in `lisp-mode'.")
diff --git a/lisp/progmodes/octave-mod.el b/lisp/progmodes/octave-mod.el
index e0f4a878a3e..5287eff1347 100644
--- a/lisp/progmodes/octave-mod.el
+++ b/lisp/progmodes/octave-mod.el
@@ -294,17 +294,16 @@ parenthetical grouping.")
     (modify-syntax-entry ?\" "\"" table)
     (modify-syntax-entry ?. "w"   table)
     (modify-syntax-entry ?_ "w"   table)
-    ;; FIXME: The "b" flag only applies to the second letter of the comstart
+    ;; The "b" flag only applies to the second letter of the comstart
     ;; and the first letter of the comend, i.e. the "4b" below is ineffective.
     ;; If we try to put `b' on the single-line comments, we get a similar
     ;; problem where the % and # chars appear as first chars of the 2-char
     ;; comend, so the multi-line ender is also turned into style-b.
-    ;; Really, we can't make it work without extending the syntax-tables, or
-    ;; via font-lock-syntactic-keywords.
+    ;; So we need the new "c" comment style.
     (modify-syntax-entry ?\% "< 13"  table)
     (modify-syntax-entry ?\# "< 13"  table)
-    (modify-syntax-entry ?\{ "(} 2b"  table)
-    (modify-syntax-entry ?\} "){ 4b"  table)
+    (modify-syntax-entry ?\{ "(} 2c"  table)
+    (modify-syntax-entry ?\} "){ 4c"  table)
     (modify-syntax-entry ?\n ">"  table)
     table)
   "Syntax table in use in `octave-mode' buffers.")
diff --git a/lisp/progmodes/scheme.el b/lisp/progmodes/scheme.el
index ce8a34220e4..da143db5ffb 100644
--- a/lisp/progmodes/scheme.el
+++ b/lisp/progmodes/scheme.el
@@ -107,7 +107,7 @@
     ;; Special characters
     (modify-syntax-entry ?, "'   " st)
     (modify-syntax-entry ?@ "'   " st)
-    (modify-syntax-entry ?# "' 14b" st)
+    (modify-syntax-entry ?# "' 14" st)
     (modify-syntax-entry ?\\ "\\   " st)
     st))
 
diff --git a/src/ChangeLog b/src/ChangeLog
index 7e8959d4b61..14213e1c750 100644
--- a/src/ChangeLog
+++ b/src/ChangeLog
@@ -1,3 +1,22 @@
+2010-08-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        Introduce a new comment style "c" flag.
+        * syntax.c (SYNTAX_FLAGS_COMMENT_STYLEB)
+        (SYNTAX_FLAGS_COMMENT_STYLEC): New macros.
+        (SYNTAX_FLAGS_COMMENT_STYLE): Use them, add an argument.
+        (syntax_prefix_flag_p): New function.
+        (Fstring_to_syntax): Understand new "c" flag.
+        (Finternal_describe_syntax_value): Recognize new flag; use the
+        SYNTAX_FLAGS_* macros.
+        (scan_sexps_forward, Fparse_partial_sexp): Change representation of
+        comment style to accomodate the new styles.
+        (back_comment, forw_comment, Fforward_comment, scan_lists)
+        (scan_sexps_forward): Update code to obey the new comment style flag.
+
+        * syntax.h: Move SYNTAX_FLAGS_FOO() macros to syntax.c.
+
+        * casefiddle.c (casify_region): Use the new syntax_prefix_flag_p.
+
 2010-08-11  Jan Djärv  <jan.h.d@swipnet.se>
 
         * xfns.c (x_defined_color): If USE_GTK, call xg_check_special_colors
@@ -21,8 +40,8 @@
 
         * xselect.c (Fx_get_atom_name): Use char empty[] instead of literal "".
 
-        * xrdb.c (get_system_app): Make path const and use char *p for non-const
-        char.
+        * xrdb.c (get_system_app): Make path const and use char *p for
+        non-const char.
 
         * xmenu.c (Fx_popup_dialog): error_name is const char*.
         (xmenu_show): error parameter is const char **. pane_string is const
@@ -80,9 +99,9 @@
 2010-08-09  Dan Nicolaescu  <dann@ics.uci.edu>
 
         * font.h (font_parse_xlfd, font_parse_fcname, font_unparse_fcname)
-        (font_parse_name): font_open_by_name):
+        (font_parse_name, font_open_by_name):
         * font.c (font_parse_xlfd, font_parse_fcname, font_unparse_fcname)
-        (font_parse_name): font_open_by_name): Remove const.
+        (font_parse_name, font_open_by_name): Remove const.
 
 2010-08-09  Andreas Schwab  <schwab@linux-m68k.org>
 
@@ -205,17 +224,17 @@
 
         * s/freebsd.h (DECLARE_GETPWUID_WITH_UID_T): Remove, unused.
 
-        * xrdb.c: Remove include guard.  Remove
-        DECLARE_GETPWUID_WITH_UID_T conditional it had no effect.
+        * xrdb.c: Remove include guard.
+        Remove DECLARE_GETPWUID_WITH_UID_T conditional it had no effect.
         Remove #if 0 code.  Replace malloc->xmalloc, free->xfree,
         realloc->xrealloc instead of using #defines.
 
 2010-08-08  Eli Zaretskii  <eliz@gnu.org>
 
         * cmds.c (Fforward_line, Fbeginning_of_line, Fend_of_line):
-        * editfns.c (Fline_beginning_position, Fline_end_position): State
-        in the doc strings that start and end of line are in the logical
-        order.
+        * editfns.c (Fline_beginning_position, Fline_end_position):
+        State in the doc strings that start and end of line are in the
+        logical order.
 
         * xdisp.c (display_line): Move the handling of overlay arrow after
         the call to find_row_edges.  (Bug#6699)
diff --git a/src/casefiddle.c b/src/casefiddle.c
index 9545cf697a8..815f684e26a 100644
--- a/src/casefiddle.c
+++ b/src/casefiddle.c
@@ -243,7 +243,8 @@ casify_region (enum case_action flag, Lisp_Object b, Lisp_Object e)
                && (!inword || flag != CASE_CAPITALIZE_UP))
         c = UPCASE1 (c);
       if ((int) flag >= (int) CASE_CAPITALIZE)
-        inword = ((SYNTAX (c) == Sword) && (inword || !SYNTAX_PREFIX (c)));
+        inword = ((SYNTAX (c) == Sword)
+                  && (inword || !syntax_prefix_flag_p (c)));
       if (c != c2)
         {
           last = start;
diff --git a/src/syntax.c b/src/syntax.c
index 9b707c6c3b7..f0a7dca42dc 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -34,6 +34,60 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #include "syntax.h"
 #include "intervals.h"
+#include "category.h"
+
+/* Then there are seven single-bit flags that have the following meanings:
+  1. This character is the first of a two-character comment-start sequence.
+  2. This character is the second of a two-character comment-start sequence.
+  3. This character is the first of a two-character comment-end sequence.
+  4. This character is the second of a two-character comment-end sequence.
+  5. This character is a prefix, for backward-prefix-chars.
+  6. The char is part of a delimiter for comments of style "b".
+  7. This character is part of a nestable comment sequence.
+  8. The char is part of a delimiter for comments of style "c".
+  Note that any two-character sequence whose first character has flag 1
+  and whose second character has flag 2 will be interpreted as a comment start.
+
+  bit 6 and 8 are used to discriminate between different comment styles.
+  Languages such as C++ allow two orthogonal syntax start/end pairs
+  and bit 6 is used to determine whether a comment-end or Scommentend
+  ends style a or b.  Comment markers can start style a, b, c, or bc.
+  Style a is always the default.
+  For 2-char comment markers, the style b flag is only looked up on the second
+  char of the comment marker and on the first char of the comment ender.
+  For style c (like to for the nested flag), the flag can be placed on any
+  one of the chars.
+  */
+
+/* These macros extract specific flags from an integer
+   that holds the syntax code and the flags.  */
+
+#define SYNTAX_FLAGS_COMSTART_FIRST(flags) (((flags) >> 16) & 1)
+
+#define SYNTAX_FLAGS_COMSTART_SECOND(flags) (((flags) >> 17) & 1)
+
+#define SYNTAX_FLAGS_COMEND_FIRST(flags) (((flags) >> 18) & 1)
+
+#define SYNTAX_FLAGS_COMEND_SECOND(flags) (((flags) >> 19) & 1)
+
+#define SYNTAX_FLAGS_PREFIX(flags) (((flags) >> 20) & 1)
+
+#define SYNTAX_FLAGS_COMMENT_STYLEB(flags) (((flags) >> 21) & 1)
+#define SYNTAX_FLAGS_COMMENT_STYLEC(flags) (((flags) >> 22) & 2)
+/* FLAGS should be the flags of the main char of the comment marker, e.g.
+   the second for comstart and the first for comend.  */
+#define SYNTAX_FLAGS_COMMENT_STYLE(flags, other_flags) \
+  (SYNTAX_FLAGS_COMMENT_STYLEB (flags) \
+   | SYNTAX_FLAGS_COMMENT_STYLEC (flags) \
+   | SYNTAX_FLAGS_COMMENT_STYLEC (other_flags))
+
+#define SYNTAX_FLAGS_COMMENT_NESTED(flags) (((flags) >> 22) & 1)
+
+/* These macros extract a particular flag for a given character.  */
+
+#define SYNTAX_COMEND_FIRST(c) \
+  (SYNTAX_FLAGS_COMEND_FIRST (SYNTAX_WITH_FLAGS (c)))
+#define SYNTAX_PREFIX(c) (SYNTAX_FLAGS_PREFIX (SYNTAX_WITH_FLAGS (c)))
 
 /* We use these constants in place for comment-style and
    string-ender-char to distinguish  comments/strings started by
@@ -41,7 +95,6 @@ along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
 
 #define ST_COMMENT_STYLE (256 + 1)
 #define ST_STRING_STYLE (256 + 2)
-#include "category.h"
 
 Lisp_Object Qsyntax_table_p, Qsyntax_table, Qscan_error;
 
@@ -106,6 +159,11 @@ static void scan_sexps_forward (struct lisp_parse_state *,
                                 int, Lisp_Object, int);
 static int in_classes (int, Lisp_Object);
 
+/* Whether the syntax of the character C has the prefix flag set.  */
+int syntax_prefix_flag_p (int c)
+{
+  return SYNTAX_PREFIX (c);
+}
 
 struct gl_state_s gl_state;             /* Global state of syntax parser.  */
 
@@ -514,7 +572,8 @@ back_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop, int comnested
       /* Check for 2-char comment markers.  */
       com2start = (SYNTAX_FLAGS_COMSTART_FIRST (syntax)
                    && SYNTAX_FLAGS_COMSTART_SECOND (prev_syntax)
-                   && comstyle == SYNTAX_FLAGS_COMMENT_STYLE (prev_syntax)
+                   && (comstyle
+                       == SYNTAX_FLAGS_COMMENT_STYLE (prev_syntax, syntax))
                    && (SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax)
                        || SYNTAX_FLAGS_COMMENT_NESTED (syntax)) == comnested);
       com2end = (SYNTAX_FLAGS_COMEND_FIRST (syntax)
@@ -543,7 +602,8 @@ back_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop, int comnested
                && SYNTAX_FLAGS_COMEND_FIRST (next_syntax))
               || ((com2end || comnested)
                   && SYNTAX_FLAGS_COMSTART_SECOND (syntax)
-                  && comstyle == SYNTAX_FLAGS_COMMENT_STYLE (syntax)
+                  && (comstyle
+                      == SYNTAX_FLAGS_COMMENT_STYLE (syntax, prev_syntax))
                   && SYNTAX_FLAGS_COMSTART_FIRST (next_syntax)))
             goto lossage;
           /* UPDATE_SYNTAX_TABLE_FORWARD (next + 1); */
@@ -563,7 +623,7 @@ back_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop, int comnested
         code = Scomment;
       /* Ignore comment starters of a different style.  */
       else if (code == Scomment
-               && (comstyle != SYNTAX_FLAGS_COMMENT_STYLE (syntax)
+               && (comstyle != SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0)
                    || SYNTAX_FLAGS_COMMENT_NESTED (syntax) != comnested))
         continue;
 
@@ -613,7 +673,7 @@ back_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop, int comnested
           break;
 
         case Sendcomment:
-          if (SYNTAX_FLAGS_COMMENT_STYLE (syntax) == comstyle
+          if (SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0) == comstyle
               && ((com2end && SYNTAX_FLAGS_COMMENT_NESTED (prev_syntax))
                   || SYNTAX_FLAGS_COMMENT_NESTED (syntax)) == comnested)
             /* This is the same style of comment ender as ours. */
@@ -930,6 +990,10 @@ text property.  */)
       case 'n':
         val |= 1 << 22;
         break;
+
+      case 'c':
+        val |= 1 << 23;
+        break;
       }
 
   if (val < XVECTOR (Vsyntax_code_object)->size && NILP (match))
@@ -969,12 +1033,13 @@ Defined flags are the characters 1, 2, 3, 4, b, p, and n.
  3 means CHAR is the start of a two-char comment end sequence.
  4 means CHAR is the second character of such a sequence.
 
-There can be up to two orthogonal comment sequences.  This is to support
+There can be several orthogonal comment sequences.  This is to support
 language modes such as C++.  By default, all comment sequences are of style
 a, but you can set the comment sequence style to b (on the second character
-of a comment-start, or the first character of a comment-end sequence) using
-this flag:
+of a comment-start, and the first character of a comment-end sequence) and/or
+c (on any of its chars) using this flag:
  b means CHAR is part of comment sequence b.
+ c means CHAR is part of comment sequence c.
  n means CHAR is part of a nestable comment sequence.
 
  p means CHAR is a prefix character for `backward-prefix-chars';
@@ -1017,7 +1082,9 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
   (Lisp_Object syntax)
 {
   register enum syntaxcode code;
-  char desc, start1, start2, end1, end2, prefix, comstyle, comnested;
+  int syntax_code;
+  char desc, start1, start2, end1, end2, prefix,
+    comstyleb, comstylec, comnested;
   char str[2];
   Lisp_Object first, match_lisp, value = syntax;
 
@@ -1048,14 +1115,16 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
       return syntax;
     }
 
-  code = (enum syntaxcode) (XINT (first) & 0377);
-  start1 = (XINT (first) >> 16) & 1;
-  start2 = (XINT (first) >> 17) & 1;
-  end1 = (XINT (first) >> 18) & 1;
-  end2 = (XINT (first) >> 19) & 1;
-  prefix = (XINT (first) >> 20) & 1;
-  comstyle = (XINT (first) >> 21) & 1;
-  comnested = (XINT (first) >> 22) & 1;
+  syntax_code = XINT (first);
+  code = (enum syntaxcode) (syntax_code & 0377);
+  start1 = SYNTAX_FLAGS_COMSTART_FIRST (syntax_code);
+  start2 = SYNTAX_FLAGS_COMSTART_SECOND (syntax_code);;
+  end1 = SYNTAX_FLAGS_COMEND_FIRST (syntax_code);
+  end2 = SYNTAX_FLAGS_COMEND_SECOND (syntax_code);
+  prefix = SYNTAX_FLAGS_PREFIX (syntax_code);
+  comstyleb = SYNTAX_FLAGS_COMMENT_STYLEB (syntax_code);
+  comstylec = SYNTAX_FLAGS_COMMENT_STYLEC (syntax_code);
+  comnested = SYNTAX_FLAGS_COMMENT_NESTED (syntax_code);
 
   if ((int) code < 0 || (int) code >= (int) Smax)
     {
@@ -1084,8 +1153,10 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
 
   if (prefix)
     insert ("p", 1);
-  if (comstyle)
+  if (comstyleb)
     insert ("b", 1);
+  if (comstylec)
+    insert ("c", 1);
   if (comnested)
     insert ("n", 1);
 
@@ -1145,8 +1216,10 @@ DEFUN ("internal-describe-syntax-value", Finternal_describe_syntax_value,
     insert_string (",\n\t  is the first character of a comment-end sequence");
   if (end2)
     insert_string (",\n\t  is the second character of a comment-end sequence");
-  if (comstyle)
+  if (comstyleb)
     insert_string (" (comment style b)");
+  if (comstylec)
+    insert_string (" (comment style c)");
   if (comnested)
     insert_string (" (nestable)");
 
@@ -2060,7 +2133,7 @@ in_classes (int c, Lisp_Object iso_classes)
    FROM_BYTE is the bytepos corresponding to FROM.
    Do not move past STOP (a charpos).
    The comment over which we have to jump is of style STYLE
-     (either SYNTAX_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
+     (either SYNTAX_FLAGS_COMMENT_STYLE(foo) or ST_COMMENT_STYLE).
    NESTING should be positive to indicate the nesting at the beginning
      for nested comments and should be zero or negative else.
      ST_COMMENT_STYLE cannot be nested.
@@ -2087,7 +2160,7 @@ forw_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop,
 {
   register int c, c1;
   register enum syntaxcode code;
-  register int syntax;
+  register int syntax, other_syntax;
 
   if (nesting <= 0) nesting = -1;
 
@@ -2109,7 +2182,7 @@ forw_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop,
       syntax = SYNTAX_WITH_FLAGS (c);
       code = syntax & 0xff;
       if (code == Sendcomment
-          && SYNTAX_FLAGS_COMMENT_STYLE (syntax) == style
+          && SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0) == style
           && (SYNTAX_FLAGS_COMMENT_NESTED (syntax) ?
               (nesting > 0 && --nesting == 0) : nesting < 0))
         /* we have encountered a comment end of the same style
@@ -2125,7 +2198,7 @@ forw_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop,
       if (nesting > 0
           && code == Scomment
           && SYNTAX_FLAGS_COMMENT_NESTED (syntax)
-          && SYNTAX_FLAGS_COMMENT_STYLE (syntax) == style)
+          && SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0) == style)
         /* we have encountered a nested comment of the same style
            as the comment sequence which began this comment section */
         nesting++;
@@ -2134,11 +2207,13 @@ forw_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop,
 
     forw_incomment:
       if (from < stop && SYNTAX_FLAGS_COMEND_FIRST (syntax)
-          && SYNTAX_FLAGS_COMMENT_STYLE (syntax) == style
           && (c1 = FETCH_CHAR_AS_MULTIBYTE (from_byte),
-              SYNTAX_COMEND_SECOND (c1))
+              other_syntax = SYNTAX_WITH_FLAGS (c1),
+              SYNTAX_FLAGS_COMEND_SECOND (other_syntax))
+          && SYNTAX_FLAGS_COMMENT_STYLE (syntax, other_syntax) == style
           && ((SYNTAX_FLAGS_COMMENT_NESTED (syntax) ||
-               SYNTAX_COMMENT_NESTED (c1)) ? nesting > 0 : nesting < 0))
+               SYNTAX_FLAGS_COMMENT_NESTED (other_syntax))
+              ? nesting > 0 : nesting < 0))
         {
           if (--nesting <= 0)
             /* we have encountered a comment end of the same style
@@ -2155,10 +2230,11 @@ forw_comment (EMACS_INT from, EMACS_INT from_byte, EMACS_INT stop,
           && from < stop
           && SYNTAX_FLAGS_COMSTART_FIRST (syntax)
           && (c1 = FETCH_CHAR_AS_MULTIBYTE (from_byte),
-              SYNTAX_COMMENT_STYLE (c1) == style
-              && SYNTAX_COMSTART_SECOND (c1))
+              other_syntax = SYNTAX_WITH_FLAGS (c1),
+              SYNTAX_FLAGS_COMMENT_STYLE (other_syntax, syntax) == style
+              && SYNTAX_FLAGS_COMSTART_SECOND (other_syntax))
           && (SYNTAX_FLAGS_COMMENT_NESTED (syntax) ||
-              SYNTAX_COMMENT_NESTED (c1)))
+              SYNTAX_FLAGS_COMMENT_NESTED (other_syntax)))
         /* we have encountered a nested comment of the same style
            as the comment sequence which began this comment
            section */
@@ -2209,7 +2285,7 @@ between them, return t; otherwise return nil.  */)
     {
       do
         {
-          int comstart_first;
+          int comstart_first, syntax, other_syntax;
 
           if (from == stop)
             {
@@ -2218,15 +2294,17 @@ between them, return t; otherwise return nil.  */)
               return Qnil;
             }
           c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
+          syntax = SYNTAX_WITH_FLAGS (c);
           code = SYNTAX (c);
-          comstart_first = SYNTAX_COMSTART_FIRST (c);
-          comnested = SYNTAX_COMMENT_NESTED (c);
-          comstyle = SYNTAX_COMMENT_STYLE (c);
+          comstart_first = SYNTAX_FLAGS_COMSTART_FIRST (syntax);
+          comnested = SYNTAX_FLAGS_COMMENT_NESTED (syntax);
+          comstyle = SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0);
           INC_BOTH (from, from_byte);
           UPDATE_SYNTAX_TABLE_FORWARD (from);
           if (from < stop && comstart_first
               && (c1 = FETCH_CHAR_AS_MULTIBYTE (from_byte),
-                  SYNTAX_COMSTART_SECOND (c1)))
+                  other_syntax = SYNTAX_WITH_FLAGS (c1),
+                  SYNTAX_FLAGS_COMSTART_SECOND (other_syntax)))
             {
               /* We have encountered a comment start sequence and we
                  are ignoring all text inside comments.  We must record
@@ -2234,8 +2312,9 @@ between them, return t; otherwise return nil.  */)
                  only a comment end of the same style actually ends
                  the comment section.  */
               code = Scomment;
-              comstyle = SYNTAX_COMMENT_STYLE (c1);
-              comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
+              comstyle = SYNTAX_FLAGS_COMMENT_STYLE (other_syntax, syntax);
+              comnested
+                = comnested || SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
               INC_BOTH (from, from_byte);
               UPDATE_SYNTAX_TABLE_FORWARD (from);
             }
@@ -2271,7 +2350,7 @@ between them, return t; otherwise return nil.  */)
     {
       while (1)
         {
-          int quoted;
+          int quoted, syntax;
 
           if (from <= stop)
             {
@@ -2284,15 +2363,17 @@ between them, return t; otherwise return nil.  */)
           /* char_quoted does UPDATE_SYNTAX_TABLE_BACKWARD (from).  */
           quoted = char_quoted (from, from_byte);
           c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
+          syntax = SYNTAX_WITH_FLAGS (c);
           code = SYNTAX (c);
           comstyle = 0;
-          comnested = SYNTAX_COMMENT_NESTED (c);
+          comnested = SYNTAX_FLAGS_COMMENT_NESTED (syntax);
           if (code == Sendcomment)
-            comstyle = SYNTAX_COMMENT_STYLE (c);
-          if (from > stop && SYNTAX_COMEND_SECOND (c)
+            comstyle = SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0);
+          if (from > stop && SYNTAX_FLAGS_COMEND_SECOND (syntax)
               && prev_char_comend_first (from, from_byte)
               && !char_quoted (from - 1, dec_bytepos (from_byte)))
             {
+              int other_syntax;
               /* We must record the comment style encountered so that
                  later, we can match only the proper comment begin
                  sequence of the same style.  */
@@ -2301,8 +2382,10 @@ between them, return t; otherwise return nil.  */)
               /* Calling char_quoted, above, set up global syntax position
                  at the new value of FROM.  */
               c1 = FETCH_CHAR_AS_MULTIBYTE (from_byte);
-              comstyle = SYNTAX_COMMENT_STYLE (c1);
-              comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
+              other_syntax = SYNTAX_WITH_FLAGS (c1);
+              comstyle = SYNTAX_FLAGS_COMMENT_STYLE (other_syntax, syntax);
+              comnested
+                = comnested || SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
             }
 
           if (code == Scomment_fence)
@@ -2349,7 +2432,7 @@ between them, return t; otherwise return nil.  */)
                     {
                       /* Failure: we should go back to the end of this
                          not-quite-endcomment.  */
-                      if (SYNTAX(c) != code)
+                      if (SYNTAX (c) != code)
                         /* It was a two-char Sendcomment.  */
                         INC_BOTH (from, from_byte);
                       goto leave;
@@ -2423,21 +2506,23 @@ scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpf
     {
       while (from < stop)
         {
-          int comstart_first, prefix;
+          int comstart_first, prefix, syntax, other_syntax;
           UPDATE_SYNTAX_TABLE_FORWARD (from);
           c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
+          syntax = SYNTAX_WITH_FLAGS (c);
           code = SYNTAX_WITH_MULTIBYTE_CHECK (c);
-          comstart_first = SYNTAX_COMSTART_FIRST (c);
-          comnested = SYNTAX_COMMENT_NESTED (c);
-          comstyle = SYNTAX_COMMENT_STYLE (c);
-          prefix = SYNTAX_PREFIX (c);
+          comstart_first = SYNTAX_FLAGS_COMSTART_FIRST (syntax);
+          comnested = SYNTAX_FLAGS_COMMENT_NESTED (syntax);
+          comstyle = SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0);
+          prefix = SYNTAX_FLAGS_PREFIX (syntax);
           if (depth == min_depth)
             last_good = from;
           INC_BOTH (from, from_byte);
           UPDATE_SYNTAX_TABLE_FORWARD (from);
           if (from < stop && comstart_first
               && (c = FETCH_CHAR_AS_MULTIBYTE (from_byte),
-                  SYNTAX_COMSTART_SECOND (c))
+                  other_syntax = SYNTAX_WITH_FLAGS (c),
+                  SYNTAX_FLAGS_COMSTART_SECOND (other_syntax))
               && parse_sexp_ignore_comments)
             {
               /* we have encountered a comment start sequence and we
@@ -2446,9 +2531,9 @@ scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpf
                  only a comment end of the same style actually ends
                  the comment section */
               code = Scomment;
-              c1 = FETCH_CHAR_AS_MULTIBYTE (from_byte);
-              comstyle = SYNTAX_COMMENT_STYLE (c1);
-              comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
+              comstyle = SYNTAX_FLAGS_COMMENT_STYLE (other_syntax, syntax);
+              comnested
+                = comnested || SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
               INC_BOTH (from, from_byte);
               UPDATE_SYNTAX_TABLE_FORWARD (from);
             }
@@ -2592,29 +2677,34 @@ scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpf
     {
       while (from > stop)
         {
+          int syntax;
           DEC_BOTH (from, from_byte);
           UPDATE_SYNTAX_TABLE_BACKWARD (from);
           c = FETCH_CHAR_AS_MULTIBYTE (from_byte);
+          syntax= SYNTAX_WITH_FLAGS (c);
           code = SYNTAX_WITH_MULTIBYTE_CHECK (c);
           if (depth == min_depth)
             last_good = from;
           comstyle = 0;
-          comnested = SYNTAX_COMMENT_NESTED (c);
+          comnested = SYNTAX_FLAGS_COMMENT_NESTED (syntax);
           if (code == Sendcomment)
-            comstyle = SYNTAX_COMMENT_STYLE (c);
-          if (from > stop && SYNTAX_COMEND_SECOND (c)
+            comstyle = SYNTAX_FLAGS_COMMENT_STYLE (syntax, 0);
+          if (from > stop && SYNTAX_FLAGS_COMEND_SECOND (syntax)
               && prev_char_comend_first (from, from_byte)
               && 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.  */
+              int c1, other_syntax;
               DEC_BOTH (from, from_byte);
               UPDATE_SYNTAX_TABLE_BACKWARD (from);
               code = Sendcomment;
               c1 = FETCH_CHAR_AS_MULTIBYTE (from_byte);
-              comstyle = SYNTAX_COMMENT_STYLE (c1);
-              comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
+              other_syntax = SYNTAX_WITH_FLAGS (c1);
+              comstyle = SYNTAX_FLAGS_COMMENT_STYLE (other_syntax, syntax);
+              comnested
+                = comnested || SYNTAX_FLAGS_COMMENT_NESTED (other_syntax);
             }
 
           /* Quoting turns anything except a comment-ender
@@ -2625,7 +2715,7 @@ scan_lists (register EMACS_INT from, EMACS_INT count, EMACS_INT depth, int sexpf
               DEC_BOTH (from, from_byte);
               code = Sword;
             }
-          else if (SYNTAX_PREFIX (c))
+          else if (SYNTAX_FLAGS_PREFIX (syntax))
             continue;
 
           switch (SWITCH_ENUM_CAST (code))
@@ -2949,8 +3039,11 @@ do { prev_from = from;				\
       oldstate = Fcdr (oldstate);
       oldstate = Fcdr (oldstate);
       tem = Fcar (oldstate);
-      state.comstyle = NILP (tem) ? 0 : (EQ (tem, Qsyntax_table)
-                                         ? ST_COMMENT_STYLE : 1);
+      state.comstyle = (NILP (tem)
+                        ? 0
+                        : (EQ (tem, Qsyntax_table)
+                           ? ST_COMMENT_STYLE
+                           : INTEGERP (tem) ? XINT (tem) : 1));
 
       oldstate = Fcdr (oldstate);
       tem = Fcar (oldstate);
@@ -2995,22 +3088,25 @@ do { prev_from = from;				\
 
   while (from < end)
     {
+      int syntax;
       INC_FROM;
       code = prev_from_syntax & 0xff;
 
       if (from < end
           && SYNTAX_FLAGS_COMSTART_FIRST (prev_from_syntax)
           && (c1 = FETCH_CHAR (from_byte),
-              SYNTAX_COMSTART_SECOND (c1)))
+              syntax = SYNTAX_WITH_FLAGS (c1),
+              SYNTAX_FLAGS_COMSTART_SECOND (syntax)))
         /* Duplicate code to avoid a complex if-expression
            which causes trouble for the SGI compiler.  */
         {
           /* Record the comment style we have entered so that only
              the comment-end sequence of the same style actually
              terminates the comment section.  */
-          state.comstyle = SYNTAX_COMMENT_STYLE (c1);
+          state.comstyle
+            = SYNTAX_FLAGS_COMMENT_STYLE (syntax, prev_from_syntax);
           comnested = SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax);
-          comnested = comnested || SYNTAX_COMMENT_NESTED (c1);
+          comnested = comnested || SYNTAX_FLAGS_COMMENT_NESTED (syntax);
           state.incomment = comnested ? 1 : -1;
           state.comstr_start = prev_from;
           INC_FROM;
@@ -3028,7 +3124,7 @@ do { prev_from = from;				\
         }
       else if (code == Scomment)
         {
-          state.comstyle = SYNTAX_FLAGS_COMMENT_STYLE (prev_from_syntax);
+          state.comstyle = SYNTAX_FLAGS_COMMENT_STYLE (prev_from_syntax, 0);
           state.incomment = (SYNTAX_FLAGS_COMMENT_NESTED (prev_from_syntax) ?
                              1 : -1);
           state.comstr_start = prev_from;
@@ -3221,8 +3317,7 @@ Value is a list of elements describing final state of parsing:
     else an integer (the current comment nesting).
  5. t if following a quote character.
  6. the minimum paren-depth encountered during this scan.
- 7. t if in a comment of style b; symbol `syntax-table' if the comment
-    should be terminated by a generic comment delimiter.
+ 7. style of comment, if any.
  8. character address of start of comment or string; nil if not in one.
  9. Intermediate data for continuation of parsing (subject to change).
 If third arg TARGETDEPTH is non-nil, parsing stops if the depth
@@ -3258,8 +3353,10 @@ Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
   SET_PT (state.location);
 
   return Fcons (make_number (state.depth),
-           Fcons (state.prevlevelstart < 0 ? Qnil : make_number (state.prevlevelstart),
-             Fcons (state.thislevelstart < 0 ? Qnil : make_number (state.thislevelstart),
+           Fcons (state.prevlevelstart < 0
+                  ? Qnil : make_number (state.prevlevelstart),
+             Fcons (state.thislevelstart < 0
+                    ? Qnil : make_number (state.thislevelstart),
                Fcons (state.instring >= 0
                       ? (state.instring == ST_STRING_STYLE
                          ? Qt : make_number (state.instring)) : Qnil,
@@ -3270,8 +3367,9 @@ Sixth arg COMMENTSTOP non-nil means stop at the start of a comment.
                      Fcons (make_number (state.mindepth),
                        Fcons ((state.comstyle
                                ? (state.comstyle == ST_COMMENT_STYLE
-                                  ? Qsyntax_table : Qt) :
-                               Qnil),
+                                  ? Qsyntax_table
+                                  : make_number (state.comstyle))
+                               : Qnil),
                               Fcons (((state.incomment
                                        || (state.instring >= 0))
                                       ? make_number (state.comstr_start)
diff --git a/src/syntax.h b/src/syntax.h
index 9eaf553f2e5..48146572d19 100644
--- a/src/syntax.h
+++ b/src/syntax.h
@@ -128,56 +128,9 @@ extern Lisp_Object syntax_temp;
     : Qnil))
 #endif
 
-/* Then there are seven single-bit flags that have the following meanings:
-  1. This character is the first of a two-character comment-start sequence.
-  2. This character is the second of a two-character comment-start sequence.
-  3. This character is the first of a two-character comment-end sequence.
-  4. This character is the second of a two-character comment-end sequence.
-  5. This character is a prefix, for backward-prefix-chars.
-  6. see below
-  7. This character is part of a nestable comment sequence.
-  Note that any two-character sequence whose first character has flag 1
-  and whose second character has flag 2 will be interpreted as a comment start.
 
-  bit 6 is used to discriminate between two different comment styles.
-  Languages such as C++ allow two orthogonal syntax start/end pairs
-  and bit 6 is used to determine whether a comment-end or Scommentend
-  ends style a or b.  Comment start sequences can start style a or b.
-  Style a is always the default.
-  */
-
-/* These macros extract a particular flag for a given character.  */
-
-#define SYNTAX_COMSTART_FIRST(c) ((SYNTAX_WITH_FLAGS (c) >> 16) & 1)
-
-#define SYNTAX_COMSTART_SECOND(c) ((SYNTAX_WITH_FLAGS (c) >> 17) & 1)
-
-#define SYNTAX_COMEND_FIRST(c) ((SYNTAX_WITH_FLAGS (c) >> 18) & 1)
-
-#define SYNTAX_COMEND_SECOND(c) ((SYNTAX_WITH_FLAGS (c) >> 19) & 1)
-
-#define SYNTAX_PREFIX(c) ((SYNTAX_WITH_FLAGS (c) >> 20) & 1)
-
-#define SYNTAX_COMMENT_STYLE(c) ((SYNTAX_WITH_FLAGS (c) >> 21) & 1)
-
-#define SYNTAX_COMMENT_NESTED(c) ((SYNTAX_WITH_FLAGS (c) >> 22) & 1)
-
-/* These macros extract specific flags from an integer
-   that holds the syntax code and the flags.  */
-
-#define SYNTAX_FLAGS_COMSTART_FIRST(flags) (((flags) >> 16) & 1)
-
-#define SYNTAX_FLAGS_COMSTART_SECOND(flags) (((flags) >> 17) & 1)
-
-#define SYNTAX_FLAGS_COMEND_FIRST(flags) (((flags) >> 18) & 1)
-
-#define SYNTAX_FLAGS_COMEND_SECOND(flags) (((flags) >> 19) & 1)
-
-#define SYNTAX_FLAGS_PREFIX(flags) (((flags) >> 20) & 1)
-
-#define SYNTAX_FLAGS_COMMENT_STYLE(flags) (((flags) >> 21) & 1)
-
-#define SYNTAX_FLAGS_COMMENT_NESTED(flags) (((flags) >> 22) & 1)
+/* Whether the syntax of the character C has the prefix flag set.  */
+extern int syntax_prefix_flag_p (int c);
 
 /* This array, indexed by a character, contains the syntax code which that
  character signifies (as a char).  For example,