#include <stdio.h>
#include <ctype.h>

static int copy_code(int code, char *s, int i);
static int copy_character(int c, char *s, int i);
static int copy_special_characters(int code, char *s, int i);

static char codes[][4] = {"bol", "eol", "any", "lit", "ccl", "ncl",	"clo"};
enum{ BOL = 0, EOL, ANY, LIT, CCL, NCL, CLO};

static char special_characters[][8] = {"space", "newline", "tab"};
enum{SPACE, NEWLINE, TAB};

enum{VALID_REGEXP = 0, INVALID_REGEXP};

int encode_regular_expression(char *regexp, char *encode)
{
	/* i is the index of current character in regexp ang j is the current character being output */
	int i, j, escaped;
	char c;

	i = j = escaped = 0;
	encode[j++] = '(';
	/* parse through the regular expression */
	for(;;)
	{
		/* read the character in regexp in c */
		c = regexp[i++];

		if(c == '\0')
			break;

		if(c == '\\')								/* escape character */
		{
			escaped = 1;
			continue;
		}

		encode[j++] = '(';

		if(!escaped && c == '^' && i == 1)					/* begining of line character '^' is not escaped and located at the start of regexp */
			j = copy_code(BOL, encode, j);
		else if(!escaped && c == '$' && regexp[i] == '\0')		/* end of line character '$' is not escaped and located at the end of regexp */
			j = copy_code(EOL, encode, j);
		else if(!escaped && c == '.')							/* any character */
		{
			if(regexp[i] == '*')
			{
				j = copy_code(CLO, encode, j);
				encode[j++] = ' ';
				i++;
			}

			j = copy_code(ANY, encode, j);
		}
		else if(!escaped && c == '[')							/* begining of character class */
		{
			int k;

			/* check for closure and validity of character class */
			for(k = i; regexp[k] != '\0' && regexp[k] != ']'; k++);

			/* if no ending bracket, return invalid regexp */
			if(regexp[k] == '\0')
				return INVALID_REGEXP;

			/* check for closure */
			if(regexp[k+1] == '*')
			{
				j = copy_code(CLO, encode, j);
				encode[j++] = ' ';
			}

			/* check for negated character */
			if(regexp[i] == '^')
			{
				j = copy_code(NCL, encode, j);
				i++;
			}
			else
				j = copy_code(CCL, encode, j);

			while(regexp[i] != '\0' && regexp[i] != ']')
			{
				char start, end;

				if(regexp[i+1] != '-')
				{
					j = copy_character(regexp[i], encode, j);
					i++;
					continue;
				}

				if(!isalnum(regexp[i]) && !isalnum(regexp[i+2]))
					return INVALID_REGEXP;

				if(isalpha(regexp[i])  && !isalpha(regexp[i+2]))
					return INVALID_REGEXP;

				if(isdigit(regexp[i])  && !isdigit(regexp[i+2]))
					return INVALID_REGEXP;

				if(regexp[i] > regexp[i+2])
					return INVALID_REGEXP;

				/*now expand the given range */
				for(start = regexp[i], end = regexp[i+2]; start <= end; start++)
					j = copy_character(start, encode, j);

				i = i + 3;
			}

			i++;
			if(regexp[i] == '*')
				i++;
		}
		else							/* literal character */
		{
			if(regexp[i] == '*')
			{
				j = copy_code(CLO, encode, j);
				encode[j++] = ' ';
				i++;
			}

			j = copy_code(LIT, encode, j);

			/* handle special characters */
			if(escaped && c == 'n')
				j = copy_special_characters(NEWLINE, encode, j);
			else if(escaped && c == 't')
				j = copy_special_characters(TAB, encode, j);
			else if(c == ' ')
				j = copy_special_characters(SPACE, encode, j);
			else
				j = copy_character(c, encode, j);
		}
		encode[j++] = ')';
		encode[j++] = ' ';
	}
	encode[j-1] = ')';
	encode[j] = '\0';
	return VALID_REGEXP;
}

static int copy_code(int code, char *s, int i)
{
	int j;

	for(j = 0; codes[code][j] != '\0'; j++)
		s[i++] = codes[code][j];

	return i;
}

static int copy_special_characters(int code, char *s, int i)
{
	int j;

	s[i++] = ' ';
	s[i++] = '#';
	s[i++] = '\\';

	for(j = 0; special_characters[code][j] != '\0'; j++)
		s[i++] = special_characters[code][j];

	return i;
}

static int copy_character(int c, char *s, int i)
{
	s[i++] = ' ';
	s[i++] = '#';
	s[i++] = '\\';
	s[i++] = c;

	return i;
}

http://matt.might.net/articles/implementation-of-regular-expression-matching-in-scheme-with-derivatives/

The implementation for regular languages is remarkably compact.

import Control.Applicative ((<$>), (*>), (<*), (<*>))
import Data.Char
import Text.Parsec
import Text.Parsec.String

data Elem = Lit Char | Esc Char | Any | Set Bool [Elem] deriving Show
data Chunk = Elem Elem | BoL | EoL | Star Elem deriving Show

regex :: Parser [Chunk]
regex = (++) <$> bol <*> many chunk where
    bol = option [] (const [BoL] <$> char '^')
    chunk = choice [Star <$> try (element <* char '*'),
                    const EoL <$> try (char '$' <* eof),
                    Elem <$> element]
    element = choice [esc <$> try (char '\\' *> anyChar),
                      const Any <$> char '.',
                      Set False . expandSet <$> set "[^",
                      Set True . expandSet <$> set "[",
                      Lit <$> noneOf "]"]
    esc c = if elem c "nt" then Esc c else Lit c
    set s = try (string s *> many1 element <* char ']')
    expandSet (Lit a:Lit '-':Lit b:xs)
        | validRange a b = map Lit [a..b] ++ expandSet xs
    expandSet (x:xs) = x : expandSet xs
    expandSet _ = []
    validRange a b = b > a && ((isLower a && isLower b) ||
                               (isUpper a && isUpper b) ||
                               (isDigit a && isDigit b))
    
parseRegex :: String -> Either ParseError [Chunk]
parseRegex = parse regex ""

import Control.Applicative ((<$>), (*>), (<*), (<*>))
import Text.Parsec
import Text.Parsec.String

data Elem = Lit Char | Any | Set Bool [Char] deriving Show
data Chunk = Elem Elem | BoL | EoL | Star Elem deriving Show

regex :: Parser [Chunk]
regex = (++) <$> bol <*> many chunk where
    bol = option [] (const [BoL] <$> char '^')
    chunk = choice [Star <$> try (element <* char '*'),
                    const EoL <$> try (char '$' <* eof),
                    Elem <$> element]
    element = choice [const Any <$> char '.',
                      Set False . expandSet <$> set "[^",
                      Set True . expandSet <$> set "[",
                      Lit <$> anyChar]
    set s = try (string s *> many1 (noneOf "]") <* char ']')
    expandSet (a:'-':b:xs) = [a..b] ++ expandSet xs
    expandSet (x:xs) = x : expandSet xs
    expandSet _ = []

parseRegex :: String -> Either ParseError [Chunk]
parseRegex = parse regex ""