ooxml_crypt 0.1.0

data/vendor/cybozulib/include/cybozu/atoi.hpp

@@ -0,0 +1,238 @@
+#pragma once
+/**
+	@file
+	@brief converter between integer and string
+
+	@author MITSUNARI Shigeo(@herumi)
+*/
+
+#include <memory.h>
+#include <limits>
+#include <cybozu/exception.hpp>
+
+namespace cybozu {
+
+namespace atoi_local {
+
+template<typename T, size_t n>
+T convertToInt(bool *b, const char *p, size_t size, const char (&max)[n], T min, T overflow1, char overflow2)
+{
+	if (size > 0 && *p) {
+		bool isMinus = false;
+		size_t i = 0;
+		if (*p == '-') {
+			isMinus = true;
+			i++;
+		}
+		if (i < size && p[i]) {
+			// skip leading zero
+			while (i < size && p[i] == '0') i++;
+			// check minimum
+			if (isMinus && size - i >= n - 1 && memcmp(max, &p[i], n - 1) == 0) {
+				if (b) *b = true;
+				return min;
+			}
+			T x = 0;
+			for (;;) {
+				unsigned char c;
+				if (i == size || (c = static_cast<unsigned char>(p[i])) == '\0') {
+					if (b) *b = true;
+					return isMinus ? -x : x;
+				}
+				unsigned int y = c - '0';
+				if (y > 9 || x > overflow1 || (x == overflow1 && c >= overflow2)) {
+					break;
+				}
+				x = x * 10 + T(y);
+				i++;
+			}
+		}
+	}
+	if (b) {
+		*b = false;
+		return 0;
+	} else {
+		throw cybozu::Exception("atoi::convertToInt") << cybozu::exception::makeString(p, size);
+	}
+}
+
+template<typename T>
+T convertToUint(bool *b, const char *p, size_t size, T overflow1, char overflow2)
+{
+	if (size > 0 && *p) {
+		size_t i = 0;
+		// skip leading zero
+		while (i < size && p[i] == '0') i++;
+		T x = 0;
+		for (;;) {
+			unsigned char c;
+			if (i == size || (c = static_cast<unsigned char>(p[i])) == '\0') {
+				if (b) *b = true;
+				return x;
+			}
+			unsigned int y = c - '0';
+			if (y > 9 || x > overflow1 || (x == overflow1 && c >= overflow2)) {
+				break;
+			}
+			x = x * 10 + T(y);
+			i++;
+		}
+	}
+	if (b) {
+		*b = false;
+		return 0;
+	} else {
+		throw cybozu::Exception("atoi::convertToUint") << cybozu::exception::makeString(p, size);
+	}
+}
+
+template<typename T>
+T convertHexToInt(bool *b, const char *p, size_t size)
+{
+	if (size > 0 && *p) {
+		size_t i = 0;
+		T x = 0;
+		for (;;) {
+			unsigned int c;
+			if (i == size || (c = static_cast<unsigned char>(p[i])) == '\0') {
+				if (b) *b = true;
+				return x;
+			}
+			if (c - 'A' <= 'F' - 'A') {
+				c = (c - 'A') + 10;
+			} else if (c - 'a' <= 'f' - 'a') {
+				c = (c - 'a') + 10;
+			} else if (c - '0' <= '9' - '0') {
+				c = c - '0';
+			} else {
+				break;
+			}
+			// avoid overflow
+			if (x > (std::numeric_limits<T>::max)() / 16) break;
+			x = x * 16 + T(c);
+			i++;
+		}
+	}
+	if (b) {
+		*b = false;
+		return 0;
+	} else {
+		throw cybozu::Exception("atoi::convertHexToInt") << cybozu::exception::makeString(p, size);
+	}
+}
+
+} // atoi_local
+
+/**
+	auto detect return value class
+	@note if you set bool pointer p then throw nothing and set *p = false if bad string
+*/
+class atoi {
+	const char *p_;
+	size_t size_;
+	bool *b_;
+	void set(bool *b, const char *p, size_t size)
+	{
+		b_ = b;
+		p_ = p;
+		size_ = size;
+	}
+public:
+	atoi(const char *p, size_t size = -1)
+	{
+		set(0, p, size);
+	}
+	atoi(bool *b, const char *p, size_t size = -1)
+	{
+		set(b, p, size);
+	}
+	atoi(const std::string& str)
+	{
+		set(0, str.c_str(), str.size());
+	}
+	atoi(bool *b, const std::string& str)
+	{
+		set(b, str.c_str(), str.size());
+	}
+	inline operator signed char() const
+	{
+		return atoi_local::convertToInt<signed char>(b_, p_, size_, "128", -128, 12, '8');
+	}
+	inline operator unsigned char() const
+	{
+		return atoi_local::convertToUint<unsigned char>(b_, p_, size_, 25, '6');
+	}
+	inline operator short() const
+	{
+		return atoi_local::convertToInt<short>(b_, p_, size_, "32768", -32768, 3276, '8');
+	}
+	inline operator unsigned short() const
+	{
+		return atoi_local::convertToUint<unsigned short>(b_, p_, size_, 6553, '6');
+	}
+	inline operator int() const
+	{
+		return atoi_local::convertToInt<int>(b_, p_, size_, "2147483648", (std::numeric_limits<int>::min)() /* -2147483648 */, 214748364, '8');
+	}
+	inline operator unsigned int() const
+	{
+		return atoi_local::convertToUint<unsigned int>(b_, p_, size_, 429496729, '6');
+	}
+	inline operator long long() const
+	{
+		return atoi_local::convertToInt<long long>(b_, p_, size_, "9223372036854775808", CYBOZU_LLONG_MIN, 922337203685477580LL, '8');
+	}
+	inline operator unsigned long long() const
+	{
+		return atoi_local::convertToUint<unsigned long long>(b_, p_, size_, 1844674407370955161ULL, '6');
+	}
+#if defined(__SIZEOF_LONG__) && (__SIZEOF_LONG__ == 8)
+	inline operator long() const { return static_cast<long>(static_cast<long long>(*this)); }
+	inline operator unsigned long() const { return static_cast<unsigned long>(static_cast<unsigned long long>(*this)); }
+#else
+	inline operator long() const { return static_cast<long>(static_cast<int>(*this)); }
+	inline operator unsigned long() const { return static_cast<unsigned long>(static_cast<unsigned int>(*this)); }
+#endif
+};
+
+class hextoi {
+	const char *p_;
+	size_t size_;
+	bool *b_;
+	void set(bool *b, const char *p, size_t size)
+	{
+		b_ = b;
+		p_ = p;
+		size_ = size;
+	}
+public:
+	hextoi(const char *p, size_t size = -1)
+	{
+		set(0, p, size);
+	}
+	hextoi(bool *b, const char *p, size_t size = -1)
+	{
+		set(b, p, size);
+	}
+	hextoi(const std::string& str)
+	{
+		set(0, str.c_str(), str.size());
+	}
+	hextoi(bool *b, const std::string& str)
+	{
+		set(b, str.c_str(), str.size());
+	}
+	operator unsigned char() const { return atoi_local::convertHexToInt<unsigned char>(b_, p_, size_); }
+	operator unsigned short() const { return atoi_local::convertHexToInt<unsigned short>(b_, p_, size_); }
+	operator unsigned int() const { return atoi_local::convertHexToInt<unsigned int>(b_, p_, size_); }
+	operator unsigned long() const { return atoi_local::convertHexToInt<unsigned long>(b_, p_, size_); }
+	operator unsigned long long() const { return atoi_local::convertHexToInt<unsigned long long>(b_, p_, size_); }
+	operator char() const { return atoi_local::convertHexToInt<char>(b_, p_, size_); }
+	operator signed char() const { return atoi_local::convertHexToInt<signed char>(b_, p_, size_); }
+	operator short() const { return atoi_local::convertHexToInt<short>(b_, p_, size_); }
+	operator int() const { return atoi_local::convertHexToInt<int>(b_, p_, size_); }
+	operator long() const { return atoi_local::convertHexToInt<long>(b_, p_, size_); }
+	operator long long() const { return atoi_local::convertHexToInt<long long>(b_, p_, size_); }
+};
+
+} // cybozu

data/vendor/cybozulib/include/cybozu/atomic.hpp

@@ -0,0 +1,146 @@
+#pragma once
+/**
+	@file
+	@brief atomic operation
+
+	@author MITSUNARI Shigeo(@herumi)
+	@author MITSUNARI Shigeo
+*/
+#include <cybozu/inttype.hpp>
+#ifdef _WIN32
+#ifndef WIN32_LEAN_AND_MEAN
+	#define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#include <intrin.h>
+#else
+#include <emmintrin.h>
+#endif
+
+namespace cybozu {
+
+namespace atomic_local {
+
+template<size_t S>
+struct Tag {};
+
+template<>
+struct Tag<4> {
+	template<class T>
+	static inline T AtomicAddSub(T *p, T y)
+	{
+#ifdef _WIN32
+		return (T)_InterlockedExchangeAdd((long*)p, (long)y);
+#else
+		return static_cast<T>(__sync_fetch_and_add(p, y));
+#endif
+	}
+
+	template<class T>
+	static inline T AtomicCompareExchangeSub(T *p, T newValue, T oldValue)
+	{
+#ifdef _WIN32
+		return (T)_InterlockedCompareExchange((long*)p, (long)newValue, (long)oldValue);
+#else
+		return static_cast<T>(__sync_val_compare_and_swap(p, oldValue, newValue));
+#endif
+	}
+
+	template<class T>
+	static inline T AtomicExchangeSub(T *p, T newValue)
+	{
+#ifdef _WIN32
+		return (T)_InterlockedExchange((long*)p, (long)newValue);
+#else
+		return static_cast<T>(__sync_lock_test_and_set(p, newValue));
+#endif
+	}
+};
+
+template<>
+struct Tag<8> {
+#if (CYBOZU_OS_BIT == 64)
+	template<class T>
+	static inline T AtomicAddSub(T *p, T y)
+	{
+#ifdef _WIN32
+		return (T)_InterlockedExchangeAdd64((int64_t*)p, (int64_t)y);
+#else
+		return static_cast<T>(__sync_fetch_and_add(p, y));
+#endif
+	}
+#endif
+
+	template<class T>
+	static inline T AtomicCompareExchangeSub(T *p, T newValue, T oldValue)
+	{
+#ifdef _WIN32
+		return (T)_InterlockedCompareExchange64((int64_t*)p, (int64_t)newValue, (int64_t)oldValue);
+#else
+		return static_cast<T>(__sync_val_compare_and_swap(p, oldValue, newValue));
+#endif
+	}
+
+#if (CYBOZU_OS_BIT == 64)
+	template<class T>
+	static inline T AtomicExchangeSub(T *p, T newValue)
+	{
+#ifdef _WIN32
+		return (T)_InterlockedExchange64((int64_t*)p, (int64_t)newValue);
+#else
+		return static_cast<T>(__sync_lock_test_and_set(p, newValue));
+#endif
+	}
+#endif
+};
+
+} // atomic_local
+
+/**
+	atomic operation
+	see http://gcc.gnu.org/onlinedocs/gcc-4.4.0/gcc/Atomic-Builtins.html
+	http://msdn.microsoft.com/en-us/library/ms683504(VS.85).aspx
+*/
+/**
+	tmp = *p;
+	*p += y;
+	return tmp;
+*/
+template<class T>
+T AtomicAdd(T *p, T y)
+{
+	return atomic_local::Tag<sizeof(T)>::AtomicAddSub(p, y);
+}
+
+/**
+	tmp = *p;
+	if (*p == oldValue) *p = newValue;
+	return tmp;
+*/
+template<class T>
+T AtomicCompareExchange(T *p, T newValue, T oldValue)
+{
+	return atomic_local::Tag<sizeof(T)>::AtomicCompareExchangeSub(p, newValue, oldValue);
+}
+
+/**
+	tmp = *p;
+	*p = newValue;
+	return tmp;
+*/
+template<class T>
+T AtomicExchange(T *p, T newValue)
+{
+	return atomic_local::Tag<sizeof(T)>::AtomicExchangeSub(p, newValue);
+}
+
+inline void mfence()
+{
+#ifdef _MSC_VER
+	MemoryBarrier();
+#else
+	_mm_mfence();
+#endif
+}
+
+} // cybozu

data/vendor/cybozulib/include/cybozu/base64.hpp

@@ -0,0 +1,210 @@
+#pragma once
+/**
+	@file
+	@brief base64 encoder and decoder
+
+	@author MITSUNARI Shigeo(@herumi)
+*/
+
+#include <iostream>
+#include <assert.h>
+#include <cybozu/stream.hpp>
+#include <cybozu/line_stream.hpp>
+
+namespace cybozu {
+
+namespace base64 {
+
+const int useLF = 0;
+const int useCRLF = 1;
+const int noEndLine = 2;
+
+} // base64
+
+namespace base64_local {
+
+static inline void addEndLine(char *outBuf, size_t& outBufSize, int mode)
+{
+	if (mode == base64::noEndLine) return;
+	if (mode == base64::useCRLF) outBuf[outBufSize++] = cybozu::line_stream::CR;
+	outBuf[outBufSize++] = cybozu::line_stream::LF;
+}
+
+} // base64_local
+
+/**
+	base64 encode
+	@param os [in] output stream
+	@param is [in] intpu stream
+	@param maxLineSize [in] max line size(multiply of 4 or zero(means infinite line))
+	@param isCRLF [in] put CRLF if ture, put LF if false
+*/
+template<class OutputStream, class InputStream>
+void EncodeToBase64(OutputStream& os, InputStream& is, size_t maxLineSize = 76, int mode = base64::useCRLF)
+{
+	const size_t innerMaxLineSize = 128;
+	if (maxLineSize > innerMaxLineSize || ((maxLineSize % 4) != 0)) {
+		throw cybozu::Exception("base64::EncodeToBase64:bad line size") << maxLineSize;
+	}
+
+	const char *tbl = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+	unsigned int remain = 0;
+	size_t idx = 0; /* 0, 1, 2 */
+	size_t pos = 0; /* line position */
+
+	char inBuf[1024];
+	char outBuf[4096];
+	assert(sizeof(outBuf) > (sizeof(inBuf) * 4) / 3 +(sizeof(inBuf) * 2) /* max # of CRLF */ + 16 /* margin */);
+	size_t outBufSize = 0;
+	for (;;) {
+		size_t readSize = cybozu::readSome(inBuf, sizeof(inBuf), is);
+		if (readSize == 0) break;
+		for (size_t i = 0; i < readSize; i++) {
+			unsigned int c = static_cast<unsigned char>(inBuf[i]);
+			if (idx == 0) {
+				remain = (c & 3) << 4;
+				outBuf[outBufSize++] = tbl[c >> 2];
+				pos++;
+				idx = 1;
+			} else if (idx == 1) {
+				unsigned int tmp = remain | (c >> 4);
+				remain = (c & 0xf) << 2;
+				outBuf[outBufSize++] = tbl[tmp];
+				pos++;
+				idx = 2;
+			} else {
+				outBuf[outBufSize++] = tbl[remain | (c >> 6)];
+				outBuf[outBufSize++] = tbl[c & 0x3f];
+				pos += 2;
+				idx = 0;
+			}
+			if (maxLineSize && pos == maxLineSize) {
+				base64_local::addEndLine(outBuf, outBufSize, mode);
+				pos = 0;
+			}
+			assert(outBufSize <= sizeof(outBuf));
+		}
+		cybozu::write(os, outBuf, outBufSize);
+		outBufSize = 0;
+	}
+	if (idx > 0) {
+		outBuf[outBufSize++] = tbl[remain];
+		outBuf[outBufSize++] = '=';
+		pos += 2;
+		if (idx == 1) {
+			outBuf[outBufSize++] = '=';
+			pos++;
+		}
+	}
+	if (maxLineSize && pos > 0) {
+		base64_local::addEndLine(outBuf, outBufSize, mode);
+	}
+	if (outBufSize > 0) {
+		cybozu::write(os, outBuf, outBufSize);
+	}
+}
+
+/*
+	base64 decoder class
+	@param os [in] output stream
+*/
+template<class OutputStream>
+class Base64Decoder {
+	OutputStream& os_;
+	char outBuf_[1024];
+	size_t outBufSize_;
+	size_t idx_;
+	unsigned int cur_;
+	Base64Decoder(const Base64Decoder&);
+	void operator=(const Base64Decoder&);
+public:
+	Base64Decoder(OutputStream& os)
+		: os_(os)
+		, outBufSize_(0)
+		, idx_(0)
+		, cur_(0)
+	{
+	}
+	/*
+		@param buf [in] input buffer
+		@param size [in] input buffer size
+		@return same size(always)
+	*/
+	ssize_t write(const char *buf, size_t size)
+	{
+		const unsigned int S = 255; /* skip character */
+		static const unsigned int tbl[256] = {
+			S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
+			S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
+			S, S, S, S, S, S, S, S, S, S, S, 62, S, S, S, 63,
+			52, 53, 54, 55, 56, 57, 58, 59, 60, 61, S, S, S, S, S, S,
+			S, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+			15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, S, S, S, S, S,
+			S, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
+			41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, S, S, S, S, S,
+			S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
+			S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
+			S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
+			S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
+			S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
+			S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
+			S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
+			S, S, S, S, S, S, S, S, S, S, S, S, S, S, S, S,
+		};
+		for (size_t i = 0; i < size; i++) {
+			unsigned int t = tbl[static_cast<unsigned char>(buf[i])];
+			if (t == S) continue;
+			if (idx_ == 0) {
+				cur_ = t << 2;
+				idx_ = 1;
+			} else if (idx_ == 1) {
+				outBuf_[outBufSize_++] = static_cast<char>(cur_ | (t >> 4));
+				cur_ = (t & 0xf) << 4;
+				idx_ = 2;
+			} else if (idx_ == 2) {
+				outBuf_[outBufSize_++] = static_cast<char>(cur_ | (t >> 2));
+				cur_ = (t & 3) << 6;
+				idx_ = 3;
+			} else {
+				outBuf_[outBufSize_++] = static_cast<char>(cur_ | t);
+				idx_ = 0;
+			}
+			if (outBufSize_ == sizeof(outBuf_)) {
+				cybozu::write(os_, outBuf_, outBufSize_);
+				outBufSize_ = 0;
+			}
+		}
+		return static_cast<ssize_t>(size);
+	}
+	/**
+		flush data
+	*/
+	void flush()
+	{
+		if (outBufSize_ > 0) {
+			cybozu::write(os_, outBuf_, outBufSize_);
+			outBufSize_ = 0;
+		}
+	}
+};
+
+/**
+	base64 decode
+	@param os [in] output stream
+	@param is [in] intpu stream
+*/
+template<class OutputStream, class InputStream>
+void DecodeFromBase64(OutputStream& os, InputStream& is)
+{
+	cybozu::Base64Decoder<OutputStream> dec(os);
+	for (;;) {
+		char buf[1024];
+		size_t readSize = cybozu::readSome(buf, sizeof(buf), is);
+		if (readSize <= 0) break;
+		dec.write(buf, readSize);
+	}
+	dec.flush();
+}
+
+} // cybozu