コード例 #1
0
        static string getMoveAddresses(MesenLine line)
        {
            Match match;

            if (AddressingMode.BlockMove.IsMatch(line.Parameters))
            {
                match = AddressingMode.BlockMove.Match(line.Parameters);
            }
            else if (AddressingMode.BlockMoveArrow.IsMatch(line.Parameters))
            {
                match = AddressingMode.BlockMoveArrow.Match(line.Parameters);
            }
            else
            {
                throw new Exception("Unknown addressing Mode");
            }
            var source = $"${match.Groups[1].Value}{line.State.X}";
            var dest   = $"${match.Groups[2].Value}{line.State.Y}";

            return($"{source} -> {dest}");
        }
コード例 #2
0
        static void processMesen(string filename)
        {
            var rawlines = File.ReadAllLines(filename);
            //var folder = Path.Combine(Path.GetDirectoryName(filename), $"{Path.GetFileNameWithoutExtension(filename)} {DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss")}");
            var folder = Path.Combine(Path.GetDirectoryName(filename), Path.GetFileNameWithoutExtension(filename));

            Directory.CreateDirectory(folder);

            // Raw input
            File.WriteAllLines(Path.Combine(folder, "raw.txt"), rawlines);

            // Parse lines into usable form
            var lines = MesenLine.ConvertTrace(rawlines.ToList());

            var notMesen =
                rawlines
                .Where(x => !string.IsNullOrEmpty(x) && !MesenLine.IsA(x));

            File.WriteAllLines(Path.Combine(folder, "not-mesen.txt"), notMesen);
            notMesen = null;
            rawlines = null;

            // Simple, just code & address ordered
            var code =
                lines
                .Select(x => $"{x.Address} {x.Op} {x.Parameters}".Trim())
                .Distinct()
                .OrderBy(x => x)
                .ToList();

            File.WriteAllLines(Path.Combine(folder, "code.txt"), code);

            // Code with labels and line breaks
            var labeled = SourceProcessing.LabelCode(code);

            File.WriteAllLines(Path.Combine(folder, "code-labeled.txt"), labeled);
            code    = null;
            labeled = null;

            // Address/instruction usage counts
            var addresses =
                lines
                .Where(x => !string.IsNullOrEmpty(x.Target))
                .Select(x => $"{x.Target} {x.Op}");

            GroupCountAndWriteFile(addresses, Path.Combine(folder, "address-usage.txt"));
            addresses = null;

            // Code instruction counts
            var codeAddresses =
                lines
                .Select(x => x.Address);

            GroupCountAndWriteFile(codeAddresses, Path.Combine(folder, "code-address-counts.txt"));
            codeAddresses = null;

            // Move counts
            var moves =
                lines
                .Where(x => x.Op == "mvn" || x.Op == "mvp")
                .Select(x => $"{getMoveAddresses(x)} {x.Op}");

            GroupCountAndWriteFile(moves, Path.Combine(folder, "moves.txt"));
            moves = null;

            // Move counts - source
            moves =
                lines
                .Where(x => x.Op == "mvn" || x.Op == "mvp")
                .Select(x => $"{getMoveAddresses(x).Split(' ')[0]} {x.Op}");
            GroupCountAndWriteFile(moves, Path.Combine(folder, "moves-source.txt"));
            moves = null;

            // Move counts - destination
            moves =
                lines
                .Where(x => x.Op == "mvn" || x.Op == "mvp")
                .Select(x => $"{getMoveAddresses(x).Split(' ')[2]} {x.Op}");
            GroupCountAndWriteFile(moves, Path.Combine(folder, "moves-destination.txt"));
            moves = null;

            // Move counts - both
            moves =
                lines
                .Where(x => x.Op == "mvn" || x.Op == "mvp")
                .Select(x => $"{getMoveAddresses(x).Split(' ')[0]} {x.Op}")
                .Concat(
                    lines
                    .Where(x => x.Op == "mvn" || x.Op == "mvp")
                    .Select(x => $"{getMoveAddresses(x).Split(' ')[2]} {x.Op}")
                    );
            GroupCountAndWriteFile(moves, Path.Combine(folder, "moves-both.txt"));
            moves = null;


            // With missing sections
            var olines = Line.ToLines(lines);
            var groups = LineGroup.MakeGroups(olines);

            olines = null;
            var missing = SourceProcessing.GetMissingOutput(groups, (x) => x.ToString());

            File.WriteAllLines(Path.Combine(folder, "with-missing.txt"), missing);
            missing = null;
            groups  = null;

            // Jump targets
            Regex targetsRegex     = new Regex(@"^(?:jsr|jrl|jmp|jml)$", RegexOptions.Compiled);
            Regex containsIndirect = new Regex(@",|\[|\(", RegexOptions.Compiled);
            var   targets          =
                lines
                .Where(x => targetsRegex.IsMatch(x.Op) && containsIndirect.IsMatch(x.Parameters))
                .Select(x => $"{x.Address} {x.Op} {x.Parameters} [{x.Target}]");

            GroupCountAndWriteFile(targets, Path.Combine(folder, "jump-targets.txt"));
            targets = null;

            // Wrong bytecode conversions
            var wrong =
                lines
                .Where(x => x.BytecodeOriginal != x.Bytecode)
                .Select(x => $"{x.Op} {x.Parameters}   log={x.BytecodeOriginal}  computed={x.Bytecode}")
                .ToList();

            File.WriteAllLines(Path.Combine(folder, "wrong-bytecode.txt"), wrong);
            wrong = null;
            lines = null;

            var f = 8;
        }