A gentle introduction to Template Metaprogramming with C++

• Download demo project - 65 Kb

Background

A while ago I was working on a program that used a large lookup table to do some computations. The contents of the table depended on a large number of parameters that I had to tweak to get optimal performance from my code. And every time I changed one parameter the whole table had to be recalculated...

I had written a function that dumped the content of the table to standard output. That way I could compile my program with the new parameters set, cut-and-paste the table from screen and into my source code and finally recompile the whole project. I didn't mind doing that - the first twenty times. After that I figured there had to be a better way. There was. Enter Template Metaprogramming.

What is Template Metaprogramming (TMP)

Template Metaprogramming is a generic programming technique that uses extremely early binding. The compiler acts as an interpreter or a "virtual computer" that emits the instructions that make up the final program. It can be used for static configuration, adaptive programs, optimization and much more.



In this article I intend to explain how to use C++ template classes to produce compile-time generated code.

Different kind of Metatemplates

I make a difference between two kinds on Metatemplates - ones that calculate a constant value and ones that produce code. The difference is that the first kind should never produce instructions that are executed at runtime.

Templates that calculate a value

Assume you want to calculate the number of bits set in an byte. If you do this at runtime you might have a function looking like this:

int bits_set(unsigned char byte)
{int count = 0;
 for (int i = 0; i < 8; i++)
    if ( (0x1L << i) & byte ) 
        count++;
 
 return count;
}

In cases where the byte is known at compile time this can also be done by the compiler, using TMP:

template< unsigned char byte > class BITS_SET
{
public:
    enum {
     B0 = (byte & 0x01) ? 1:0,
     B1 = (byte & 0x02) ? 1:0,
     B2 = (byte & 0x04) ? 1:0,
     B3 = (byte & 0x08) ? 1:0,
     B4 = (byte & 0x10) ? 1:0,
     B5 = (byte & 0x20) ? 1:0,
     B6 = (byte & 0x40) ? 1:0,
     B7 = (byte & 0x80) ? 1:0
    };
public:
 enum{RESULT = B0+B1+B2+B3+B4+B5+B6+B7};
};

I have used an enum for the temporary variables as well as for the result since they are easier to use and enumerators have the type of const int. Another way would be to use static const int:s in the class instead.

You can now use BITS_SET<15>::RESULT and get the constant 4 in your code. In this case the compiler evaluate the line enum{RESULT = B0+B1+B2+B3+B4+B5+B6+B7}; to enum{RESULT = 1+1+1+1+0+0+0+0}; and finally to enum{RESULT = 4};.

It is also possible to calculate a value using a loop. With TMP we rely on recursion within the template definition. The following code is a compile-time factorial calculator:

template< int i >
class FACTOR{
  public:
      enum {RESULT = i * FACTOR<I-1>::RESULT};
};

class FACTOR< 1 >{
  public:
      enum {RESULT = 1};
};

If we for example write this:

int j = FACTOR< 5 >::RESULT;

somewhere in our code the compiler will generate something like the following line of assembler code:

; int j = FACTOR< 5 >::RESULT;

mov    DWORD PTR _j$[ebp], 120            ; 00000078H - a constant value!

How does this work? As we instantiate FACTOR<5> the definition of this class depends on FACTOR<4>, which in turn depend on FACTOR<3> and so on. The compiler needs to create all these classes until the template specialization FACTOR<1> is reached. This means the entire recursion is done by the compiler, while the final program just contain a constant.

Templates that unroll loops/specialize functions

Template metaprograms can generate useful code when interpreted by the compiler, for example a massively inlined algorithm that has its loops unrolled. The result is usually a large speed increase in the application.

For example, look at the following code that calculates the sum of the numbers 1..1000:

int sum = 0;
for (int i = 1 ; i <= 1000; i++)
     sum += i;

We are actually performing 2000 additions, rather than 1000 (as we have to increment i by one for each loop). In addition we perform a thousand test operations on the variable i. Another way would be to write the code the following way:

int sum = 0;
sum += 1;
sum += 2;
...
sum += 1000;

This is the way a Template Metaprogram would expand a loop. Now we perform exactly a thousand additions, but this method also has a prize. The code size increase, meaning that we theoretically could take a performance hit by increasing the number of page faults. In practice, though, code is often invoked multiple times and already loaded in cache.

Loop unrolling

Loop unrolling is easily defined using recursive templates, similar to calculating a value:

template< int i >
class LOOP{
  public:
    static inline void EXEC(){
      cout << "A-" << i << " ";
            LOOP< i-1 >::EXEC();
       cout << "B-" << i << " ";
    }
};

class LOOP< 0 >{
  public:
    static inline void EXEC(){
      cout << "A-" << i;
      cout << "\n"; 
       cout << "B-" << i;
    }
};

The output of LOOP< 8 >::EXEC() is shown below:

A-8 A-7 A-6 A-5 A-4 A-3 A-2 A-1 A-0
B-0 B-1 B-2 B-3 B-4 B-5 B-6 B-7 B-8

Again, the thing to notice is that there is no loop in the resulting binary code. The loop unrolls itself to produce code like:

cout << "A-" << 8 << " ";
cout << "A-" << 7 << " ";
...
cout << "A-" << 0;
cout << "\n"; 
cout << "B-" << 0;
...
cout << "B-" << 7 << " ";
cout << "B-" << 8 << " ";

An unrelated, but interesting thing can be found in class LOOP< 0 >. Look at how LOOP< 0 >::EXEC() uses i. This identifier has been declared in the template LOOP< int i >, but is still accessible from the "special case" LOOP< 0 >. I don't know if this is standard C++ behavior, however.

Beside loops other statements can be constructed:

IF - statement

template< bool Condition >
class IF {
public:
    static inline void EXEC(){
    cout << "Statement is true";
    }
};

class IF< false > {
public:
    static inline void EXEC(){
    cout << "Statement is false";
    }
};

 

SWITCH - statement

template< int _case >
class SWITCH {
public:
    static inline void EXEC(){
        cout << " SWITCH - default ";
    }
};

class SWITCH< 1 > {
    public:
    static inline void EXEC(){
        cout << " SWITCH - 1 ";
    }
};

class SWITCH< 2 > {
    public:
    static inline void EXEC(){
        cout << " SWITCH - 2 ";
    }
};

...

Example of usage of the two classes:

SWITCH< 2 > myTwoSwitch; // store for delayed execution

myTwoSwitch.EXEC();
IF< false >::EXEC();
myTwoSwitch.EXEC();

The output will be: " SWITCH - 2 Statement is false SWITCH - 2 "

Using Meta-Metatemplates

It is possible to define a generic template for a special kind of operation, like an if- or for-statement. I like to call this a Meta-Metatemplate since the operation is defined in a class outside the template itself. Even if this might be useful it can make the code very hard to understand in complex cases. Also it will probably take a few years before compilers will be able to take full advantage of these kinds of constructs. For now I prefer to use specialized templates, but for simple cases Meta-Metatemplates might be useful. Sample code for the simplest of these constructs, the if-statement is given below:

template< bool Condition, class THEN, class ELSE > struct IF
{
    template< bool Condition > struct selector
    {typedef THEN SELECT_CLASS;}; 
 
    struct selector< false >
    {typedef ELSE SELECT_CLASS;};     

 typedef selector< Condition >::SELECT_CLASS RESULT;
};

Example of usage:

struct THEN
{
 static int func() 
 {cout << "Inside THEN";
  return 42;
 }
};

struct ELSE
{
 static int func() 
 {cout << "Inside ELSE";
  return 0;
 }
};

int main(int argc, char* argv[])
{
 int result = IF< 4 == sizeof(int), THEN, ELSE >::RESULT::func();
 cout << " - returning: " << result;
}

On 32-bit architectures this will print "Inside THEN - returning: 42" to standard output. Note that if func() was not defined inside ELSE this would be a simple compile-time assert breaking compilation on 4 != sizeof(int).

A real world example

Included as a sample is a small class that does generic CRC (Cyclic Redundancy Codes - a set of simple hash algorithms) calculations. The class uses a set of parameters that are #define:d at the top of the header. The main reason I chose CRC for this article is that the CRC algorithms usually use a lookup table based on a set of parameters, making the example somewhat similar to my original problem.

The class generate a lookup table with 256 entries at compile time. The implementation is pretty straightforward, and I hope that the comments in the source is enough to explain usage of the class. In some cases I have used macros where TMP would have been a possible solution. The reason for this is readability, an important factor when choosing which technique to use.
If you want a further explanation of CRC algorithms, I suggest reading Ross N. Williams "A PAINLESS GUIDE TO CRC ERROR DETECTION ALGORITHMS". I have included a verbatim copy of the text in the sample.

One thing to remember when compiling this is that the source is using a lot of compiler heap memory. I had to increase the memory allocation limit by using the compiler option '/Zm400'. This is one drawback of TMP - it really pushes the compiler to the limit.

Coding conventions

The compiler doesn't like being abused as described above. Not a bit. And it will put up a struggle. Warnings and errors will range from cryptic to C1001 - INTERNAL COMPILER ERROR. And you can't debug a Metatemplate program like a runtime program.

For those reasons using well defined coding conventions is more important with TMP than with other programming techniques. Below I give some rules that I've found useful.

General suggestions

As template metaprograms are somewhat similar to macros I prefer to give all TMP classes uppercase names. Also try to make the name as descriptive as possible. The main reason for this is that public variables/functions usually have non-descriptive names (see below). A TMP class is the one defining the operation, not the member functions/variables.

Also try to limit a TMP class to a single operation. Template Metaprogramming is challenging enough without trying to generalize the class to support multiple operations. Often this will only result in code bloat.

Variable/functions names

I usually prefer to have only one of two possible public operations defined in a TMP class:

• RESULT for templates that calculate a value
• EXEC() for loop unrolling/function simplification.

Usually one function or one member variable is the only thing the Template Metaprogram needs to expose to the programmer. It makes sense to give the type of operation a single name for all possible classes. Another advantage is that you can look at a template class and immediately see if it is a Template Metaprogram or an ordinary template class.

Should I use TMP in my program?

Template Metaprogramming is a great technique when used correctly. On the other hand it might result in code bloat and performance decrease. Below are some rules of thumb when to use TMP.

Use TMP when:

• A macro is not enough. You need something more complex than a macro, and you need it expanded before compiled.
• Using recursive function with a predetermined number of loops. In this case the overhead of function calls and setting up stack variables can be avoided and runtime will significantly decrease.
• Using loops that can be unrolled at compile time. For example hash-algorithms like MD5 and SHA1 contains well-defined block processing loops that can be unrolled with TMP.
• When calculating constant values. If you have constants that depend on other constants in your program, they might be a candidate for TMP.
• When the program should be portable to other platforms. In this case TMP might be an alternative to macros.

Don't use TMP when:

• When a macro will do. In most cases a macro will be enough. And a macro is often easier to understand than TMP.
• You want a small executable. Templates in general, and TMP in particular will in often increase the code size.
• Your program already takes a long time to compile. TMP might significantly increase compile time.
• You are on a strict deadline. As noted above the complier will be very unfriendly when working with Template Metaprograms. Unless the changes you intend to make are very simple, you might want to save yourself a few hours of banging your head in the wall.

Acknowledgements and references

1. Thanks to Joaqu�n M L�pez Mu�oz for introducing me to TMP.
2. Ross N. Williams has written a great tutorial on CRC algorithms: "A PAINLESS GUIDE TO CRC ERROR DETECTION ALGORITHMS". I have included a verbatim copy in the sample (zip-ball?) above.

You must Sign In to use this message board.

FAQ    Noise Tolerance Very HighHighMediumLowVery Low   Layout Expand Posts & RepliesThread ViewNo JavascriptNo JS + Preview   Per page 102550

Msgs 1 to 25 of 36 (Total in Forum: 36) (Refresh) FirstPrevNext

Good one !!!! ccpptrain 18:55 29 Apr '08   nice introduction to TMP. hope to see some more examples on TMP. Sign In·View Thread·PermaLink TMP is explicit Partial Evaluation Vasian Cepa 1:22 27 Nov '06   There are always one or more nice tricks to learn, or refresh about the C++ template dark sides, every time you read such an article . A reference book with more information on this topic is: Generative Programming: Methods, Tools, and Applications, Addison-Wesley Professional, 2000, ISBN: 0201309777, by Krzysztof Czarnecki, Ulrich Eisenecker. The chapter 10 of this book, on template meta-programming, is written by Ulrich Eisenecker. The TMP goes against the idea of an optimizing compiler. If I write a function to calculate the factorial of a number, as a normal C++ function, and call it in code as factorial(5), then I would expect a good optimizing C/C++ compiler to replace it with the constant 120 in the final generated code. If the compiler does not, then it must be improved . The technique behind TMP, or such compiler optimizations is known more generally as partial evaluation. The partial evaluation is preferably done by the compiler, so that programmer does not have to care, this is why the compiler is for. Partial evaluation applies also not only to code that produces constants, but also to code block reduction when some of the inputs are known. With TMP you can do partial evaluation, but it is not transparent, and hence not so convenient. TMP is a nice technique to demonstrate what can be done, but apart of this are few areas where the technique can useful, when an good optimizing compiler is available (e.g, template hoisting - but this is also needed because most compilers cannot properly factor automatically the template generated code). With better compilers, theoretically, there is not much need for TMP. Sign In·View Thread·PermaLink Is there a version that compiles on VC7? pmackell 15:20 7 Apr '06   Thanks. Sign In·View Thread·PermaLink Re: Is there a version that compiles on VC7? Amir Ebrahimi 10:44 3 May '06   Although some people said below that you can compile this under VC7.1 I still get an Internal Compiler Error. Any suggetsions? Sign In·View Thread·PermaLink compile time loops :(, plz help. Mohammed Hossny 2:22 13 Oct '03   i m trying to make use of compile time looping. But an error came out. Any ideas . in the following code segment, how can i pass a parameter in init . Code Segment: template class loop { public: static void EXEC(){looponce::EXEC();} template class looponce { public: static void EXEC(){cout<<N<<endl; looponce::EXEC();} }; class looponce { public: static void EXEC(){cout<<init<<endl;} }; }; Error Message: D:\My Documents\My Projects\tmpdemo\main.cpp(35) : error C2011: 'looponce<`template-parameter513'>' : 'class' type redefinition D:\My Documents\My Projects\tmpdemo\main.cpp(40) : see reference to class template instantiation 'loop' being compiled thx alot. Yours, M. Hossny Sign In·View Thread·PermaLink Re: compile time loops :(, plz help. moliate 9:14 13 Oct '03   The problem is that you try to assign a dynamic value to a template specialization. The compiler will not see a difference between looponce<N> and looponce<init> and dismiss the code as a type redefinition. To solve this I suggest you rewrite your class something like this: template<unsigned long init, unsigned long step, unsigned long end> class loop { public: static void EXEC() {looponce<init-end>::EXEC();} template<unsigned long N> class looponce {public: static void EXEC(){cout<<N+end<<endl; looponce<N-step>::EXEC();} }; class looponce<0> {public: static void EXEC() {cout<<end<<endl;} }; }; Now looponce will use a well defined endpoint for the recursion at 0. Note, however, that a call to loop<8,2,3>::EXEC() will end up in an infinite loop since you will never reach 0. The same problem existed in the original code. Regards # moliate The corners of my eyes catch hasty, bloodless motion - a mouse? Well, certainly a peripheral of some kind. Neil Gaiman - Cold Colours Sign In·View Thread·PermaLink Re: compile time loops :(, plz help. Anonymous 3:06 15 Oct '03   thx alot my friend. do u ve any good links about TMP programming a tricks . thx again for time . salam Sign In·View Thread·PermaLink Re: compile time loops :(, plz help. moliate 8:03 16 Oct '03   Anonymous wrote: do u ve any good links about TMP programming a tricks . Below are some links that may be of interest: Template Metaprograms, Todd Veldhuizen[^] C++ Templates: Metaprograms[^] C++ Tips: Templates[^] Regards # moliate The corners of my eyes catch hasty, bloodless motion - a mouse? Well, certainly a peripheral of some kind. Neil Gaiman - Cold Colours Sign In·View Thread·PermaLink something similar ... monty page 5:44 19 Mar '03   the following works on my Macintosh under CodeWarrior, but does not compile on my PC with Visual C++, any ideas? template // multi-dimensional array class nArray { public : nArray *array; // various allocators, operators, etc. }; template <1, class DaType> // one-dimensional array class nArray { public : DaType *array; // various stuff ... }; note that the simpler class works on the PC : template class Fibonacci { public: enum { value = Fibonacci::value + Fibonacci::value }; }; class Fibonacci<1> { public: enum { value = 1 }; }; class Fibonacci<0> { public: enum { value = 0 }; }; the problem is in going from 2 template arguments to 1. Of course, none of the unix compilers can handle either one. Sign In·View Thread·PermaLink Re: something similar ... monty page 5:48 19 Mar '03   the damn message board lost the template arguments to the main classes : int N, class DaType for some reason you can't put the brackets around them sorry ... Sign In·View Thread·PermaLink Re: something similar ... Daniel Turini 5:53 19 Mar '03   Next time, check the "Display this message as-is (no HTML)" when posting a message, otherwise templates will become HTML tags. It's not the fall that kills you: it's the sudden stop - Down by Law, Jim Jamursch (1986) Sign In·View Thread·PermaLink Re: something similar ... monty page 7:40 19 Mar '03   I saw the workaround for VC7 below, but the function I wanted to implement was as follows: template class nArray { public: nArray *array; nArray &operator [] (int i) { return array[i]; } // with appropriate bounds checking }; class nArray<1, class DaType> { public: DaType *array; DaType &operator [] (int i) { return array[i]; } }; I couldn't figure out how to do that with the nested inner classes. Sign In·View Thread·PermaLink Re: something similar ... moliate 6:27 19 Mar '03   monty page wrote: template <1, class DaType> // one-dimensional array Visual C++ does not have partial template specialization yet. Next version (Visual Studio .NET 2003) will support PTS as well as other template improvements. Until the release you have to use some kind of workaround. One example is using internal classes like in the second IF-class in the article. [edit] GCC should be able to handle PTS on Unix/Linux. Look here[^] for the latest version. [/edit] Cheers /moliate The corners of my eyes catch hasty, bloodless motion - a mouse? Well, certainly a peripheral of some kind. Neil Gaiman - Cold Colours Sign In·View Thread·PermaLink Re: something similar ... monty page 7:45 19 Mar '03   thanks for the help guys.   its not really killing me now, i can make special arrays for each dimension i need, its just that it fell into the "i really ought to be able to do this" category. Sign In·View Thread·PermaLink Great Article joncaves 7:37 11 Mar '03   It's great to see template meta-programming really starting to be used in the real-world. I do though have to point out a couple of typos in the examples. The following code template< int i > class FACTOR{ public: enum {RESULT = i * FACTOR::RESULT}; }; should be: template< int i > class FACTOR{ public: enum {RESULT = i * FACTOR<i - 1>::RESULT}; }; (Actually this one might just be an HTML formatting problem -- TMP and HTML do not mix well) Also: template< bool Condition, class Then, class Else > struct IF { template< bool Condition > struct selector {typedef THEN SELECT_CLASS;}; struct selector< false > {typedef ELSE SELECT_CLASS;}; typedef selector< Condition >::SELECT_CLASS RESULT; }; Should be: template< bool Condition, class THEN, class ELSE > struct IF { template< bool Condition > struct selector {typedef THEN SELECT_CLASS;}; template<> struct selector< false > {typedef ELSE SELECT_CLASS;}; typedef selector< Condition >::SELECT_CLASS RESULT; }; Personally I would prefer: template< bool Condition, class Then, class Else > struct IF { template< bool Condition > struct selector; template<> struct selector< true > {typedef THEN SELECT_CLASS;}; template<> struct selector< false > {typedef ELSE SELECT_CLASS;}; typedef selector< Condition >::SELECT_CLASS RESULT; }; I find it makes the code just that bit clearer. As for performance: for the upcoming Visual Studio .NET 2003 "Everett" release we did do some work to improve the performance of the compiler when dealing with TMP -- we also did work to ensure that the code we eventually generate is as optimal as possible. I know that in general I don't mind a slow compiler -- if the result is extremely fast code. Compiler throughput (especially when dealing with templates) is something we will contiune to work on in future releases. Using templates in Visual C++ should not in general result in significantly increased code size -- the work we have done in the linker to support the merging of instantiations of function templates that generate identical code really helps to reduce code bloat. JonCaves Sign In·View Thread·PermaLink 5.00/5 (1 vote) Re: Great Article moliate 7:48 14 Mar '03   joncaves wrote: I do though have to point out a couple of typos in the examples. Thanks! I'll fix those. Nice to get some response from a representative of the VS team. I'm very eager to try out Visual Studio .NET 2003. I've come to understand that with the release of this version Microsoft will provide one of the most standard-compliant C++ compilers in existance. /moliate The corners of my eyes catch hasty, bloodless motion - a mouse? Well, certainly a peripheral of some kind. Neil Gaiman - Cold Colours Sign In·View Thread·PermaLink Cool Anthony_Yio 23:09 10 Mar '03   Feeling like reading some underground stuff. Like viruses, hacking etc. Sign In·View Thread·PermaLink HTML bytes templates Pierre Arnaud 22:43 10 Mar '03   Your example of the recursive FACTOR template contains a display problem;P. If you look at the HTML source, you'll see the proper recursion using FACTOR<I-1>::RESULT; however, what is being displayed in my browser is FACTOR::RESULT (the <I-1> being eaten as an unknown HTML tag)... Sign In·View Thread·PermaLink VC7 Workaround Peter Hancock 15:33 8 Mar '03   Nice introduction. Got my 5. There is a way to work around the lack of partial template specialization, using inner classes. For each template parameter you wish to specialize on - delegate from the outer class to an inner class... template<typename J, bool K> class TemplateFromHell { private: template<typename SK> struct SpecialK { // true case static int VALUE = 5; }; //Specialize for false case template>< struct SpecialK<false> { // false case static int VALUE = 0; }; public: // special stuff from J can go here... (Or in the inner) // class if it depends on the specialization. J myVar; // Delegate specialized stuff to the inner class... but // show it as public here... static int VALUE = SpecialK<K>::VALUE; }; Each additional parameter that you wish to partially specialize on needs to be in an inner class though. Currently I've done this to 3 nested classes. Not pretty - but it works! And they still ran faster and faster and faster, till they all just melted away, and there was nothing left but a great big pool of melted butter "I ask candidates to create an object model of a chicken." -Bruce Eckel Sign In·View Thread·PermaLink Re: VC7 Workaround moliate 1:22 9 Mar '03   Peter Hancock wrote: Nice introduction. Got my 5. Thanks! Peter Hancock wrote: There is a way to work around the lack of partial template specialization, using inner classes. Works on VC6 as well. I did something like that in the second IF-class in the article. The problem, as you said, is readability. I'm really looking forward to trying Everett. Perhaps even Loki will compile on that one.. [edit] Loki has been ported to VC6/SP5 (http://fara.cs.uni-potsdam.de/~kaufmann/?page=lokiport[^]) I can't belive the effort put into that one... [/edit] Cheers /moliate The corners of my eyes catch hasty, bloodless motion - a mouse? Well, certainly a peripheral of some kind. Neil Gaiman - Cold Colours Sign In·View Thread·PermaLink Re: VC7 Workaround Peter Hancock 16:28 9 Mar '03   moliate wrote: Perhaps even Loki will compile on that one.. [HOMER]Mmmm.... Loki [/HOMER] Definitely a fan of this library... and the book is sensationa moliate wrote: I can't belive the effort put into that one... Amazing!!! Definitely. And they still ran faster and faster and faster, till they all just melted away, and there was nothing left but a great big pool of melted butter "I ask candidates to create an object model of a chicken." -Bruce Eckel Sign In·View Thread·PermaLink Too cool TV 14:09 8 Mar '03   Really nice article, I enjoyed it and gave a 5. I hope that there will be other original article like this one in the future! Sign In·View Thread·PermaLink reminds me of something Chris Losinger 10:35 7 Mar '03   LibTiff does some similar things with C-style macros: #define REPEAT8(op) REPEAT4(op); REPEAT4(op) #define REPEAT4(op) REPEAT2(op); REPEAT2(op) #define REPEAT2(op) op; op #define CASE8(x,op) \ switch (x) { \ case 7: op; case 6: op; case 5: op; \ case 4: op; case 3: op; case 2: op; \ case 1: op; \ } so you can perform an operation 7 times by doing this: CASE8(7, DoSomething()); or, 8 times, like this: REPEAT8(DoSomething()); macros rock -c When history comes, it always takes you by surprise. Bobber! Sign In·View Thread·PermaLink Re: reminds me of something Jörgen Sigvardsson 15:18 7 Mar '03   Chris Losinger wrote: macros rock Yes they do sometimes. For code refactoring it's an ubiqitous tool, despite what Bjarne says. -- Shine, enlighten me - shine Shine, awaken me - shine Shine for all your suffering - shine Sign In·View Thread·PermaLink Re: reminds me of something moliate 0:39 8 Mar '03   Chris Losinger wrote: macros rock Creativity rock I actually tried using macros at first, but I ended up with a sourcefile that would make the finals in one of those C-code obfuscation contests.. /moliate The corners of my eyes catch hasty, bloodless motion - a mouse? Well, certainly a peripheral of some kind. Neil Gaiman - Cold Colours Sign In·View Thread·PermaLink

Last Visit: 17:07 9 Jul '09     Last Update: 17:07 9 Jul '09 12 Next »