Parser.cs

using System.Text.RegularExpressions;

namespace hackAssembler;

partial class Parser
{
    private int _lineIndex = -1; // no instruction initially
    private string[] _instructions;

    private List<string> _cparts = new List<string>() {"", "", ""};

    public Parser(string inputFile)
    {
        _instructions = File.ReadAllLines(inputFile);
    }
    public Boolean HasMoreLines()
    {
        return _lineIndex + 1 < _instructions.Length ? true : false;
    }

    //debug only
    public string CurrentInstruction() => _instructions[_lineIndex];

    public void Advance()
    {
        while(true)
        {
            if (HasMoreLines() is true) _lineIndex++;

            //ignore comments and trim
            string raw = _instructions[_lineIndex];
            Regex rgx =  new Regex(@"\/\/.*");
            string result = rgx.Replace(raw, String.Empty);
            result = result.Trim();

            _instructions[_lineIndex] = result;
            // keep going in case it's comments only
            if (result != String.Empty) break;
        }
        CInstructionParts();
    }

    public InstructType InstructionType()
    {
        char firstChar = _instructions[_lineIndex][0];
        if (firstChar == '@') return InstructType.A_INSTRUCTION;
        else if (firstChar == '(') return InstructType.L_INSTRUCTION;
        else return InstructType.C_INSTRUCTION; 
        //!! Not checking if it is, in fact, a valid instruction!!
    }

    public string Symbol()
    {
        if (InstructionType() == InstructType.C_INSTRUCTION)
        {
            return "N/A";
        }
        if (InstructionType() == InstructType.A_INSTRUCTION)
        {
            // ignore the first '@' of the instruction
            return _instructions[_lineIndex].Substring(1);
        }
        if (InstructionType() == InstructType.L_INSTRUCTION)
        {
            Regex rgx =  new Regex(@"[^()]+");
            Match match = rgx.Match(_instructions[_lineIndex]);
            if (match.Success is true)
            {
                return match.Value;
            }
        }
        return $"Unknown Symbol, instruction: {_instructions[_lineIndex]}";
    }

    // collects the current C-instruction parts, 
    // but doesn't check the validity
    private void CInstructionParts()
    {
        if (InstructionType() is not InstructType.C_INSTRUCTION) return;

        Regex rgx = MyRegex();
        Match match = rgx.Match(_instructions[_lineIndex]);
        if (match.Success is false)
        {
            Console.WriteLine(
                "Error: can't understand the instruction: "
                +_instructions[_lineIndex]);
        }
        Group dest = match.Groups["dest"];
        Group comp = match.Groups["comp"];
        Group jmp  = match.Groups["jmp" ];

        _cparts[0] = dest.Success ? dest.Value : "null";
        _cparts[1] = comp.Success ? comp.Value : "null";
        _cparts[2] = jmp.Success  ? jmp.Value  : "null";
    }

    public string Dest() => _cparts[0];
    public string Comp() => _cparts[1];
    public string Jump() => _cparts[2];

    //overly complex regex!
    [GeneratedRegex(@"(?:(?'dest'[AMD]{0,3})=)?(?'comp'[AMD\-+!10&\|]{0,3})(?:;(?'jmp'[A-Z]{0,3}))?")]
    private static partial Regex MyRegex();
}

enum InstructType { A_INSTRUCTION, C_INSTRUCTION, L_INSTRUCTION }