1.2.0 [date]:
    Complete re-write of codeform. Features include:
        - Much faster than codeform 1.10 (about a quarter of the speed)
        - Binary search for rules making it much faster for many rules
        - Sequential keywords of the same colour have one tag
        - Unlimited line length for rules and input files
        - Support for multiple input, output, and rules files
        - Inline rules which can be specified on the command line
        - Greatly improved data files which support variables and part sharing
        - Automatic termination of strings that don't terminate
        - Support for comments inside comments (ie, /**/ inside #)
        - Much more generic and easier to extend (few hard-coded assumptions)
        - Comments in the code so it's pretty much readable

C:\>outclip | codeform rules\c_1_vbb | clipboard

[...]
29: [:$(midwordb):$(midworda)
30: ]:*:*
31: (:*:*
32: ):*:*
33: {:*:*
34: }:*:*
35: lt=<
36: gt=>
37: $(lt):*:*
38: $(gt):*:*

#include "stdafx.h"

#include <iostream>
#include <string>
#include <fstream>
#include <ctime>

#include <windows.h>



using namespace std;



bool copy_to_clipboard( LPCTSTR pszText )
{
	size_t			nBytes;
	unsigned int	format;

	HGLOBAL			hGlobal;
	LPTSTR			pClipboardData;

	#ifdef	UNICODE 
		format = CF_UNICODETEXT;
	#else	
		format = CF_TEXT;
	#endif

	if( !OpenClipboard( NULL ) ) return false;

	EmptyClipboard();

	nBytes = ( _tcslen( pszText ) + 1 ) * sizeof( TCHAR );

	hGlobal = GlobalAlloc( GMEM_MOVEABLE, nBytes );
	if( !hGlobal )
	{
		std::cerr<< "\nERROR: hGlobal! Nothing copied to clipboard";
		CloseClipboard();

		return false;
	}

	pClipboardData = (char*)GlobalLock( hGlobal );

	if( !pClipboardData )
	{ 
		std::cerr<< "\nERROR: pClopboardData! Nothing copied to clipboard";
		CloseClipboard();

		return false;
	}

	memcpy( pClipboardData, pszText, nBytes );

	GlobalUnlock( hGlobal );
	SetClipboardData( format, hGlobal );
	CloseClipboard();

	return true;
}

std::string get_clipboard( void )
{
	string data;

	if(OpenClipboard(NULL))
	{
		HANDLE GlobalHWnd = GetClipboardData( CF_TEXT );

		if ( GlobalHWnd != 0 )
		{ 
			char* text = (char *)GlobalLock(GlobalHWnd);
			data = text;
			GlobalUnlock(GlobalHWnd);
		}
		CloseClipboard();
	}

	return data;
}

int main( void )
{  
	const std::string tofile   = "thing1.txt";
	const std::string fromfile = "thing1.cpp";



	// Save clipboard to file
	std::ofstream out( fromfile.c_str() );

	if ( !out )
		return 0;

	out<< get_clipboard();
	out.close();



	// Use codeform to paint the code nicely, and save it to file 
	system( ("codeform -o " + tofile + " -f rules\\cpp_1_vbb " + fromfile).c_str() );



	// Now get the data from aforementioned file
	std::ifstream in( tofile.c_str() );
	
	if ( !in )
		return 0;



	// Copy to clipboard. 
	std::string File, Line;

	while ( std::getline( in, Line ) )
		File += Line + "\n";

	copy_to_clipboard( File.c_str() );

	in.close();

	

	return 0;
}

printf("Example: %d",sin(atoi((const char*)foo)));

printf("Example: %d",sin(atoi((const char*)foo)));

C:\>outclip | codeform_parenthesis -f rules\_vbb -f parenthesis -f rules\c_1 | clipboard

=parenthesis

parenthesisbb=$(formbb)
parenthesisba=$(formba)
parenthesisa=$(forma)

$(parenthesisbb)red$(parenthesisba):$(parenthesisa):\
$(parenthesisbb)green$(parenthesisba):$(parenthesisa):\
$(parenthesisbb)blue$(parenthesisba):$(parenthesisa)

57a58
>     TYPE_PARENTHESIS,
246a248
> int type_parenthesis(struct onerule_t *rule, struct typefunc_t *tf);
272a275
>             {"parenthesis", (size_t)-1, 1, 9999, type_parenthesis},
1969a1973,1999
> int type_parenthesis(struct onerule_t *rule, struct typefunc_t *tf) {
>     static size_t level = 0;
>     char c;
>     
>     if(!rule->data.number) return 0;
>     if(tf->func.number) return 0;
>     
>     if(**tf->p != '(' && **tf->p != ')') return 0;
>     c = **tf->p;
>     
>     if(c == ')') {
>         if(--level == (size_t)-1) level = rule->data.number/2 - 1;
>     }
>     
>     append_rulelist(0, 0, tf->list, tf->out);
>     
>     fputs(rule->data.data[level * 2], tf->out);
>     print_chars(tf->p, 1, tf->out);
>     fputs(rule->data.data[level * 2 + 1], tf->out);
> 
>     if(c == '(') {
>         if(++level >= rule->data.number/2) level = 0;
>     }
> 
>     return 1;
> }
>

$ codeform -e '=start:<html><head><title>codeform</title></head><body bgcolor="#000000">' -f rules/c_1_html

//comment

/*comment

"string

if(call_type_cdat(rules, tf)) return 1;

                if(call_one_type(rules, tf)) redo = 1;

                if(call_one_type(rules, tf) || call_type_cdat(rules, tf)) {
                    redo = 1;
                }

codeform.c:738: warning: 'tlen' might be used uninitialized in this function

void add_rules_file(struct rules_t *rules, const char *fn) {
    FILE *fp = open_file(fn, "r");
    char *str = 0;
    int line = 0, isb;
    size_t tlen, len, flen = 0, alen = 0;

    if(!fp) return;

    do {
        len = 0;

        isb = 1;
        while(isb && (tlen = get_string(&str, len, &alen, fp)) != len) {
            flen = tlen;

            if(flen && str[flen-1] == '\n') str[--flen] = 0;

            isb = is_backslashed(str+len, str+flen);

            len = flen;
            line ++;

            if(len && str[len-1] == '\\') str[--len] = 0;
        }

        add_rule_var(rules, str, fn, line);
    } while(tlen != len);

    if(fp != stdin) fclose(fp);

    free(str);
}

size_t tlen = 0, len, flen = 0, alen = 0;