← Back to branch summary

~ubuntu-branches/ubuntu/wily/clamav/wily-proposed

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Scott Kitterman, Sebastian Andrzej Siewior, Andreas Cadhalpun, Scott Kitterman, Javier Fernández-Sanguino
  • Date: 2015-01-28 00:25:13 UTC
  • mfrom: (0.48.14 sid)
  • Revision ID: package-import@ubuntu.com-20150128002513-lil2oi74cooy4lzr
Tags: 0.98.6+dfsg-1
http://bugs.debian.org/774686
http://bugs.debian.org/767350
http://bugs.debian.org/775400
http://bugs.debian.org/767353
http://bugs.debian.org/773563
[ Sebastian Andrzej Siewior ]
* update "fix-ssize_t-size_t-off_t-printf-modifier", include of misc.h was
  missing but was pulled in via the systemd patch.
* Don't leak return codes from libmspack to clamav API. (Closes: #774686).

[ Andreas Cadhalpun ]
* Add patch to avoid emitting incremental progress messages when not
  outputting to a terminal. (Closes: #767350)
* Update lintian-overrides for unused-file-paragraph-in-dep5-copyright.
* clamav-base.postinst: always chown /var/log/clamav and /var/lib/clamav
  to clamav:clamav, not only on fresh installations. (Closes: #775400)
* Adapt the clamav-daemon and clamav-freshclam logrotate scripts,
  so that they correctly work under systemd.
* Move the PidFile variable from the clamd/freshclam configuration files
  to the init scripts. This makes the init scripts more robust against
  misconfiguration and avoids error messages with systemd. (Closes: #767353)
* debian/copyright: drop files from Files-Excluded only present in github
  tarballs
* Drop Workaround-a-bug-in-libc-on-Hurd.patch, because hurd got fixed.
  (see #752237)
* debian/rules: Remove useless --with-system-tommath --without-included-ltdl
  configure options.

[ Scott Kitterman ]
* Stop stripping llvm when repacking the tarball as the system llvm on some
  releases is too old to use
* New upstream bugfix release
  - Library shared object revisions.
  - Includes a patch from Sebastian Andrzej Siewior making ClamAV pid files
    compatible with systemd.
  - Fix a heap out of bounds condition with crafted Yoda's crypter files.
    This issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted mew packer files. This
    issue was discovered by Felix Groebert of the Google Security Team.
  - Fix a heap out of bounds condition with crafted upx packer files. This
    issue was discovered by Kevin Szkudlapski of Quarkslab.
  - Fix a heap out of bounds condition with crafted upack packer files. This
    issue was discovered by Sebastian Andrzej Siewior. CVE-2014-9328.
  - Compensate a crash due to incorrect compiler optimization when handling
    crafted petite packer files. This issue was discovered by Sebastian
    Andrzej Siewior.
* Update lintian override for embedded zlib to match new so version

[ Javier Fernández-Sanguino ]
* Updated Spanish Debconf template translation (Closes: #773563)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/Support/raw_ostream.cpp
 
1
//===--- raw_ostream.cpp - Implement the raw_ostream classes --------------===//
 
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 implements support for bulk buffered stream output.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#include "llvm/Support/raw_ostream.h"
 
15
#include "llvm/Support/Format.h"
 
16
#include "llvm/System/Program.h"
 
17
#include "llvm/System/Process.h"
 
18
#include "llvm/ADT/SmallVector.h"
 
19
#include "llvm/Config/config.h"
 
20
#include "llvm/Support/Compiler.h"
 
21
#include "llvm/Support/ErrorHandling.h"
 
22
#include "llvm/System/Signals.h"
 
23
#include "llvm/ADT/STLExtras.h"
 
24
#include <cctype>
 
25
#include <cerrno>
 
26
#include <sys/stat.h>
 
27
#include <sys/types.h>
 
28
 
 
29
#if defined(HAVE_UNISTD_H)
 
30
# include <unistd.h>
 
31
#endif
 
32
#if defined(HAVE_FCNTL_H)
 
33
# include <fcntl.h>
 
34
#endif
 
35
 
 
36
#if defined(_MSC_VER)
 
37
#include <io.h>
 
38
#include <fcntl.h>
 
39
#ifndef STDIN_FILENO
 
40
# define STDIN_FILENO 0
 
41
#endif
 
42
#ifndef STDOUT_FILENO
 
43
# define STDOUT_FILENO 1
 
44
#endif
 
45
#ifndef STDERR_FILENO
 
46
# define STDERR_FILENO 2
 
47
#endif
 
48
#endif
 
49
 
 
50
using namespace llvm;
 
51
 
 
52
raw_ostream::~raw_ostream() {
 
53
  // raw_ostream's subclasses should take care to flush the buffer
 
54
  // in their destructors.
 
55
  assert(OutBufCur == OutBufStart &&
 
56
         "raw_ostream destructor called with non-empty buffer!");
 
57
 
 
58
  if (BufferMode == InternalBuffer)
 
59
    delete [] OutBufStart;
 
60
}
 
61
 
 
62
// An out of line virtual method to provide a home for the class vtable.
 
63
void raw_ostream::handle() {}
 
64
 
 
65
size_t raw_ostream::preferred_buffer_size() const {
 
66
  // BUFSIZ is intended to be a reasonable default.
 
67
  return BUFSIZ;
 
68
}
 
69
 
 
70
void raw_ostream::SetBuffered() {
 
71
  // Ask the subclass to determine an appropriate buffer size.
 
72
  if (size_t Size = preferred_buffer_size())
 
73
    SetBufferSize(Size);
 
74
  else
 
75
    // It may return 0, meaning this stream should be unbuffered.
 
76
    SetUnbuffered();
 
77
}
 
78
 
 
79
void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
 
80
                                    BufferKind Mode) {
 
81
  assert(((Mode == Unbuffered && BufferStart == 0 && Size == 0) ||
 
82
          (Mode != Unbuffered && BufferStart && Size)) &&
 
83
         "stream must be unbuffered or have at least one byte");
 
84
  // Make sure the current buffer is free of content (we can't flush here; the
 
85
  // child buffer management logic will be in write_impl).
 
86
  assert(GetNumBytesInBuffer() == 0 && "Current buffer is non-empty!");
 
87
 
 
88
  if (BufferMode == InternalBuffer)
 
89
    delete [] OutBufStart;
 
90
  OutBufStart = BufferStart;
 
91
  OutBufEnd = OutBufStart+Size;
 
92
  OutBufCur = OutBufStart;
 
93
  BufferMode = Mode;
 
94
 
 
95
  assert(OutBufStart <= OutBufEnd && "Invalid size!");
 
96
}
 
97
 
 
98
raw_ostream &raw_ostream::operator<<(unsigned long N) {
 
99
  // Zero is a special case.
 
100
  if (N == 0)
 
101
    return *this << '0';
 
102
 
 
103
  char NumberBuffer[20];
 
104
  char *EndPtr = NumberBuffer+sizeof(NumberBuffer);
 
105
  char *CurPtr = EndPtr;
 
106
 
 
107
  while (N) {
 
108
    *--CurPtr = '0' + char(N % 10);
 
109
    N /= 10;
 
110
  }
 
111
  return write(CurPtr, EndPtr-CurPtr);
 
112
}
 
113
 
 
114
raw_ostream &raw_ostream::operator<<(long N) {
 
115
  if (N <  0) {
 
116
    *this << '-';
 
117
    N = -N;
 
118
  }
 
119
 
 
120
  return this->operator<<(static_cast<unsigned long>(N));
 
121
}
 
122
 
 
123
raw_ostream &raw_ostream::operator<<(unsigned long long N) {
 
124
  // Output using 32-bit div/mod when possible.
 
125
  if (N == static_cast<unsigned long>(N))
 
126
    return this->operator<<(static_cast<unsigned long>(N));
 
127
 
 
128
  char NumberBuffer[20];
 
129
  char *EndPtr = NumberBuffer+sizeof(NumberBuffer);
 
130
  char *CurPtr = EndPtr;
 
131
 
 
132
  while (N) {
 
133
    *--CurPtr = '0' + char(N % 10);
 
134
    N /= 10;
 
135
  }
 
136
  return write(CurPtr, EndPtr-CurPtr);
 
137
}
 
138
 
 
139
raw_ostream &raw_ostream::operator<<(long long N) {
 
140
  if (N < 0) {
 
141
    *this << '-';
 
142
    // Avoid undefined behavior on INT64_MIN with a cast.
 
143
    N = -(unsigned long long)N;
 
144
  }
 
145
 
 
146
  return this->operator<<(static_cast<unsigned long long>(N));
 
147
}
 
148
 
 
149
raw_ostream &raw_ostream::write_hex(unsigned long long N) {
 
150
  // Zero is a special case.
 
151
  if (N == 0)
 
152
    return *this << '0';
 
153
 
 
154
  char NumberBuffer[20];
 
155
  char *EndPtr = NumberBuffer+sizeof(NumberBuffer);
 
156
  char *CurPtr = EndPtr;
 
157
 
 
158
  while (N) {
 
159
    uintptr_t x = N % 16;
 
160
    *--CurPtr = (x < 10 ? '0' + x : 'a' + x - 10);
 
161
    N /= 16;
 
162
  }
 
163
 
 
164
  return write(CurPtr, EndPtr-CurPtr);
 
165
}
 
166
 
 
167
raw_ostream &raw_ostream::write_escaped(StringRef Str) {
 
168
  for (unsigned i = 0, e = Str.size(); i != e; ++i) {
 
169
    unsigned char c = Str[i];
 
170
 
 
171
    switch (c) {
 
172
    case '\\':
 
173
      *this << '\\' << '\\';
 
174
      break;
 
175
    case '\t':
 
176
      *this << '\\' << 't';
 
177
      break;
 
178
    case '\n':
 
179
      *this << '\\' << 'n';
 
180
      break;
 
181
    case '"':
 
182
      *this << '\\' << '"';
 
183
      break;
 
184
    default:
 
185
      if (std::isprint(c)) {
 
186
        *this << c;
 
187
        break;
 
188
      }
 
189
 
 
190
      // Always expand to a 3-character octal escape.
 
191
      *this << '\\';
 
192
      *this << char('0' + ((c >> 6) & 7));
 
193
      *this << char('0' + ((c >> 3) & 7));
 
194
      *this << char('0' + ((c >> 0) & 7));
 
195
    }
 
196
  }
 
197
 
 
198
  return *this;
 
199
}
 
200
 
 
201
raw_ostream &raw_ostream::operator<<(const void *P) {
 
202
  *this << '0' << 'x';
 
203
 
 
204
  return write_hex((uintptr_t) P);
 
205
}
 
206
 
 
207
raw_ostream &raw_ostream::operator<<(double N) {
 
208
  return this->operator<<(format("%e", N));
 
209
}
 
210
 
 
211
 
 
212
 
 
213
void raw_ostream::flush_nonempty() {
 
214
  assert(OutBufCur > OutBufStart && "Invalid call to flush_nonempty.");
 
215
  size_t Length = OutBufCur - OutBufStart;
 
216
  OutBufCur = OutBufStart;
 
217
  write_impl(OutBufStart, Length);
 
218
}
 
219
 
 
220
raw_ostream &raw_ostream::write(unsigned char C) {
 
221
  // Group exceptional cases into a single branch.
 
222
  if (BUILTIN_EXPECT(OutBufCur >= OutBufEnd, false)) {
 
223
    if (BUILTIN_EXPECT(!OutBufStart, false)) {
 
224
      if (BufferMode == Unbuffered) {
 
225
        write_impl(reinterpret_cast<char*>(&C), 1);
 
226
        return *this;
 
227
      }
 
228
      // Set up a buffer and start over.
 
229
      SetBuffered();
 
230
      return write(C);
 
231
    }
 
232
 
 
233
    flush_nonempty();
 
234
  }
 
235
 
 
236
  *OutBufCur++ = C;
 
237
  return *this;
 
238
}
 
239
 
 
240
raw_ostream &raw_ostream::write(const char *Ptr, size_t Size) {
 
241
  // Group exceptional cases into a single branch.
 
242
  if (BUILTIN_EXPECT(OutBufCur+Size > OutBufEnd, false)) {
 
243
    if (BUILTIN_EXPECT(!OutBufStart, false)) {
 
244
      if (BufferMode == Unbuffered) {
 
245
        write_impl(Ptr, Size);
 
246
        return *this;
 
247
      }
 
248
      // Set up a buffer and start over.
 
249
      SetBuffered();
 
250
      return write(Ptr, Size);
 
251
    }
 
252
 
 
253
    // Write out the data in buffer-sized blocks until the remainder
 
254
    // fits within the buffer.
 
255
    do {
 
256
      size_t NumBytes = OutBufEnd - OutBufCur;
 
257
      copy_to_buffer(Ptr, NumBytes);
 
258
      flush_nonempty();
 
259
      Ptr += NumBytes;
 
260
      Size -= NumBytes;
 
261
    } while (OutBufCur+Size > OutBufEnd);
 
262
  }
 
263
 
 
264
  copy_to_buffer(Ptr, Size);
 
265
 
 
266
  return *this;
 
267
}
 
268
 
 
269
void raw_ostream::copy_to_buffer(const char *Ptr, size_t Size) {
 
270
  assert(Size <= size_t(OutBufEnd - OutBufCur) && "Buffer overrun!");
 
271
 
 
272
  // Handle short strings specially, memcpy isn't very good at very short
 
273
  // strings.
 
274
  switch (Size) {
 
275
  case 4: OutBufCur[3] = Ptr[3]; // FALL THROUGH
 
276
  case 3: OutBufCur[2] = Ptr[2]; // FALL THROUGH
 
277
  case 2: OutBufCur[1] = Ptr[1]; // FALL THROUGH
 
278
  case 1: OutBufCur[0] = Ptr[0]; // FALL THROUGH
 
279
  case 0: break;
 
280
  default:
 
281
    memcpy(OutBufCur, Ptr, Size);
 
282
    break;
 
283
  }
 
284
 
 
285
  OutBufCur += Size;
 
286
}
 
287
 
 
288
// Formatted output.
 
289
raw_ostream &raw_ostream::operator<<(const format_object_base &Fmt) {
 
290
  // If we have more than a few bytes left in our output buffer, try
 
291
  // formatting directly onto its end.
 
292
  size_t NextBufferSize = 127;
 
293
  size_t BufferBytesLeft = OutBufEnd - OutBufCur;
 
294
  if (BufferBytesLeft > 3) {
 
295
    size_t BytesUsed = Fmt.print(OutBufCur, BufferBytesLeft);
 
296
 
 
297
    // Common case is that we have plenty of space.
 
298
    if (BytesUsed <= BufferBytesLeft) {
 
299
      OutBufCur += BytesUsed;
 
300
      return *this;
 
301
    }
 
302
 
 
303
    // Otherwise, we overflowed and the return value tells us the size to try
 
304
    // again with.
 
305
    NextBufferSize = BytesUsed;
 
306
  }
 
307
 
 
308
  // If we got here, we didn't have enough space in the output buffer for the
 
309
  // string.  Try printing into a SmallVector that is resized to have enough
 
310
  // space.  Iterate until we win.
 
311
  SmallVector<char, 128> V;
 
312
 
 
313
  while (1) {
 
314
    V.resize(NextBufferSize);
 
315
 
 
316
    // Try formatting into the SmallVector.
 
317
    size_t BytesUsed = Fmt.print(V.data(), NextBufferSize);
 
318
 
 
319
    // If BytesUsed fit into the vector, we win.
 
320
    if (BytesUsed <= NextBufferSize)
 
321
      return write(V.data(), BytesUsed);
 
322
 
 
323
    // Otherwise, try again with a new size.
 
324
    assert(BytesUsed > NextBufferSize && "Didn't grow buffer!?");
 
325
    NextBufferSize = BytesUsed;
 
326
  }
 
327
}
 
328
 
 
329
/// indent - Insert 'NumSpaces' spaces.
 
330
raw_ostream &raw_ostream::indent(unsigned NumSpaces) {
 
331
  static const char Spaces[] = "                                "
 
332
                               "                                "
 
333
                               "                ";
 
334
 
 
335
  // Usually the indentation is small, handle it with a fastpath.
 
336
  if (NumSpaces < array_lengthof(Spaces))
 
337
    return write(Spaces, NumSpaces);
 
338
 
 
339
  while (NumSpaces) {
 
340
    unsigned NumToWrite = std::min(NumSpaces,
 
341
                                   (unsigned)array_lengthof(Spaces)-1);
 
342
    write(Spaces, NumToWrite);
 
343
    NumSpaces -= NumToWrite;
 
344
  }
 
345
  return *this;
 
346
}
 
347
 
 
348
 
 
349
//===----------------------------------------------------------------------===//
 
350
//  Formatted Output
 
351
//===----------------------------------------------------------------------===//
 
352
 
 
353
// Out of line virtual method.
 
354
void format_object_base::home() {
 
355
}
 
356
 
 
357
//===----------------------------------------------------------------------===//
 
358
//  raw_fd_ostream
 
359
//===----------------------------------------------------------------------===//
 
360
 
 
361
/// raw_fd_ostream - Open the specified file for writing. If an error
 
362
/// occurs, information about the error is put into ErrorInfo, and the
 
363
/// stream should be immediately destroyed; the string will be empty
 
364
/// if no error occurred.
 
365
raw_fd_ostream::raw_fd_ostream(const char *Filename, std::string &ErrorInfo,
 
366
                               unsigned Flags) : Error(false), pos(0) {
 
367
  assert(Filename != 0 && "Filename is null");
 
368
  // Verify that we don't have both "append" and "excl".
 
369
  assert((!(Flags & F_Excl) || !(Flags & F_Append)) &&
 
370
         "Cannot specify both 'excl' and 'append' file creation flags!");
 
371
 
 
372
  ErrorInfo.clear();
 
373
 
 
374
  // Handle "-" as stdout. Note that when we do this, we consider ourself
 
375
  // the owner of stdout. This means that we can do things like close the
 
376
  // file descriptor when we're done and set the "binary" flag globally.
 
377
  if (Filename[0] == '-' && Filename[1] == 0) {
 
378
    FD = STDOUT_FILENO;
 
379
    // If user requested binary then put stdout into binary mode if
 
380
    // possible.
 
381
    if (Flags & F_Binary)
 
382
      sys::Program::ChangeStdoutToBinary();
 
383
    // Close stdout when we're done, to detect any output errors.
 
384
    ShouldClose = true;
 
385
    return;
 
386
  }
 
387
 
 
388
  int OpenFlags = O_WRONLY|O_CREAT;
 
389
#ifdef O_BINARY
 
390
  if (Flags & F_Binary)
 
391
    OpenFlags |= O_BINARY;
 
392
#endif
 
393
 
 
394
  if (Flags & F_Append)
 
395
    OpenFlags |= O_APPEND;
 
396
  else
 
397
    OpenFlags |= O_TRUNC;
 
398
  if (Flags & F_Excl)
 
399
    OpenFlags |= O_EXCL;
 
400
 
 
401
  while ((FD = open(Filename, OpenFlags, 0664)) < 0) {
 
402
    if (errno != EINTR) {
 
403
      ErrorInfo = "Error opening output file '" + std::string(Filename) + "'";
 
404
      ShouldClose = false;
 
405
      return;
 
406
    }
 
407
  }
 
408
 
 
409
  // Ok, we successfully opened the file, so it'll need to be closed.
 
410
  ShouldClose = true;
 
411
}
 
412
 
 
413
raw_fd_ostream::~raw_fd_ostream() {
 
414
  if (FD >= 0) {
 
415
    flush();
 
416
    if (ShouldClose)
 
417
      while (::close(FD) != 0)
 
418
        if (errno != EINTR) {
 
419
          error_detected();
 
420
          break;
 
421
        }
 
422
  }
 
423
 
 
424
  // If there are any pending errors, report them now. Clients wishing
 
425
  // to avoid report_fatal_error calls should check for errors with
 
426
  // has_error() and clear the error flag with clear_error() before
 
427
  // destructing raw_ostream objects which may have errors.
 
428
  if (has_error())
 
429
    report_fatal_error("IO failure on output stream.");
 
430
}
 
431
 
 
432
 
 
433
void raw_fd_ostream::write_impl(const char *Ptr, size_t Size) {
 
434
  assert(FD >= 0 && "File already closed.");
 
435
  pos += Size;
 
436
 
 
437
  do {
 
438
    ssize_t ret = ::write(FD, Ptr, Size);
 
439
 
 
440
    if (ret < 0) {
 
441
      // If it's a recoverable error, swallow it and retry the write.
 
442
      //
 
443
      // Ideally we wouldn't ever see EAGAIN or EWOULDBLOCK here, since
 
444
      // raw_ostream isn't designed to do non-blocking I/O. However, some
 
445
      // programs, such as old versions of bjam, have mistakenly used
 
446
      // O_NONBLOCK. For compatibility, emulate blocking semantics by
 
447
      // spinning until the write succeeds. If you don't want spinning,
 
448
      // don't use O_NONBLOCK file descriptors with raw_ostream.
 
449
      if (errno == EINTR || errno == EAGAIN
 
450
#ifdef EWOULDBLOCK
 
451
          || errno == EWOULDBLOCK
 
452
#endif
 
453
          )
 
454
        continue;
 
455
 
 
456
      // Otherwise it's a non-recoverable error. Note it and quit.
 
457
      error_detected();
 
458
      break;
 
459
    }
 
460
 
 
461
    // The write may have written some or all of the data. Update the
 
462
    // size and buffer pointer to reflect the remainder that needs
 
463
    // to be written. If there are no bytes left, we're done.
 
464
    Ptr += ret;
 
465
    Size -= ret;
 
466
  } while (Size > 0);
 
467
}
 
468
 
 
469
void raw_fd_ostream::close() {
 
470
  assert(ShouldClose);
 
471
  ShouldClose = false;
 
472
  flush();
 
473
  while (::close(FD) != 0)
 
474
    if (errno != EINTR) {
 
475
      error_detected();
 
476
      break;
 
477
    }
 
478
  FD = -1;
 
479
}
 
480
 
 
481
uint64_t raw_fd_ostream::seek(uint64_t off) {
 
482
  flush();
 
483
  pos = ::lseek(FD, off, SEEK_SET);
 
484
  if (pos != off)
 
485
    error_detected();
 
486
  return pos;
 
487
}
 
488
 
 
489
size_t raw_fd_ostream::preferred_buffer_size() const {
 
490
#if !defined(_MSC_VER) && !defined(__MINGW32__) && !defined(__minix)
 
491
  // Windows and Minix have no st_blksize.
 
492
  assert(FD >= 0 && "File not yet open!");
 
493
  struct stat statbuf;
 
494
  if (fstat(FD, &statbuf) != 0)
 
495
    return 0;
 
496
 
 
497
  // If this is a terminal, don't use buffering. Line buffering
 
498
  // would be a more traditional thing to do, but it's not worth
 
499
  // the complexity.
 
500
  if (S_ISCHR(statbuf.st_mode) && isatty(FD))
 
501
    return 0;
 
502
  // Return the preferred block size.
 
503
  return statbuf.st_blksize;
 
504
#else
 
505
  return raw_ostream::preferred_buffer_size();
 
506
#endif
 
507
}
 
508
 
 
509
raw_ostream &raw_fd_ostream::changeColor(enum Colors colors, bool bold,
 
510
                                         bool bg) {
 
511
  if (sys::Process::ColorNeedsFlush())
 
512
    flush();
 
513
  const char *colorcode =
 
514
    (colors == SAVEDCOLOR) ? sys::Process::OutputBold(bg)
 
515
    : sys::Process::OutputColor(colors, bold, bg);
 
516
  if (colorcode) {
 
517
    size_t len = strlen(colorcode);
 
518
    write(colorcode, len);
 
519
    // don't account colors towards output characters
 
520
    pos -= len;
 
521
  }
 
522
  return *this;
 
523
}
 
524
 
 
525
raw_ostream &raw_fd_ostream::resetColor() {
 
526
  if (sys::Process::ColorNeedsFlush())
 
527
    flush();
 
528
  const char *colorcode = sys::Process::ResetColor();
 
529
  if (colorcode) {
 
530
    size_t len = strlen(colorcode);
 
531
    write(colorcode, len);
 
532
    // don't account colors towards output characters
 
533
    pos -= len;
 
534
  }
 
535
  return *this;
 
536
}
 
537
 
 
538
bool raw_fd_ostream::is_displayed() const {
 
539
  return sys::Process::FileDescriptorIsDisplayed(FD);
 
540
}
 
541
 
 
542
//===----------------------------------------------------------------------===//
 
543
//  outs(), errs(), nulls()
 
544
//===----------------------------------------------------------------------===//
 
545
 
 
546
/// outs() - This returns a reference to a raw_ostream for standard output.
 
547
/// Use it like: outs() << "foo" << "bar";
 
548
raw_ostream &llvm::outs() {
 
549
  // Set buffer settings to model stdout behavior.
 
550
  // Delete the file descriptor when the program exists, forcing error
 
551
  // detection. If you don't want this behavior, don't use outs().
 
552
  static raw_fd_ostream S(STDOUT_FILENO, true);
 
553
  return S;
 
554
}
 
555
 
 
556
/// errs() - This returns a reference to a raw_ostream for standard error.
 
557
/// Use it like: errs() << "foo" << "bar";
 
558
raw_ostream &llvm::errs() {
 
559
  // Set standard error to be unbuffered by default.
 
560
  static raw_fd_ostream S(STDERR_FILENO, false, true);
 
561
  return S;
 
562
}
 
563
 
 
564
/// nulls() - This returns a reference to a raw_ostream which discards output.
 
565
raw_ostream &llvm::nulls() {
 
566
  static raw_null_ostream S;
 
567
  return S;
 
568
}
 
569
 
 
570
 
 
571
//===----------------------------------------------------------------------===//
 
572
//  raw_string_ostream
 
573
//===----------------------------------------------------------------------===//
 
574
 
 
575
raw_string_ostream::~raw_string_ostream() {
 
576
  flush();
 
577
}
 
578
 
 
579
void raw_string_ostream::write_impl(const char *Ptr, size_t Size) {
 
580
  OS.append(Ptr, Size);
 
581
}
 
582
 
 
583
//===----------------------------------------------------------------------===//
 
584
//  raw_svector_ostream
 
585
//===----------------------------------------------------------------------===//
 
586
 
 
587
// The raw_svector_ostream implementation uses the SmallVector itself as the
 
588
// buffer for the raw_ostream. We guarantee that the raw_ostream buffer is
 
589
// always pointing past the end of the vector, but within the vector
 
590
// capacity. This allows raw_ostream to write directly into the correct place,
 
591
// and we only need to set the vector size when the data is flushed.
 
592
 
 
593
raw_svector_ostream::raw_svector_ostream(SmallVectorImpl<char> &O) : OS(O) {
 
594
  // Set up the initial external buffer. We make sure that the buffer has at
 
595
  // least 128 bytes free; raw_ostream itself only requires 64, but we want to
 
596
  // make sure that we don't grow the buffer unnecessarily on destruction (when
 
597
  // the data is flushed). See the FIXME below.
 
598
  OS.reserve(OS.size() + 128);
 
599
  SetBuffer(OS.end(), OS.capacity() - OS.size());
 
600
}
 
601
 
 
602
raw_svector_ostream::~raw_svector_ostream() {
 
603
  // FIXME: Prevent resizing during this flush().
 
604
  flush();
 
605
}
 
606
 
 
607
/// resync - This is called when the SmallVector we're appending to is changed
 
608
/// outside of the raw_svector_ostream's control.  It is only safe to do this
 
609
/// if the raw_svector_ostream has previously been flushed.
 
610
void raw_svector_ostream::resync() {
 
611
  assert(GetNumBytesInBuffer() == 0 && "Didn't flush before mutating vector");
 
612
 
 
613
  if (OS.capacity() - OS.size() < 64)
 
614
    OS.reserve(OS.capacity() * 2);
 
615
  SetBuffer(OS.end(), OS.capacity() - OS.size());
 
616
}
 
617
 
 
618
void raw_svector_ostream::write_impl(const char *Ptr, size_t Size) {
 
619
  // If we're writing bytes from the end of the buffer into the smallvector, we
 
620
  // don't need to copy the bytes, just commit the bytes because they are
 
621
  // already in the right place.
 
622
  if (Ptr == OS.end()) {
 
623
    assert(OS.size() + Size <= OS.capacity() && "Invalid write_impl() call!");
 
624
    OS.set_size(OS.size() + Size);
 
625
  } else {
 
626
    assert(GetNumBytesInBuffer() == 0 &&
 
627
           "Should be writing from buffer if some bytes in it");
 
628
    // Otherwise, do copy the bytes.
 
629
    OS.append(Ptr, Ptr+Size);
 
630
  }
 
631
 
 
632
  // Grow the vector if necessary.
 
633
  if (OS.capacity() - OS.size() < 64)
 
634
    OS.reserve(OS.capacity() * 2);
 
635
 
 
636
  // Update the buffer position.
 
637
  SetBuffer(OS.end(), OS.capacity() - OS.size());
 
638
}
 
639
 
 
640
uint64_t raw_svector_ostream::current_pos() const {
 
641
   return OS.size();
 
642
}
 
643
 
 
644
StringRef raw_svector_ostream::str() {
 
645
  flush();
 
646
  return StringRef(OS.begin(), OS.size());
 
647
}
 
648
 
 
649
//===----------------------------------------------------------------------===//
 
650
//  raw_null_ostream
 
651
//===----------------------------------------------------------------------===//
 
652
 
 
653
raw_null_ostream::~raw_null_ostream() {
 
654
#ifndef NDEBUG
 
655
  // ~raw_ostream asserts that the buffer is empty. This isn't necessary
 
656
  // with raw_null_ostream, but it's better to have raw_null_ostream follow
 
657
  // the rules than to change the rules just for raw_null_ostream.
 
658
  flush();
 
659
#endif
 
660
}
 
661
 
 
662
void raw_null_ostream::write_impl(const char *Ptr, size_t Size) {
 
663
}
 
664
 
 
665
uint64_t raw_null_ostream::current_pos() const {
 
666
  return 0;
 
667
}
 
668
 
 
669
//===----------------------------------------------------------------------===//
 
670
//  tool_output_file
 
671
//===----------------------------------------------------------------------===//
 
672
 
 
673
tool_output_file::CleanupInstaller::CleanupInstaller(const char *filename)
 
674
  : Filename(filename), Keep(false) {
 
675
  // Arrange for the file to be deleted if the process is killed.
 
676
  if (Filename != "-")
 
677
    sys::RemoveFileOnSignal(sys::Path(Filename));
 
678
}
 
679
 
 
680
tool_output_file::CleanupInstaller::~CleanupInstaller() {
 
681
  // Delete the file if the client hasn't told us not to.
 
682
  if (!Keep && Filename != "-")
 
683
    sys::Path(Filename).eraseFromDisk();
 
684
 
 
685
  // Ok, the file is successfully written and closed, or deleted. There's no
 
686
  // further need to clean it up on signals.
 
687
  if (Filename != "-")
 
688
    sys::DontRemoveFileOnSignal(sys::Path(Filename));
 
689
}
 
690
 
 
691
tool_output_file::tool_output_file(const char *filename, std::string &ErrorInfo,
 
692
                                   unsigned Flags)
 
693
  : Installer(filename),
 
694
    OS(filename, ErrorInfo, Flags) {
 
695
  // If open fails, no cleanup is needed.
 
696
  if (!ErrorInfo.empty())
 
697
    Installer.Keep = true;
 
698
}