[PATCH 1/1] fortran: allow non-traditional C preprocessing via -fno-traditional-cpp

The TODO at the top of gfc_cpp_post_options in gcc/fortran/cpp.cc has
been sitting there for many years:

    /* TODO: allow non-traditional modes, e.g. by -cpp-std=...?  */
    cpp_option->traditional = 1;

This commit finally lifts that restriction.  A new -fno-traditional-cpp
option, off by default so existing users see no change, picks the full C
preprocessor instead of the historic traditional mode.

For this to be safe in the presence of Fortran source, libcpp gains two
new c_lang values: CLK_GNUF77 for fixed-form and CLK_GNUF90 for
free-form Fortran.  When either of them is active the lexer:

  - emits "//" as two CPP_DIV tokens, since in Fortran "//" is the
    string-concatenation operator rather than a C++ line comment,
  - treats '!' outside of preprocessing directives as a Fortran line
    comment, so that an unbalanced apostrophe inside a comment
    ("John's variable" and friends) does not start a runaway C
    character literal,
  - under CLK_GNUF77 only, additionally treats a column-1 'C', 'c',
    '*', 'D' or 'd' as a fixed-form comment-line marker.

The driver also forces -C / -CC in non-traditional mode so that the
comments survive into the preprocessed output.  This is not just
cosmetic, because compiler pragmas ("!$OMP", "!$ACC", "!GCC$") are
lexically Fortran comments but carry directive semantics that the
gfortran scanner must still see.  Dropping them would silently disable
every parallel or offload directive in the program.

Running a C preprocessor over Fortran source is itself a GNU extension
(the Fortran standard does not specify a preprocessor), and the updated
invoke.texi now says so explicitly.

Bootstrapped and regtested on x86_64-pc-linux-gnu, no new test
failures introduced.

gcc/fortran/ChangeLog:

	* cpp.cc (gfc_cpp_post_options): Honour flag_traditional_cpp.
	Pick CLK_GNUF77 / CLK_GNUF90 for cpp_create_reader when running
	the full C preprocessor, and force discard_comments off in that
	mode.  Reject -fno-traditional-cpp without -cpp.
	* invoke.texi: Document -ftraditional-cpp /
	-fno-traditional-cpp and note that running CPP over Fortran is
	a GNU extension.
	* lang.opt (ftraditional-cpp): New option.

libcpp/ChangeLog:

	* include/cpplib.h (enum c_lang): Add CLK_GNUF77 and CLK_GNUF90.
	* init.cc (lang_defaults): Add corresponding rows.
	* lex.cc (save_comment): Preserve the leading comment-marker
	byte from from[-1] instead of hard-coding '/'.
	(_cpp_lex_direct): In Fortran modes treat '!' as a line comment
	outside of directives and disable the C/C++ "//" line-comment
	branch.  In fixed-form Fortran additionally recognise the
	column-1 'C'/'c'/'*'/'D'/'d' comment-line markers.  Share the
	comment-emission code via a new fortran_line_comment label.

gcc/testsuite/ChangeLog:

	* gfortran.dg/cpp_non_traditional_1.F90: New test.
	* gfortran.dg/cpp_non_traditional_2.F90: New test.
	* gfortran.dg/cpp_non_traditional_3.F: New test.
	* gfortran.dg/cpp_non_traditional_4.f90: New test.
	* gfortran.dg/cpp_non_traditional_5.F90: New test.

Signed-off-by: Henri Menke <[email protected]>
---
 gcc/fortran/cpp.cc                            | 31 ++++++++--
 gcc/fortran/invoke.texi                       | 43 +++++++++++++-
 gcc/fortran/lang.opt                          |  4 ++
 .../gfortran.dg/cpp_non_traditional_1.F90     | 37 ++++++++++++
 .../gfortran.dg/cpp_non_traditional_2.F90     | 23 ++++++++
 .../gfortran.dg/cpp_non_traditional_3.F       | 32 ++++++++++
 .../gfortran.dg/cpp_non_traditional_4.f90     | 13 ++++
 .../gfortran.dg/cpp_non_traditional_5.F90     | 18 ++++++
 libcpp/include/cpplib.h                       |  3 +-
 libcpp/init.cc                                |  4 +-
 libcpp/lex.cc                                 | 59 ++++++++++++++++++-
 11 files changed, 255 insertions(+), 12 deletions(-)
 create mode 100644 gcc/testsuite/gfortran.dg/cpp_non_traditional_1.F90
 create mode 100644 gcc/testsuite/gfortran.dg/cpp_non_traditional_2.F90
 create mode 100644 gcc/testsuite/gfortran.dg/cpp_non_traditional_3.F
 create mode 100644 gcc/testsuite/gfortran.dg/cpp_non_traditional_4.f90
 create mode 100644 gcc/testsuite/gfortran.dg/cpp_non_traditional_5.F90

diff --git a/gcc/fortran/cpp.cc b/gcc/fortran/cpp.cc
index 6b5f136e4f3..143ad2a7a04 100644
--- a/gcc/fortran/cpp.cc
+++ b/gcc/fortran/cpp.cc
@@ -500,13 +500,24 @@ gfc_cpp_post_options (bool verbose_missing_dir_warn)
 	  || gfc_cpp_option.print_include_names
 	  || gfc_cpp_option.no_line_commands
 	  || gfc_cpp_option.dump_macros
-	  || gfc_cpp_option.dump_includes))
+	  || gfc_cpp_option.dump_includes
+	  || !flag_traditional_cpp))
     gfc_fatal_error ("To enable preprocessing, use %<-cpp%>");
 
   if (!gfc_cpp_enabled ())
     return;
 
-  cpp_in = cpp_create_reader (CLK_GNUC89, NULL, line_table);
+  /* Traditional preprocessing has historically been used regardless of source
+     form, so we keep CLK_GNUC89 in that case for backwards compatibility.
+     Non-traditional mode picks a Fortran-specific language tag instead, so
+     that libcpp recognises "//" as the concatenation operator and '!' (along
+     with the fixed-form column-1 markers) as comment starters.  */
+  enum c_lang cpp_lang = CLK_GNUC89;
+  if (!flag_traditional_cpp)
+    cpp_lang = (gfc_current_form == FORM_FIXED
+		? CLK_GNUF77 : CLK_GNUF90);
+
+  cpp_in = cpp_create_reader (cpp_lang, NULL, line_table);
   gcc_assert (cpp_in);
 
   /* The cpp_options-structure defines far more flags than those set here.
@@ -515,10 +526,22 @@ gfc_cpp_post_options (bool verbose_missing_dir_warn)
   cpp_option = cpp_get_options (cpp_in);
   gcc_assert (cpp_option);
 
-  /* TODO: allow non-traditional modes, e.g. by -cpp-std=...?  */
-  cpp_option->traditional = 1;
+  cpp_option->traditional = flag_traditional_cpp;
   cpp_option->cplusplus_comments = 0;
 
+  /* When running the full (non-traditional) C preprocessor on Fortran source,
+     preserve comments unconditionally so that the Fortran scanner can
+     re-process them along with the surrounding tokens.  This is particularly
+     important because compiler pragmas such as "!$OMP", "!$ACC" and "!GCC$"
+     are lexically Fortran comments but carry directive semantics that the
+     gfortran scanner must still see.  Discarding them would silently drop
+     OpenMP / OpenACC / GCC directives from the preprocessed output.  */
+  if (!flag_traditional_cpp)
+    {
+      gfc_cpp_option.discard_comments = 0;
+      gfc_cpp_option.discard_comments_in_macro_exp = 0;
+    }
+
   cpp_option->cpp_pedantic = pedantic;
 
   cpp_option->dollars_in_ident = flag_dollar_ok;
diff --git a/gcc/fortran/invoke.texi b/gcc/fortran/invoke.texi
index b3e74148a08..5f2391ff66b 100644
--- a/gcc/fortran/invoke.texi
+++ b/gcc/fortran/invoke.texi
@@ -676,6 +676,15 @@ Part 3 of the Fortran 95 standard (ISO/IEC 1539-3:1998) defines
 Conditional Compilation, which is not widely used and not directly
 supported by the GNU Fortran compiler.
 
+@cindex GNU extensions, preprocessor
+Note that running a C preprocessor over Fortran source is itself a
+GNU extension.  The Fortran standard does not specify a preprocessor,
+so any behaviour outside of the lexical conventions described below is
+implementation-defined.  Source files that rely on @option{-cpp} (or
+on the implicit preprocessing triggered by an upper-case
+@file{.F}-style extension) are therefore not portable between Fortran
+implementations.
+
 The following options control preprocessing of Fortran code:
 
 @table @gcctabopt
@@ -693,12 +702,40 @@ this option to manually enable preprocessing of any kind of Fortran file.
 To disable preprocessing of files with any of the above listed extensions,
 use the negative form: @option{-nocpp}.
 
-The preprocessor is run in traditional mode. Any restrictions of the
-file format, especially the limits on line length, apply for
-preprocessed output as well, so it might be advisable to use the
+The preprocessor is run in traditional mode by default.  Pass
+@option{-fno-traditional-cpp} to run the full C preprocessor instead.
+See @option{-ftraditional-cpp} below.  Any restrictions of the file
+format, especially the limits on line length, apply for preprocessed
+output as well, so it might be advisable to use the
 @option{-ffree-line-length-none} or @option{-ffixed-line-length-none}
 options.
 
+@opindex ftraditional-cpp
+@opindex fno-traditional-cpp
+@cindex preprocessor, traditional
+@item -ftraditional-cpp
+@itemx -fno-traditional-cpp
+Pick between traditional and full C preprocessing of Fortran source.
+
+In traditional mode, which is the default, the preprocessor does no
+real tokenisation.  Fortran-specific lexical constructs such as
+@code{//} (string concatenation), @samp{!} comments, and the
+@samp{'} and @samp{"} string delimiters therefore pass through
+unmolested, exactly as they have done for many years.
+
+With @option{-fno-traditional-cpp} gfortran instead invokes the full
+C preprocessor.  This enables ISO-style function-like macros with
+@samp{#} stringification and @samp{##} token pasting.  To keep the
+Fortran lexical conventions intact in this mode, libcpp is taught to
+recognise @samp{!} as a line comment outside of preprocessing
+directives and to leave @code{//} alone.  In fixed-form sources, a
+@samp{C}, @samp{c}, @samp{*}, @samp{D} or @samp{d} in column 1 is
+additionally treated as a comment-line starter.  Comments are
+preserved in the output, as if @option{-C} had been given, so that
+the gfortran scanner sees them again afterwards (which matters, since
+sentinels like @samp{!$OMP} are lexically comments but carry directive
+semantics).
+
 @opindex dM
 @cindex preprocessor, debugging
 @cindex debugging, preprocessor
diff --git a/gcc/fortran/lang.opt b/gcc/fortran/lang.opt
index cbd13aa2019..3867bafc017 100644
--- a/gcc/fortran/lang.opt
+++ b/gcc/fortran/lang.opt
@@ -381,6 +381,10 @@ nocpp
 Fortran Negative(cpp)
 Disable preprocessing.
 
+ftraditional-cpp
+Fortran Var(flag_traditional_cpp) Init(1)
+Use traditional preprocessing.  This is the default; pass -fno-traditional-cpp to invoke the full C preprocessor instead.
+
 d
 Fortran Joined
 ; Documented in common.opt
diff --git a/gcc/testsuite/gfortran.dg/cpp_non_traditional_1.F90 b/gcc/testsuite/gfortran.dg/cpp_non_traditional_1.F90
new file mode 100644
index 00000000000..6ddf3ad02bc
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/cpp_non_traditional_1.F90
@@ -0,0 +1,37 @@
+! { dg-do preprocess }
+! { dg-options "-cpp -fno-traditional-cpp -P" }
+!
+! Check that running the full (non-traditional) C preprocessor on Fortran
+! source still preserves the Fortran-specific lexical features that the
+! traditional mode used to protect:
+!
+!   - "//" is the Fortran string-concatenation operator and must be emitted
+!     as two CPP_DIV tokens, not swallowed as a C++-style line comment.
+!   - '!' starts a Fortran line comment, even when the comment text contains
+!     unbalanced apostrophes that would otherwise confuse the C
+!     character-literal lexer.
+!   - Comments are preserved verbatim in the output (as if -C had been
+!     given) so that the Fortran scanner can re-process them.
+!   - Function-like macros with '#' stringification and "##" token pasting
+!     finally work, which is the whole reason for choosing non-traditional
+!     mode in the first place.
+
+#define STR(x) #x
+#define CAT(a,b) a##b
+
+program test
+  character(len=12) :: greeting
+  greeting = "hello" // ", world!"  ! it's a concat
+  print *, STR(spam)
+  print *, CAT(my_,var)
+end program test
+
+! "//" must survive as two tokens, possibly with whitespace between the
+! slashes because the non-traditional output reformats spacing.
+! { dg-final { scan-file "cpp_non_traditional_1.i" {"hello"[ \t]*/[ \t]*/[ \t]*", world!"} } }
+! The trailing '!' comment must be preserved verbatim.
+! { dg-final { scan-file "cpp_non_traditional_1.i" {! it's a concat} } }
+! Stringification:
+! { dg-final { scan-file "cpp_non_traditional_1.i" {"spam"} } }
+! Token pasting:
+! { dg-final { scan-file "cpp_non_traditional_1.i" {my_var} } }
diff --git a/gcc/testsuite/gfortran.dg/cpp_non_traditional_2.F90 b/gcc/testsuite/gfortran.dg/cpp_non_traditional_2.F90
new file mode 100644
index 00000000000..35cfc27aeb7
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/cpp_non_traditional_2.F90
@@ -0,0 +1,23 @@
+! { dg-do preprocess }
+! { dg-options "-cpp -fno-traditional-cpp -P" }
+!
+! Check that inside #if / #elif preprocessing expressions '!' still
+! means logical-not, even when the surrounding Fortran source treats it
+! as a line-comment marker.
+
+#define FOO 0
+
+#if !FOO
+      integer, parameter :: not_foo = 1
+#else
+#error "FOO should be falsy here"
+#endif
+
+#if !defined(BAR)
+      integer, parameter :: no_bar = 1
+#else
+#error "BAR should not be defined"
+#endif
+
+! { dg-final { scan-file "cpp_non_traditional_2.i" {not_foo} } }
+! { dg-final { scan-file "cpp_non_traditional_2.i" {no_bar} } }
diff --git a/gcc/testsuite/gfortran.dg/cpp_non_traditional_3.F b/gcc/testsuite/gfortran.dg/cpp_non_traditional_3.F
new file mode 100644
index 00000000000..b3f875e18d8
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/cpp_non_traditional_3.F
@@ -0,0 +1,32 @@
+! { dg-do preprocess }
+! { dg-options "-cpp -fno-traditional-cpp -P" }
+!
+! Two fixed-form gotchas for non-traditional preprocessing:
+!
+!   - A '!' comment containing an unbalanced apostrophe must not start
+!     a C character literal that then runs all the way to end-of-file.
+!   - The column-1 markers 'C', 'c', '*', 'D' and 'd' must be picked
+!     up as fixed-form comment-line starters, even though those
+!     characters are otherwise valid identifier or operator beginnings.
+!     Without the fixed-form lexer hook in libcpp the apostrophes
+!     inside such comment lines would, again, start runaway C
+!     character literals.
+
+C This is a column-1 'C' comment with John's apostrophe.
+c This is a column-1 'c' comment, can't be a runaway literal.
+* This is a column-1 '*' comment with don't-tokenize-me.
+D This is a column-1 'D' debug comment.
+d This is a column-1 'd' debug comment.
+       program t
+       integer i
+       i = 1                  ! John's variable
+       i = 2                  ! don't tokenize the apostrophe
+       end program t
+
+! { dg-final { scan-file "cpp_non_traditional_3.i" {John's variable} } }
+! { dg-final { scan-file "cpp_non_traditional_3.i" {don't tokenize the apostrophe} } }
+! { dg-final { scan-file "cpp_non_traditional_3.i" {C This is a column-1 'C' comment} } }
+! { dg-final { scan-file "cpp_non_traditional_3.i" {c This is a column-1 'c' comment} } }
+! { dg-final { scan-file "cpp_non_traditional_3.i" {\* This is a column-1 '\*' comment} } }
+! { dg-final { scan-file "cpp_non_traditional_3.i" {D This is a column-1 'D' debug comment} } }
+! { dg-final { scan-file "cpp_non_traditional_3.i" {d This is a column-1 'd' debug comment} } }
diff --git a/gcc/testsuite/gfortran.dg/cpp_non_traditional_4.f90 b/gcc/testsuite/gfortran.dg/cpp_non_traditional_4.f90
new file mode 100644
index 00000000000..723a70ac883
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/cpp_non_traditional_4.f90
@@ -0,0 +1,13 @@
+! { dg-do compile }
+! { dg-options "-fno-traditional-cpp" }
+!
+! Passing -fno-traditional-cpp on its own should error out, since
+! preprocessing was not actually enabled.  The user has to combine it
+! with -cpp (or rely on the implicit preprocessing implied by a .F90
+! extension, which this .f90 file deliberately does not have).
+
+program t
+end program t
+
+! { dg-error "To enable preprocessing, use .-cpp." "" { target *-*-* } 0 }
+! { dg-prune-output "compilation terminated" }
diff --git a/gcc/testsuite/gfortran.dg/cpp_non_traditional_5.F90 b/gcc/testsuite/gfortran.dg/cpp_non_traditional_5.F90
new file mode 100644
index 00000000000..13b515ac25a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/cpp_non_traditional_5.F90
@@ -0,0 +1,18 @@
+! { dg-do preprocess }
+! { dg-options "-cpp -P" }
+!
+! Backwards-compatibility check.  Without -fno-traditional-cpp the
+! preprocessor must stay in the traditional mode that gfortran has
+! always used.  The output preserves the source byte-for-byte through
+! macro expansion, so "//" stays as written and "##" token pasting
+! is *not* available.
+
+#define CONCAT a // b
+
+program t
+  character(len=*), parameter :: x = CONCAT
+end program t
+
+! "//" must appear with no whitespace between the slashes, since
+! traditional mode does not retokenize.
+! { dg-final { scan-file "cpp_non_traditional_5.i" {a // b} } }
diff --git a/libcpp/include/cpplib.h b/libcpp/include/cpplib.h
index bc0d7714e96..96776b6a807 100644
--- a/libcpp/include/cpplib.h
+++ b/libcpp/include/cpplib.h
@@ -183,7 +183,8 @@ enum c_lang {CLK_GNUC89 = 0, CLK_GNUC99, CLK_GNUC11, CLK_GNUC17, CLK_GNUC23,
 	     CLK_GNUCXX, CLK_CXX98, CLK_GNUCXX11, CLK_CXX11,
 	     CLK_GNUCXX14, CLK_CXX14, CLK_GNUCXX17, CLK_CXX17,
 	     CLK_GNUCXX20, CLK_CXX20, CLK_GNUCXX23, CLK_CXX23,
-	     CLK_GNUCXX26, CLK_CXX26, CLK_ASM};
+	     CLK_GNUCXX26, CLK_CXX26, CLK_ASM,
+	     CLK_GNUF77, CLK_GNUF90};
 
 /* Payload of a NUMBER, STRING, CHAR or COMMENT token.  */
 struct GTY(()) cpp_string {
diff --git a/libcpp/init.cc b/libcpp/init.cc
index a480d1d4a26..7994645222c 100644
--- a/libcpp/init.cc
+++ b/libcpp/init.cc
@@ -151,7 +151,9 @@ static const struct lang_flags lang_defaults[] = {
   /* CXX23    */ { 1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,0,0,1 },
   /* GNUCXX26 */ { 1,1,1,1,1,1,0,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,0,1 },
   /* CXX26    */ { 1,1,1,1,1,1,1,1,1,1,1,1,1,0,1,1,1,0,1,1,1,1,1,0,1,1,0,1 },
-  /* ASM      */ { 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }
+  /* ASM      */ { 0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
+  /* GNUF77   */ { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 },
+  /* GNUF90   */ { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 }
 };
 
 /* Sets internal flags correctly for a given language.  */
diff --git a/libcpp/lex.cc b/libcpp/lex.cc
index 9652e7d5aae..fcbc593d731 100644
--- a/libcpp/lex.cc
+++ b/libcpp/lex.cc
@@ -3069,7 +3069,9 @@ save_comment (cpp_reader *pfile, cpp_token *token, const unsigned char *from,
   token->val.str.len = clen;
   token->val.str.text = buffer;
 
-  buffer[0] = '/';
+  /* Preserve the starting delimiter of the comment: '/' for C and C++ style
+     comments, '!' or one of the fixed-form column-1 markers for Fortran.  */
+  buffer[0] = from[-1];
   memcpy (buffer + 1, from, len - 1);
 
   /* Finish conversion to a C comment, if necessary.  */
@@ -3963,6 +3965,16 @@ _cpp_lex_direct (cpp_reader *pfile)
     result->src_loc = linemap_position_for_column (pfile->line_table,
 					  CPP_BUF_COLUMN (buffer, buffer->cur));
 
+  /* In fixed-form Fortran a 'C', 'c', '*', 'D' or 'd' in column 1 starts
+     a comment line.  The other Fortran comment marker, '!', works for
+     both fixed and free form and is handled by case '!' below.  */
+  if (CPP_OPTION (pfile, lang) == CLK_GNUF77
+      && ! pfile->state.in_directive
+      && CPP_BUF_COLUMN (buffer, buffer->cur - 1) == 0
+      && (c == 'c' || c == 'C' || c == '*'
+	  || c == 'd' || c == 'D'))
+    goto fortran_line_comment;
+
   switch (c)
     {
     case ' ': case '\t': case '\f': case '\v': case '\0':
@@ -4081,7 +4093,9 @@ _cpp_lex_direct (cpp_reader *pfile)
 	  if (_cpp_skip_block_comment (pfile))
 	    cpp_error (pfile, CPP_DL_ERROR, "unterminated comment");
 	}
-      else if (c == '/' && ! CPP_OPTION (pfile, traditional))
+      else if (c == '/' && ! CPP_OPTION (pfile, traditional)
+	       && CPP_OPTION (pfile, lang) != CLK_GNUF90
+	       && CPP_OPTION (pfile, lang) != CLK_GNUF77)
 	{
 	  /* Don't warn for system headers.  */
 	  if (_cpp_in_system_header (pfile))
@@ -4335,7 +4349,46 @@ _cpp_lex_direct (cpp_reader *pfile)
 
     case '*': IF_NEXT_IS ('=', CPP_MULT_EQ, CPP_MULT); break;
     case '=': IF_NEXT_IS ('=', CPP_EQ_EQ, CPP_EQ); break;
-    case '!': IF_NEXT_IS ('=', CPP_NOT_EQ, CPP_NOT); break;
+    case '!':
+      if (!((CPP_OPTION (pfile, lang) == CLK_GNUF90
+	     || CPP_OPTION (pfile, lang) == CLK_GNUF77)
+	    && ! pfile->state.in_directive))
+	{
+	  /* '!' is the logical-not operator, as in "#if !FOO".  */
+	  IF_NEXT_IS ('=', CPP_NOT_EQ, CPP_NOT);
+	  break;
+	}
+      /* Fall through.  */
+
+    fortran_line_comment:
+      /* A Fortran line comment.  */
+      comment_start = buffer->cur;
+
+      if (skip_line_comment (pfile) && CPP_OPTION (pfile, warn_comments))
+	cpp_warning (pfile, CPP_W_COMMENTS, "multi-line comment");
+
+      if (fallthrough_comment_p (pfile, comment_start))
+	fallthrough_comment = true;
+
+      if (pfile->cb.comment)
+	{
+	  size_t len = pfile->buffer->cur - comment_start;
+	  pfile->cb.comment (pfile, result->src_loc, comment_start - 1,
+			     len + 1);
+	}
+
+      if (!pfile->state.save_comments)
+	{
+	  result->flags |= PREV_WHITE;
+	  goto update_tokens_line;
+	}
+
+      if (fallthrough_comment)
+	result->flags |= PREV_FALLTHROUGH;
+
+      /* Save the comment as a token in its own right.  */
+      save_comment (pfile, result, comment_start, c);
+      break;
     case '^':
       result->type = CPP_XOR;
       if (*buffer->cur == '=')
-- 
2.54.0