C# File stream reading strings (Coco/R Taste)

Question

I'm working with Coco R sample Taste, in C#.

I'm trying to expand the code to write Strings when an operation is given such as

write hello world

I have identified a way, in which I can store and write strings. I'm putting out relevant code for the problem I'm having:

Expanded Taste.ATG

| "write" 
    { Expr<out type>    (. if (type != integer) SemErr("integer type expected");
                            gen.Emit(Op.WRITE); .)
    | '"' 
    ident       (. name = Convert.ToString(t.val);
                            gen.Emit(Op.READS);
                            gen.Emit(Op.WRITES).)
    '"'
    }';'

Expanded Operations in CodeGen.cs: Filestream is used in this way

public void Interpret (string data) { 
    int val;
    try {
        FileStream s = new FileStream(data, FileMode.Open);
        Console.WriteLine();
        pc = progStart; stack[0] = 0; top = 1; bp = 0;

and added case switches, that use filestream

case Op.READ:  val = ReadInt(s); Push(val); break;
case Op.READS: stackString[index] = ReadString(s) ; Push(index); index++; break;
case Op.WRITE: Console.WriteLine(Pop()); break;
case Op.WRITES: Console.WriteLine(stackString[Pop()]); break;

The problem is, I cant find anywhere on the internet a way to read a String, clearly ReadString(s) doesn't work the same way ReadInt(s) does. I was wondering if I can get help to find an operation, that reads a string from the file stream.

I haven't done any filestream management before.

Answer 1

EDIT3 After looking into this stuff again, I found a bigger problem with this approach. First off some explanation: Coco/R generates the scanner and parser from the atg file, the main program in Taste.cs uses these to compile the Taste.TAS.

The compiled Taste.TAS is then fed into the CodeGen.cs's Interpret method which works down the opcodes it receives like a virtual machine, so it's ReadInt() method is supposed to read from Taste.IN, which contains sample data for the compiled Taste.TAS-program.

So, to add support for a hello world in the CodeGen.cs, it is not enough to change the Interpret method, you will have to patch the Emit method as well, to allow the compiler to add the string at compile-time.

Hacky as always (goes into CodeGen.cs):

List<string> strStack = new List<string>();
public void Emit(Op op, string str)
{
    int idx = strStack.Count;
    strStack.Add(str);
    Emit(op, idx); // adds the opcode, 
}

In the Taste.ATG you will have to change the Write-instruction to Gen.Emit(Op.WRITES, t.val);

And in the Interpret-method, you will need to use the reference to the string list:

case Op.WRITES: Console.WriteLine(strStack[Next2()]); break;

EDIT4 - Just for future reference To read a string literal from a file you could use the StreamReader class like so:

    /// <summary>
    ///     Reads a string literal from a file, essentially implementing the regex pattern /\"{.*}\"/.
    ///     Ignores escape characters (for instance, "\"" will fail)
    /// </summary>
    /// <param name="fs">The file stream to read from.</param>
    /// <returns>The string literal without it's quotes upon success, null otherwise.</returns>
    static string ReadString(FileStream fs)
    {
        if (!fs.CanRead)
            return null; // cant read from stream, throw an exception here

        var reader = new StreamReader(fs);
        var sb = new StringBuilder();

        bool inString = false;

        while (true)
        {
            if (reader.Peek() < 0)
                return null; // reached EOF before string ended, throw exception here

            char ch = (char)reader.Read();

            if (inString)
                if (ch == '"')
                    break;
                else
                    sb.Append(ch);
            else
                if (ch == '"')
                    inString = true;
                else if (!char.IsWhiteSpace(ch))
                    return null; // string does not start with quote, throw exception here
        }

        return sb.ToString();
    }

An alternative would be to use the [Regex][3] class, but since it by default only works with strings, it requires some tricky read-and-seek operations to get strings spanning multiple lines (if supported), so you do not fubar the filestream for the rest of the program.