//===-- clang-format/ClangFormat.cpp - Clang format tool ------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// /// /// \file /// This file implements a clang-format tool that automatically formats /// (fragments of) C++ code. /// //===----------------------------------------------------------------------===// #include "../../lib/Format/MatchFilePath.h" #include "clang/Basic/Diagnostic.h" #include "clang/Basic/DiagnosticOptions.h" #include "clang/Basic/FileManager.h" #include "clang/Basic/SourceManager.h" #include "clang/Basic/Version.h" #include "clang/Format/Format.h" #include "clang/Rewrite/Core/Rewriter.h" #include "llvm/ADT/StringSwitch.h" #include "llvm/Support/CommandLine.h" #include "llvm/Support/FileSystem.h" #include "llvm/Support/InitLLVM.h" #include "llvm/Support/Process.h" #include <fstream> usingnamespacellvm; Replacements; static cl::opt<bool> Help("h", cl::desc("Alias for -help"), cl::Hidden); // Mark all our options with this category, everything else (except for -version // and -help) will be hidden. static cl::OptionCategory ClangFormatCategory("Clang-format options"); static cl::list<unsigned> Offsets("offset", cl::desc("Format a range starting at this byte offset.\n" "Multiple ranges can be formatted by specifying\n" "several -offset and -length pairs.\n" "Can only be used with one input file."), cl::cat(ClangFormatCategory)); static cl::list<unsigned> Lengths("length", cl::desc("Format a range of this length (in bytes).\n" "Multiple ranges can be formatted by specifying\n" "several -offset and -length pairs.\n" "When only a single -offset is specified without\n" "-length, clang-format will format up to the end\n" "of the file.\n" "Can only be used with one input file."), cl::cat(ClangFormatCategory)); static cl::list<std::string> LineRanges("lines", cl::desc("<start line>:<end line> - format a range of\n" "lines (both 1-based).\n" "Multiple ranges can be formatted by specifying\n" "several -lines arguments.\n" "Can't be used with -offset and -length.\n" "Can only be used with one input file."), cl::cat(ClangFormatCategory)); static cl::opt<std::string> Style("style", cl::desc(clang::format::StyleOptionHelpDescription), cl::init(clang::format::DefaultFormatStyle), cl::cat(ClangFormatCategory)); static cl::opt<std::string> FallbackStyle("fallback-style", cl::desc("The name of the predefined style used as a\n" "fallback in case clang-format is invoked with\n" "-style=file, but can not find the .clang-format\n" "file to use. Defaults to 'LLVM'.\n" "Use -fallback-style=none to skip formatting."), cl::init(clang::format::DefaultFallbackStyle), cl::cat(ClangFormatCategory)); static cl::opt<std::string> AssumeFileName( "assume-filename", cl::desc("Set filename used to determine the language and to find\n" ".clang-format file.\n" "Only used when reading from stdin.\n" "If this is not passed, the .clang-format file is searched\n" "relative to the current working directory when reading stdin.\n" "Unrecognized filenames are treated as C++.\n" "supported:\n" " CSharp: .cs\n" " Java: .java\n" " JavaScript: .mjs .js .ts\n" " Json: .json\n" " Objective-C: .m .mm\n" " Proto: .proto .protodevel\n" " TableGen: .td\n" " TextProto: .txtpb .textpb .pb.txt .textproto .asciipb\n" " Verilog: .sv .svh .v .vh"), cl::init("<stdin>"), cl::cat(ClangFormatCategory)); static cl::opt<bool> Inplace("i", cl::desc("Inplace edit <file>s, if specified."), cl::cat(ClangFormatCategory)); static cl::opt<bool> OutputXML("output-replacements-xml", cl::desc("Output replacements as XML."), cl::cat(ClangFormatCategory)); static cl::opt<bool> DumpConfig("dump-config", cl::desc("Dump configuration options to stdout and exit.\n" "Can be used with -style option."), cl::cat(ClangFormatCategory)); static cl::opt<unsigned> Cursor("cursor", cl::desc("The position of the cursor when invoking\n" "clang-format from an editor integration"), cl::init(0), cl::cat(ClangFormatCategory)); static cl::opt<bool> SortIncludes("sort-includes", cl::desc("If set, overrides the include sorting behavior\n" "determined by the SortIncludes style flag"), cl::cat(ClangFormatCategory)); static cl::opt<std::string> QualifierAlignment( "qualifier-alignment", cl::desc("If set, overrides the qualifier alignment style\n" "determined by the QualifierAlignment style flag"), cl::init(""), cl::cat(ClangFormatCategory)); static cl::opt<std::string> Files( "files", cl::desc("A file containing a list of files to process, one per line."), cl::value_desc("filename"), cl::init(""), cl::cat(ClangFormatCategory)); static cl::opt<bool> Verbose("verbose", cl::desc("If set, shows the list of processed files"), cl::cat(ClangFormatCategory)); // Use --dry-run to match other LLVM tools when you mean do it but don't // actually do it static cl::opt<bool> DryRun("dry-run", cl::desc("If set, do not actually make the formatting changes"), cl::cat(ClangFormatCategory)); // Use -n as a common command as an alias for --dry-run. (git and make use -n) static cl::alias DryRunShort("n", cl::desc("Alias for --dry-run"), cl::cat(ClangFormatCategory), cl::aliasopt(DryRun), cl::NotHidden); // Emulate being able to turn on/off the warning. static cl::opt<bool> WarnFormat("Wclang-format-violations", cl::desc("Warnings about individual formatting changes needed. " "Used only with --dry-run or -n"), cl::init(true), cl::cat(ClangFormatCategory), cl::Hidden); static cl::opt<bool> NoWarnFormat("Wno-clang-format-violations", cl::desc("Do not warn about individual formatting changes " "needed. Used only with --dry-run or -n"), cl::init(false), cl::cat(ClangFormatCategory), cl::Hidden); static cl::opt<unsigned> ErrorLimit( "ferror-limit", cl::desc("Set the maximum number of clang-format errors to emit\n" "before stopping (0 = no limit).\n" "Used only with --dry-run or -n"), cl::init(0), cl::cat(ClangFormatCategory)); static cl::opt<bool> WarningsAsErrors("Werror", cl::desc("If set, changes formatting warnings to errors"), cl::cat(ClangFormatCategory)); namespace { enum class WNoError { … }; } static cl::bits<WNoError> WNoErrorList( "Wno-error", cl::desc("If set don't error out on the specified warning type."), cl::values( clEnumValN(WNoError::Unknown, "unknown", "If set, unknown format options are only warned about.\n" "This can be used to enable formatting, even if the\n" "configuration contains unknown (newer) options.\n" "Use with caution, as this might lead to dramatically\n" "differing format depending on an option being\n" "supported or not.")), cl::cat(ClangFormatCategory)); static cl::opt<bool> ShowColors("fcolor-diagnostics", cl::desc("If set, and on a color-capable terminal controls " "whether or not to print diagnostics in color"), cl::init(true), cl::cat(ClangFormatCategory), cl::Hidden); static cl::opt<bool> NoShowColors("fno-color-diagnostics", cl::desc("If set, and on a color-capable terminal controls " "whether or not to print diagnostics in color"), cl::init(false), cl::cat(ClangFormatCategory), cl::Hidden); static cl::list<std::string> FileNames(cl::Positional, cl::desc("[@<file>] [<file> ...]"), cl::cat(ClangFormatCategory)); static cl::opt<bool> FailOnIncompleteFormat( "fail-on-incomplete-format", cl::desc("If set, fail with exit code 1 on incomplete format."), cl::init(false), cl::cat(ClangFormatCategory)); static cl::opt<bool> ListIgnored("list-ignored", cl::desc("List ignored files."), cl::cat(ClangFormatCategory), cl::Hidden); namespace clang { namespace format { static FileID createInMemoryFile(StringRef FileName, MemoryBufferRef Source, SourceManager &Sources, FileManager &Files, llvm::vfs::InMemoryFileSystem *MemFS) { … } // Parses <start line>:<end line> input to a pair of line numbers. // Returns true on error. static bool parseLineRange(StringRef Input, unsigned &FromLine, unsigned &ToLine) { … } static bool fillRanges(MemoryBuffer *Code, std::vector<tooling::Range> &Ranges) { … } static void outputReplacementXML(StringRef Text) { … } static void outputReplacementsXML(const Replacements &Replaces) { … } static bool emitReplacementWarnings(const Replacements &Replaces, StringRef AssumedFileName, const std::unique_ptr<llvm::MemoryBuffer> &Code) { … } static void outputXML(const Replacements &Replaces, const Replacements &FormatChanges, const FormattingAttemptStatus &Status, const cl::opt<unsigned> &Cursor, unsigned CursorPosition) { … } class ClangFormatDiagConsumer : public DiagnosticConsumer { … }; // Returns true on error. static bool format(StringRef FileName, bool ErrorOnIncompleteFormat = false) { … } } // namespace format } // namespace clang static void PrintVersion(raw_ostream &OS) { … } // Dump the configuration. static int dumpConfig() { … } String; static String IgnoreDir; // Directory of .clang-format-ignore file. static String PrevDir; // Directory of previous `FilePath`. static SmallVector<String> Patterns; // Patterns in .clang-format-ignore file. // Check whether `FilePath` is ignored according to the nearest // .clang-format-ignore file based on the rules below: // - A blank line is skipped. // - Leading and trailing spaces of a line are trimmed. // - A line starting with a hash (`#`) is a comment. // - A non-comment line is a single pattern. // - The slash (`/`) is used as the directory separator. // - A pattern is relative to the directory of the .clang-format-ignore file (or // the root directory if the pattern starts with a slash). // - A pattern is negated if it starts with a bang (`!`). static bool isIgnored(StringRef FilePath) { … } int main(int argc, const char **argv) { … }
Codebase Browser
llvm