public static string[] smartSplit(
                         string delimitedData,
                         char delimiter,
                         char escape) {}

def extract(input, delim, escape):
  # states
  parsing = 0
  escaped = 1

  state = parsing
  found = []
  parsed = ""

  for c in input:
    if state == parsing:
      if c == delim:
        found.append(parsed)
        parsed = ""
      elif c == escape:
        state = escaped
      else:
        parsed += c
    else: # state == escaped
       parsed += c
       state = parsing

  if parsed:
    found.append(parsed)

  return found

void smartSplit(string const& text, char delim, char esc, vector<string>& tokens)
{
    enum State { NORMAL, IN_ESC };
    State state = NORMAL;
    string frag;

    for (size_t i = 0; i<text.length(); ++i)
    {
    	char c = text[i];
    	switch (state)
    	{
    	case NORMAL:
    		if (c == delim)
    		{
    			if (!frag.empty())
    				tokens.push_back(frag);
    			frag.clear();
    		}
    		else if (c == esc)
    			state = IN_ESC;
    		else
    			frag.append(1, c);
    		break;
    	case IN_ESC:
    		frag.append(1, c);
    		state = NORMAL;
    		break;
    	}
    }
    if (!frag.empty())
    	tokens.push_back(frag);
}

state(input)     action
========================
BEGIN(*):         token.clear(); state=START;
END(*):           return;
*(n):          token.emit(); state=END;
START(DELIMITER): ; // NB: the input is *not* added to the token!
START(ESCAPE):    state=ESC; // NB: the input is *not* added to the token!
START(*):         token.append(input); state=NORM;
NORM(DELIMITER):  token.emit(); token.clear(); state=START;
NORM(ESCAPE):     state=ESC; // NB: the input is *not* added to the token!
NORM(*):          token.append(input);
ESC(*):           token.append(input); state=NORM;

public static void smartSplit(string text, char delim, char esc, ref List<string> listToBuild)
    {
        bool currentlyEscaped = false;
        StringBuilder fragment = new StringBuilder();

        for (int i = 0; i < text.Length; i++)
        {
            char c = text[i];
            if (currentlyEscaped)
            {
                fragment.Append(c);
                currentlyEscaped = false;
            }
            else
            {
                if (c == delim)
                {
                    if (fragment.Length > 0)
                    {
                        listToBuild.Add(fragment.ToString());
                        fragment.Remove(0, fragment.Length);
                    }

                }
                else if (c == esc)
                    currentlyEscaped = true;
                else
                    fragment.Append(c);
            }
        }

        if (fragment.Length > 0)
        {
            listToBuild.Add(fragment.ToString());
        }
    }

private static string[] Split(string input, char delimiter, char escapeChar, bool removeEmpty)
    {
        if (input == null)
        {
            return new string[0];
        }

        char[] specialChars = new char[]{delimiter, escapeChar};

        var tokens = new List<string>();
        var token = new StringBuilder();

        for (int i = 0; i < input.Length; i++)
        {
            var c = input[i];

            if (c.Equals(escapeChar))
            {
                if (i >= input.Length - 1)
                {
                    throw new ArgumentException("Uncompleted escape sequence has been encountered at the end of the input");
                }

                var nextChar = input[i + 1];

                if (nextChar != escapeChar && nextChar != delimiter)
                {
                    throw new ArgumentException("Unknown escape sequence has been encountered: " + c + nextChar);
                }

                token.Append(nextChar);
                i++;
            }
            else if (c.Equals(delimiter))
            {
                if (!removeEmpty || token.Length > 0)
                {
                    tokens.Add(token.ToString());
                    token.Length = 0;
                }
            }
            else
            {
                var index = input.IndexOfAny(specialChars, i);

                if (index < 0)
                {
                    token.Append(c);
                }
                else
                {
                    token.Append(input.Substring(i, index - i));
                    i = index - 1;
                }
            }
        }

        if (!removeEmpty || token.Length > 0)
        {
            tokens.Add(token.ToString());
        }

        return tokens.ToArray();
    }