Assuming that there are only about 10 minutes to write such a
 parser on paper without any reference, it is difficult, indeed.

 Let me try to see, what I can write in 10 minutes without a
 reference

// 2006-11-04T17:48:18+01:00

public class CsvParser
{ private CsvScanner tokenSource;
 public CsvParser( final CsvScanner tokenSource )
 { this.tokenSource = tokenSource; }

// 2006-11-04T17:50:09+01:00

 public void parseAll()
 { while( tokenSource.isMoreInSource() )parseLine(); }

// 2006-11-04T17:51:26+01:00

 public void parseLine()
 { while( tokenSource.isMoreInLine() )parseValue(); }

// 2006-11-04T17:54:43+01:00

 public void parseValue()
 { final Token token = tokenSource.getToken();
   token.to( new TokenProcessor()
     { public void processNumericStart(){ /* todo */ }
       public void processTextStart(){ /* todo */ }
       /* here my time limit was reached */

// 2006-11-04T17:58:31+01:00

 Sometimes an interviewer might give you an "impossible"
 task just to see how you cope with that.

Then write your own; it's a trivial thing to do. Here, in fact, is one I
wrote earlier:

/**
* MIDP does not provide a StringTokenizer. Because this has to be
* compatible with MIDP we'll provide our own. If you have access to a real
* StringTokenizer don't use this one - it is minimal and possibly
* inefficient.
*/
public class StringTokenizer
{
       //~ Instance fields -----------------------------------------------

       /** the source string, which I tokenize */
       private String source = null;

       /** the separator character which I split it on */
       private char sep = ' ';

       /** my current cursor into the strong */
       private int cursor = 0;

       //~ Constructors --------------------------------------------------

       /**
        * @param sep the separator which separates tokens in this source
        * @param source the source string to separate into tokens
        */
       public StringTokenizer( String source, char sep )
       {
               super(  );
               this.sep = sep;
               this.source = source;
       }

       //~ Methods -------------------------------------------------------

       /**
        * @return true if this tokenizer still has more tokens, else false
        */
       public boolean hasMoreTokens(  )
       {
               return ( ( source != null ) && ( cursor < source.length(  ) ) );
       }

       /**
        * Test harness only - do not use
        *
        * @param args
        */
       public static void main( String[] args )
       {
               if ( args.length == 2 )
               {
                       StringTokenizer tock =
                               new StringTokenizer( args[0], args[1].charAt( 0 ) );

                       System.out.println( "String is: '" + args[0] + "'" );
                       System.out.println( "Separator is: '" + args[1].charAt( 0 ) + "'" );

                       for ( int i = 0; tock.hasMoreTokens(  ); i++ )
                       {
                               System.out.println( Integer.toString( i ) + ": '" +
                                       tock.nextToken(  ) + "'" );
                       }
               }
       }

       /**
        * @return the next token from this string tokenizer, or null if there are
        *                 no more.
        */
       public synchronized String nextToken(  )
       {
               String result = null;
               int end = source.indexOf( sep, cursor );

               if ( cursor < source.length(  ) )
               {
                       if ( end > -1 )
                       {
                               result = source.substring( cursor, end );
                               cursor = end + 1;
                       }
                       else
                       {
                               result = source.substring( cursor );
                               cursor = source.length(  );
                       }
               }

               return result;
       }
}