verible: formatting: make line terminator character configurable

Precise control of file contents is required. This makes verible handle
files in `binary` mode, effectively disabling the platform-specific
hooks that for example translate \n into \r\n for DOS systems.

Let's introduce the line_terminator flag into BasicFormatStyle so that
users can decide which line terminator they want to use. Current options
are \n (LF) or \r\n (CRLF). LF is the default configuration.

Author: IEncinas10

verible/common/formatting/basic-format-style-init.cc

@@ -37,6 +37,9 @@ ABSL_FLAG(int, over_column_limit_penalty, 100,
 ABSL_FLAG(int, line_break_penalty, 2,
           "Penalty added to solution for each introduced line break.");
 
+ABSL_FLAG(verible::LineTerminatorStyle, line_terminator, verible::LineTerminatorStyle::kLF,
+          "Line terminator");
+
 namespace verible {
 void InitializeFromFlags(BasicFormatStyle *style) {
 #define STYLE_FROM_FLAG(name) style->name = absl::GetFlag(FLAGS_##name)
@@ -47,6 +50,7 @@ void InitializeFromFlags(BasicFormatStyle *style) {
   STYLE_FROM_FLAG(column_limit);
   STYLE_FROM_FLAG(over_column_limit_penalty);
   STYLE_FROM_FLAG(line_break_penalty);
+  STYLE_FROM_FLAG(line_terminator);
 
 #undef STYLE_FROM_FLAG
 }

verible/common/formatting/basic-format-style.cc

@@ -48,4 +48,34 @@ std::string AbslUnparseFlag(const IndentationStyle &mode) {
   return stream.str();
 }
 
+static const verible::EnumNameMap<LineTerminatorStyle> &
+LineTerminatorStyleStrings() {
+  static const verible::EnumNameMap<LineTerminatorStyle>
+      kLineTerminatorStyleStringMap({
+          {"CRLF", LineTerminatorStyle::kCRLF},
+          {"LF", LineTerminatorStyle::kLF},
+      });
+  return kLineTerminatorStyleStringMap;
+}
+
+std::ostream &operator<<(std::ostream &stream, LineTerminatorStyle style) {
+  switch (style) {
+    case LineTerminatorStyle::kLF:
+      return stream << "\n";
+    case LineTerminatorStyle::kCRLF:
+      return stream << "\r\n";
+  }
+  __builtin_unreachable();
+}
+
+bool AbslParseFlag(std::string_view text, LineTerminatorStyle *mode,
+                   std::string *error) {
+  return LineTerminatorStyleStrings().Parse(text, mode, error,
+                                            "LineTerminatorStyle");
+}
+
+std::string AbslUnparseFlag(const LineTerminatorStyle &mode) {
+  return std::string{LineTerminatorStyleStrings().EnumName(mode)};
+}
+
 }  // namespace verible

verible/common/formatting/basic-format-style.h

@@ -21,6 +21,20 @@
 
 namespace verible {
 
+
+enum class LineTerminatorStyle {
+  // Line Feed `\n` (UNIX Style)
+  kLF,
+  // Carriage return + Line Feed `\r\n` (DOS Style)
+  kCRLF,
+};
+
+std::ostream &operator<<(std::ostream &, LineTerminatorStyle);
+
+bool AbslParseFlag(std::string_view, LineTerminatorStyle *, std::string *);
+
+std::string AbslUnparseFlag(const LineTerminatorStyle &);
+
 // Style configuration common to all languages.
 struct BasicFormatStyle {
   // Each indentation level adds this many spaces.
@@ -42,6 +56,9 @@ struct BasicFormatStyle {
   // Penalty added to solution for each introduced line break.
   int line_break_penalty = 2;
 
+  // Line terminator character sequence
+  LineTerminatorStyle line_terminator = LineTerminatorStyle::kLF;
+
   // -- Note: when adding new fields, add them in basic_format_style_init.cc
 };
 

verible/verilog/formatting/BUILD

@@ -215,6 +215,7 @@ cc_library(
     srcs = ["comment-controls.cc"],
     hdrs = ["comment-controls.h"],
     deps = [
+        "//verible/common/formatting:basic-format-style",
         "//verible/common/strings:comment-utils",
         "//verible/common/strings:display-utils",
         "//verible/common/strings:line-column-map",

verible/verilog/formatting/comment-controls.cc

@@ -121,7 +121,7 @@ static size_t NewlineCount(std::string_view s) {
 void FormatWhitespaceWithDisabledByteRanges(
     std::string_view text_base, std::string_view space_text,
     const ByteOffsetSet &disabled_ranges, bool include_disabled_ranges,
-    std::ostream &stream) {
+    std::ostream &stream, verible::LineTerminatorStyle line_terminator_style) {
   VLOG(3) << __FUNCTION__;
   CHECK(verible::IsSubRange(space_text, text_base));
   const int start = std::distance(text_base.begin(), space_text.begin());
@@ -136,7 +136,7 @@ void FormatWhitespaceWithDisabledByteRanges(
   if (space_text.empty() && start != 0) {
     if (!disabled_ranges.Contains(start)) {
       VLOG(3) << "output: 1*\"\\n\" (empty space text)";
-      stream << '\n';
+      stream << line_terminator_style;
       return;
     }
   }
@@ -159,7 +159,9 @@ void FormatWhitespaceWithDisabledByteRanges(
           text_base.substr(range.first, range.second - range.first));
       const size_t newline_count = NewlineCount(enabled);
       VLOG(3) << "output: " << newline_count << "*\"\\n\" (formatted)";
-      stream << verible::Spacer(newline_count, '\n');
+      for (size_t i = 0; i < newline_count; i++) {
+        stream << line_terminator_style;
+      }
       partially_enabled = true;
       total_enabled_newlines += newline_count;
     }
@@ -177,7 +179,7 @@ void FormatWhitespaceWithDisabledByteRanges(
   // Print at least one newline if some subrange was format-enabled.
   if (partially_enabled && total_enabled_newlines == 0 && start != 0) {
     VLOG(3) << "output: 1*\"\\n\"";
-    stream << '\n';
+    stream << line_terminator_style;
   }
 }
 

verible/verilog/formatting/comment-controls.h

@@ -18,6 +18,7 @@
 #include <ostream>
 #include <string_view>
 
+#include "verible/common/formatting/basic-format-style.h"
 #include "verible/common/strings/line-column-map.h"
 #include "verible/common/strings/position.h"  // for ByteOffsetSet, LineNumberSet
 #include "verible/common/text/token-stream-view.h"
@@ -48,7 +49,9 @@ verible::ByteOffsetSet EnabledLinesToDisabledByteRanges(
 void FormatWhitespaceWithDisabledByteRanges(
     std::string_view text_base, std::string_view space_text,
     const verible::ByteOffsetSet &disabled_ranges, bool include_disabled_ranges,
-    std::ostream &stream);
+    std::ostream &stream,
+    verible::LineTerminatorStyle line_terminator_style =
+        verible::LineTerminatorStyle::kLF);
 
 }  // namespace formatter
 }  // namespace verilog

verible/verilog/formatting/formatter.cc

@@ -993,7 +993,7 @@ void Formatter::Emit(bool include_disabled, std::ostream &stream) const {
         full_text.substr(position, front_offset - position));
     FormatWhitespaceWithDisabledByteRanges(full_text, leading_whitespace,
                                            disabled_ranges_, include_disabled,
-                                           stream);
+                                           stream, style_.line_terminator);
 
     // When front of first token is format-disabled, the previous call will
     // already cover the space up to the front token, in which case,
@@ -1010,7 +1010,7 @@ void Formatter::Emit(bool include_disabled, std::ostream &stream) const {
   const std::string_view trailing_whitespace(full_text.substr(position));
   FormatWhitespaceWithDisabledByteRanges(full_text, trailing_whitespace,
                                          disabled_ranges_, include_disabled,
-                                         stream);
+                                         stream, style_.line_terminator);
 }
 
 }  // namespace formatter