chipper 0.4.2

data/ext/util/test.h

@@ -0,0 +1,57 @@
+// Copyright 2009 The RE2 Authors.  All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef RE2_UTIL_TEST_H__
+#define RE2_UTIL_TEST_H__
+
+#include "util/util.h"
+#include "util/flags.h"
+
+#define TEST(x, y) \
+	void x##y(void); \
+	TestRegisterer r##x##y(x##y, # x "." # y); \
+	void x##y(void)
+
+void RegisterTest(void (*)(void), const char*);
+
+class TestRegisterer {
+ public:
+  TestRegisterer(void (*fn)(void), const char *s) {
+    RegisterTest(fn, s);
+  }
+};
+
+// TODO(rsc): Do a better job.
+#define EXPECT_EQ CHECK_EQ
+#define EXPECT_TRUE CHECK
+#define EXPECT_LT CHECK_LT
+#define EXPECT_GT CHECK_GT
+#define EXPECT_LE CHECK_LE
+#define EXPECT_GE CHECK_GE
+#define EXPECT_FALSE(x) CHECK(!(x))
+
+#define ARRAYSIZE arraysize
+
+#define EXPECT_TRUE_M(x, y) CHECK(x) << (y)
+#define EXPECT_FALSE_M(x, y) CHECK(!(x)) << (y)
+#define ASSERT_TRUE_M(x, y) CHECK(x) << (y)
+#define ASSERT_EQUALS(x, y) CHECK_EQ(x, y)
+
+const bool UsingMallocCounter = false;
+namespace testing {
+class MallocCounter {
+ public:
+  MallocCounter(int x) { } 
+  static const int THIS_THREAD_ONLY = 0;
+  long long HeapGrowth() { return 0; }
+  long long PeakHeapGrowth() { return 0; }
+  void Reset() { }
+};
+}  // namespace testing
+
+namespace re2 {
+int64 VirtualProcessSize();
+} // namespace re2
+
+#endif  // RE2_UTIL_TEST_H__

data/ext/util/thread.h

@@ -0,0 +1,26 @@
+// Copyright 2009 The RE2 Authors.  All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef RE2_UTIL_THREAD_H__
+#define RE2_UTIL_THREAD_H__
+
+#include <pthread.h>
+
+class Thread {
+ public:
+  Thread();
+  virtual ~Thread();
+  void Start();
+  void Join();
+  void SetJoinable(bool);
+  virtual void Run() = 0;
+ 
+ private:
+  pthread_t pid_;
+  bool running_;
+  bool joinable_;
+};
+
+#endif  // RE2_UTIL_THREAD_H__
+

data/ext/util/utf.h

@@ -0,0 +1,43 @@
+/*
+ * The authors of this software are Rob Pike and Ken Thompson.
+ *              Copyright (c) 2002 by Lucent Technologies.
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose without fee is hereby granted, provided that this entire notice
+ * is included in all copies of any software which is or includes a copy
+ * or modification of this software and in all copies of the supporting
+ * documentation for such software.
+ * THIS SOFTWARE IS BEING PROVIDED "AS IS", WITHOUT ANY EXPRESS OR IMPLIED
+ * WARRANTY.  IN PARTICULAR, NEITHER THE AUTHORS NOR LUCENT TECHNOLOGIES MAKE ANY
+ * REPRESENTATION OR WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY
+ * OF THIS SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE.
+ *
+ * This file and rune.cc have been converted to compile as C++ code
+ * in name space re2.
+ */
+#ifndef RE2_UTIL_UTF_H__
+#define RE2_UTIL_UTF_H__
+
+#include <stdint.h>
+
+namespace re2 {
+
+typedef signed int Rune;	/* Code-point values in Unicode 4.0 are 21 bits wide.*/
+
+enum
+{
+  UTFmax	= 4,		/* maximum bytes per rune */
+  Runesync	= 0x80,		/* cannot represent part of a UTF sequence (<) */
+  Runeself	= 0x80,		/* rune and UTF sequences are the same (<) */
+  Runeerror	= 0xFFFD,	/* decoding error in UTF */
+  Runemax	= 0x10FFFF,	/* maximum rune value */
+};
+
+int runetochar(char* s, const Rune* r);
+int chartorune(Rune* r, const char* s);
+int fullrune(const char* s, int n);
+int utflen(const char* s);
+char* utfrune(const char*, Rune);
+
+}  // namespace re2
+
+#endif  // RE2_UTIL_UTF_H__

data/ext/util/util.h

@@ -0,0 +1,127 @@
+// Copyright 2009 The RE2 Authors.  All Rights Reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#ifndef RE2_UTIL_UTIL_H__
+#define RE2_UTIL_UTIL_H__
+
+// C
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+#include <stddef.h>         // For size_t
+#include <assert.h>
+#include <stdarg.h>
+#include <sys/time.h>
+#include <time.h>
+
+// C++
+#include <vector>
+#include <string>
+#include <algorithm>
+#include <iosfwd>
+#include <map>
+#include <stack>
+#include <iostream>
+#include <utility>
+#include <set>
+
+// Use std names.
+using std::set;
+using std::pair;
+using std::vector;
+using std::string;
+using std::min;
+using std::max;
+using std::ostream;
+using std::map;
+using std::stack;
+using std::sort;
+using std::swap;
+using std::make_pair;
+
+#if defined(__GNUC__) && !defined(USE_CXX0X)
+
+#include <tr1/unordered_set>
+using std::tr1::unordered_set;
+
+#else
+
+#include <unordered_set>
+using std::unordered_set;
+
+#endif
+
+namespace re2 {
+
+typedef int8_t int8;
+typedef uint8_t uint8;
+typedef int16_t int16;
+typedef uint16_t uint16;
+typedef int32_t int32;
+typedef uint32_t uint32;
+typedef int64_t int64;
+typedef uint64_t uint64;
+
+typedef unsigned long ulong;
+typedef unsigned int uint;
+typedef unsigned short ushort;
+
+// COMPILE_ASSERT causes a compile error about msg if expr is not true.
+template<bool> struct CompileAssert {};
+#define COMPILE_ASSERT(expr, msg) \
+  typedef CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1]
+
+// DISALLOW_EVIL_CONSTRUCTORS disallows the copy and operator= functions.
+// It goes in the private: declarations in a class.
+#define DISALLOW_EVIL_CONSTRUCTORS(TypeName) \
+  TypeName(const TypeName&);                 \
+  void operator=(const TypeName&)
+
+#define arraysize(array) (sizeof(array)/sizeof((array)[0]))
+
+// Fake lock annotations.  For real ones, see
+// http://code.google.com/p/data-race-test/
+#define ANNOTATE_PUBLISH_MEMORY_RANGE(a, b)
+#define ANNOTATE_IGNORE_WRITES_BEGIN()
+#define ANNOTATE_IGNORE_WRITES_END()
+#define ANNOTATE_BENIGN_RACE(a, b)
+#define NO_THREAD_SAFETY_ANALYSIS
+#define ANNOTATE_HAPPENS_BEFORE(x)
+#define ANNOTATE_HAPPENS_AFTER(x)
+
+class StringPiece;
+
+string CEscape(const StringPiece& src);
+int CEscapeString(const char* src, int src_len, char* dest, int dest_len);
+
+extern string StringPrintf(const char* format, ...);
+extern void SStringPrintf(string* dst, const char* format, ...);
+extern void StringAppendF(string* dst, const char* format, ...);
+extern string PrefixSuccessor(const StringPiece& prefix);
+
+uint32 hashword(const uint32*, size_t, uint32);
+void hashword2(const uint32*, size_t, uint32*, uint32*);
+
+static inline uint32 Hash32StringWithSeed(const char* s, int len, uint32 seed) {
+  return hashword((uint32*)s, len/4, seed);
+}
+
+static inline uint64 Hash64StringWithSeed(const char* s, int len, uint32 seed) {
+  uint32 x, y;
+  x = seed;
+  y = 0;
+  hashword2((uint32*)s, len/4, &x, &y);
+  return ((uint64)x << 32) | y;
+}
+
+int RunningOnValgrind();
+
+}  // namespace re2
+
+#include "util/arena.h"
+#include "util/logging.h"
+#include "util/mutex.h"
+#include "util/utf.h"
+
+#endif // RE2_UTIL_UTIL_H__