← Back to branch summary

~louis/ubuntu/trusty/clamav/lp799623_fix_logrotate

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/include/llvm/ADT/StringExtras.h

  • 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/include/llvm/ADT/StringExtras.h
 
1
//===-- llvm/ADT/StringExtras.h - Useful string functions -------*- 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 some functions that are useful when dealing with strings.
 
11
//
 
12
//===----------------------------------------------------------------------===//
 
13
 
 
14
#ifndef LLVM_ADT_STRINGEXTRAS_H
 
15
#define LLVM_ADT_STRINGEXTRAS_H
 
16
 
 
17
#include "llvm/System/DataTypes.h"
 
18
#include "llvm/ADT/APFloat.h"
 
19
#include "llvm/ADT/StringRef.h"
 
20
#include <cctype>
 
21
#include <cstdio>
 
22
#include <string>
 
23
#include <vector>
 
24
 
 
25
namespace llvm {
 
26
template<typename T> class SmallVectorImpl;
 
27
 
 
28
/// hexdigit - Return the (uppercase) hexadecimal character for the
 
29
/// given number \arg X (which should be less than 16).
 
30
static inline char hexdigit(unsigned X) {
 
31
  return X < 10 ? '0' + X : 'A' + X - 10;
 
32
}
 
33
 
 
34
/// utohex_buffer - Emit the specified number into the buffer specified by
 
35
/// BufferEnd, returning a pointer to the start of the string.  This can be used
 
36
/// like this: (note that the buffer must be large enough to handle any number):
 
37
///    char Buffer[40];
 
38
///    printf("0x%s", utohex_buffer(X, Buffer+40));
 
39
///
 
40
/// This should only be used with unsigned types.
 
41
///
 
42
template<typename IntTy>
 
43
static inline char *utohex_buffer(IntTy X, char *BufferEnd) {
 
44
  char *BufPtr = BufferEnd;
 
45
  *--BufPtr = 0;      // Null terminate buffer.
 
46
  if (X == 0) {
 
47
    *--BufPtr = '0';  // Handle special case.
 
48
    return BufPtr;
 
49
  }
 
50
 
 
51
  while (X) {
 
52
    unsigned char Mod = static_cast<unsigned char>(X) & 15;
 
53
    *--BufPtr = hexdigit(Mod);
 
54
    X >>= 4;
 
55
  }
 
56
  return BufPtr;
 
57
}
 
58
 
 
59
static inline std::string utohexstr(uint64_t X) {
 
60
  char Buffer[40];
 
61
  return utohex_buffer(X, Buffer+40);
 
62
}
 
63
 
 
64
static inline std::string utostr_32(uint32_t X, bool isNeg = false) {
 
65
  char Buffer[20];
 
66
  char *BufPtr = Buffer+19;
 
67
 
 
68
  *BufPtr = 0;                  // Null terminate buffer...
 
69
  if (X == 0) *--BufPtr = '0';  // Handle special case...
 
70
 
 
71
  while (X) {
 
72
    *--BufPtr = '0' + char(X % 10);
 
73
    X /= 10;
 
74
  }
 
75
 
 
76
  if (isNeg) *--BufPtr = '-';   // Add negative sign...
 
77
 
 
78
  return std::string(BufPtr);
 
79
}
 
80
 
 
81
static inline std::string utostr(uint64_t X, bool isNeg = false) {
 
82
  if (X == uint32_t(X))
 
83
    return utostr_32(uint32_t(X), isNeg);
 
84
 
 
85
  char Buffer[40];
 
86
  char *BufPtr = Buffer+39;
 
87
 
 
88
  *BufPtr = 0;                  // Null terminate buffer...
 
89
  if (X == 0) *--BufPtr = '0';  // Handle special case...
 
90
 
 
91
  while (X) {
 
92
    *--BufPtr = '0' + char(X % 10);
 
93
    X /= 10;
 
94
  }
 
95
 
 
96
  if (isNeg) *--BufPtr = '-';   // Add negative sign...
 
97
  return std::string(BufPtr);
 
98
}
 
99
 
 
100
 
 
101
static inline std::string itostr(int64_t X) {
 
102
  if (X < 0)
 
103
    return utostr(static_cast<uint64_t>(-X), true);
 
104
  else
 
105
    return utostr(static_cast<uint64_t>(X));
 
106
}
 
107
 
 
108
static inline std::string ftostr(double V) {
 
109
  char Buffer[200];
 
110
  sprintf(Buffer, "%20.6e", V);
 
111
  char *B = Buffer;
 
112
  while (*B == ' ') ++B;
 
113
  return B;
 
114
}
 
115
 
 
116
static inline std::string ftostr(const APFloat& V) {
 
117
  if (&V.getSemantics() == &APFloat::IEEEdouble)
 
118
    return ftostr(V.convertToDouble());
 
119
  else if (&V.getSemantics() == &APFloat::IEEEsingle)
 
120
    return ftostr((double)V.convertToFloat());
 
121
  return "<unknown format in ftostr>"; // error
 
122
}
 
123
 
 
124
static inline std::string LowercaseString(const std::string &S) {
 
125
  std::string result(S);
 
126
  for (unsigned i = 0; i < S.length(); ++i)
 
127
    if (isupper(result[i]))
 
128
      result[i] = char(tolower(result[i]));
 
129
  return result;
 
130
}
 
131
 
 
132
static inline std::string UppercaseString(const std::string &S) {
 
133
  std::string result(S);
 
134
  for (unsigned i = 0; i < S.length(); ++i)
 
135
    if (islower(result[i]))
 
136
      result[i] = char(toupper(result[i]));
 
137
  return result;
 
138
}
 
139
 
 
140
/// StrInStrNoCase - Portable version of strcasestr.  Locates the first
 
141
/// occurrence of string 's1' in string 's2', ignoring case.  Returns
 
142
/// the offset of s2 in s1 or npos if s2 cannot be found.
 
143
StringRef::size_type StrInStrNoCase(StringRef s1, StringRef s2);
 
144
 
 
145
/// getToken - This function extracts one token from source, ignoring any
 
146
/// leading characters that appear in the Delimiters string, and ending the
 
147
/// token at any of the characters that appear in the Delimiters string.  If
 
148
/// there are no tokens in the source string, an empty string is returned.
 
149
/// The function returns a pair containing the extracted token and the
 
150
/// remaining tail string.
 
151
std::pair<StringRef, StringRef> getToken(StringRef Source,
 
152
                                         StringRef Delimiters = " \t\n\v\f\r");
 
153
 
 
154
/// SplitString - Split up the specified string according to the specified
 
155
/// delimiters, appending the result fragments to the output list.
 
156
void SplitString(StringRef Source,
 
157
                 SmallVectorImpl<StringRef> &OutFragments,
 
158
                 StringRef Delimiters = " \t\n\v\f\r");
 
159
 
 
160
/// HashString - Hash funtion for strings.
 
161
///
 
162
/// This is the Bernstein hash function.
 
163
//
 
164
// FIXME: Investigate whether a modified bernstein hash function performs
 
165
// better: http://eternallyconfuzzled.com/tuts/algorithms/jsw_tut_hashing.aspx
 
166
//   X*33+c -> X*33^c
 
167
static inline unsigned HashString(StringRef Str, unsigned Result = 0) {
 
168
  for (unsigned i = 0, e = Str.size(); i != e; ++i)
 
169
    Result = Result * 33 + Str[i];
 
170
  return Result;
 
171
}
 
172
 
 
173
} // End llvm namespace
 
174
 
 
175
#endif