示例#1
0
        public void TestErrorOnIndirectAddressingForNOnSupportingOpCodes()
        {
            string source = @"* = $2000

                          SCREEN = $0400


                                    lda (SCREEN)
                                    sta (SCREEN)
          
                                    jsr (TEST)
          
                                    lda #1
                                    bne (THEEND)
          
                          THEEND          
                          TEST          
                                    rts";

            C64Studio.Parser.ASMFileParser parser = new C64Studio.Parser.ASMFileParser();
            parser.SetAssemblerType(C64Studio.Types.AssemblerType.C64_STUDIO);

            C64Studio.Parser.CompileConfig config = new C64Studio.Parser.CompileConfig();
            config.OutputFile = "test.prg";
            config.TargetType = C64Studio.Types.CompileTargetType.PRG;
            config.Assembler  = C64Studio.Types.AssemblerType.C64_STUDIO;

            C64Studio.Types.ErrorCode code = C64Studio.Types.ErrorCode.OK;

            Assert.IsFalse(parser.Parse(source, null, config));

            foreach (var entry in parser.Messages.Values)
            {
                code = entry.Code;
                break;
            }

            Assert.AreEqual(4, parser.Errors);
            Assert.AreEqual(C64Studio.Types.ErrorCode.E1105_INVALID_OPCODE, code);
        }
示例#2
0
        public void TestMacroWithLocalLabels()
        {
            string source = @"* = $0801

        !basic

        LABEL_POS = $2000

        ; add immediate 16bit value to memory 
        !macro add16im .dest, .val {
              lda #<.val 
        clc
        adc .dest
        sta .dest
        lda #>.val 
        adc .dest + 1
        sta .dest + 1
        } 


        +add16im LABEL_POS, 256
        rts";


            C64Studio.Parser.ASMFileParser parser = new C64Studio.Parser.ASMFileParser();
            parser.SetAssemblerType(C64Studio.Types.AssemblerType.C64_STUDIO);

            C64Studio.Parser.CompileConfig config = new C64Studio.Parser.CompileConfig();
            config.OutputFile = "test.prg";
            config.TargetType = C64Studio.Types.CompileTargetType.PRG;
            config.Assembler  = C64Studio.Types.AssemblerType.C64_STUDIO;

            Assert.IsTrue(parser.Parse(source, null, config));
            Assert.IsTrue(parser.Assemble(config));

            var assembly = parser.AssembledOutput;

            Assert.AreEqual("01080B080A009E32303631000000A900186D00208D0020A9016D01208D012060", assembly.Assembly.ToString());
        }
        private void editCalc_TextChanged(object sender, EventArgs e)
        {
            Parser.ASMFileParser parser = new C64Studio.Parser.ASMFileParser();
            var tokens = parser.ParseTokenInfo(editCalc.Text, 0, editCalc.TextLength);

            if (tokens != null)
            {
                if (parser.EvaluateTokens(-1, tokens, out SymbolInfo result))
                {
                    editResult.Text    = "$" + result.ToInteger().ToString("X") + ", " + result.ToInteger().ToString();
                    editCalc.BackColor = System.Drawing.SystemColors.Window;
                }
                else
                {
                    editCalc.BackColor = System.Drawing.Color.LightPink;
                }
            }
            else
            {
                editCalc.BackColor = System.Drawing.Color.LightPink;
            }
        }
示例#4
0
        public void TestSourceInfo1()
        {
            string source = @"
                !to ""macro_macro.prg"",cbm

            ;* = $1000
            ;MACRO_START

            !macro fill5bytes v1,v2,v3,v4,v5
                      lda #v1
                      sta 1024
                      lda #v2
                      sta 1025
                      lda #v3
                      sta 1026
                      lda #v4
                      sta 1027
                      lda #v5
                      sta 1028
            !end



            ;MACRO_END

            ;!if ( MACRO_START != MACRO_END ) {
            ;!error Macro has size!
            ;}

            * = $2000
                      lda #$01
                      sta 53281
            CALLEDLED_MACRO
                      +fill5bytes 10,20,30,40,50
            CALLEDLED_MACRO_END
                      inc 53280
                      +fill5bytes 1,2,3,4,5

                      rts";

            C64Studio.Parser.ASMFileParser parser = new C64Studio.Parser.ASMFileParser();
            parser.SetAssemblerType(C64Studio.Types.AssemblerType.C64_STUDIO);

            C64Studio.Parser.CompileConfig config = new C64Studio.Parser.CompileConfig();
            config.OutputFile = "test.prg";
            config.TargetType = C64Studio.Types.CompileTargetType.PRG;
            config.Assembler  = C64Studio.Types.AssemblerType.C64_STUDIO;

            Assert.IsTrue(parser.Parse(source, null, config));

            Assert.IsTrue(parser.Assemble(config));

            var assembly = parser.AssembledOutput;

            string file;
            int    lineIndex;

            parser.ASMFileInfo.DocumentAndLineFromAddress(0x2000, out file, out lineIndex);

            Assert.IsTrue(parser.ASMFileInfo.Labels.ContainsKey("CALLEDLED_MACRO"));
            Assert.IsTrue(parser.ASMFileInfo.Labels.ContainsKey("CALLEDLED_MACRO_END"));

            Assert.AreEqual(28, lineIndex);

            var label  = parser.ASMFileInfo.Labels["CALLEDLED_MACRO"];
            var label2 = parser.ASMFileInfo.Labels["CALLEDLED_MACRO_END"];

            Assert.AreEqual(30, label.LocalLineIndex);
            Assert.AreEqual(32, label2.LocalLineIndex);

            Assert.AreEqual(0x2005, label.AddressOrValue);
            Assert.AreEqual(0x201e, label2.AddressOrValue);

            var tokenInfo = parser.ASMFileInfo.TokenInfoFromName("CALLEDLED_MACRO", "", "");

            Assert.IsNotNull(tokenInfo);
            Assert.AreEqual(30, tokenInfo.LocalLineIndex);

            tokenInfo = parser.ASMFileInfo.TokenInfoFromName("CALLEDLED_MACRO_END", "", "");
            Assert.IsNotNull(tokenInfo);
            Assert.AreEqual(32, tokenInfo.LocalLineIndex);
        }
示例#5
0
        public void TestNoVirtualSectionAt840()
        {
            string source = @"!to ""lady-bug.prg"",cbm
        *=$0801   : !BASIC          ; Basiczeile erzeugen

        BLOCK     = 33            ; Spriteblock -> Block*64 = Spritedaten
        MATRIX    = $0400         ; Bildschirmspeicher
        POINTER_0   = MATRIX+$03F8        ; Spritepointer

              SEI           ; IRQ sperren

              LDA #$B0          ; X-Koordinate
              STA $D000         ; Sprite 0

              LDA #$81          ; Y-Koordinate
              STA $D001         ; Sprite 0

              LDA #BLOCK          ; Spriteblock
              STA POINTER_0       ; Spritepointer 0

              LDA #%00000001        ; Sprite Nr. 0
              STA $D015         ; Sprite-DMA Register

        -     JMP -           ; Warten

              !FILL $19,$EA       ; Code bis $083E bis 083F = Kein Sprite

        *=BLOCK*64                ; Adresse der Spritedaten -> Ballon

              !BYTE %00000011,%11111000,%00000000
              !BYTE %00001111,%11111110,%00000000
              !BYTE %00011111,%11111111,%00000000
              !BYTE %00011111,%00111111,%00000000
              !BYTE %00111110,%11001111,%10000000
              !BYTE %00111110,%11111111,%10000000
              !BYTE %00111110,%11001111,%10000000
              !BYTE %00011111,%00111111,%00000000
              !BYTE %00011111,%11111111,%00000000
              !BYTE %00011111,%11111111,%00000000
              !BYTE %00010111,%11111101,%00000000
              !BYTE %00001011,%11111010,%00000000
              !BYTE %00001001,%11110010,%00000000
              !BYTE %00000100,%11100100,%00000000
              !BYTE %00000100,%11100100,%00000000
              !BYTE %00000010,%01001000,%00000000
              !BYTE %00000010,%01001000,%00000000
              !BYTE %00000001,%11110000,%00000000
              !BYTE %00000001,%11110000,%00000000
              !BYTE %00000001,%11110000,%00000000
              !BYTE %00000000,%11100000,%00000000
              !BYTE $00";

            C64Studio.Parser.ASMFileParser parser = new C64Studio.Parser.ASMFileParser();
            parser.SetAssemblerType(C64Studio.Types.AssemblerType.C64_STUDIO);

            C64Studio.Parser.CompileConfig config = new C64Studio.Parser.CompileConfig();
            config.OutputFile = "test.prg";
            config.Assembler  = C64Studio.Types.AssemblerType.C64_STUDIO;

            Assert.IsTrue(parser.Parse(source, null, config, null));
            Assert.IsTrue(parser.Assemble(config));

            var assembly = parser.AssembledOutput;

            Assert.AreEqual("01080B080A009E3230363100000078A9B08D00D0A9818D01D0A9218DF807A9018D15D04C2208EAEAEAEAEAEAEAEAEAEAEAEAEAEAEAEAEAEAEAEAEAEAEAEAEA000003F8000FFE001FFF001F3F003ECF803EFF803ECF801F3F001FFF001FFF0017FD000BFA0009F20004E40004E40002480002480001F00001F00001F00000E00000", assembly.Assembly.ToString());
        }