Import("env")

if env["TEST"] :

if env["PLATFORM"] == "win32" :

cppflags = ["/I" + Dir("src/include").abspath]

else :

cppflags = [("-isystem", Dir("src/include").abspath)]

################################################################################

# Module flags

################################################################################

if env["SCONS_STAGE"] == "flags" :

env["CPPUNIT_FLAGS"] = {

#pragma GCC diagnostic ignored "-Wold-style-cast"

#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"

#pragma clang diagnostic ignored "-Wshorten-64-to-32"

#pragma clang diagnostic ignored "-Wunreachable-code"

#ifndef EXCEPTION_BUFFER_SIZE

#define EXCEPTION_BUFFER_SIZE 65536

#endif

#define VIRT_FUNC_LIMIT 1024

#elif VIRT_FUNC_LIMIT > 1024

#error Adjust the code to support more than 1024 virtual functions before setting the VIRT_FUNC_LIMIT above 1024

#endif

#ifdef __EDG__

#define FUNCTION_BASE 3

#define FUNCTION_STRIDE 2

#else

#define FUNCTION_STRIDE 1

#endif

#include <list>

#include <map>

#include <memory>

#include <iostream>

#include <sstream>

#include <cstring>

#ifdef _MSC_VER

#pragma warning(push)

// If you can't generate an assignment operator the least you can do is shut up.

#pragma warning(disable: 4512)

// Alignment not right in a union?

#pragma warning(disable: 4121)

// Template parameters have the tendency not to change between executions.

#pragma warning(disable: 4127)

// No deprecated warnings on functions that really aren't deprecated at all.

#pragma warning(disable: 4996)

Once,

DontCare

};

// base type

class base_mock {

public:

void destroy() { unwriteVft(); delete this; }

virtual ~base_mock() {}

{

void *oldVf = *(void **)this;

*(void **)this = newVf;

return oldVf;

}

{

*(void **)this = (*(void ***)this)[-1];

}

};

{

{

}

};

struct NotPrintable { template <typename T> NotPrintable(T const&) {} };

inline std::ostream &operator<<(std::ostream &os, NotPrintable const&)

{

os << "???";

return os;

}

template <typename T>

{

static inline void print(std::ostream &os, T arg, bool withComma)

{

if (withComma) os << ",";

os << arg;

}

};

template <>

struct printArg<NullType>

{

static void print(std::ostream &, NullType , bool)

{

}

};

{

protected:

{

{

}

virtual bool operator==(const base_tuple &) const = 0;

virtual void printTo(std::ostream &os) const = 0;

};

template <typename X>

struct no_cref { typedef X type; };

template <typename T>

struct comparer

{

static inline bool compare(T a, T b)

{

return a == b;

}

};

typename M = NullType, typename N = NullType, typename O = NullType, typename P = NullType>

class tuple : public base_tuple

{

public:

typename no_cref<A>::type a;

typename no_cref<B>::type b;

typename no_cref<C>::type c;

typename no_cref<D>::type d;

typename no_cref<E>::type e;

typename no_cref<H>::type h;

typename no_cref<I>::type i;

typename no_cref<J>::type j;

typename no_cref<K>::type k;

typename no_cref<L>::type l;

typename no_cref<M>::type m;

typename no_cref<N>::type n;

typename no_cref<O>::type o;

typename no_cref<P>::type p;

typename no_cref<G>::type g = typename no_cref<G>::type(), typename no_cref<H>::type h = typename no_cref<H>::type(),

typename no_cref<O>::type o = typename no_cref<O>::type(), typename no_cref<P>::type p = typename no_cref<P>::type())

: a(a), b(b), c(c), d(d), e(e), f(f), g(g), h(h), i(i), j(j), k(k), l(l), m(m), n(n), o(o), p(p)

{}

bool operator==(const base_tuple &bo) const {

const tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &to = (const tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &)bo;

return (comparer<A>::compare(a, to.a) &&

comparer<B>::compare(b, to.b) &&

comparer<C>::compare(c, to.c) &&

comparer<D>::compare(d, to.d) &&

template <typename T>

int getFunctionIndex(T func) {

func_index idx;

return ((&idx)->*reinterpret_cast<int (func_index::*)()>(func))() * FUNCTION_STRIDE + FUNCTION_BASE;

}

// mock types

template <class T>

{

friend class MockRepository;

unsigned char remaining[sizeof(T)];

void NotImplemented() { throw NotImplementedException(repo); }

protected:

void *oldVft;

void (*funcs[VIRT_FUNC_LIMIT])();

MockRepository *repo;

public:

int funcMap[VIRT_FUNC_LIMIT];

: repo(repo)

{

{

funcs[i] = getNonvirtualMemberFunctionAddress<void (*)()>(&mock<T>::NotImplemented);

funcMap[i] = -1;

}

memset(remaining, 0, sizeof(remaining));

oldVft = base_mock::rewriteVft(funcs);

}

{

{

if (funcMap[i] == x) return i;

}

return -1;

}

};

template <class T>

class classMock : public mock<T>

{

void *backupVft;

public:

: mock<T>(repo)

{

mock<T>::oldVft = base_mock::rewriteVft((void *)mock<T>::funcs);

new(this)T();

backupVft = base_mock::rewriteVft((void *)mock<T>::funcs);

}

~classMock()

{

base_mock::rewriteVft(backupVft);

((T *)this)->~T();

}

};

//Type-safe exception wrapping

public:

virtual ~ExceptionHolder() {}

};

template <class T>

class ExceptionWrapper : public ExceptionHolder {

T exception;

public:

ExceptionWrapper(T exception) : exception(exception) {}

void rethrow() { throw exception; }

};

// Do() function wrapping

class VirtualDestructable { public: virtual ~VirtualDestructable() {} };

template <typename Y>

{

public:

virtual Y operator()(const base_tuple &tupl) = 0;

};

template <typename Y,

typename M = NullType, typename N = NullType, typename O = NullType, typename P = NullType>

class Invocable : public TupleInvocable<Y>

{

public:

virtual Y operator()(A a = A(), B b = B(), C c = C(), D d = D(), E e = E(), F f = F(), G g = G(), H h = H(), I i = I(), J j = J(), K k = K(), L l = L(), M m = M(), N n = N(), O o = O(), P p = P()) = 0;

virtual Y operator()(const base_tuple &tupl) {

const tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &rTupl = reinterpret_cast<const tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &>(tupl);

rTupl.i, rTupl.j, rTupl.k, rTupl.l, rTupl.m, rTupl.n, rTupl.o, rTupl.p);

}

};

template <typename T, typename Y,

typename M, typename N, typename O, typename P>

class DoWrapper : public Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> {

T &t;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p)

{

return t(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p);

}

using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>::operator();

};

template <typename T, typename Y,

typename M, typename N, typename O>

class DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> {

T &t;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, NullType)

{

return t(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o);

}

using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O>::operator();

};

template <typename T, typename Y,

typename M, typename N>

class DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> {

T &t;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, NullType, NullType)

{

return t(a,b,c,d,e,f,g,h,i,j,k,l,m,n);

}

using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N>::operator();

};

template <typename T, typename Y,

typename M>

class DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,J,K,L,M,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> {

T &t;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f,g,h,i,j,k,l,m);

}

using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L,M>::operator();

};

template <typename T, typename Y,

typename I, typename J, typename K, typename L>

class DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,J,K,L,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L> {

T &t;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f,g,h,i,j,k,l);

}

using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K,L>::operator();

};

template <typename T, typename Y,

typename I, typename J, typename K>

class DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,J,K,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H,I,J,K> {

T &t;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f,g,h,i,j,k);

}

using Invocable<Y,A,B,C,D,E,F,G,H,I,J,K>::operator();

};

template <typename T, typename Y,

typename I, typename J>

class DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,J,NullType,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H,I,J> {

T &t;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, NullType, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f,g,h,i,j);

}

using Invocable<Y,A,B,C,D,E,F,G,H,I,J>::operator();

};

template <typename T, typename Y,

typename I>

class DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,NullType,NullType,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H,I>{

T &t;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, H h, I i, NullType, NullType, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f,g,h,i);

}

using Invocable<Y,A,B,C,D,E,F,G,H,I>::operator();

};

template <typename T, typename Y,

typename E, typename F, typename G, typename H>

class DoWrapper<T,Y,A,B,C,D,E,F,G,H,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G,H> {

T &t;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, H h, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f,g,h);

}

using Invocable<Y,A,B,C,D,E,F,G,H>::operator();

};

template <typename T, typename Y,

typename E, typename F, typename G>

class DoWrapper<T,Y,A,B,C,D,E,F,G,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F,G> {

T &t;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, G g, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f,g);

}

using Invocable<Y,A,B,C,D,E,F,G>::operator();

};

template <typename T, typename Y,

typename E, typename F>

class DoWrapper<T,Y,A,B,C,D,E,F,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E,F> {

T &t;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, F f, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e,f);

}

using Invocable<Y,A,B,C,D,E,F>::operator();

};

template <typename T, typename Y,

typename E>

class DoWrapper<T,Y,A,B,C,D,E,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType,NullType> : public Invocable<Y,A,B,C,D,E> {

T &t;

public:

DoWrapper(T &t) : t(t) {}

virtual Y operator()(A a, B b, C c, D d, E e, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType, NullType)

{

return t(a,b,c,d,e);

}

VirtualDestructable *functor;

int funcIndex;

std::list<Call *> previousCalls;

RegistrationType expectation;

bool satisfied;

int lineno;

const char *funcName;

const char *fileName;

protected:

functor(0),

expectation(expectation),

satisfied(false),

lineno(X),

funcName(funcName),

fileName(fileName)

{

}

public:

virtual const base_tuple *getArgs() const = 0;

{

delete eHolder;

delete functor;

delete retVal;

}

};

std::ostream &operator<<(std::ostream &os, const Call &call);

typename M = NullType, typename N = NullType, typename O = NullType, typename P = NullType>

class TCall : public Call {

private:

tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> *args;

public:

const base_tuple *getArgs() const { return args; }

TCall(RegistrationType expectation, base_mock *mock, int funcIndex, int X, const char *funcName, const char *fileName) : Call(expectation, mock, funcIndex, X, funcName, fileName), args(0) {}

~TCall() { delete args; }

bool matchesArgs(const base_tuple &tupl) { return !args || *args == reinterpret_cast<const tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &>(tupl); }

}

previousCalls.push_back(&call);

}

template <typename T>

Call &Do(T &function) { functor = new DoWrapper<T,Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(function); return *this; }

Call &Return(Y obj) { retVal = new ReturnValueWrapper<Y>(obj); return *this; }

template <typename Ex>

Call &Throw(Ex exception) { eHolder = new ExceptionWrapper<Ex>(exception); return *this; }

};

typename M, typename N, typename O, typename P>

class TCall<void,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> : public Call {

private:

tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> *args;

public:

const base_tuple *getArgs() const { return args; }

TCall(RegistrationType expectation, base_mock *mock, int funcIndex, int X, const char *funcName, const char *fileName) : Call(expectation, mock, funcIndex, X, funcName, fileName), args(0) {}

~TCall() { delete args; }

bool matchesArgs(const base_tuple &tupl) { return (!args) || (*args == reinterpret_cast<const tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &>(tupl)); }

}

previousCalls.push_back(&call);

}

template <typename T>

Call &Do(T &function) { functor = new DoWrapper<T,void,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(function); return *this; }

template <typename Ex>

Call &Throw(Ex exception) { eHolder = new ExceptionWrapper<Ex>(exception); return *this; }

};

class MockRepository {

private:

#define NeverCall(obj, func) RegisterExpect_<__LINE__, Never>(obj, &func, #func, __FILE__, __LINE__)

#define OnCallOverload(obj, func) RegisterExpect_<__LINE__, DontCare>(obj, func, #func, __FILE__, __LINE__)

#define ExpectCallOverload(obj, func) RegisterExpect_<__LINE__, Once>(obj, func, #func, __FILE__, __LINE__)

#define NeverCallOverload(obj, func) RegisterExpect_<__LINE__, Never>(obj, func, #func, __FILE__, __LINE__)

#endif

template <int X, RegistrationType expect, typename Z2, typename Y, typename Z>

TCall<Y> &RegisterExpect_(Z2 *mck, Y (Z::*func)(), const char *funcName, const char *fileName, unsigned long lineNo);

template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A>

TCall<Y,A> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A), const char *funcName, const char *fileName, unsigned long lineNo);

typename A, typename B>

TCall<Y,A,B> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B), const char *funcName, const char *fileName, unsigned long lineNo);

typename A, typename B, typename C>

TCall<Y,A,B,C> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C), const char *funcName, const char *fileName, unsigned long lineNo);

typename A, typename B, typename C, typename D>

TCall<Y,A,B,C,D> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D), const char *funcName, const char *fileName, unsigned long lineNo);

typename E>

TCall<Y,A,B,C,D,E> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E), const char *funcName, const char *fileName, unsigned long lineNo);

typename E, typename F>

TCall<Y,A,B,C,D,E,F> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F), const char *funcName, const char *fileName, unsigned long lineNo);

typename E, typename F, typename G>

TCall<Y,A,B,C,D,E,F,G> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G), const char *funcName, const char *fileName, unsigned long lineNo);

typename E, typename F, typename G, typename H>

TCall<Y,A,B,C,D,E,F,G,H> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H), const char *funcName, const char *fileName, unsigned long lineNo);

typename E, typename F, typename G, typename H,

typename I>

TCall<Y,A,B,C,D,E,F,G,H,I> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I), const char *funcName, const char *fileName, unsigned long lineNo);

typename E, typename F, typename G, typename H,

typename I, typename J>

TCall<Y,A,B,C,D,E,F,G,H,I,J> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J), const char *funcName, const char *fileName, unsigned long lineNo);

typename E, typename F, typename G, typename H,

typename I, typename J, typename K>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K), const char *funcName, const char *fileName, unsigned long lineNo);

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L), const char *funcName, const char *fileName, unsigned long lineNo);

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M), const char *funcName, const char *fileName, unsigned long lineNo);

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N), const char *funcName, const char *fileName, unsigned long lineNo);

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N, typename O>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O), const char *funcName, const char *fileName, unsigned long lineNo);

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N, typename O, typename P>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P), const char *funcName, const char *fileName, unsigned long lineNo);

//GCC 3.x doesn't seem to understand overloading on const or non-const member function. Volatile appears to work though.

#if !defined(__GNUC__) || __GNUC__ > 3

template <int X, RegistrationType expect, typename Z2, typename Y, typename Z>

TCall<Y> &RegisterExpect_(Z2 *mck, Y (Z::*func)() volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)())(func), funcName, fileName, lineNo); }

template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A>

TCall<Y,A> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A))(func), funcName, fileName, lineNo); }

typename A, typename B>

TCall<Y,A,B> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B))(func), funcName, fileName, lineNo); }

typename A, typename B, typename C>

TCall<Y,A,B,C> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C))(func), funcName, fileName, lineNo); }

typename A, typename B, typename C, typename D>

TCall<Y,A,B,C,D> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D))(func), funcName, fileName, lineNo); }

typename E>

TCall<Y,A,B,C,D,E> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E))(func), funcName, fileName, lineNo); }

typename E, typename F>

TCall<Y,A,B,C,D,E,F> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G>

TCall<Y,A,B,C,D,E,F,G> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H>

TCall<Y,A,B,C,D,E,F,G,H> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I>

TCall<Y,A,B,C,D,E,F,G,H,I> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J>

TCall<Y,A,B,C,D,E,F,G,H,I,J> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N, typename O>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N, typename O, typename P>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P))(func), funcName, fileName, lineNo); }

template <int X, RegistrationType expect, typename Z2, typename Y, typename Z>

TCall<Y> &RegisterExpect_(Z2 *mck, Y (Z::*func)() const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)())(func), funcName, fileName, lineNo); }

template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A>

TCall<Y,A> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A))(func), funcName, fileName, lineNo); }

typename A, typename B>

TCall<Y,A,B> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B))(func), funcName, fileName, lineNo); }

typename A, typename B, typename C>

TCall<Y,A,B,C> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C))(func), funcName, fileName, lineNo); }

typename A, typename B, typename C, typename D>

TCall<Y,A,B,C,D> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D))(func), funcName, fileName, lineNo); }

typename E>

TCall<Y,A,B,C,D,E> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E))(func), funcName, fileName, lineNo); }

typename E, typename F>

TCall<Y,A,B,C,D,E,F> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G>

TCall<Y,A,B,C,D,E,F,G> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H>

TCall<Y,A,B,C,D,E,F,G,H> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I>

TCall<Y,A,B,C,D,E,F,G,H,I> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J>

TCall<Y,A,B,C,D,E,F,G,H,I,J> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N, typename O>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N, typename O, typename P>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) const volatile, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P))(func), funcName, fileName, lineNo); }

template <int X, RegistrationType expect, typename Z2, typename Y, typename Z>

TCall<Y> &RegisterExpect_(Z2 *mck, Y (Z::*func)() const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)())(func), funcName, fileName, lineNo); }

template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A>

TCall<Y,A> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A))(func), funcName, fileName, lineNo); }

typename A, typename B>

TCall<Y,A,B> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B))(func), funcName, fileName, lineNo); }

typename A, typename B, typename C>

TCall<Y,A,B,C> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C))(func), funcName, fileName, lineNo); }

typename A, typename B, typename C, typename D>

TCall<Y,A,B,C,D> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D))(func), funcName, fileName, lineNo); }

typename E>

TCall<Y,A,B,C,D,E> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E))(func), funcName, fileName, lineNo); }

typename E, typename F>

TCall<Y,A,B,C,D,E,F> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G>

TCall<Y,A,B,C,D,E,F,G> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H>

TCall<Y,A,B,C,D,E,F,G,H> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I>

TCall<Y,A,B,C,D,E,F,G,H,I> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J>

TCall<Y,A,B,C,D,E,F,G,H,I,J> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N, typename O>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O))(func), funcName, fileName, lineNo); }

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N, typename O, typename P>

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> &RegisterExpect_(Z2 *mck, Y (Z::*func)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P) const, const char *funcName, const char *fileName, unsigned long lineNo) { return RegisterExpect_<X,expect>(mck, (Y(Z::*)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P))(func), funcName, fileName, lineNo); }

#endif

template <typename Z>

void BasicRegisterExpect(mock<Z> *zMock, int funcIndex, void (base_mock::*func)(), int X);

template <typename Z>

Z DoExpectation(base_mock *mock, int funcno, const base_tuple &tuple);

{

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno &&

call->matchesArgs(tuple) &&

!call->satisfied)

{

bool allSatisfy = true;

for (std::list<Call *>::iterator callsBefore = call->previousCalls.begin();

{

if (!(*callsBefore)->satisfied)

{

allSatisfy = false;

}

}

if (!allSatisfy) continue;

call->satisfied = true;

if (call->eHolder)

call->eHolder->rethrow();

if (call->functor != NULL)

(*(TupleInvocable<void> *)(call->functor))(tuple);

return;

}

}

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno &&

call->matchesArgs(tuple))

{

bool allSatisfy = true;

for (std::list<Call *>::iterator callsBefore = call->previousCalls.begin();

callsBefore != call->previousCalls.end(); ++callsBefore)

}

}

if (!allSatisfy) continue;

call->satisfied = true;

throw ExpectationException(this, call->getArgs(), call->funcName);

}

}

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno &&

call->matchesArgs(tuple))

{

bool allSatisfy = true;

for (std::list<Call *>::iterator callsBefore = call->previousCalls.begin();

callsBefore != call->previousCalls.end(); ++callsBefore)

call->eHolder->rethrow();

if (call->functor != NULL)

(*(TupleInvocable<void> *)(call->functor))(tuple);

return;

}

}

const char *funcName = NULL;

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno)

funcName = call->funcName;

}

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno)

funcName = call->funcName;

}

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno)

funcName = call->funcName;

}

throw ExpectationException(this, &tuple, funcName);

}

: autoExpect(true)

{

}

{

if (!std::uncaught_exception())

VerifyAll();

reset();

{

(*i)->destroy();

}

mocks.clear();

}

{

{

delete *i;

}

expectations.clear();

{

delete *i;

}

neverCalls.clear();

{

delete *i;

}

optionals.clear();

}

{

{

if (!(*i)->satisfied)

throw CallMissingException(this);

}

}

template <typename base>

base *InterfaceMock();

template <typename base>

base *ClassMock();

};

// mock function providers

template <typename Z, typename Y>

class mockFuncs : public mock<Z> {

mockFuncs();

public:

template <int X>

Y expectation0()

{

MockRepository *repo = mock<Z>::repo;

return repo->template DoExpectation<Y>(this, mock<Z>::translateX(X), tuple<>());

}

template <int X, typename A>

Y expectation16(A a, B b, C c, D d, E e, F f, G g, H h, I i, J j, K k, L l, M m, N n, O o, P p)

{

MockRepository *repo = mock<Z>::repo;

return repo->template DoExpectation<Y>(this, mock<Z>::translateX(X), tuple<A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p));

}

};

template <typename Z>

class mockFuncs<Z, void> : public mock<Z> {

mockFuncs();

public:

template <int X>

void expectation0()

{

MockRepository *repo = mock<Z>::repo;

repo->DoVoidExpectation(this, mock<Z>::translateX(X), tuple<>());

}

template <int X, typename A>

if (zMock->funcMap[funcIndex] == -1)

{

zMock->funcs[funcIndex] = getNonvirtualMemberFunctionAddress<void (*)()>(func);

zMock->funcMap[funcIndex] = X;

}

}

// Mock repository implementation

template <int X, RegistrationType expect, typename Z2, typename Y, typename Z>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)();

mfp = &mockFuncs<Z2, Y>::template expectation0<X>;

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y> *call = new TCall<Y>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

template <int X, RegistrationType expect, typename Z2, typename Y, typename Z, typename A>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A);

mfp = &mockFuncs<Z2, Y>::template expectation1<X,A>;

funcIndex,

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A> *call = new TCall<Y,A>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename A, typename B>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B);

mfp = &mockFuncs<Z2, Y>::template expectation2<X,A,B>;

funcIndex,

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B> *call = new TCall<Y,A,B>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename A, typename B, typename C>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C);

mfp = &mockFuncs<Z2, Y>::template expectation3<X,A,B,C>;

funcIndex,

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B,C> *call = new TCall<Y,A,B,C>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename A, typename B, typename C, typename D>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D);

mfp = &mockFuncs<Z2, Y>::template expectation4<X,A,B,C,D>;

funcIndex,

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B,C,D> *call = new TCall<Y,A,B,C,D>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename E>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E);

mfp = &mockFuncs<Z2, Y>::template expectation5<X,A,B,C,D,E>;

funcIndex,

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B,C,D,E> *call = new TCall<Y,A,B,C,D,E>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename E, typename F>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F);

mfp = &mockFuncs<Z2, Y>::template expectation6<X,A,B,C,D,E,F>;

funcIndex,

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B,C,D,E,F> *call = new TCall<Y,A,B,C,D,E,F>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename E, typename F, typename G>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G);

mfp = &mockFuncs<Z2, Y>::template expectation7<X,A,B,C,D,E,F,G>;

funcIndex,

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B,C,D,E,F,G> *call = new TCall<Y,A,B,C,D,E,F,G>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename E, typename F, typename G, typename H>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H);

mfp = &mockFuncs<Z2, Y>::template expectation8<X,A,B,C,D,E,F,G,H>;

funcIndex,

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B,C,D,E,F,G,H> *call = new TCall<Y,A,B,C,D,E,F,G,H>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I);

mfp = &mockFuncs<Z2, Y>::template expectation9<X,A,B,C,D,E,F,G,H,I>;

funcIndex,

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B,C,D,E,F,G,H,I> *call = new TCall<Y,A,B,C,D,E,F,G,H,I>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I, typename J>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I,J);

mfp = &mockFuncs<Z2, Y>::template expectation10<X,A,B,C,D,E,F,G,H,I,J>;

funcIndex,

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B,C,D,E,F,G,H,I,J> *call = new TCall<Y,A,B,C,D,E,F,G,H,I,J>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I, typename J, typename K>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I,J,K);

mfp = &mockFuncs<Z2, Y>::template expectation11<X,A,B,C,D,E,F,G,H,I,J,K>;

funcIndex,

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B,C,D,E,F,G,H,I,J,K> *call = new TCall<Y,A,B,C,D,E,F,G,H,I,J,K>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I,J,K,L);

mfp = &mockFuncs<Z2, Y>::template expectation12<X,A,B,C,D,E,F,G,H,I,J,K,L>;

funcIndex,

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L> *call = new TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I,J,K,L,M);

mfp = &mockFuncs<Z2, Y>::template expectation13<X,A,B,C,D,E,F,G,H,I,J,K,L,M>;

funcIndex,

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M> *call = new TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I,J,K,L,M,N);

mfp = &mockFuncs<Z2, Y>::template expectation14<X,A,B,C,D,E,F,G,H,I,J,K,L,M,N>;

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N> *call = new TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N, typename O>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O);

mfp = &mockFuncs<Z2, Y>::template expectation15<X,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O>;

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O> *call = new TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

typename E, typename F, typename G, typename H,

typename I, typename J, typename K, typename L,

typename M, typename N, typename O, typename P>

{

int funcIndex = getFunctionIndex(func);

Y (mockFuncs<Z2, Y>::*mfp)(A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P);

mfp = &mockFuncs<Z2, Y>::template expectation16<X,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>;

funcIndex,

reinterpret_cast<void (base_mock::*)()>(mfp),X);

TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P> *call = new TCall<Y,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P>(expect, reinterpret_cast<base_mock *>(mck), funcIndex, lineNo, funcName, fileName);

switch(expect)

{

case Never: neverCalls.push_back(call); break;

case DontCare: optionals.push_back(call); break;

case Once:

{

call->previousCalls.push_back(expectations.back());

}

expectations.push_back(call);

break;

}

return *call;

}

template <typename Z>

{

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno &&

call->matchesArgs(tuple) &&

!call->satisfied)

{

bool allSatisfy = true;

for (std::list<Call *>::iterator callsBefore = call->previousCalls.begin();

if (call->retVal)

return ((ReturnValueWrapper<Z> *)call->retVal)->rv;

if (call->functor != NULL)

return (*(TupleInvocable<Z> *)(call->functor))(tuple);

throw NoResultSetUpException(call->getArgs(), call->funcName);

}

}

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno &&

call->matchesArgs(tuple))

{

bool allSatisfy = true;

for (std::list<Call *>::iterator callsBefore = call->previousCalls.begin();

callsBefore != call->previousCalls.end(); ++callsBefore)

}

}

if (!allSatisfy) continue;

call->satisfied = true;

throw ExpectationException(this, call->getArgs(), call->funcName);

}

}

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno &&

call->matchesArgs(tuple))

{

bool allSatisfy = true;

for (std::list<Call *>::iterator callsBefore = call->previousCalls.begin();

callsBefore != call->previousCalls.end(); ++callsBefore)

{

if (!(*callsBefore)->satisfied)

{

allSatisfy = false;

}

}

if (!allSatisfy) continue;

call->satisfied = true;

if (call->eHolder)

call->eHolder->rethrow();

if (call->retVal)

return ((ReturnValueWrapper<Z> *)call->retVal)->rv;

if (call->functor != NULL)

return (*(TupleInvocable<Z> *)(call->functor))(tuple);

throw NoResultSetUpException(call->getArgs(), call->funcName);

}

}

const char *funcName = NULL;

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno)

funcName = call->funcName;

}

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno)

funcName = call->funcName;

}

{

Call *call = *i;

if (call->mock == mock &&

call->funcIndex == funcno)

funcName = call->funcName;

}

throw ExpectationException(this, &tuple, funcName);

}

template <typename base>

os << "Optional results set up:" << std::endl;

for (std::list<Call *>::const_iterator exp = repo.optionals.begin(); exp != repo.optionals.end(); ++exp)

os << **exp;

os << std::endl;

}

return os;

}

{

std::stringstream text;

text << description;

text << *repo;

std::string result = text.str();

strncpy(buffer, result.c_str(), sizeof(buffer)-1);

buffer[sizeof(buffer)-1] = '\0';

}

#ifdef _MSC_VER

#pragma warning(pop)

#endif

#endif

host_platform = env.get('HOST_ARCH')

if not host_platform:

host_platform = platform.machine()

# TODO(2.5): the native Python platform.machine() function returns

# '' on all Python versions before 2.6, after which it also uses

# PROCESSOR_ARCHITECTURE.

if not host_platform:

host_platform = os.environ.get('PROCESSOR_ARCHITECTURE', '')

# Retain user requested TARGET_ARCH

req_target_platform = env.get('TARGET_ARCH')

debug('vc.py:get_host_target() req_target_platform:%s'%req_target_platform)

if req_target_platform:

# If user requested a specific platform then only try that one.

target_platform = req_target_platform

else:

target_platform = host_platform

try:

host = _ARCH_TO_CANONICAL[host_platform.lower()]

except KeyError, e:

msg = "Unrecognized host architecture %s"

raise ValueError(msg % repr(host_platform))

try:

target = _ARCH_TO_CANONICAL[target_platform.lower()]

except KeyError, e:

raise ValueError("Unrecognized target architecture %s" % target_platform)

return (host, target,req_target_platform)

_VCVER_TO_PRODUCT_DIR = {

'10.0': [

r'Microsoft\VisualStudio\10.0\Setup\VC\ProductDir'],

'9.0': [

r'Microsoft\VisualStudio\9.0\Setup\VC\ProductDir'],

'9.0Exp' : [

r'Microsoft\VCExpress\9.0\Setup\VC\ProductDir'],

'8.0': [

r'Microsoft\VisualStudio\8.0\Setup\VC\ProductDir'],

'8.0Exp': [

r'Microsoft\VCExpress\8.0\Setup\VC\ProductDir'],

'7.1': [

r'Microsoft\VisualStudio\7.1\Setup\VC\ProductDir'],

'7.0': [

r'Microsoft\VisualStudio\7.0\Setup\VC\ProductDir'],

'6.0': [

r'Microsoft\VisualStudio\6.0\Setup\Microsoft Visual C++\ProductDir']

}

def msvc_version_to_maj_min(msvc_version):

msvc_version_numeric = ''.join([x for x in msvc_version if x in string_digits + '.'])

t = msvc_version_numeric.split(".")

if not len(t) == 2:

raise ValueError("Unrecognized version %s (%s)" % (msvc_version,msvc_version_numeric))

try:

maj = int(t[0])

min = int(t[1])

def find_batch_file(env,msvc_version,host_arch,target_arch):

"""

Find the location of the batch script which should set up the compiler

for any TARGET_ARCH whose compilers were installed by Visual Studio/VCExpress

"""

pdir = find_vc_pdir(msvc_version)

if pdir is None:

raise NoVersionFound("No version of Visual Studio found")

debug('vc.py: find_batch_file() pdir:%s'%pdir)

# filter out e.g. "Exp" from the version name

msvc_ver_numeric = ''.join([x for x in msvc_version if x in string_digits + "."])

vernum = float(msvc_ver_numeric)

if 7 <= vernum < 8:

pdir = os.path.join(pdir, os.pardir, "Common7", "Tools")

batfilename = os.path.join(pdir, "vsvars32.bat")

elif vernum < 7:

pdir = os.path.join(pdir, "Bin")

batfilename = os.path.join(pdir, "vcvars32.bat")

else: # >= 8

batfilename = os.path.join(pdir, "vcvarsall.bat")

if not os.path.exists(batfilename):

debug("Not found: %s" % batfilename)

batfilename = None

installed_sdks=get_installed_sdks()

for _sdk in installed_sdks:

sdk_bat_file=_sdk.get_sdk_vc_script(host_arch,target_arch)

sdk_bat_file_path=os.path.join(pdir,sdk_bat_file)

debug('vc.py:find_batch_file() sdk_bat_file_path:%s'%sdk_bat_file_path)

if os.path.exists(sdk_bat_file_path):

return (batfilename,sdk_bat_file_path)

else:

debug("vc.py:find_batch_file() not found:%s"%sdk_bat_file_path)

raise BatchFileExecutionError("\n".join(olines[:2]))

return common.parse_output(stdout)

def get_default_version(env):

debug('get_default_version()')

msvc_version = env.get('MSVC_VERSION')

msvs_version = env.get('MSVS_VERSION')

debug('get_default_version(): msvc_version:%s msvs_version:%s'%(msvc_version,msvs_version))

if msvs_version and not msvc_version:

SCons.Warnings.warn(

SCons.Warnings.DeprecatedWarning,

"MSVS_VERSION is deprecated: please use MSVC_VERSION instead ")

return msvs_version

elif msvc_version and msvs_version:

if not msvc_version == msvs_version:

# 64 bit tools installed

try_target_archs = [target_platform]

if target_platform=='amd64':

try_target_archs.append('x86')

d = None

for tp in try_target_archs:

# Set to current arch.

env['TARGET_ARCH']=tp

debug("vc.py:msvc_find_valid_batch_script() trying target_platform:%s"%tp)

host_target = (host_platform, tp)

if not is_host_target_supported(host_target, version):

warn_msg = "host, target = %s not supported for MSVC version %s" % \

(host_target, version)

SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)

arg = _HOST_TARGET_ARCH_TO_BAT_ARCH[host_target]

# Try to locate a batch file for this host/target platform combo

try:

(vc_script,sdk_script) = find_batch_file(env,version,host_platform,tp)

debug('vc.py:msvc_find_valid_batch_script() vc_script:%s sdk_script:%s'%(vc_script,sdk_script))

except VisualCException, e:

msg = str(e)

debug('Caught exception while looking for batch file (%s)' % msg)

warn_msg = "VC version %s not installed. " + \

"C/C++ compilers are most likely not set correctly.\n" + \

" Installed versions are: %s"

warn_msg = warn_msg % (version, cached_get_installed_vcs())

SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)

continue

# Try to use the located batch file for this host/target platform combo

debug('vc.py:msvc_find_valid_batch_script() use_script 2 %s, args:%s\n' % (repr(vc_script), arg))

if vc_script:

try:

d = script_env(vc_script, args=arg)

except BatchFileExecutionError, e:

debug('vc.py:msvc_find_valid_batch_script() use_script 3: failed running VC script %s: %s: Error:%s'%(repr(vc_script),arg,e))

vc_script=None

if not vc_script and sdk_script:

debug('vc.py:msvc_find_valid_batch_script() use_script 4: trying sdk script: %s'%(sdk_script))

try:

d = script_env(sdk_script,args=[])

except BatchFileExecutionError,e:

debug('vc.py:msvc_find_valid_batch_script() use_script 5: failed running SDK script %s: Error:%s'%(repr(sdk_script),e))

continue

elif not vc_script and not sdk_script:

debug('vc.py:msvc_find_valid_batch_script() use_script 6: Neither VC script nor SDK script found')

continue

# If we cannot find a viable installed compiler, reset the TARGET_ARCH

# To it's initial value

if not d:

env['TARGET_ARCH']=req_target_platform

return d

def msvc_setup_env(env):

debug('msvc_setup_env()')

version = get_default_version(env)

if version is None:

warn_msg = "No version of Visual Studio compiler found - C/C++ " \

"compilers most likely not set correctly"

SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)

return None

debug('msvc_setup_env: using specified MSVC version %s\n' % repr(version))

# XXX: we set-up both MSVS version for backward

# compatibility with the msvs tool

env['MSVC_VERSION'] = version

env['MSVS_VERSION'] = version

env['MSVS'] = {}

use_script = env.get('MSVC_USE_SCRIPT', True)

if SCons.Util.is_String(use_script):

debug('vc.py:msvc_setup_env() use_script 1 %s\n' % repr(use_script))

d = script_env(use_script)

d = msvc_find_valid_batch_script(env,version)

debug('vc.py:msvc_setup_env() use_script 2 %s\n' % d)

if not d:

return d

else:

debug('MSVC_USE_SCRIPT set to False')

warn_msg = "MSVC_USE_SCRIPT set to False, assuming environment " \

"set correctly."

SCons.Warnings.warn(SCons.Warnings.VisualCMissingWarning, warn_msg)

for k, v in d.items():

debug('vc.py:msvc_setup_env() env:%s -> %s'%(k,v))

env.PrependENVPath(k, v, delete_existing=True)

def msvc_exists(version=None):

vcs = cached_get_installed_vcs()

if version is None:

return len(vcs) > 0

return version in vcs

################################################################################

vars = Variables(os.path.join(Dir("#").abspath, "config.py"))

vars.Add('cc', "C compiler")

vars.Add('cxx', "C++ compiler")

vars.Add('ccflags', "Extra C/C++/ObjC compiler flags")

vars.Add('cxxflags', "Extra C++ compiler flags")

vars.Add('link', "Linker")

vars.Add('linkflags', "Extra linker flags")

vars.Add(BoolVariable("ccache", "Use CCache", "no"))

vars.Add(EnumVariable("test", "Compile and run tests", "none", ["none", "all", "unit", "system"]))

vars.Add(BoolVariable("optimize", "Compile with optimizations turned on", "no"))

vars.Add(BoolVariable("debug", "Compile with debug information", "yes"))

vars.Add(BoolVariable("allow_warnings", "Allow compilation warnings during compilation", "yes"))

vars.Add(BoolVariable("assertions", "Compile with assertions", "yes"))

vars.Add(BoolVariable("max_jobs", "Build with maximum number of parallel jobs", "no"))

vars.Add(EnumVariable("target", "Choose a target platform for compilation", "native", ["native", "iphone-simulator", "iphone-device", "xcode", "android"]))

vars.Add('android_toolchain', "Path to Android toolchain")

vars.Add(BoolVariable("mac105", "Link against the 10.5 frameworks", "no"))

vars.Add(BoolVariable("mac106", "Link against the 10.6 frameworks", "no"))

if os.name == "nt" :

vars.Add(PathVariable("vcredist", "MSVC redistributable dir", None, PathVariable.PathAccept))

if os.name == "nt" :

vars.Add(PathVariable("wix_bindir", "Path to WiX binaries", "", PathVariable.PathAccept))

if os.name == "nt" :

vars.Add(PackageVariable("bonjour", "Bonjour SDK location", "yes"))

vars.Add(PackageVariable("openssl", "OpenSSL location", "yes"))

vars.Add(BoolVariable("openssl_force_bundled", "Force use of the bundled OpenSSL", "no"))

vars.Add(PackageVariable("hunspell", "Hunspell location", False))

vars.Add(PathVariable("boost_includedir", "Boost headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("boost_libdir", "Boost library location", None, PathVariable.PathAccept))

vars.Add(PathVariable("expat_includedir", "Expat headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("expat_libdir", "Expat library location", None, PathVariable.PathAccept))

vars.Add(PackageVariable("icu", "ICU library location", "no"))

vars.Add(PathVariable("libidn_includedir", "LibIDN headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("libidn_libdir", "LibIDN library location", None, PathVariable.PathAccept))

vars.Add(PathVariable("libminiupnpc_includedir", "LibMiniUPNPC headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("libminiupnpc_libdir", "LibMiniUPNPC library location", None, PathVariable.PathAccept))

vars.Add("libminiupnpc_libname", "LibMiniUPNPC library name", "libminiupnpc" if os.name == "nt" else "miniupnpc")

vars.Add(PathVariable("libnatpmp_includedir", "LibNATPMP headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("libnatpmp_libdir", "LibNATPMP library location", None, PathVariable.PathAccept))

vars.Add("libnatpmp_libname", "LibNATPMP library name", "libnatpmp" if os.name == "nt" else "natpmp")

vars.Add(PathVariable("sqlite_includedir", "SQLite headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("sqlite_libdir", "SQLite library location", None, PathVariable.PathAccept))

vars.Add("sqlite_force_bundled", "Force use of the bundled SQLite", None)

vars.Add(PathVariable("lua_includedir", "Lua headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("lua_libdir", "Lua library location", None, PathVariable.PathAccept))

vars.Add("lua_libname", "Lua library name", "liblua" if os.name == "nt" else "lua")

vars.Add("lua_force_bundled", "Force use of the bundled Lua", None)

vars.Add(PathVariable("editline_includedir", "Readline headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("editline_libdir", "Readline library location", None, PathVariable.PathAccept))

vars.Add("editline_libname", "Readline library name", "libedit" if os.name == "nt" else "edit")

vars.Add(PathVariable("avahi_includedir", "Avahi headers location", None, PathVariable.PathAccept))

vars.Add(PathVariable("avahi_libdir", "Avahi library location", None, PathVariable.PathAccept))

vars.Add(PathVariable("qt", "Qt location", "", PathVariable.PathAccept))

vars.Add(BoolVariable("qt5", "Compile in Qt5 mode", "no")) # TODO: auto-detect this

vars.Add(PathVariable("docbook_xml", "DocBook XML", None, PathVariable.PathAccept))

vars.Add(PathVariable("docbook_xsl", "DocBook XSL", None, PathVariable.PathAccept))

vars.Add(BoolVariable("build_examples", "Build example programs", "yes"))

vars.Add(BoolVariable("enable_variants", "Build in a separate dir under build/, depending on compile flags", "no"))

vars.Add(BoolVariable("experimental_ft", "Build experimental file transfer", "yes"))

vars.Add(BoolVariable("experimental", "Build experimental features", "no"))

vars.Add(BoolVariable("set_iterator_debug_level", "Set _ITERATOR_DEBUG_LEVEL=0", "yes"))

vars.Add(BoolVariable("unbound", "Build bundled ldns and unbound. Use them for DNS lookup.", "no"))

################################################################################

# Set up default build & configure environment

################################################################################

env_ENV = {

'LD_LIBRARY_PATH' : os.environ.get("LD_LIBRARY_PATH", ""),

'TERM' : os.environ.get("TERM", ""),

}

if "MSVC_VERSION" in ARGUMENTS :

else :

Help(vars.GenerateHelpText(env))

# Workaround for missing Visual Studio 2012 support in SCons

# Requires scons to be run from a VS2012 console

if env.get("MSVC_VERSION", "").startswith("11.0") :

env["ENV"]["LIB"] = os.environ["LIB"]

env["ENV"]["INCLUDE"] = os.environ["INCLUDE"]

env.Tool("BuildVersion", toolpath = ["#/BuildTools/SCons/Tools"])

env.Tool("Flags", toolpath = ["#/BuildTools/SCons/Tools"])

if env["PLATFORM"] == "darwin" :

env.Tool("Nib", toolpath = ["#/BuildTools/SCons/Tools"])

env.Tool("AppBundle", toolpath = ["#/BuildTools/SCons/Tools"])

if env["PLATFORM"] == "win32" :

env.Tool("WindowsBundle", toolpath = ["#/BuildTools/SCons/Tools"])

#So we don't need to escalate with UAC

if "TMP" in os.environ.keys() :

env.Tool("SLOCCount", toolpath = ["#/BuildTools/SCons/Tools"])

# Max out the number of jobs

if env["max_jobs"] :

try :

import multiprocessing

SetOption("num_jobs", multiprocessing.cpu_count())

except NotImplementedError :

pass

env["ENV"][key] = value

env["CC"] = os.environ["CC"]

env["CXX"] = os.environ["CXX"]

# Override the compiler with custom variables set at config time

if "cc" in env :

env["CC"] = env["cc"]

if "cxx" in env :

env["CXX"] = env["cxx"]

if "link" in env :

env["SHLINK"] = env["link"]

env["LINK"] = env["link"]

for flags_type in ["ccflags", "cxxflags", "linkflags"] :

if flags_type in env :

if isinstance(env[flags_type], str) :

# FIXME: Make the splitting more robust

env[flags_type.upper()] = env[flags_type].split(" ")

else :

env.Append(CCFLAGS = ["/MDd"])

else :

env.Append(CCFLAGS = ["-g"])

elif env["PLATFORM"] == "win32" :

env.Append(CCFLAGS = ["/MD"])

if env.get("universal", 0) :

assert(env["PLATFORM"] == "darwin")

env.Append(CCFLAGS = [

"-arch", "ppc"])

env.Append(LINKFLAGS = [

"-arch", "ppc"])

# Link against other versions of the OS X SDKs.

# FIXME: This method does not work anymore, we need to set deployment targets.

if env.get("mac105", 0) :

assert(env["PLATFORM"] == "darwin")

env.Append(CCFLAGS = [

"-arch", "i386"])

env.Append(LINKFLAGS = [

"-arch", "i386"])

if env.get("mac106", 0) :

assert(env["PLATFORM"] == "darwin")

env.Append(CCFLAGS = [

"-arch", "i386"])

env.Append(LINKFLAGS = [

"-arch", "i386"])

if not env["assertions"] :

env.Append(CPPDEFINES = ["NDEBUG"])

if env["experimental_ft"] :

env.Append(CPPDEFINES = ["SWIFT_EXPERIMENTAL_FT"])

if env["experimental"] :

# If we build shared libs on AMD64, we need -fPIC.

# This should have no performance impact om AMD64

if env["PLATFORM"] == "posix" and platform.machine() == "x86_64" :

env.Append(CCFLAGS = ["-fPIC"])

# Warnings

if env["PLATFORM"] == "win32" :

env.Append(CXXFLAGS = ["/wd4068"])

else :

if "clang" in env["CXX"] :

env.Append(CXXFLAGS = [

"-Weverything",

"-Wno-unknown-warning-option", # To stay compatible between CLang versions

"-Wno-unknown-pragmas", # To stay compatible between CLang versions

"-Wno-weak-vtables", # Virtually none of our elements have outlined methods. This also seems to affect classes in .cpp files, which in turn affects all our tests, which may need fixing in CLang

"-Wno-shadow", # Also warns for shadowing on constructor arguments, which we do a lot

"-Wno-documentation", # We don't care about documentation warnings

assert(env["PLATFORM"] != "win32")

env.Append(CCFLAGS = ["-fprofile-arcs", "-ftest-coverage"])

env.Append(LINKFLAGS = ["-fprofile-arcs", "-ftest-coverage"])

if env["PLATFORM"] == "win32" :

env.Append(LIBS = ["user32", "crypt32", "dnsapi", "iphlpapi", "ws2_32", "wsock32", "Advapi32"])

env.Append(CCFLAGS = ["/EHsc", "/nologo", "/Zm256"])

env.Append(LINKFLAGS = ["/INCREMENTAL:no", "/NOLOGO"])

if int(env["MSVS_VERSION"].split(".")[0]) < 10 :

if env["PLATFORM"] == "darwin" and not env["target"] in ["iphone-device", "iphone-simulator", "xcode", "android"] :

env["PLATFORM_FLAGS"]["FRAMEWORKS"] += ["IOKit", "AppKit", "SystemConfiguration", "Security", "SecurityInterface"]

# Testing

env["TEST_TYPE"] = env["test"]

if "check" in ARGUMENTS :

env["TEST_TYPE"] = "unit"

env["checker_report"] = ARGUMENTS.get("checker_report", False)

env["TEST"] = (env["TEST_TYPE"] != "none") or env.GetOption("clean")

if env.get("valgrind", 0) :

env["TEST_RUNNER"] = "valgrind --suppressions=QA/valgrind.supp -q --leak-check=full --track-origins=yes "

env["TEST_IGNORE_RESULT"] = "ignore_test_result" in ARGUMENTS

env.Append(CCFLAGS = env["XCODE_ARCH_FLAGS"] + ["-fvisibility=hidden", "-miphoneos-version-min=" + env["IPHONEOS_DEPLOYMENT_TARGET"]])

env.Append(LINKFLAGS = "-miphoneos-version-min=" + env["IPHONEOS_DEPLOYMENT_TARGET"])

if os.environ.get("GCC_THUMB_SUPPORT", False) :

env.Append(CCFLAGS = ["-mthumb"])

env.Append(LINKFLAGS = env["XCODE_ARCH_FLAGS"])

env.Append(CPPFLAGS = ["-isysroot", "$XCODE_SDKROOT"])

env.Append(FRAMEWORKS = ["CoreFoundation", "Foundation", "UIKit", "CoreGraphics"])

env.Append(LINKFLAGS = env["XCODE_ARCH_FLAGS"] + ["-isysroot", "$XCODE_SDKROOT", "-L\"$XCODE_SDKROOT/usr/lib\"", "-F\"$XCODE_SDKROOT/System/Library/Frameworks\"", "-F\"$XCODE_SDKROOT/System/Library/PrivateFrameworks\""])

# Bit of a hack, because BOOST doesn't know the endianness for ARM

################################################################################

# Android

################################################################################

if target in ["android"] :

env["ENV"]["PATH"] = env["android_toolchain"] + "/bin:" + env["ENV"]["PATH"]

env["CC"] = "arm-linux-androideabi-gcc"

env["CXX"] = "arm-linux-androideabi-g++"

env["RANLIB"] = "arm-linux-androideabi-ranlib"

root = Dir("../..").abspath

# Override SConscript to handle tests

oldSConscript = SConscript

def SConscript(*arguments, **keywords) :

if not keywords.get("test_only", False) or env["TEST"] :

return apply(oldSConscript, arguments, keywords)

env.SConscript = SConscript

################################################################################

# Extend the default build environment (not affecting the configure env)

#

# Keeping both environments separated mostly because of SCons Issue 2391,

# although it doesn't hurt to separate them (e.g. not have pretty printed

# strings in config.log)

################################################################################

#if env["PLATFORM"] == "win32" :

conf = Configure(conf_env)

if not conf.CheckCXX() or not conf.CheckCC() :

print "Error: You need a working compiler"

Exit(1)

env["HAVE_ZLIB"] = True

else :

env["ZLIB_BUNDLED"] = True

if conf.CheckLib("resolv") :

env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["resolv"]

if env["PLATFORM"] != "win32" :

if conf.CheckLib("pthread") :

env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["pthread"]

if conf.CheckLib("dl") :

env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["dl"]

if conf.CheckLib("m") :

env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["m"]

if conf.CheckLib("c") :

env["PLATFORM_FLAGS"]["LIBS"] = env["PLATFORM_FLAGS"].get("LIBS", []) + ["c"]

conf.Finish()

# Boost

boost_conf_env = conf_env.Clone()

boost_flags = {}

if env.get("boost_libdir", None) :

boost_flags["LIBPATH"] = [env["boost_libdir"]]

if env.get("boost_includedir", None) :

boost_flags["CPPPATH"] = [env["boost_includedir"]]

else :

# Using isystem to avoid getting warnings from a system boost

# Unfortunately, this also disables dependency tracking

boost_flags["CPPFLAGS"] = [("-isystem", env["boost_includedir"])]

boost_conf_env.MergeFlags(boost_flags)

conf = Configure(boost_conf_env)

allLibsPresent = True

libNames = []

for (lib, header) in boostLibs :

if header :

header = "boost/" + header

else :

header = "boost/" + lib + ".hpp"

if not conf.CheckCXXHeader(header) :

allLibsPresent = False

break

if env["PLATFORM"] != "win32" :

libName = "boost_" + lib

libName += "-mt"

allLibsPresent = False

break

libNames.append(libName)

if allLibsPresent :

env["BOOST_FLAGS"] = boost_flags

if env["PLATFORM"] != "win32" :

env["BOOST_FLAGS"].update({"LIBS": libNames})

if not conf.CheckCXXHeader("boost/uuid/uuid.hpp") :

# FIXME: Remove this workaround when UUID is available in most distros

env["BOOST_BUNDLED_UUID_ONLY"] = True

else :

env["BOOST_BUNDLED"] = True

conf.Finish()

# Xss

env["HAVE_XSS"] = 0

if env["PLATFORM"] != "win32" and env["PLATFORM"] != "darwin" :

xss_flags = {

xss_env.MergeFlags(xss_flags)

conf = Configure(xss_env)

if conf.CheckFunc("XScreenSaverQueryExtension") :

env["HAVE_XSS"] = 1

env["XSS_FLAGS"] = xss_flags

conf.Finish()

# GConf

env["HAVE_GCONF"] = 0

gconf_env = conf_env.Clone()

conf = Configure(gconf_env, custom_tests = {"CheckPKG": CheckPKG})

if conf.CheckPKG("gconf-2.0") :

gconf_bare_env = Environment()

gconf_bare_env.ParseConfig('pkg-config --cflags gconf-2.0 gobject-2.0 --libs gconf-2.0 gobject-2.0')

gconf_flags = {

"LIBS": gconf_bare_env["LIBS"],

"CCFLAGS": gconf_bare_env["CCFLAGS"],

"CPPPATH": gconf_bare_env["CPPPATH"],

env["GROWL_FRAMEWORK"] = "/Library/Frameworks/Growl.framework"

conf.Finish()

# Snarl

if env["PLATFORM"] == "win32" :

env["HAVE_SNARL"] = True

# LibXML

conf = Configure(conf_env, custom_tests = {"CheckVersion": CheckVersion})

#and conf.CheckVersion("LibXML", "2.6.23", "LIBXML_VERSION", "libxml/xmlversion.h", 20623) :

env["HAVE_LIBXML"] = 1

env["LIBXML_FLAGS"] = { "LIBS": ["xml2"] }

conf.Finish()

libxml_env = conf_env.Clone()

libxml_env.Append(CPPPATH = ["/usr/include/libxml2"])

conf = Configure(libxml_env, custom_tests = {"CheckVersion": CheckVersion})

if conf.CheckCHeader("libxml/parser.h") and conf.CheckLib("xml2") :

# and conf.CheckVersion("LibXML", "2.6.23", "LIBXML_VERSION", "libxml/xmlversion.h", 20623):

env["HAVE_LIBXML"] = 1

env["LIBXML_FLAGS"] = { "CPPPATH": ["/usr/include/libxml2"], "LIBS": ["xml2"] }

conf.Finish()

# Expat

expat_conf_env = conf_env.Clone()

expat_flags = {}

if env.get("expat_libdir", None) :

expat_flags["LIBPATH"] = [env["expat_libdir"]]

if env.get("expat_includedir", None) :

expat_flags["CPPPATH"] = [env["expat_includedir"]]

expat_conf_env.MergeFlags(expat_flags)

conf = Configure(expat_conf_env)

if conf.CheckCHeader("expat.h") and conf.CheckLib(env["expat_libname"]) :

env["EXPAT_BUNDLED"] = True

################################################################################

# IDN library

################################################################################

# ICU

icu_env = conf_env.Clone()

use_icu = bool(env["icu"])

icu_flags = {}

if icu_prefix :

icu_flags = { "CPPPATH": [os.path.join(icu_prefix, "include")] }

icu_flags["LIBPATH"] = [os.path.join(icu_prefix, "lib")]

icu_env.MergeFlags(icu_flags)

icu_conf = Configure(icu_env)

if use_icu and icu_conf.CheckCHeader("unicode/usprep.h") :

env["HAVE_ICU"] = 1

# LibIDN

libidn_conf_env = conf_env.Clone()

libidn_flags = {}

if env.get("libidn_libdir", None) :

libidn_flags["LIBPATH"] = [env["libidn_libdir"]]

if env.get("libidn_includedir", None) :

libidn_flags["CPPPATH"] = [env["libidn_includedir"]]

libidn_conf_env.MergeFlags(libidn_flags)

conf = Configure(libidn_conf_env)

env["HAVE_LIBIDN"] = 1

env["LIBIDN_FLAGS"] = { "LIBS": [env["libidn_libname"]] }

env["LIBIDN_FLAGS"].update(libidn_flags)

conf.Finish()

# Fallback to bundled LibIDN

if not env.get("HAVE_ICU", False) and not env.get("HAVE_LIBIDN", False) :

# Unbound

if env["unbound"] :

env["LDNS_BUNDLED"] = 1

env["UNBOUND_BUNDLED"] = 1

else :

env["LDNS_FLAGS"] = {}

env["UNBOUND_FLAGS"] = {}

# Avahi

avahi_conf_env = conf_env.Clone()

avahi_flags = {}

if env.get("avahi_libdir", None) :

avahi_flags["LIBPATH"] = [env["avahi_libdir"]]

if env.get("avahi_includedir", None) :

avahi_flags["CPPPATH"] = [env["avahi_includedir"]]

avahi_conf_env.MergeFlags(avahi_flags)

conf = Configure(avahi_conf_env)

env["HAVE_AVAHI"] = True

env["AVAHI_FLAGS"] = { "LIBS": ["avahi-client", "avahi-common"] }

env["AVAHI_FLAGS"].update(avahi_flags)

conf.Finish()

# Qt

if env["qt"] :

env["QTDIR"] = env["qt"]

# OpenSSL

openssl_env = conf_env.Clone()

if env.get("openssl_force_bundled", False) or env["target"] in ("iphone-device", "iphone-simulator", "xcode", "android") :

env["OPENSSL_BUNDLED"] = True

env["HAVE_OPENSSL"] = True

else :

use_openssl = bool(env["openssl"])

openssl_flags = {}

if openssl_prefix :

openssl_flags["LIBPATH"] = [os.path.join(openssl_prefix, "lib", "VC")]

env["OPENSSL_DIR"] = openssl_prefix

else :

openssl_flags["LIBPATH"] = [os.path.join(openssl_prefix, "lib")]

openssl_env.MergeFlags(openssl_flags)

openssl_conf = Configure(openssl_env)

if use_openssl and openssl_conf.CheckCHeader("openssl/ssl.h") :

env["HAVE_OPENSSL"] = 1

env["OPENSSL_FLAGS"] = openssl_flags

env["OPENSSL_FLAGS"]["LIBS"] = ["libeay32MD", "ssleay32MD"]

else:

env["OPENSSL_FLAGS"]["LIBS"] = ["ssl", "crypto"]

if env["PLATFORM"] == "darwin" :

if platform.mac_ver()[0].startswith("10.5") :

env["OPENSSL_FLAGS"]["FRAMEWORKS"] = ["Security"]

else :

env["OPENSSL_FLAGS"] = {}

env["HAVE_SCHANNEL"] = True

# If we're compiling for Windows and OpenSSL isn't being used, use Schannel

env.Append(LIBS = ["secur32"])

openssl_conf.Finish()

#Hunspell

hunspell_env = conf_env.Clone()

hunspell_prefix = env["hunspell"] if isinstance(env.get("hunspell", False), str) else ""

hunspell_conf.Finish()

# Bonjour

if env["PLATFORM"] == "darwin" and env["target"] == "native" :

env["HAVE_BONJOUR"] = 1

elif env.get("bonjour", False) :

bonjour_env = conf_env.Clone()

bonjour_conf = Configure(bonjour_env)

bonjour_flags = {}

bonjour_prefix = env["bonjour"]

bonjour_flags["CPPPATH"] = [os.path.join(bonjour_prefix, "include")]

bonjour_flags["LIBPATH"] = [os.path.join(bonjour_prefix, "lib", "win32")]

bonjour_env.MergeFlags(bonjour_flags)

if bonjour_conf.CheckCHeader("dns_sd.h") and bonjour_conf.CheckLib("dnssd") :

env["HAVE_BONJOUR"] = 1

env["BONJOUR_FLAGS"] = bonjour_flags

env["BONJOUR_FLAGS"]["LIBS"] = ["dnssd"]

bonjour_conf.Finish()

env["DOCBOOK_XSL_DIR"] = env["docbook_xsl"]

################################################################################

# Set up git hooks

################################################################################

try:

if env.Dir("#/.git").exists() :

env.Install("#/.git/hooks", Glob("#/BuildTools/Git/Hooks/*"))

except TypeError:

print "You seem to be using Swift in a Git submodule. Not installing hooks."

################################################################################

# Replace #pragma once with proper guards on platforms that require it

################################################################################

parsers.append("LibXML")

if env.get("HAVE_EXPAT", 0):

parsers.append("Expat")

if env.get("EXPAT_BUNDLED", False) :

parsers.append("(Bundled)")

print " Projects: " + ' '.join(env["PROJECTS"])

print ""

print " XML Parsers: " + ' '.join(parsers)

print

import SCons.Util, os

def generate(env) :

def registerTest(env, target, type = "unit", is_checker = False) :

if env["TEST_TYPE"] == "all" or env["TEST_TYPE"] == type :

params = ""

# Special support for unittest checker

if is_checker and env.get("checker_report", False) :

params = " --xml > " + os.path.join(target[0].dir.path, "checker-report.xml")

ignore_prefix = ""

if env.get("TEST_IGNORE_RESULT", False) :

ignore_prefix = "-"

# Set environment variables for running the test

test_env = env.Clone()

for i in ["HOME", "USERPROFILE", "APPDATA"]:

if os.environ.get(i, "") :

test_env["ENV"][i] = os.environ[i]

elif test_env["PLATFORM"] == "win32" :

test_env["ENV"]["PATH"] = ";".join(map(lambda x : str(x), test_env.get("LIBRUNPATH", []))) + ";" + test_env["ENV"]["PATH"]

# Run the test

if env["target"] == "android":

exec_name = os.path.basename(cmd)

test_env.Command("**dummy**", target, SCons.Action.Action(

["adb shell mount -o rw,remount /system",

"adb shell SWIFT_CLIENTTEST_JID=\"" + os.getenv("SWIFT_CLIENTTEST_JID") + "\" SWIFT_CLIENTTEST_PASS=\"" + os.getenv("SWIFT_CLIENTTEST_PASS") + "\" " + env.get("TEST_RUNNER", "") + "/system/bin/" + exec_name], cmdstr = "$TESTCOMSTR"))

else :

SCons.Action.Action(ignore_prefix + env.get("TEST_RUNNER", "") + cmd + " " + params, cmdstr = "$TESTCOMSTR"))

def registerScriptTests(env, scripts, name, type) :

if env["TEST_TYPE"] == "all" or env["TEST_TYPE"] == type :

pass

env.AddMethod(registerTest, "Test")

env.AddMethod(registerScriptTests, "ScriptTests")

tag = git("describe --tags --exact --match \"" + project + "-*\"", root)

if tag :

return tag.rstrip()[len(project)+1:]

tag = git("describe --tags --match \"" + project + "-*\"", root)

if tag :

m = re.match(project + "-(.*)-(.*)-(.*)", tag)

if m :

return m.group(1) + "-dev" + m.group(2)

return None

def git(cmd, root) :

full_cmd = "git " + cmd

p = subprocess.Popen(full_cmd, cwd=root, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=(os.name != "nt"))

gitVersion = p.stdout.read()

# error = p.stderr.read()

# if error:

# print "Git error: " + error

p.stdin.close()

def getBuildVersion(root, project) :

versionFilename = os.path.join(root, "VERSION." + project)

if os.path.isfile(versionFilename) :

f = open(versionFilename)

version = f.read().strip()

f.close()

return version

if gitVersion :

return gitVersion

return datetime.date.today().strftime("%Y%m%d")

def convertToWindowsVersion(version) :

version_match = re.match("(\d+)\.(\d+)(.*)", version)

major = int(version_match.group(1)) if version_match else 0

minor = int(version_match.group(2)) if version_match else 0

patch = 10000*int(rc_match.group(1))

build_string = rc_match.group(2)

else :

patch = 0

alpha_match = re.match("^alpha(.*)", version_match.group(3))

if alpha_match :

build_string = alpha_match.group(1)

if len(build_string) > 0 :

if build_match :

patch += int(build_match.group(1))

return (major, minor, patch)

Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:

Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.

Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WA RRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

--- END OF SIMPLIFIED BSD LICENSE

===============

Google Breakpad

===============

Copyright (c) 2006, Google Inc.

All rights reserved.

Redistribution and use in source and binary forms, with or without

and installation of the library.

Activities other than copying, distribution and modification are not

covered by this License; they are outside its scope. The act of

running a program using the Library is not restricted, and output from

such a program is covered only if its contents constitute a work based

on the Library (independent of the use of the Library in a tool for

writing it). Whether that is true depends on what the Library does

and what the program that uses the Library does.

1. You may copy and distribute verbatim copies of the Library's

complete source code as you receive it, in any medium, provided that

you conspicuously and appropriately publish on each copy an

appropriate copyright notice and disclaimer of warranty; keep intact

all the notices that refer to this License and to the absence of any

warranty; and distribute a copy of this License along with the

Library.

You may charge a fee for the physical act of transferring a copy,

example_env.Program("EchoBot" + str(i), ["EchoBot" + str(i) + ".cpp"])

example_env.Program("EchoComponent", "EchoComponent.cpp")

# C++0x

cpp0x = False

cpp0x_env = example_env.Clone()

if env["PLATFORM"] == "win32" :

if int(env["MSVS_VERSION"].split(".")[0]) >= 10 :

cpp0x = True

else :

if env["CCVERSION"].split(".") >= ["4", "5", "0"] :

# Temporarily disabling c++0x mode because of problems with boost::thread

# on some platforms

#cpp0x = True

cpp0x_env.Replace(CXXFLAGS = [flag for flag in env["CXXFLAGS"] if flag != "-Werror"])

cpp0x_env.Append(CXXFLAGS = ["-std=c++0x"])

if cpp0x :

cpp0x_env.Program("EchoBot0x", "EchoBot0x.cpp")

# FIXME: Takes the largest match

m = re.match(".*\/* \(\*\) (.*) \*/.*", line)

if m :

cobID = "cob-" + calloutPrefix + "-" + str(nextID)

coID = "co-" + calloutPrefix + "-" + str(nextID)

nextID += 1

line = re.sub("/\*.*\*/", "]]><co id=\"%(cobID)s\" linkends=\"%(coID)s\"/><![CDATA[" % {"cobID" : cobID, "coID" : coID}, line)

calloutLines.append("<callout arearefs=\"%(cobID)s\" id=\"%(coID)s\"><para>%(text)s</para></callout>" % {"cobID": cobID, "coID": coID, "text": m.group(1)})

newProgramLines.append(line)

return ("\n".join(newProgramLines), callouts)

# Parse program

filename = source[0].abspath

filenameBase = os.path.basename(filename).replace(".cpp", "")

inputfile = open(filename)

program = ""

programs = {}

programName = ""

inEllipsis = False

for line in inputfile.readlines() :

Import("env")

if env["TEST"] :

if env["SCONS_STAGE"] == "flags" :

"CPPPATH" : ["#/3rdParty/HippoMocks"],

"LIBS": ["Checker"],

"LIBPATH": [Dir(".")],

}

if env["SCONS_STAGE"] == "build" :

checker_env = env.Clone()

checker_env.UseFlags(env["SWIFTEN_FLAGS"])

checker_env.UseFlags(env["BOOST_FLAGS"])

checker_env.UseFlags(env["CPPUNIT_FLAGS"])

checker_env.Library("Checker", ["checker.cpp", "IO.cpp"])

Import("env")

env["BUILD_SLIMBER"] = True

if env["PLATFORM"] == "win32" :

if not env.get("HAVE_BONJOUR") and "Slimber" in env["PROJECTS"] :

env["PROJECTS"].remove("Slimber")

elif env["PLATFORM"] != "darwin" :

if not env.get("HAVE_AVAHI", False) and "Slimber" in env["PROJECTS"] :

env["PROJECTS"].remove("Slimber")

if not "Slimber" in env["PROJECTS"] and env["SCONS_STAGE"] == "flags" :

print "Bonjour missing. Not building Slimber."

if "Slimber" in env["PROJECTS"] :

################################################################################

# Flags

################################################################################

if env["SCONS_STAGE"] == "flags" :

env["SLIMBER_FLAGS"] = {

"LIBPATH": [Dir(".")],

"LinkLocalPresenceManager.cpp",

"FileVCardCollection.cpp",

"VCardCollection.cpp",

"Server.cpp",

"MainController.cpp",

"MenuletController.cpp",

"Menulet.cpp"

])

env["SLIMBER_VERSION"] = "0.9.9." + datetime.date.today().strftime("%Y%m%d")

env.Append(UNITTEST_SOURCES = [

File("UnitTest/LinkLocalPresenceManagerTest.cpp"),

File("UnitTest/MenuletControllerTest.cpp")

])

SConscript("CLI/SConscript")

if env["PLATFORM"] == "darwin" :

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <SwifTools/Application/UnixApplicationPathProvider.h>

#include <unistd.h>

#include <boost/algorithm/string.hpp>

#include <iostream>

#include <Swiften/Base/String.h>

#include <Swiften/Base/foreach.h>

namespace Swift {

}

boost::filesystem::path UnixApplicationPathProvider::getDataDir() const {

char* xdgDataHome = getenv("XDG_DATA_HOME");

std::string dataDir;

if (xdgDataHome) {

dataDir = std::string(xdgDataHome);

}

: boost::filesystem::path(dataDir)) / boost::to_lower_copy(getApplicationName());

try {

boost::filesystem::create_directories(dataPath);

}

catch (const boost::filesystem::filesystem_error& e) {

std::cerr << "ERROR: " << e.what() << std::endl;

}

return dataPath;

/*

* Copyright (c) 2011 Tobias Markmann

* Licensed under the simplified BSD license.

* See Documentation/Licenses/BSD-simplified.txt for more information.

*/

#pragma once

#include <string>

#include <stack>

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Parser/XMLParserFactory.h>

#include <Swiften/Parser/XMLParserClient.h>

#include <Swiften/Parser/XMLParser.h>

namespace Swift {

/*

* Copyright (c) 2010 Remko Tronçon

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <boost/function.hpp>

#include <list>

#include <deque>

#include <Swiften/Base/API.h>

#include <Swiften/EventLoop/Event.h>

namespace Swift {

class EventOwner;

class SWIFTEN_API EventLoop {

public:

EventLoop();

virtual ~EventLoop();

void postEvent(boost::function<void ()> event, boost::shared_ptr<EventOwner> owner = boost::shared_ptr<EventOwner>());

void removeEventsFromOwner(boost::shared_ptr<EventOwner> owner);

protected:

/**

* Reimplement this to call handleEvent(event) from the thread in which

* the event loop is residing.

*/

virtual void post(const Event& event) = 0;

void handleEvent(const Event& event);

private:

boost::mutex eventsMutex_;

unsigned int nextEventID_;

std::list<Event> events_;

bool handlingEvents_;

std::deque<Event> eventsToHandle_;

};

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#pragma once

#include <Swiften/Base/ByteArray.h>

#include <Swiften/EventLoop/EventLoop.h>

namespace Swift {

class BonjourQuerier;

class BonjourRegisterQuery : public DNSSDRegisterQuery, public BonjourQuery {

BonjourRegisterQuery(const std::string& name, int port, const ByteArray& txtRecord, boost::shared_ptr<BonjourQuerier> querier, EventLoop* eventLoop) : BonjourQuery(querier, eventLoop) {

DNSServiceErrorType result = DNSServiceRegister(

&BonjourRegisterQuery::handleServiceRegisteredStatic, this);

if (result != kDNSServiceErr_NoError) {

sdRef = NULL;

}

}

void registerService() {

if (sdRef) {

run();

#include <Swiften/Network/UnixNetworkEnvironment.h>

namespace Swift {

typedef UnixNetworkEnvironment PlatformNetworkEnvironment;

}

#elif defined(SWIFTEN_PLATFORM_WIN32)

#include <Swiften/Network/WindowsNetworkEnvironment.h>

namespace Swift {

typedef WindowsNetworkEnvironment PlatformNetworkEnvironment;

}

#else

#include <Swiften/Network/UnixNetworkEnvironment.h>

namespace Swift {

typedef UnixNetworkEnvironment PlatformNetworkEnvironment;

}

#endif

sourceList.append("PlatformDomainNameAddressQuery.cpp")

if myenv["PLATFORM"] == "darwin" and myenv["target"] != "android":

myenv.Append(FRAMEWORKS = ["CoreServices", "SystemConfiguration"])

sourceList += [ "MacOSXProxyProvider.cpp" ]

sourceList += [ "UnixNetworkEnvironment.cpp" ]

elif myenv["PLATFORM"] == "win32" :

sourceList += [ "WindowsProxyProvider.cpp" ]

sourceList += [ "WindowsNetworkEnvironment.cpp" ]

else :

sourceList += [ "UnixNetworkEnvironment.cpp" ]

sourceList += [ "UnixProxyProvider.cpp" ]

sourceList += [ "EnvironmentProxyProvider.cpp" ]

if myenv.get("HAVE_GCONF", 0) :

myenv.Append(CPPDEFINES = "HAVE_GCONF")

myenv.MergeFlags(myenv["GCONF_FLAGS"])

sourceList += [ "GConfProxyProvider.cpp" ]

objects = myenv.SwiftenObject(sourceList)

# LibNATPMP classes

if myenv.get("HAVE_LIBNATPMP", False) :

natpmp_env.Append(CPPDEFINES = natpmp_env["LIBNATPMP_FLAGS"].get("INTERNAL_CPPDEFINES", []))

myenv.Append(CPPDEFINES = ["HAVE_LIBNATPMP"])

objects += natpmp_env.SwiftenObject([

"NATPMPInterface.cpp",

])

# LibMINIUPnP classes

if myenv.get("HAVE_LIBMINIUPNPC", False) :

upnp_env = myenv.Clone()

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <boost/bind.hpp>

#include <algorithm>

#include <Swiften/Parser/PayloadParserFactoryCollection.h>

#include <Swiften/Parser/PayloadParserFactory.h>

PayloadParserFactoryCollection::PayloadParserFactoryCollection() : defaultFactory_(NULL) {

}

void PayloadParserFactoryCollection::addFactory(PayloadParserFactory* factory) {

factories_.push_back(factory);

}

void PayloadParserFactoryCollection::removeFactory(PayloadParserFactory* factory) {

}

void PayloadParserFactoryCollection::setDefaultFactory(PayloadParserFactory* factory) {

defaultFactory_ = factory;

}

PayloadParserFactory* PayloadParserFactoryCollection::getPayloadParserFactory(const std::string& element, const std::string& ns, const AttributeMap& attributes) {

std::vector<PayloadParserFactory*>::reverse_iterator i = std::find_if(

boost::bind(&PayloadParserFactory::canParse, _1, element, ns, attributes));

return (i != factories_.rend() ? *i : defaultFactory_);

}

}

#include <Swiften/Base/API.h>

#include <Swiften/Roster/XMPPRoster.h>

namespace Swift {

class SWIFTEN_API XMPPRosterImpl : public XMPPRoster {

public:

XMPPRosterImpl();

void removeContact(const JID& jid);

void clear();

bool containsJID(const JID& jid);

RosterItemPayload::Subscription getSubscriptionStateForJID(const JID& jid);

std::string getNameForJID(const JID& jid) const;

std::vector<std::string> getGroupsForJID(const JID& jid);

virtual std::vector<XMPPRosterItem> getItems() const;

/*

* Licensed under the GNU General Public License v3.

* See Documentation/Licenses/GPLv3.txt for more information.

*/

#include <boost/bind.hpp>

#include <algorithm>

#include <Swiften/Serializer/PayloadSerializerCollection.h>

#include <Swiften/Serializer/PayloadSerializer.h>

PayloadSerializerCollection::PayloadSerializerCollection() {

}

void PayloadSerializerCollection::addSerializer(PayloadSerializer* serializer) {

serializers_.push_back(serializer);

}

void PayloadSerializerCollection::removeSerializer(PayloadSerializer* serializer) {

}

PayloadSerializer* PayloadSerializerCollection::getPayloadSerializer(boost::shared_ptr<Payload> payload) const {

std::vector<PayloadSerializer*>::const_iterator i = std::find_if(

boost::bind(&PayloadSerializer::canSerialize, _1, payload));

return (i != serializers_.end() ? *i : NULL);

}

}

#include <Swiften/StreamStack/WhitespacePingLayer.h>

#include <Swiften/StreamStack/CompressionLayer.h>

#include <Swiften/StreamStack/TLSLayer.h>

#include <Swiften/TLS/TLSContextFactory.h>

#include <Swiften/TLS/TLSContext.h>

namespace Swift {

BasicSessionStream::BasicSessionStream(

TimerFactory* timerFactory,

XMLParserFactory* xmlParserFactory) :

compressionLayer(NULL),

tlsLayer(NULL),

whitespacePingLayer(NULL) {

xmppLayer = new XMPPLayer(payloadParserFactories, payloadSerializers, xmlParserFactory, streamType);

xmppLayer->onStreamStart.connect(boost::bind(&BasicSessionStream::handleStreamStartReceived, this, _1));

xmppLayer->onElement.connect(boost::bind(&BasicSessionStream::handleElementReceived, this, _1));

xmppLayer->onError.connect(boost::bind(&BasicSessionStream::handleXMPPError, this));

xmppLayer->onDataRead.connect(boost::bind(&BasicSessionStream::handleDataRead, this, _1));

xmppLayer->onWriteData.connect(boost::bind(&BasicSessionStream::handleDataWritten, this, _1));

streamStack = new StreamStack(xmppLayer, connectionLayer);

available = true;

}

BasicSessionStream::~BasicSessionStream() {

delete compressionLayer;

if (tlsLayer) {

tlsLayer->onConnected.disconnect(boost::bind(&BasicSessionStream::handleTLSConnected, this));

delete tlsLayer;

}

delete whitespacePingLayer;

delete streamStack;

connection->onDisconnected.disconnect(boost::bind(&BasicSessionStream::handleConnectionFinished, this, _1));

delete connectionLayer;