Cleaning up Compiler class What is the best way to considerably decrease the size of the following code without sacrificing functionality, and to make it more readable, and well, make it look professional?

class Compiler
{        
    public string Compile(TextReader src)
    {
        string rtn = SourceTemplate.Top;

        var preprocessor = new PreProcessor();

        Parser[] ParserRounds = {
                                    new PredefinedConstantParser(),
                                    new VariableDeclarationParser(), 
                                    new ConditionalExpressionParser(),
                                    new FunctionCallParser()//,
                                  //new FunctionParser
                                };

        foreach (var l in preprocessor.Process(src))
        {
            var line = l;

            foreach (var parser in ParserRounds)
            {
                line = parser.Parse(line);
            }

            rtn += "\t\t\t" + line + "\n";
        }

        return rtn + SourceTemplate.Bottom;
    }

    public static void Start(string[] args)
    {
        TextReader src = File.OpenText(args[0]);      

        var com = new Compiler();
        var source = com.Compile(src);

        string target = args[0].TrimEnd(".hack".ToCharArray());
        target += ".cs";                     
    }

    public void SaveToFile(string source, string target)
    {
        TextWriter wsrc = File.CreateText(target);
        wsrc.WriteLine(source);
        wsrc.Close();
    }
}


In my personal opinion, the above code looks like a mess at this stage. Also, please suggest good and expressive variable names instead of rtn , src etc.  Should I also make this class generic?
Just some generic notes since I'm not too familiar with C#:


rtn should be StringBuilder
I'd change the preprocessor and ParserRounds variables to fields and pass their values to the constructor of the class. It makes testing easier (you can test only one parser at a time, you can test with a mocked preprocessor etc.) and it results looser coupling.
Using SourceTemplate.Top and SourceTemplate.Bottom also tight coupling, pass these values to the constructor too, store them in a field and use these fields in the Compile method. (Maybe it's worth creating a SourceTemplate interface with GetTop() and GetBottom() methods and passing a proper instance to the Compiler class.)
I'm really missing the input validation. For example, if the Compile method get a null as a value of TextReader you should throw an exception immediately. It helps debugging a lot. Why would you do any compiling if it will throw an exception later since the TextReader is null?

The Start method also should check the input values.
Some variable naming ideas:


src -> sourceReader or srcReader
com -> compiler
target -> targetFileName
rtn -> result
wsrc -> targetWriter