← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/Support/FormattedStream.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Scott Kitterman
  • Date: 2010-03-12 11:30:04 UTC
  • mfrom: (0.41.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20100312113004-b0fop4bkycszdd0z
Tags: 0.96~rc1+dfsg-0ubuntu1
https://launchpad.net/bugs/537636
* New upstream RC - FFE (LP: #537636):
  - Add OfficialDatabaseOnly option to clamav-base.postinst.in
  - Add LocalSocketGroup option to clamav-base.postinst.in
  - Add LocalSocketMode option to clamav-base.postinst.in
  - Add CrossFilesystems option to clamav-base.postinst.in
  - Add ClamukoScannerCount option to clamav-base.postinst.in
  - Add BytecodeSecurity opiton to clamav-base.postinst.in
  - Add DetectionStatsHostID option to clamav-freshclam.postinst.in
  - Add Bytecode option to clamav-freshclam.postinst.in
  - Add MilterSocketGroup option to clamav-milter.postinst.in
  - Add MilterSocketMode option to clamav-milter.postinst.in
  - Add ReportHostname option to clamav-milter.postinst.in
  - Bump libclamav SO version to 6.1.0 in libclamav6.install
  - Drop clamdmon from clamav.examples (no longer shipped by upstream)
  - Drop libclamav.a from libclamav-dev.install (not built by upstream)
  - Update SO version for lintian override for libclamav6
  - Add new Bytecode Testing Tool, usr/bin/clambc, to clamav.install
  - Add build-depends on python and python-setuptools for new test suite
  - Update debian/copyright for the embedded copy of llvm (using the system
    llvm is not currently feasible)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/Support/FormattedStream.cpp
 
1
//===-- llvm/Support/FormattedStream.cpp - Formatted streams ----*- C++ -*-===//
 
2
//
 
3
//                     The LLVM Compiler Infrastructure
 
4
//
 
5
// This file is distributed under the University of Illinois Open Source
 
6
// License. See LICENSE.TXT for details.
 
7
//
 
8
//===----------------------------------------------------------------------===//
 
9
//
 
10
// This file contains the implementation of formatted_raw_ostream.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#include "llvm/Support/Debug.h"
 
15
#include "llvm/Support/FormattedStream.h"
 
16
 
 
17
using namespace llvm;
 
18
 
 
19
/// CountColumns - Examine the given char sequence and figure out which
 
20
/// column we end up in after output.
 
21
///
 
22
static unsigned CountColumns(unsigned Column, const char *Ptr, size_t Size) {
 
23
  // Keep track of the current column by scanning the string for
 
24
  // special characters
 
25
 
 
26
  for (const char *End = Ptr + Size; Ptr != End; ++Ptr) {
 
27
    ++Column;
 
28
    if (*Ptr == '\n' || *Ptr == '\r')
 
29
      Column = 0;
 
30
    else if (*Ptr == '\t')
 
31
      // Assumes tab stop = 8 characters.
 
32
      Column += (8 - (Column & 0x7)) & 0x7;
 
33
  }
 
34
 
 
35
  return Column;
 
36
}
 
37
 
 
38
/// ComputeColumn - Examine the current output and figure out which
 
39
/// column we end up in after output.
 
40
void formatted_raw_ostream::ComputeColumn(const char *Ptr, size_t Size) {
 
41
  // If our previous scan pointer is inside the buffer, assume we already
 
42
  // scanned those bytes. This depends on raw_ostream to not change our buffer
 
43
  // in unexpected ways.
 
44
  if (Ptr <= Scanned && Scanned <= Ptr + Size) {
 
45
    // Scan all characters added since our last scan to determine the new
 
46
    // column.
 
47
    ColumnScanned = CountColumns(ColumnScanned, Scanned, 
 
48
                                 Size - (Scanned - Ptr));
 
49
  } else
 
50
    ColumnScanned = CountColumns(ColumnScanned, Ptr, Size);
 
51
 
 
52
  // Update the scanning pointer.
 
53
  Scanned = Ptr + Size;
 
54
}
 
55
 
 
56
/// PadToColumn - Align the output to some column number.
 
57
///
 
58
/// \param NewCol - The column to move to.
 
59
///
 
60
formatted_raw_ostream &formatted_raw_ostream::PadToColumn(unsigned NewCol) { 
 
61
  // Figure out what's in the buffer and add it to the column count.
 
62
  ComputeColumn(getBufferStart(), GetNumBytesInBuffer());
 
63
 
 
64
  // Output spaces until we reach the desired column.
 
65
  indent(std::max(int(NewCol - ColumnScanned), 1));
 
66
  return *this;
 
67
}
 
68
 
 
69
void formatted_raw_ostream::write_impl(const char *Ptr, size_t Size) {
 
70
  // Figure out what's in the buffer and add it to the column count.
 
71
  ComputeColumn(Ptr, Size);
 
72
 
 
73
  // Write the data to the underlying stream (which is unbuffered, so
 
74
  // the data will be immediately written out).
 
75
  TheStream->write(Ptr, Size);
 
76
 
 
77
  // Reset the scanning pointer.
 
78
  Scanned = 0;
 
79
}
 
80
 
 
81
/// fouts() - This returns a reference to a formatted_raw_ostream for
 
82
/// standard output.  Use it like: fouts() << "foo" << "bar";
 
83
formatted_raw_ostream &llvm::fouts() {
 
84
  static formatted_raw_ostream S(outs());
 
85
  return S;
 
86
}
 
87
 
 
88
/// ferrs() - This returns a reference to a formatted_raw_ostream for
 
89
/// standard error.  Use it like: ferrs() << "foo" << "bar";
 
90
formatted_raw_ostream &llvm::ferrs() {
 
91
  static formatted_raw_ostream S(errs());
 
92
  return S;
 
93
}
 
94
 
 
95
/// fdbgs() - This returns a reference to a formatted_raw_ostream for
 
96
/// the debug stream.  Use it like: fdbgs() << "foo" << "bar";
 
97
formatted_raw_ostream &llvm::fdbgs() {
 
98
  static formatted_raw_ostream S(dbgs());
 
99
  return S;
 
100
}