Hello

int DownloadSingleFile(const char* server, const char* path);
int DownloadAllFiles(const char* server, const char* files[], int n)
{
	int totalBytes = 0;

	Semaphore lock = 1;
	Semaphore childrenDone = 0;

	for (int i=0; i < n; ++i)
	{
		ThreadNew("DownloadSingleFile", DownloadSingleFile, 4, server, files[i], &
		totalBytes, lock, childrenDone);
	}
	for (int i=0; i < n; ++i)
	{
		// wait return.
		SemaphoreWait(childrenDone);
	}

	return totalBytes;
}

void DownloadHelper(const char* server, const char* path, 
	int* returnButes, Semaphore lock, Semaphore parentToSignal)
{
	int bytesDownloaded = DownloadSingleFile(server, path);
	SemaphoreWait(lock);
	*numBytes += bytesDownloaded;
	SemaphoreSignal(lock);
	SemaphoreSignal(parentToSignal);
}

Semaphore forks[5] = {1, 1, 1, 1, 1}
Semaphore numAllowedToEat(4); // 최소한 한명은 Idle. DeadLock 피함.

void Philosopher(int id)
{
	for (int i=0; i < 3; ++i) 
	{
		Think();
		SemaphoreWait( numAllowedToEat );
		SemaphoreWait( forks[ id ] );
		SemaphoreWait( forks[ (i+1)%5 ] );
		Eat();
		SemaphoreSignal( forks[ id ] );
		SemaphoreSignal( forks[ (id+1)%5 ] );
		SemaphoreSignal( numAllowedToEat );
	}
}

char buffer[8];
Semaphore emptyBuffers(8);
Semaphore fullBuffers(0);

int main()
{
	ThreadNew("Writer", Writer, 0);
	ThreadNew("Reader", Reader, 0);
	RunAllThread();
}

void Writer()
{
	for (int i=0; i < 40; ++i)
	{
		char c = PrepareRandomChar();
		SemaphoreWait(emptyBuffers);
		buffer[ i%f ] = c;
		SemaphoreSignal(fullBuffers);
	}
}

void Reader()
{
	for (int i=0; i < 40; ++i)
	{
		SemaphoreWait(fullBuffers);
		char c = buffer[ i%f ];
		ProcessChar(c);
		SemaphoreSignal(emptyBuffers);
	}
}

void* vptr() { return * reinterpret_cast<void**>(this); }

결국 vptr()을 통해서 해당 virtual function에 직접 access 가능 하다.

실제 사용은,

// ...
if (value.isCell() && (value.asCell()->vptr() == globaData.jsFunctionVPtr)
// ...
struct VPtrSet {
    VPtrSet();
    
    void* jsArrayVPtr;
    void* jsByteArrayVPtr;
    void* jsStringVPtr;
    void* jsFunctionVPtr;
};

요렇게 쓰인다.

<location /svn/<project>>
	  DAV svn
	  SVNPath /var/svn/<project>
	  #SVNParentPath /var/svn
	  AuthType Basic
	  AuthName "Subversion Repository"
	  AuthUserFile /var/trac/<project>/passwd

	  <limitexcept get="" propfind="" options="" report="">
	  	       Require valid-user
	  </limitexcept>
</location>

<Location /trac/<project>>
	SetHandler mod_python
	PythonHandler trac.web.modpython_frontend
	PythonOption TracEnvParentDir /var/trac/<project>
	
	PythonOption TracEnv /var/trac/<project>
	PythonOption TracUriRoot /trac/<project>

	AuthType Basic
	AuthName "Repository"
	AuthUserFile /var/trac/<project>/passwd
	Require valid-user
</Location>

#<Location /trac/*/login>
<Location /trac/<project>/login>
	AuthType Basic
	AuthName "Repository"
	AuthUserFile /var/trac/<project>/passwd
	Require valid-user
</Location>

// tunable parameters
template<size_t bytesPerWord> struct CellSize;

// cell size needs to be a power of two for certain optimizations in collector.cpp
template<> struct CellSize<sizeof(uint32_t)> { static const size_t m_value = 64; };
template<> struct CellSize<sizeof(uint64_t)> { static const size_t m_value = 64; };

const size_t MINIMUM_CELL_SIZE = CellSize<sizeof(void*)>::m_value;
const size_t CELL_ARRAY_LENGTH = (MINIMUM_CELL_SIZE / sizeof(double)) + \
	(MINIMUM_CELL_SIZE % sizeof(double) != 0 ? sizeof(double) : 0);
const size_t CELL_SIZE = CELL_ARRAY_LENGTH * sizeof(double);

#define COMPILE_ASSERT(exp, name) typedef int dummy##name [(exp) ? 1 : -1]
#define ASSERT_CLASS_FITS_IN_CELL(class) \
	COMPILE_ASSERT(sizeof(class) <= CELL_SIZE, class_fits_in_cell)

  
static inline unsigned int generic_hweight32(unsigned int w)
{
    unsigned int res = (w & 0x55555555) + ((w >> 1) & 0x55555555);
    res = (res & 0x33333333) + ((res >> 2) & 0x33333333);
    res = (res & 0x0F0F0F0F) + ((res >> 4) & 0x0F0F0F0F);
    res = (res & 0x00FF00FF) + ((res >> 8) & 0x00FF00FF);
    return (res & 0x0000FFFF) + ((res >> 16) & 0x0000FFFF);
}

static inline unsigned int generic_hweight16(unsigned int w)
{
    unsigned int res = (w & 0x5555) + ((w >> 1) & 0x5555);
    res = (res & 0x3333) + ((res >> 2) & 0x3333);
    res = (res & 0x0F0F) + ((res >> 4) & 0x0F0F);
    return (res & 0x00FF) + ((res >> 8) & 0x00FF);
}

static inline unsigned int generic_hweight8(unsigned int w)
{
    unsigned int res = (w & 0x55) + ((w >> 1) & 0x55);
    res = (res & 0x33) + ((res >> 2) & 0x33);
    return (res & 0x0F) + ((res >> 4) & 0x0F);
}

static inline unsigned long generic_hweight64(__u64 w)
{
#if BITS_PER_LONG < 64
    return generic_hweight32((unsigned int)(w >> 32)) +
        generic_hweight32((unsigned int)w);
#else
    u64 res;
    res = (w & 0x5555555555555555ul) + ((w >> 1) & 0x5555555555555555ul);
    res = (res & 0x3333333333333333ul) + ((res >> 2) & 0x3333333333333333ul);
    res = (res & 0x0F0F0F0F0F0F0F0Ful) + ((res >> 4) & 0x0F0F0F0F0F0F0F0Ful);
    res = (res & 0x00FF00FF00FF00FFul) + ((res >> 8) & 0x00FF00FF00FF00FFul);
    res = (res & 0x0000FFFF0000FFFFul) + ((res >> 16) & 0x0000FFFF0000FFFFul);
    return (res & 0x00000000FFFFFFFFul) + ((res >> 32) & 0x00000000FFFFFFFFul);
#endif
}

#define FOR_EACH_OPCODE_ID(macro) \
    macro(op_enter, 1) \
    macro(op_enter_with_activation, 2)	\
    macro(op_init_arguments, 1) \
    macro(op_create_arguments, 1) \
    macro(op_convert_this, 2) \
    \
    macro(op_new_object, 2) \
    macro(op_new_array, 4) \
    macro(op_new_regexp, 3) \
    macro(op_mov, 3) \
    \
    macro(op_end, 2)

#define OPCODE_ID_ENUM(opcode, length) opcode,
typedef enum { FOR_EACH_OPCODE_ID(OPCODE_ID_ENUM) } OpcodeID;
#undef OPCODE_ID_ENUM

const int numOpcodeIDs = op_end + 1;

#define OPCODE_ID_LENGTHS(id, length) const int id##_length = length;
FOR_EACH_OPCODE_ID(OPCODE_ID_LENGTHS);
#undef OPCODE_ID_LENGTHS
    
#define OPCODE_LENGTH(opcode) opcode##_length

#define OPCODE_ID_LENGTH_MAP(opcode, length) length,
const int opcodeLengths[numOpcodeIDs] = {FOR_EACH_OPCODE_ID(OPCODE_ID_LENGTH_MAP)};
#undef OPCODE_ID_LENGTH_MAP

typedef enum {
    op_enter,
    op_enter_with_activation,
    op_init_arguments,
    op_create_arguments,
    op_convert_this,
    op_new_object,
    op_new_array,
    op_new_regexp,
    op_mov,
    op_end,
} OpcodeID;


const int numOpcodeIDs = op_end + 1;


const int op_enter_length = 1;
const int op_enter_with_activation_length = 2;
const int op_init_arguments_length = 1;
const int op_create_arguments_length = 1;
const int op_convert_this_length = 2;
const int op_new_object_length = 2;
const int op_new_array_length = 4;
const int op_new_regexp_length = 3;
const int op_mov_length = 3;
const int op_end_length = 2;


const int opcodeLengths[numOpcodeIDs] = { 1, 2, 1, 1, 2, 2, 4, 3, 3, 2, };

do
{
	result = false;

	...

	if ( result = foo() )
		break;
	...

	if ( result = bar() )
		break;
	
	...
} while (0);

if (false == result)
{
	...
}

if ( result = foo() )
	goto FAILED;

...

if ( result = basr() )	
	goto FAILED;

...

FAILED :
	...

if (  )
{
	if (  )
	{
		if (  )
		{
			if (  )
			{
				...
			}
		}
	}
}

do {
	if (!  )
	{
		break;
	}

	if (!  )
	{
		break;
	}

	if (!  )
	{
		break;
	}

	if (!  )
	{
		break;
	}
} while(0);

class X
{
	// ...
	X(Sometype);	// constructor : create objects
	X(const X&);	// copy constructor
	X& operator=(const X&) // copy assignment : cleanup and copy
	~X()	// destructor : cleanup
};

  
#include <iostream>
using namespace std;

class Sample
{
public:
	Sample(int e);
	Sample(const Sample&);
	Sample& operator=(const Sample&);
	~Sample();

private:
	int _elem;
};

Sample::Sample(int e) : _elem(e)
{
	cout << "Constructor : " << this << endl;
}

Sample::Sample(const Sample& s)
{
	cout << "Copy constructor : " << this << endl;

	_elem = s._elem;
}

Sample& Sample::operator=(const Sample& s)
{
	cout << "Copy assignment : " << this << endl;

	_elem = s._elem;
	return *this;
}

Sample::~Sample()
{
	cout << "Destructor : " << this << endl;
}

Sample g(Sample s)
{
	return s;
}

int main(void)
{
	Sample s(1);
	s = g(s);
	return 0;
}

  
#include <iostream>
using namespace std;

class Command
{
public:
	virtual void Execute() = 0;
};

template <class Receiver>
class SimpleCommand : public Command
{
public:
	typedef void (Receiver::*Action) ();

	SimpleCommand(Receiver* r, Action a) : _receiver(r), _action(a) {}
	virtual void Execute();

private:
	Action _action;
	Receiver* _receiver;
};

template<class Receiver>
void SimpleCommand<Receiver>::Execute()
{
	(_receiver->*_action)();
}


class MyClass
{
public:
	MyClass() {}
	MyClass(const MyClass &) {}
	MyClass(const MyClass *) {}
	void MyAction() { cout << "MyClass Action\n"; }
};

int main(void)
{
	MyClass* receiver = new MyClass;
	Command* aCommand = new SimpleCommand<MyClass>(receiver, &MyClass::MyAction);
	aCommand->Execute();
}

#define offsetofclass(base, derived) \
((DWORD_PTR)(static_cast<base*>((derived*)_ATL_PACKING))  -  _ATL_PACKING))

_AFXWIN_INLINE HWND CWnd::GetSafeHwnd() const
	{ return this == NULL ? NULL : m_hWnd; }

#define offset(s, m) \
(size_t)&reinterpret_cast<const volatile char&>((((s *)0)->m));

class A
{
public:
	class X
	{
	public:
		void callAVtFunc();
	} m_x;

	virtual void VtFunc() { std::cout << "OK\n"; }
};

void A::X::callAVtFunc()
{
	A* a = ((A*)((char*)this - offsetof(A, m_x)));
	a->VtFunc();
}

int main(void)
{
	A a;
	a.m_x.callAVtFunc();

	return 0;
}

M-x replace-string C-q C-m RET