From: Daniel Jasper Date: Wed, 20 Mar 2013 09:53:23 +0000 (+0000) Subject: Add clang-format binary to cfe. X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=9be2c5cf174b306e6e45ebcabae231631b0bda19;p=platform%2Fupstream%2Fllvm.git Add clang-format binary to cfe. llvm-svn: 177506 --- diff --git a/clang/tools/CMakeLists.txt b/clang/tools/CMakeLists.txt index cccff5d..eb5e366 100644 --- a/clang/tools/CMakeLists.txt +++ b/clang/tools/CMakeLists.txt @@ -5,6 +5,7 @@ add_subdirectory(c-arcmt-test) add_subdirectory(diagtool) add_subdirectory(driver) add_subdirectory(clang-check) +add_subdirectory(clang-format) # We support checking out the clang-tools-extra repository into the 'extra' # subdirectory. It contains tools developed as part of the Clang/LLVM project diff --git a/clang/tools/clang-format/CMakeLists.txt b/clang/tools/clang-format/CMakeLists.txt new file mode 100644 index 0000000..c86a920 --- /dev/null +++ b/clang/tools/clang-format/CMakeLists.txt @@ -0,0 +1,17 @@ +set(LLVM_LINK_COMPONENTS support) +set(LLVM_USED_LIBS clangFormat clangTooling clangBasic clangAST) + +add_clang_executable(clang-format + ClangFormat.cpp + ) + +target_link_libraries(clang-format + clangFormat + clangTooling + clangBasic + clangRewriteFrontend + ) + +install(TARGETS clang-format + RUNTIME DESTINATION bin) + diff --git a/clang/tools/clang-format/ClangFormat.cpp b/clang/tools/clang-format/ClangFormat.cpp new file mode 100644 index 0000000..c4969b2 --- /dev/null +++ b/clang/tools/clang-format/ClangFormat.cpp @@ -0,0 +1,152 @@ +//===-- clang-format/ClangFormat.cpp - Clang format tool ------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +/// +/// \file +/// \brief This file implements a clang-format tool that automatically formats +/// (fragments of) C++ code. +/// +//===----------------------------------------------------------------------===// + +#include "clang/Basic/Diagnostic.h" +#include "clang/Basic/DiagnosticOptions.h" +#include "clang/Basic/FileManager.h" +#include "clang/Basic/SourceManager.h" +#include "clang/Format/Format.h" +#include "clang/Lex/Lexer.h" +#include "clang/Rewrite/Core/Rewriter.h" +#include "llvm/Support/FileSystem.h" +#include "llvm/Support/Signals.h" + +using namespace llvm; + +static cl::opt Help("h", cl::desc("Alias for -help"), cl::Hidden); + +static cl::list Offsets( + "offset", cl::desc("Format a range starting at this file offset.")); +static cl::list Lengths( + "length", cl::desc("Format a range of this length, -1 for end of file.")); +static cl::opt Style( + "style", + cl::desc("Coding style, currently supports: LLVM, Google, Chromium."), + cl::init("LLVM")); +static cl::opt Inplace("i", + cl::desc("Inplace edit , if specified.")); + +static cl::opt OutputXML( + "output-replacements-xml", cl::desc("Output replacements as XML.")); + +static cl::opt FileName(cl::Positional, cl::desc("[]"), + cl::init("-")); + +namespace clang { +namespace format { + +static FileID createInMemoryFile(StringRef FileName, const MemoryBuffer *Source, + SourceManager &Sources, FileManager &Files) { + const FileEntry *Entry = Files.getVirtualFile(FileName == "-" ? "" : + FileName, + Source->getBufferSize(), 0); + Sources.overrideFileContents(Entry, Source, true); + return Sources.createFileID(Entry, SourceLocation(), SrcMgr::C_User); +} + +static FormatStyle getStyle() { + FormatStyle TheStyle = getGoogleStyle(); + if (Style == "LLVM") + TheStyle = getLLVMStyle(); + if (Style == "Chromium") + TheStyle = getChromiumStyle(); + return TheStyle; +} + +static void format() { + FileManager Files((FileSystemOptions())); + DiagnosticsEngine Diagnostics( + IntrusiveRefCntPtr(new DiagnosticIDs), + new DiagnosticOptions); + SourceManager Sources(Diagnostics, Files); + OwningPtr Code; + if (error_code ec = MemoryBuffer::getFileOrSTDIN(FileName, Code)) { + llvm::errs() << ec.message() << "\n"; + return; + } + FileID ID = createInMemoryFile(FileName, Code.get(), Sources, Files); + Lexer Lex(ID, Sources.getBuffer(ID), Sources, getFormattingLangOpts()); + if (Offsets.empty()) + Offsets.push_back(0); + if (Offsets.size() != Lengths.size() && + !(Offsets.size() == 1 && Lengths.empty())) { + llvm::errs() << "Number of -offset and -length arguments must match.\n"; + return; + } + std::vector Ranges; + for (cl::list::size_type i = 0, e = Offsets.size(); i != e; ++i) { + SourceLocation Start = + Sources.getLocForStartOfFile(ID).getLocWithOffset(Offsets[i]); + SourceLocation End; + if (i < Lengths.size()) { + End = Start.getLocWithOffset(Lengths[i]); + } else { + End = Sources.getLocForEndOfFile(ID); + } + Ranges.push_back(CharSourceRange::getCharRange(Start, End)); + } + tooling::Replacements Replaces = reformat(getStyle(), Lex, Sources, Ranges); + if (OutputXML) { + llvm::outs() << "\n\n"; + for (tooling::Replacements::const_iterator I = Replaces.begin(), + E = Replaces.end(); + I != E; ++I) { + llvm::outs() << "" + << I->getReplacementText() << "\n"; + } + llvm::outs() << "\n"; + } else { + Rewriter Rewrite(Sources, LangOptions()); + tooling::applyAllReplacements(Replaces, Rewrite); + if (Inplace) { + if (Replaces.size() == 0) + return; // Nothing changed, don't touch the file. + + std::string ErrorInfo; + llvm::raw_fd_ostream FileStream(FileName.c_str(), ErrorInfo, + llvm::raw_fd_ostream::F_Binary); + if (!ErrorInfo.empty()) { + llvm::errs() << "Error while writing file: " << ErrorInfo << "\n"; + return; + } + Rewrite.getEditBuffer(ID).write(FileStream); + FileStream.flush(); + } else { + Rewrite.getEditBuffer(ID).write(outs()); + } + } +} + +} // namespace format +} // namespace clang + +int main(int argc, const char **argv) { + llvm::sys::PrintStackTraceOnErrorSignal(); + cl::ParseCommandLineOptions( + argc, argv, + "A tool to format C/C++/Obj-C code.\n\n" + "Currently supports LLVM and Google style guides.\n" + "If no arguments are specified, it formats the code from standard input\n" + "and writes the result to the standard output.\n" + "If is given, it reformats the file. If -i is specified together\n" + "with , the file is edited in-place. Otherwise, the result is\n" + "written to the standard output.\n"); + if (Help) + cl::PrintHelpMessage(); + clang::format::format(); + return 0; +} diff --git a/clang/tools/clang-format/Makefile b/clang/tools/clang-format/Makefile new file mode 100644 index 0000000..d869267 --- /dev/null +++ b/clang/tools/clang-format/Makefile @@ -0,0 +1,24 @@ +##===- clang-format/Makefile -------------------------------*- Makefile -*-===## +# +# The LLVM Compiler Infrastructure +# +# This file is distributed under the University of Illinois Open Source +# License. See LICENSE.TXT for details. +# +##===----------------------------------------------------------------------===## + +CLANG_LEVEL := ../.. + +TOOLNAME = clang-format + +# No plugins, optimize startup time. +TOOL_NO_EXPORTS = 1 + +include $(CLANG_LEVEL)/../../Makefile.config +LINK_COMPONENTS := $(TARGETS_TO_BUILD) asmparser bitreader support mc +USEDLIBS = clangFormat.a clangTooling.a clangFrontend.a clangSerialization.a \ + clangDriver.a clangParse.a clangSema.a clangAnalysis.a \ + clangRewriteFrontend.a clangRewriteCore.a clangEdit.a clangAST.a \ + clangLex.a clangBasic.a + +include $(CLANG_LEVEL)/Makefile diff --git a/clang/tools/clang-format/clang-format-diff.py b/clang/tools/clang-format/clang-format-diff.py new file mode 100755 index 0000000..ab5f1b1 --- /dev/null +++ b/clang/tools/clang-format/clang-format-diff.py @@ -0,0 +1,115 @@ +#!/usr/bin/python +# +#===- clang-format-diff.py - ClangFormat Diff Reformatter ----*- python -*--===# +# +# The LLVM Compiler Infrastructure +# +# This file is distributed under the University of Illinois Open Source +# License. See LICENSE.TXT for details. +# +#===------------------------------------------------------------------------===# + +r""" +ClangFormat Diff Reformatter +============================ + +This script reads input from a unified diff and reformats all the changed +lines. This is useful to reformat all the lines touched by a specific patch. +Example usage for git users: + + git diff -U0 HEAD^ | clang-format-diff.py -p1 + +""" + +import argparse +import re +import subprocess +import sys + + +# Change this to the full path if clang-format is not on the path. +binary = 'clang-format' + + +def getOffsetLength(filename, line_number, line_count): + """ + Calculates the field offset and length based on line number and count. + """ + offset = 0 + length = 0 + with open(filename, 'r') as f: + for line in f: + if line_number > 1: + offset += len(line) + line_number -= 1 + elif line_count > 0: + length += len(line) + line_count -= 1 + else: + break + return offset, length + + +def formatRange(r, style): + """ + Formats range 'r' according to style 'style'. + """ + filename, line_number, line_count = r + # FIXME: Add other types containing C++/ObjC code. + if not (filename.endswith(".cpp") or filename.endswith(".cc") or + filename.endswith(".h")): + return + + offset, length = getOffsetLength(filename, line_number, line_count) + with open(filename, 'r') as f: + text = f.read() + p = subprocess.Popen([binary, '-offset', str(offset), '-length', str(length), + '-style', style], + stdout=subprocess.PIPE, stderr=subprocess.PIPE, + stdin=subprocess.PIPE) + stdout, stderr = p.communicate(input=text) + if stderr: + print stderr + return + if not stdout: + print 'Segfault occurred while formatting', filename + print 'Please report a bug on llvm.org/bugs.' + return + with open(filename, 'w') as f: + f.write(stdout) + + +def main(): + parser = argparse.ArgumentParser(description= + 'Reformat changed lines in diff') + parser.add_argument('-p', default=1, + help='strip the smallest prefix containing P slashes') + parser.add_argument('-style', default='LLVM', + help='formatting style to apply (LLVM, Google)') + args = parser.parse_args() + + filename = None + ranges = [] + + for line in sys.stdin: + match = re.search('^\+\+\+\ (.*?/){%s}(\S*)' % args.p, line) + if match: + filename = match.group(2) + if filename == None: + continue + + match = re.search('^@@.*\+(\d+)(,(\d+))?', line) + if match: + line_count = 1 + if match.group(3): + line_count = int(match.group(3)) + ranges.append((filename, int(match.group(1)), line_count)) + + # Reverse the ranges so that the reformatting does not influence file offsets. + for r in reversed(ranges): + # Do the actual formatting. + formatRange(r, args.style) + + +if __name__ == '__main__': + main() diff --git a/clang/tools/clang-format/clang-format.py b/clang/tools/clang-format/clang-format.py new file mode 100644 index 0000000..de92257 --- /dev/null +++ b/clang/tools/clang-format/clang-format.py @@ -0,0 +1,60 @@ +# This file is a minimal clang-format vim-integration. To install: +# - Change 'binary' if clang-format is not on the path (see below). +# - Add to your .vimrc: +# +# map :pyf /clang-format.py +# imap :pyf /clang-format.pyi +# +# The first line enables clang-format for NORMAL and VISUAL mode, the second +# line adds support for INSERT mode. Change "C-I" to another binding if you +# need clang-format on a different key (C-I stands for Ctrl+i). +# +# With this integration you can press the bound key and clang-format will +# format the current line in NORMAL and INSERT mode or the selected region in +# VISUAL mode. The line or region is extended to the next bigger syntactic +# entity. +# +# It operates on the current, potentially unsaved buffer and does not create +# or save any files. To revert a formatting, just undo. + +import vim +import subprocess + +# Change this to the full path if clang-format is not on the path. +binary = 'clang-format' + +# Get the current text. +buf = vim.current.buffer +text = "\n".join(buf) + +# Determine range to format. +offset = int(vim.eval('line2byte(' + + str(vim.current.range.start + 1) + ')')) - 1 +length = int(vim.eval('line2byte(' + + str(vim.current.range.end + 2) + ')')) - offset - 2 + +# Call formatter. +p = subprocess.Popen([binary, '-offset', str(offset), '-length', str(length)], + stdout=subprocess.PIPE, stderr=subprocess.PIPE, + stdin=subprocess.PIPE) +stdout, stderr = p.communicate(input=text) + +# If successful, replace buffer contents. +if stderr: + message = stderr.splitlines()[0] + parts = message.split(' ', 2) + if len(parts) > 2: + message = parts[2] + print 'Formatting failed: %s (total %d warnings, %d errors)' % ( + message, stderr.count('warning:'), stderr.count('error:')) + +if not stdout: + print ('No output from clang-format (crashed?).\n' + + 'Please report to bugs.llvm.org.') +elif stdout != text: + lines = stdout.split('\n') + for i in range(min(len(buf), len(lines))): + buf[i] = lines[i] + for line in lines[len(buf):]: + buf.append(line) + del buf[len(lines):]