コード例 #1
0
ファイル: Tiny64Debugger.cs プロジェクト: joos2k/C64Studio
 public void SetBreakPoints(GR.Collections.Map <string, List <Types.Breakpoint> > BreakPoints)
 {
     m_BreakPoints.Clear();
     foreach (var key in BreakPoints.Keys)
     {
         foreach (Types.Breakpoint breakPoint in BreakPoints[key])
         {
             if (breakPoint.Address != -1)
             {
                 m_BreakPoints.Add(breakPoint);
             }
         }
     }
 }
コード例 #2
0
        public int ImageToMCBitmapData(Dictionary <int, List <ColorMappingTarget> > ForceBitPattern, List <Formats.CharData> Chars, bool[,] ErrornousBlocks, int CharX, int CharY, int WidthChars, int HeightChars, out GR.Memory.ByteBuffer bitmapData, out GR.Memory.ByteBuffer screenChar, out GR.Memory.ByteBuffer screenColor)
        {
            int numErrors = 0;

            ColorMappingTarget[] bitPattern = new ColorMappingTarget[3] {
                ColorMappingTarget.BITS_01, ColorMappingTarget.BITS_10, ColorMappingTarget.BITS_11
            };
            var usedBitPattern = new GR.Collections.Set <ColorMappingTarget>();

            Dictionary <int, GR.Collections.Set <ColorMappingTarget> > usedPatterns = new Dictionary <int, GR.Collections.Set <ColorMappingTarget> >();

            screenChar  = new GR.Memory.ByteBuffer((uint)(WidthChars * HeightChars));
            screenColor = new GR.Memory.ByteBuffer((uint)(WidthChars * HeightChars));
            bitmapData  = new GR.Memory.ByteBuffer((uint)(8 * WidthChars * HeightChars));

            GR.Collections.Map <byte, ColorMappingTarget> usedColors = new GR.Collections.Map <byte, ColorMappingTarget>();

            for (int y = 0; y < HeightChars; ++y)
            {
                for (int x = 0; x < WidthChars; ++x)
                {
                    // ein zeichen-block
                    usedColors.Clear();
                    usedBitPattern.Clear();
                    if (ErrornousBlocks != null)
                    {
                        ErrornousBlocks[x, y] = false;
                    }
                    for (int charY = 0; charY < 8; ++charY)
                    {
                        for (int charX = 0; charX < 4; ++charX)
                        {
                            byte colorIndex = (byte)Image.GetPixel(x * 8 + charX * 2, y * 8 + charY);
                            if (colorIndex >= 16)
                            {
                                if (Chars != null)
                                {
                                    Chars[x + y * BlockWidth].Error = "Color index >= 16 (" + colorIndex + ") at " + (x * 8 + charX * 2).ToString() + ", " + (y * 8 + charY).ToString() + " (" + charX + "," + charY + ")";
                                }
                                if (ErrornousBlocks != null)
                                {
                                    ErrornousBlocks[x, y] = true;
                                }
                                ++numErrors;
                            }
                            if (colorIndex != Colors.BackgroundColor)
                            {
                                // remember used color
                                usedColors.Add(colorIndex, 0);
                            }
                        }
                    }
                    // more than 3 colors?
                    if (usedColors.Count > 3)
                    {
                        if (Chars != null)
                        {
                            Chars[x + y * BlockWidth].Error = "Too many colors used";
                        }
                        if (ErrornousBlocks != null)
                        {
                            ErrornousBlocks[x, y] = true;
                        }
                        ++numErrors;
                    }
                    else
                    {
                        if (usedColors.Count > 0)
                        {
                            int         colorTarget = 0;
                            List <byte> keys        = new List <byte>(usedColors.Keys);

                            // check for overlaps - two colors are used that would map to the same target pattern?
                            Dictionary <int, ColorMappingTarget> recommendedPattern = new Dictionary <int, ColorMappingTarget>();

                            numErrors += DetermineBestMapping(keys, x, y, ForceBitPattern, recommendedPattern, ErrornousBlocks);

                            foreach (byte colorIndex in keys)
                            {
                                if (recommendedPattern.ContainsKey(colorIndex))
                                {
                                    usedColors[colorIndex] = recommendedPattern[colorIndex];

                                    if (!usedPatterns.ContainsKey(colorIndex))
                                    {
                                        usedPatterns.Add(colorIndex, new GR.Collections.Set <ColorMappingTarget>());
                                    }
                                    usedPatterns[colorIndex].Add(recommendedPattern[colorIndex]);
                                    usedBitPattern.Add(recommendedPattern[colorIndex]);

                                    switch (recommendedPattern[colorIndex])
                                    {
                                    case ColorMappingTarget.BITS_01:
                                    {
                                        // upper screen char nibble
                                        byte value = screenChar.ByteAt(x + y * WidthChars);
                                        value &= 0x0f;
                                        value |= (byte)(colorIndex << 4);

                                        screenChar.SetU8At(x + y * WidthChars, value);
                                    }
                                    break;

                                    case ColorMappingTarget.BITS_10:
                                    {
                                        // lower nibble in screen char
                                        byte value = screenChar.ByteAt(x + y * WidthChars);
                                        value &= 0xf0;
                                        value |= (byte)(colorIndex);

                                        screenChar.SetU8At(x + y * WidthChars, value);
                                    }
                                    break;

                                    case ColorMappingTarget.BITS_11:
                                        // color ram
                                        screenColor.SetU8At(x + y * WidthChars, colorIndex);
                                        break;
                                    }
                                    continue;
                                }

                                if (!usedPatterns.ContainsKey(colorIndex))
                                {
                                    usedPatterns.Add(colorIndex, new GR.Collections.Set <ColorMappingTarget>());
                                }
                                usedPatterns[colorIndex].Add(bitPattern[colorTarget]);

                                colorTarget = 0;
                                while ((colorTarget < 3) &&
                                       (usedBitPattern.ContainsValue(bitPattern[colorTarget])))
                                {
                                    ++colorTarget;
                                }
                                usedBitPattern.Add(bitPattern[colorTarget]);

                                if (colorTarget == 0)
                                {
                                    // upper screen char nibble
                                    byte value = screenChar.ByteAt(x + y * WidthChars);
                                    value &= 0x0f;
                                    value |= (byte)(colorIndex << 4);

                                    screenChar.SetU8At(x + y * WidthChars, value);
                                    usedColors[colorIndex] = ColorMappingTarget.BITS_01;
                                }
                                else if (colorTarget == 1)
                                {
                                    // lower nibble in screen char
                                    byte value = screenChar.ByteAt(x + y * WidthChars);
                                    value &= 0xf0;
                                    value |= (byte)(colorIndex);

                                    screenChar.SetU8At(x + y * WidthChars, value);
                                    usedColors[colorIndex] = ColorMappingTarget.BITS_10;
                                }
                                else if (colorTarget == 2)
                                {
                                    // color ram
                                    screenColor.SetU8At(x + y * WidthChars, colorIndex);
                                    usedColors[colorIndex] = ColorMappingTarget.BITS_11;
                                }
                                ++colorTarget;
                            }
                        }
                        // write out bits

                        /*
                         * Debug.Log( "For Char " + x + "," + y );
                         * foreach ( var usedColor in usedColors )
                         * {
                         * Debug.Log( " Color " + usedColor.Key + " = " + usedColor.Value );
                         * }*/
                        for (int charY = 0; charY < 8; ++charY)
                        {
                            for (int charX = 0; charX < 4; ++charX)
                            {
                                byte colorIndex = (byte)Image.GetPixel(x * 8 + charX * 2, y * 8 + charY);
                                if (colorIndex != Colors.BackgroundColor)
                                {
                                    // other color
                                    byte colorValue = 0;

                                    switch (usedColors[colorIndex])
                                    {
                                    case ColorMappingTarget.BITS_01:
                                        colorValue = 0x01;
                                        break;

                                    case ColorMappingTarget.BITS_10:
                                        colorValue = 0x02;
                                        break;

                                    case ColorMappingTarget.BITS_11:
                                        colorValue = 0x03;
                                        break;
                                    }
                                    int bitmapIndex = x * 8 + y * 8 * WidthChars + charY;

                                    byte value = bitmapData.ByteAt(bitmapIndex);
                                    if (charX == 0)
                                    {
                                        value &= 0x3f;
                                        value |= (byte)(colorValue << 6);
                                    }
                                    else if (charX == 1)
                                    {
                                        value &= 0xcf;
                                        value |= (byte)(colorValue << 4);
                                    }
                                    else if (charX == 2)
                                    {
                                        value &= 0xf3;
                                        value |= (byte)(colorValue << 2);
                                    }
                                    else
                                    {
                                        value &= 0xfc;
                                        value |= colorValue;
                                    }
                                    bitmapData.SetU8At(bitmapIndex, value);
                                }
                            }
                        }
                    }
                }
            }

            /*
             * Debug.Log( "Used patterns:" );
             * foreach ( var entry in usedPatterns )
             * {
             * Debug.Log( "Index " + entry.Key );
             * foreach ( var pattern in entry.Value )
             * {
             *  Debug.Log( " used " + pattern );
             * }
             * }*/
            return(numErrors);
        }
コード例 #3
0
        public bool ReadFromBuffer(GR.Memory.ByteBuffer DataIn)
        {
            if (DataIn == null)
            {
                return(false);
            }
            Data.Clear();
            JumpedAtAddresses.Clear();
            NamedLabels.Clear();
            Description = "";

            GR.IO.MemoryReader memIn = DataIn.MemoryReader();

            GR.IO.FileChunk chunk = new GR.IO.FileChunk();

            while (chunk.ReadFromStream(memIn))
            {
                var chunkReader = chunk.MemoryReader();
                switch (chunk.Type)
                {
                case FileChunkConstants.DISASSEMBLY_INFO:
                    Description = chunkReader.ReadString();
                    break;

                case FileChunkConstants.DISASSEMBLY_DATA:
                {
                    DataStartAddress = chunkReader.ReadInt32();
                    uint dataLength = chunkReader.ReadUInt32();

                    chunkReader.ReadBlock(Data, dataLength);
                }
                break;

                case FileChunkConstants.DISASSEMBLY_JUMP_ADDRESSES:
                {
                    int numEntries = chunkReader.ReadInt32();

                    for (int i = 0; i < numEntries; ++i)
                    {
                        int value = chunkReader.ReadInt32();
                        JumpedAtAddresses.Add(value);
                    }
                }
                break;

                case FileChunkConstants.DISASSEMBLY_NAMED_LABELS:
                {
                    int numEntries = chunkReader.ReadInt32();

                    for (int i = 0; i < numEntries; ++i)
                    {
                        int    address = chunkReader.ReadInt32();
                        string name    = chunkReader.ReadString();

                        NamedLabels[address] = name;
                    }
                }
                break;
                }
            }
            return(true);
        }
コード例 #4
0
        public void SetAssemblerType(Types.AssemblerType Type)
        {
            // set default settings
            AllowedSingleTokens = "";
            AllowedTokenChars.Clear();
            AllowedTokenEndChars.Clear();
            AllowedTokenStartChars.Clear();
            DefineSeparatorKeywords.Clear();
            Macros.Clear();
            StatementSeparatorChars.Clear();
            MacroPrefix                         = "";
            LabelPostfix                        = "";
            MacroFunctionCallPrefix             = "";
            MacroIsZone                         = false;
            MacrosHaveVariableNumberOfArguments = false;
            CaseSensitive                       = true;
            IncludeExpectsStringLiteral         = true;
            IncludeHasOnlyFilename              = false;
            HasBinaryNot                        = true;
            MacroKeywordAfterName               = false;
            MacrosUseCheapLabelsAsParameters    = false;
            LabelsMustBeAtStartOfLine           = false;
            GreaterOrLessThanAtBeginningAffectFullExpression = false;

            OperatorPrecedence.Clear();
            OperatorPrecedence["-"]   = 0;
            OperatorPrecedence["+"]   = 0;
            OperatorPrecedence["/"]   = 1;
            OperatorPrecedence["*"]   = 1;
            OperatorPrecedence["%"]   = 2;
            OperatorPrecedence["EOR"] = 3;
            OperatorPrecedence["eor"] = 3;
            OperatorPrecedence["XOR"] = 3;
            OperatorPrecedence["xor"] = 3;
            OperatorPrecedence["^"]   = 6;
            OperatorPrecedence["OR"]  = 4;
            OperatorPrecedence["or"]  = 4;
            OperatorPrecedence["|"]   = 4;
            OperatorPrecedence["AND"] = 5;
            OperatorPrecedence["and"] = 5;
            OperatorPrecedence["&"]   = 5;
            OperatorPrecedence[">>"]  = 6;
            OperatorPrecedence["<<"]  = 6;
            OperatorPrecedence["<>"]  = 6;
            OperatorPrecedence[">="]  = 6;
            OperatorPrecedence["<="]  = 6;
            OperatorPrecedence["!="]  = 6;
            OperatorPrecedence["="]   = 6;
            OperatorPrecedence[">"]   = 7;
            OperatorPrecedence["<"]   = 7;
            OperatorPrecedence["!"]   = 7;
            OperatorPrecedence["~"]   = 7;

            switch (Type)
            {
            case Types.AssemblerType.C64_STUDIO:
                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_GLOBAL] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzÄÖÜäöü_";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]   = "#";

                OpenBracketChars  = "(" + INTERNAL_OPENING_BRACE;
                CloseBracketChars = ")" + INTERNAL_CLOSING_BRACE;

                LineSeparatorChars = ":";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_LOCAL]       = ".";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_LOCAL]            = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";
                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_CHEAP_LOCAL] = "@";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_CHEAP_LOCAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_CHAR] = "'";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_CHAR]   = "'";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_STRING] = "\"";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_STRING]   = "\"";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_NUMBER] = "0123456789abcdefABCDEF$%";
                AllowedTokenChars[Types.TokenInfo.TokenType.LITERAL_NUMBER]      = "0123456789abcdefABCDEFx";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.COMMENT] = ";";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.MACRO] = "!";
                AllowedTokenChars[Types.TokenInfo.TokenType.MACRO]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_INTERNAL] = "+-";

                AllowedSingleTokens = ",#{}*" + OpenBracketChars + CloseBracketChars;

                AddMacro("!ADDR", Types.MacroInfo.MacroType.ADDRESS);
                AddMacro("!ADDRESS", Types.MacroInfo.MacroType.ADDRESS);
                AddMacro("!BYTE", Types.MacroInfo.MacroType.BYTE);
                AddMacro("!BY", Types.MacroInfo.MacroType.BYTE);
                AddMacro("!BASIC", Types.MacroInfo.MacroType.BASIC);
                AddMacro("!8", Types.MacroInfo.MacroType.BYTE);
                AddMacro("!08", Types.MacroInfo.MacroType.BYTE);
                AddMacro("!WORD", Types.MacroInfo.MacroType.WORD);
                AddMacro("!WO", Types.MacroInfo.MacroType.WORD);
                AddMacro("!16", Types.MacroInfo.MacroType.WORD);
                AddMacro("!TEXT", Types.MacroInfo.MacroType.TEXT);
                AddMacro("!TX", Types.MacroInfo.MacroType.TEXT);
                AddMacro("!SCR", Types.MacroInfo.MacroType.TEXT_SCREEN);
                AddMacro("!PET", Types.MacroInfo.MacroType.TEXT_PET);
                AddMacro("!RAW", Types.MacroInfo.MacroType.TEXT_RAW);
                AddMacro("!PSEUDOPC", Types.MacroInfo.MacroType.PSEUDO_PC);
                AddMacro("!REALPC", Types.MacroInfo.MacroType.REAL_PC);
                AddMacro("!BANK", Types.MacroInfo.MacroType.BANK);
                AddMacro("!CONVTAB", Types.MacroInfo.MacroType.CONVERSION_TAB);
                AddMacro("!CT", Types.MacroInfo.MacroType.CONVERSION_TAB);
                AddMacro("!BINARY", Types.MacroInfo.MacroType.INCLUDE_BINARY);
                AddMacro("!BIN", Types.MacroInfo.MacroType.INCLUDE_BINARY);
                AddMacro("!BI", Types.MacroInfo.MacroType.INCLUDE_BINARY);
                AddMacro("!SOURCE", Types.MacroInfo.MacroType.INCLUDE_SOURCE);
                AddMacro("!SRC", Types.MacroInfo.MacroType.INCLUDE_SOURCE);
                AddMacro("!TO", Types.MacroInfo.MacroType.COMPILE_TARGET);
                AddMacro("!ZONE", Types.MacroInfo.MacroType.ZONE);
                AddMacro("!ZN", Types.MacroInfo.MacroType.ZONE);
                AddMacro("!ERROR", Types.MacroInfo.MacroType.ERROR);
                AddMacro("!SERIOUS", Types.MacroInfo.MacroType.ERROR);
                AddMacro("!WARN", Types.MacroInfo.MacroType.WARN);
                AddMacro("!MESSAGE", Types.MacroInfo.MacroType.MESSAGE);
                AddMacro("!IFDEF", Types.MacroInfo.MacroType.IFDEF);
                AddMacro("!IFNDEF", Types.MacroInfo.MacroType.IFNDEF);
                AddMacro("!IF", Types.MacroInfo.MacroType.IF);
                AddMacro("!FILL", Types.MacroInfo.MacroType.FILL);
                AddMacro("!FI", Types.MacroInfo.MacroType.FILL);
                AddMacro("!ALIGN", Types.MacroInfo.MacroType.ALIGN);
                AddMacro("!ENDOFFILE", Types.MacroInfo.MacroType.END_OF_FILE);
                AddMacro("!EOF", Types.MacroInfo.MacroType.END_OF_FILE);
                AddMacro("!NOWARN", Types.MacroInfo.MacroType.NO_WARNING);
                AddMacro("!FOR", Types.MacroInfo.MacroType.FOR);
                AddMacro("!END", Types.MacroInfo.MacroType.END);
                AddMacro("!MACRO", Types.MacroInfo.MacroType.MACRO);
                AddMacro("!TRACE", Types.MacroInfo.MacroType.TRACE);
                AddMacro("!MEDIA", Types.MacroInfo.MacroType.INCLUDE_MEDIA);
                AddMacro("!MEDIASRC", Types.MacroInfo.MacroType.INCLUDE_MEDIA_SOURCE);
                AddMacro("!HEX", Types.MacroInfo.MacroType.HEX);
                AddMacro("!H", Types.MacroInfo.MacroType.HEX);
                AddMacro("!SL", Types.MacroInfo.MacroType.LABEL_FILE);
                AddMacro("!CPU", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("!SET", Types.MacroInfo.MacroType.SET);

                // helper pseudo ops from ACME to generate some address vs. value warnings
                //AddMacro( "!ADDR", Types.MacroInfo.MacroType.IGNORE );
                //AddMacro( "!ADDRESS", Types.MacroInfo.MacroType.IGNORE );

                MacroPrefix             = "!";
                MacroFunctionCallPrefix = "+";
                GlobalLabelsAutoZone    = false;
                DefineSeparatorKeywords.Add("=");
                IncludeExpectsStringLiteral = true;
                StatementSeparatorChars.Add(':');
                break;

            case Types.AssemblerType.DASM:
                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_GLOBAL] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzÄÖÜäöü";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]   = "#:";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_LOCAL] = ".";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_LOCAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";

                OpenBracketChars  = "(" + INTERNAL_OPENING_BRACE;
                CloseBracketChars = ")" + INTERNAL_CLOSING_BRACE;

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_CHAR] = "'";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_CHAR]   = "'";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_STRING] = "\"";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_STRING]   = "\"";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_NUMBER] = "0123456789abcdefABCDEF$%";
                AllowedTokenChars[Types.TokenInfo.TokenType.LITERAL_NUMBER]      = "0123456789abcdefABCDEFx";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.COMMENT] = ";";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.MACRO] = "!";
                AllowedTokenChars[Types.TokenInfo.TokenType.MACRO]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.CALL_MACRO] = ":";
                AllowedTokenChars[Types.TokenInfo.TokenType.CALL_MACRO]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";

                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_INTERNAL] = "+-";

                AllowedSingleTokens = ",#*" + OpenBracketChars + CloseBracketChars;

                AddMacro("DC.B", Types.MacroInfo.MacroType.TEXT);
                AddMacro("DC.W", Types.MacroInfo.MacroType.WORD);
                AddMacro("MAC", Types.MacroInfo.MacroType.MACRO);
                AddMacro("ENDM", Types.MacroInfo.MacroType.END);
                AddMacro("!TEXT", Types.MacroInfo.MacroType.TEXT);
                AddMacro("!TX", Types.MacroInfo.MacroType.TEXT);
                AddMacro("!SCR", Types.MacroInfo.MacroType.TEXT_SCREEN);
                AddMacro("RORG", Types.MacroInfo.MacroType.PSEUDO_PC);
                AddMacro("REND", Types.MacroInfo.MacroType.REAL_PC);
                AddMacro("!BANK", Types.MacroInfo.MacroType.BANK);
                AddMacro("!CONVTAB", Types.MacroInfo.MacroType.CONVERSION_TAB);
                AddMacro("!CT", Types.MacroInfo.MacroType.CONVERSION_TAB);
                AddMacro("INCBIN", Types.MacroInfo.MacroType.INCLUDE_BINARY);
                AddMacro("INCLUDE", Types.MacroInfo.MacroType.INCLUDE_SOURCE);
                AddMacro("!TO", Types.MacroInfo.MacroType.COMPILE_TARGET);
                AddMacro("SUBROUTINE", Types.MacroInfo.MacroType.ZONE);
                AddMacro("!ERROR", Types.MacroInfo.MacroType.ERROR);
                AddMacro("!IFDEF", Types.MacroInfo.MacroType.IFDEF);
                AddMacro("!IFNDEF", Types.MacroInfo.MacroType.IFNDEF);
                AddMacro("IF", Types.MacroInfo.MacroType.IF);
                AddMacro("ELSE", Types.MacroInfo.MacroType.ELSE);
                AddMacro("ENDIF", Types.MacroInfo.MacroType.END_IF);
                AddMacro("DS.Z", Types.MacroInfo.MacroType.FILL);
                AddMacro("DS", Types.MacroInfo.MacroType.FILL);
                AddMacro("DS.B", Types.MacroInfo.MacroType.FILL);
                AddMacro("ALIGN", Types.MacroInfo.MacroType.ALIGN_DASM);
                AddMacro("!ENDOFFILE", Types.MacroInfo.MacroType.END_OF_FILE);

                AddMacro("REPEAT", Types.MacroInfo.MacroType.LOOP_START);
                AddMacro("REPEND", Types.MacroInfo.MacroType.LOOP_END);

                AddMacro("PROCESSOR", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("ORG", Types.MacroInfo.MacroType.ORG);
                AddMacro("SEG", Types.MacroInfo.MacroType.SEG);
                AddMacro("SEG.U", Types.MacroInfo.MacroType.SEG);

                LabelPostfix            = ":";
                MacroFunctionCallPrefix = ":";
                GlobalLabelsAutoZone    = false;
                DefineSeparatorKeywords.Add("SET");
                DefineSeparatorKeywords.Add("=");
                MacroIsZone = true;
                MacrosHaveVariableNumberOfArguments = true;
                IncludeExpectsStringLiteral         = false;
                CaseSensitive = false;
                break;

            case Types.AssemblerType.PDS:
                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_GLOBAL] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzÄÖÜäöü";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]   = "#";

                OpenBracketChars  = "([" + INTERNAL_OPENING_BRACE;
                CloseBracketChars = ")]" + INTERNAL_CLOSING_BRACE;

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_LOCAL] = "!:";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_LOCAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß!";

                // we misuse cheap labels as macro parameters
                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_CHEAP_LOCAL] = "@";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_CHEAP_LOCAL]      = "0123456789";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_CHAR] = "'";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_CHAR]   = "'";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_STRING] = "\"";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_STRING]   = "\"";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_NUMBER] = "0123456789abcdefABCDEF&$%";
                AllowedTokenChars[Types.TokenInfo.TokenType.LITERAL_NUMBER]      = "0123456789abcdefABCDEFx";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.COMMENT] = ";";
                AllowedTokenStartChars[Types.TokenInfo.TokenType.COMMENT_IF_FIRST_CHAR] = "*";

                AllowedTokenChars[Types.TokenInfo.TokenType.SINGLE_CHAR]      = "\\.";
                AllowedTokenStartChars[Types.TokenInfo.TokenType.SINGLE_CHAR] = "\\.";

                /*
                 * AllowedTokenStartChars[Types.TokenInfo.TokenType.MACRO] = "!";
                 * AllowedTokenChars[Types.TokenInfo.TokenType.MACRO] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
                 */

                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_INTERNAL] = "+-";

                AllowedSingleTokens = ",#*" + OpenBracketChars + CloseBracketChars;

                AddMacro("DC.B", Types.MacroInfo.MacroType.TEXT);
                AddMacro("DC.V", Types.MacroInfo.MacroType.TEXT);
                AddMacro("DB", Types.MacroInfo.MacroType.TEXT);
                AddMacro("DEFM", Types.MacroInfo.MacroType.TEXT);
                AddMacro("DM", Types.MacroInfo.MacroType.TEXT);
                AddMacro("DFM", Types.MacroInfo.MacroType.TEXT);
                AddMacro("DH", Types.MacroInfo.MacroType.HIGH_BYTE);
                AddMacro("DL", Types.MacroInfo.MacroType.LOW_BYTE);
                AddMacro("DW", Types.MacroInfo.MacroType.WORD);
                AddMacro("HEX", Types.MacroInfo.MacroType.HEX);
                AddMacro("CBM", Types.MacroInfo.MacroType.TEXT_SCREEN);
                AddMacro("INCBIN", Types.MacroInfo.MacroType.INCLUDE_BINARY);
                AddMacro("INCLUDE", Types.MacroInfo.MacroType.INCLUDE_SOURCE);
                AddMacro("ERROR", Types.MacroInfo.MacroType.ERROR);
                AddMacro("IF", Types.MacroInfo.MacroType.IF);
                AddMacro("ENDIF", Types.MacroInfo.MacroType.END_IF);
                AddMacro("ELSE", Types.MacroInfo.MacroType.ELSE);
                AddMacro("DS", Types.MacroInfo.MacroType.FILL);
                AddMacro("DO", Types.MacroInfo.MacroType.LOOP_START);
                AddMacro("LOOP", Types.MacroInfo.MacroType.LOOP_END);
                AddMacro("UNTIL", Types.MacroInfo.MacroType.LOOP_END);
                AddMacro("MACRO", Types.MacroInfo.MacroType.MACRO);
                AddMacro("ENDM", Types.MacroInfo.MacroType.END);

                AddMacro("PROCESSOR", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("ORG", Types.MacroInfo.MacroType.ORG);
                AddMacro("FREE", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("SEND", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("SKIP", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("INFO", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("RUN", Types.MacroInfo.MacroType.IGNORE);

                AddMacro("EXEC", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("START", Types.MacroInfo.MacroType.IGNORE);

                AddMacro("DSECT", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("DEND", Types.MacroInfo.MacroType.IGNORE);

                AddMacro("MSW", Types.MacroInfo.MacroType.IGNORE);

                AddMacro("END", Types.MacroInfo.MacroType.END_OF_FILE);
                AddMacro("REPEAT", Types.MacroInfo.MacroType.REPEAT);

                OperatorPrecedence["!"] = 4;

                LabelPostfix         = ":";
                GlobalLabelsAutoZone = true;
                DefineSeparatorKeywords.Add("EQU");
                DefineSeparatorKeywords.Add("=");
                CaseSensitive = false;
                IncludeExpectsStringLiteral = false;
                IncludeHasOnlyFilename      = true;
                StatementSeparatorChars.Add(':');
                MacroKeywordAfterName               = true;
                DoWithoutParameterIsUntil           = true;
                MacrosHaveVariableNumberOfArguments = true;
                MacrosUseCheapLabelsAsParameters    = true;
                HasBinaryNot = false;
                LabelsMustBeAtStartOfLine = true;
                GreaterOrLessThanAtBeginningAffectFullExpression = true;
                break;

            case Types.AssemblerType.C64ASM:
                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_GLOBAL] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzÄÖÜäöü";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]   = "#";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_LOCAL] = "_";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_LOCAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";

                OpenBracketChars  = "(" + INTERNAL_OPENING_BRACE;
                CloseBracketChars = ")" + INTERNAL_CLOSING_BRACE;

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_CHAR] = "'";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_CHAR]   = "'";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_STRING] = "\"";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_STRING]   = "\"";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_NUMBER] = "0123456789abcdefABCDEF$%";
                AllowedTokenChars[Types.TokenInfo.TokenType.LITERAL_NUMBER]      = "0123456789abcdefABCDEFx";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.COMMENT] = ";";
                //AllowedTokenStartChars[Types.TokenInfo.TokenType.COMMENT_IF_FIRST_CHAR] = "*";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.MACRO] = ".";
                AllowedTokenChars[Types.TokenInfo.TokenType.MACRO]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_INTERNAL] = "+-";

                AllowedSingleTokens = ",#{}*" + OpenBracketChars + CloseBracketChars;

                MacroPrefix = ".";

                AddMacro(".BYTE", Types.MacroInfo.MacroType.BYTE);
                AddMacro(".WORD", Types.MacroInfo.MacroType.WORD);

                GlobalLabelsAutoZone = true;
                DefineSeparatorKeywords.Add("=");
                CaseSensitive = false;
                IncludeExpectsStringLiteral = true;
                break;

            case Types.AssemblerType.CBMPRGSTUDIO:
                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_GLOBAL] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzÄÖÜäöü";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]   = "#:";

                OpenBracketChars  = "(" + INTERNAL_OPENING_BRACE;
                CloseBracketChars = ")" + INTERNAL_CLOSING_BRACE;

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_LOCAL] = ".";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_LOCAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_CHAR] = "'";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_CHAR]   = "'";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_STRING] = "\"";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_STRING]   = "\"";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_NUMBER] = "0123456789abcdefABCDEF$%";
                AllowedTokenChars[Types.TokenInfo.TokenType.LITERAL_NUMBER]      = "0123456789abcdefABCDEFx";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.COMMENT] = ";";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.MACRO] = "!";
                AllowedTokenChars[Types.TokenInfo.TokenType.MACRO]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.CALL_MACRO] = ":";
                AllowedTokenChars[Types.TokenInfo.TokenType.CALL_MACRO]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";

                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_INTERNAL] = "+-";

                AllowedSingleTokens = ",#*" + OpenBracketChars + CloseBracketChars;

                AddMacro("DC.B", Types.MacroInfo.MacroType.TEXT);
                AddMacro("DC.W", Types.MacroInfo.MacroType.WORD);
                AddMacro("MAC", Types.MacroInfo.MacroType.MACRO);
                AddMacro("ENDM", Types.MacroInfo.MacroType.END);
                AddMacro("!TEXT", Types.MacroInfo.MacroType.TEXT);
                AddMacro("!TX", Types.MacroInfo.MacroType.TEXT);
                AddMacro("!SCR", Types.MacroInfo.MacroType.TEXT_SCREEN);
                AddMacro("RORG", Types.MacroInfo.MacroType.PSEUDO_PC);
                AddMacro("REND", Types.MacroInfo.MacroType.REAL_PC);
                AddMacro("!BANK", Types.MacroInfo.MacroType.BANK);
                AddMacro("!CONVTAB", Types.MacroInfo.MacroType.CONVERSION_TAB);
                AddMacro("!CT", Types.MacroInfo.MacroType.CONVERSION_TAB);
                AddMacro("INCBIN", Types.MacroInfo.MacroType.INCLUDE_BINARY);
                AddMacro("INCLUDE", Types.MacroInfo.MacroType.INCLUDE_SOURCE);
                AddMacro("!TO", Types.MacroInfo.MacroType.COMPILE_TARGET);
                AddMacro("SUBROUTINE", Types.MacroInfo.MacroType.ZONE);
                AddMacro("!ERROR", Types.MacroInfo.MacroType.ERROR);
                AddMacro("!IFDEF", Types.MacroInfo.MacroType.IFDEF);
                AddMacro("!IFNDEF", Types.MacroInfo.MacroType.IFNDEF);
                AddMacro("IF", Types.MacroInfo.MacroType.IF);
                AddMacro("ELSE", Types.MacroInfo.MacroType.ELSE);
                AddMacro("ENDIF", Types.MacroInfo.MacroType.END_IF);
                AddMacro("DS.Z", Types.MacroInfo.MacroType.FILL);
                AddMacro("DS", Types.MacroInfo.MacroType.FILL);
                AddMacro("DS.B", Types.MacroInfo.MacroType.FILL);
                AddMacro("ALIGN", Types.MacroInfo.MacroType.ALIGN_DASM);
                AddMacro("!ENDOFFILE", Types.MacroInfo.MacroType.END_OF_FILE);

                AddMacro("REPEAT", Types.MacroInfo.MacroType.LOOP_START);
                AddMacro("REPEND", Types.MacroInfo.MacroType.LOOP_END);

                AddMacro("PROCESSOR", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("ORG", Types.MacroInfo.MacroType.ORG);
                AddMacro("SEG", Types.MacroInfo.MacroType.SEG);
                AddMacro("SEG.U", Types.MacroInfo.MacroType.SEG);
                AddMacro("BYTE", Types.MacroInfo.MacroType.BYTE);

                LabelPostfix            = ":";
                MacroFunctionCallPrefix = ":";
                GlobalLabelsAutoZone    = false;
                DefineSeparatorKeywords.Add("SET");
                DefineSeparatorKeywords.Add("=");
                MacroIsZone = true;
                MacrosHaveVariableNumberOfArguments = true;
                IncludeExpectsStringLiteral         = false;
                break;
            }
        }
コード例 #5
0
ファイル: StudioSettings.cs プロジェクト: wowjinxy/C64Studio
        public bool ReadFromBuffer(GR.Memory.ByteBuffer SettingsData)
        {
            IgnoredWarnings.Clear();

            GR.IO.BinaryReader binReader = new GR.IO.BinaryReader(SettingsData.MemoryStream());

            GR.IO.FileChunk chunkData = new GR.IO.FileChunk();

            while (chunkData.ReadFromStream(binReader))
            {
                switch (chunkData.Type)
                {
                case Types.FileChunk.SETTINGS_TOOL:
                {
                    ToolInfo tool = new ToolInfo();

                    tool.FromChunk(chunkData);

                    // sanitize args
                    tool.CartArguments = tool.CartArguments.Replace("$(BuildTargetFilename)", "$(RunFilename)");
                    tool.PRGArguments  = tool.PRGArguments.Replace("$(BuildTargetFilename)", "$(RunFilename)");
                    tool.WorkPath      = tool.WorkPath.Replace("$(FilePath)", "$(RunPath)");

                    if (string.IsNullOrEmpty(tool.TrueDriveOnArguments))
                    {
                        tool.TrueDriveOnArguments  = "-truedrive +virtualdev";
                        tool.TrueDriveOffArguments = "+truedrive -virtualdev";
                    }
                    if (tool.PRGArguments.Contains("-truedrive "))
                    {
                        tool.PRGArguments = tool.PRGArguments.Replace("-truedrive ", "");
                    }
                    if (tool.PRGArguments.Contains(" -truedrive"))
                    {
                        tool.PRGArguments = tool.PRGArguments.Replace(" -truedrive", "");
                    }
                    ToolInfos.AddLast(tool);
                }
                break;

                case Types.FileChunk.SETTINGS_ACCELERATOR:
                {
                    AcceleratorKey key = new AcceleratorKey();

                    key.FromChunk(chunkData);

                    Accelerators.Add(key.Key, key);
                }
                break;

                case Types.FileChunk.SETTINGS_DPS_LAYOUT:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    uint size = binIn.ReadUInt32();
                    GR.Memory.ByteBuffer tempData = new GR.Memory.ByteBuffer();
                    binIn.ReadBlock(tempData, size);
                    SetLayoutFromData(tempData);
                }
                break;

                case Types.FileChunk.SETTINGS_SOUND:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    PlaySoundOnSuccessfulBuild   = (binIn.ReadUInt8() != 0);
                    PlaySoundOnBuildFailure      = (binIn.ReadUInt8() != 0);
                    PlaySoundOnSearchFoundNoItem = (binIn.ReadUInt8() != 0);
                }
                break;

                case Types.FileChunk.SETTINGS_WINDOW:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    MainWindowPlacement = binIn.ReadString();
                }
                break;

                case Types.FileChunk.SETTINGS_TABS:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    TabSize = binIn.ReadInt32();
                    if ((TabSize <= 0) ||
                        (TabSize >= 100))
                    {
                        TabSize = 2;
                    }
                    AllowTabs          = (binIn.ReadUInt8() != 0);
                    TabConvertToSpaces = (binIn.ReadUInt8() != 0);
                }
                break;

                case Types.FileChunk.SETTINGS_FONT:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    SourceFontFamily = binIn.ReadString();
                    SourceFontSize   = (float)binIn.ReadInt32();

                    BASICUseNonC64Font    = (binIn.ReadUInt8() != 0);
                    BASICSourceFontFamily = binIn.ReadString();
                    BASICSourceFontSize   = (float)binIn.ReadInt32();
                    if (BASICSourceFontSize <= 0)
                    {
                        BASICSourceFontSize = 9.0f;
                    }
                }
                break;

                case Types.FileChunk.SETTINGS_SYNTAX_COLORING:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    Types.SyntaxElement element = (C64Studio.Types.SyntaxElement)binIn.ReadUInt32();

                    Types.SyntaxColor color = new C64Studio.Types.SyntaxColor(GR.EnumHelper.GetDescription(element));
                    color.FGColor     = binIn.ReadUInt32();
                    color.BGColor     = binIn.ReadUInt32();
                    color.BGColorAuto = (binIn.ReadUInt32() != 0);

                    SyntaxColoring.Add(element, color);
                }
                break;

                case Types.FileChunk.SETTINGS_UI:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    ToolbarActiveMain     = (binIn.ReadUInt8() == 1);
                    ToolbarActiveDebugger = (binIn.ReadUInt8() == 1);
                }
                break;

                case Types.FileChunk.SETTINGS_RUN_EMULATOR:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    TrueDriveEnabled = (binIn.ReadUInt8() != 0);
                }
                break;

                case Types.FileChunk.SETTINGS_DEFAULTS:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    DefaultProjectBasePath = binIn.ReadString();
                }
                break;

                case Types.FileChunk.SETTINGS_FIND_REPLACE:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    LastFindIgnoreCase = (binIn.ReadUInt8() == 1);
                    LastFindWholeWord  = (binIn.ReadUInt8() == 1);
                    LastFindRegexp     = (binIn.ReadUInt8() == 1);
                    LastFindWrap       = (binIn.ReadUInt8() == 1);
                    LastFindTarget     = binIn.ReadUInt8();

                    int numFindArguments = binIn.ReadInt32();
                    for (int i = 0; i < numFindArguments; ++i)
                    {
                        FindArguments.Add(binIn.ReadString());
                    }
                    int numReplaceArguments = binIn.ReadInt32();
                    for (int i = 0; i < numReplaceArguments; ++i)
                    {
                        ReplaceArguments.Add(binIn.ReadString());
                    }
                }
                break;

                case Types.FileChunk.SETTINGS_IGNORED_WARNINGS:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    int numIgnoredWarnings = binIn.ReadInt32();

                    for (int i = 0; i < numIgnoredWarnings; ++i)
                    {
                        IgnoredWarnings.Add((C64Studio.Types.ErrorCode)binIn.ReadInt32());
                    }
                }
                break;

                case Types.FileChunk.SETTINGS_PANEL_DISPLAY_DETAILS:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    string toolName = binIn.ReadString();

                    if (GenericTools.ContainsKey(toolName))
                    {
                        uint length = binIn.ReadUInt32();
                        GR.Memory.ByteBuffer data = new GR.Memory.ByteBuffer();

                        binIn.ReadBlock(data, length);
                        GenericTools[toolName].ApplyDisplayDetails(data);
                    }
                }
                break;

                case Types.FileChunk.SETTINGS_BASIC_KEYMAP:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    int numEntries = binIn.ReadInt32();

                    uint neutralLang = (uint)(System.Globalization.CultureInfo.CurrentCulture.KeyboardLayoutId & 0xff);

                    if ((neutralLang != 7) &&
                        (neutralLang != 9))
                    {
                        neutralLang = 9;
                    }

                    for (int i = 0; i < numEntries; ++i)
                    {
                        Keys key = (Keys)binIn.ReadUInt32();
                        Types.KeyboardKey cmdKey = (C64Studio.Types.KeyboardKey)binIn.ReadInt32();

                        var keyMapEntry = new KeymapEntry();

                        foreach (var entry in BASICKeyMap.DefaultKeymaps[neutralLang])
                        {
                            if (entry.Value.KeyboardKey == cmdKey)
                            {
                                BASICKeyMap.Keymap[key] = entry.Value;
                                break;
                            }
                        }
                    }
                }
                break;

                case Types.FileChunk.SETTINGS_ASSEMBLER_EDITOR:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    ASMHideLineNumbers = (binIn.ReadUInt8() != 0);
                }
                break;

                case Types.FileChunk.SETTINGS_BASIC_PARSER:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    BASICStripSpaces = (binIn.ReadUInt8() != 0);
                }
                break;

                case Types.FileChunk.SETTINGS_ENVIRONMENT:
                {
                    GR.IO.IReader binIn = chunkData.MemoryReader();

                    AutoOpenLastSolution = (binIn.ReadUInt8() != 0);
                }
                break;
                }
            }
            return(true);
        }
コード例 #6
0
        public void SetAssemblerType(Types.AssemblerType Type)
        {
            AllowedSingleTokens = "";
            AllowedTokenChars.Clear();
            AllowedTokenEndChars.Clear();
            AllowedTokenStartChars.Clear();
            DefineSeparatorKeywords.Clear();
            Macros.Clear();
            StatementSeparatorChars.Clear();
            MacroPrefix                         = "";
            LabelPostfix                        = "";
            MacroFunctionCallPrefix             = "";
            MacroIsZone                         = false;
            MacrosHaveVariableNumberOfArguments = false;
            CaseSensitive                       = true;

            switch (Type)
            {
            case Types.AssemblerType.C64_STUDIO:
                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_GLOBAL] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzÄÖÜäöü_";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";
                //AllowedTokenEndChars[Types.TokenInfo.TokenType.LABEL_GLOBAL] = "#:";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LABEL_GLOBAL] = "#";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_LOCAL]       = ".";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_LOCAL]            = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";
                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_CHEAP_LOCAL] = "@";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_CHEAP_LOCAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_CHAR] = "'";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_CHAR]   = "'";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_STRING] = "\"";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_STRING]   = "\"";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_NUMBER] = "0123456789abcdefABCDEF$%";
                AllowedTokenChars[Types.TokenInfo.TokenType.LITERAL_NUMBER]      = "0123456789abcdefABCDEFx";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.COMMENT] = ";";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.MACRO] = "!";
                AllowedTokenChars[Types.TokenInfo.TokenType.MACRO]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_INTERNAL] = "+-";

                AllowedSingleTokens = ",#(){}*" + INTERNAL_OPENING_BRACE + INTERNAL_CLOSING_BRACE;

                AddMacro("!ADDR", Types.MacroInfo.MacroType.ADDRESS);
                AddMacro("!ADDRESS", Types.MacroInfo.MacroType.ADDRESS);
                AddMacro("!BYTE", Types.MacroInfo.MacroType.BYTE);
                AddMacro("!BY", Types.MacroInfo.MacroType.BYTE);
                AddMacro("!BASIC", Types.MacroInfo.MacroType.BASIC);
                AddMacro("!8", Types.MacroInfo.MacroType.BYTE);
                AddMacro("!08", Types.MacroInfo.MacroType.BYTE);
                AddMacro("!WORD", Types.MacroInfo.MacroType.WORD);
                AddMacro("!WO", Types.MacroInfo.MacroType.WORD);
                AddMacro("!16", Types.MacroInfo.MacroType.WORD);
                AddMacro("!TEXT", Types.MacroInfo.MacroType.TEXT);
                AddMacro("!TX", Types.MacroInfo.MacroType.TEXT);
                AddMacro("!SCR", Types.MacroInfo.MacroType.TEXT_SCREEN);
                AddMacro("!PET", Types.MacroInfo.MacroType.TEXT_PET);
                AddMacro("!RAW", Types.MacroInfo.MacroType.TEXT_RAW);
                AddMacro("!PSEUDOPC", Types.MacroInfo.MacroType.PSEUDO_PC);
                AddMacro("!REALPC", Types.MacroInfo.MacroType.REAL_PC);
                AddMacro("!BANK", Types.MacroInfo.MacroType.BANK);
                AddMacro("!CONVTAB", Types.MacroInfo.MacroType.CONVERSION_TAB);
                AddMacro("!CT", Types.MacroInfo.MacroType.CONVERSION_TAB);
                AddMacro("!BINARY", Types.MacroInfo.MacroType.INCLUDE_BINARY);
                AddMacro("!BIN", Types.MacroInfo.MacroType.INCLUDE_BINARY);
                AddMacro("!BI", Types.MacroInfo.MacroType.INCLUDE_BINARY);
                AddMacro("!SOURCE", Types.MacroInfo.MacroType.INCLUDE_SOURCE);
                AddMacro("!SRC", Types.MacroInfo.MacroType.INCLUDE_SOURCE);
                AddMacro("!TO", Types.MacroInfo.MacroType.COMPILE_TARGET);
                AddMacro("!ZONE", Types.MacroInfo.MacroType.ZONE);
                AddMacro("!ZN", Types.MacroInfo.MacroType.ZONE);
                AddMacro("!ERROR", Types.MacroInfo.MacroType.ERROR);
                AddMacro("!SERIOUS", Types.MacroInfo.MacroType.ERROR);
                AddMacro("!WARN", Types.MacroInfo.MacroType.WARN);
                AddMacro("!MESSAGE", Types.MacroInfo.MacroType.MESSAGE);
                AddMacro("!IFDEF", Types.MacroInfo.MacroType.IFDEF);
                AddMacro("!IFNDEF", Types.MacroInfo.MacroType.IFNDEF);
                AddMacro("!IF", Types.MacroInfo.MacroType.IF);
                AddMacro("!FILL", Types.MacroInfo.MacroType.FILL);
                AddMacro("!FI", Types.MacroInfo.MacroType.FILL);
                AddMacro("!ALIGN", Types.MacroInfo.MacroType.ALIGN);
                AddMacro("!ENDOFFILE", Types.MacroInfo.MacroType.END_OF_FILE);
                AddMacro("!EOF", Types.MacroInfo.MacroType.END_OF_FILE);
                AddMacro("!NOWARN", Types.MacroInfo.MacroType.NO_WARNING);
                AddMacro("!FOR", Types.MacroInfo.MacroType.FOR);
                AddMacro("!END", Types.MacroInfo.MacroType.END);
                AddMacro("!MACRO", Types.MacroInfo.MacroType.MACRO);
                AddMacro("!TRACE", Types.MacroInfo.MacroType.TRACE);
                AddMacro("!MEDIA", Types.MacroInfo.MacroType.INCLUDE_MEDIA);
                AddMacro("!MEDIASRC", Types.MacroInfo.MacroType.INCLUDE_MEDIA_SOURCE);
                AddMacro("!SL", Types.MacroInfo.MacroType.LABEL_FILE);
                AddMacro("!CPU", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("!SET", Types.MacroInfo.MacroType.SET);

                // helper pseudo ops from ACME to generate some address vs. value warnings
                //AddMacro( "!ADDR", Types.MacroInfo.MacroType.IGNORE );
                //AddMacro( "!ADDRESS", Types.MacroInfo.MacroType.IGNORE );

                MacroPrefix             = "!";
                MacroFunctionCallPrefix = "+";
                GlobalLabelsAutoZone    = false;
                DefineSeparatorKeywords.Add("=");
                IncludeExpectsStringLiteral = true;
                StatementSeparatorChars.Add(':');
                break;

            case Types.AssemblerType.DASM:
                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_GLOBAL] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzÄÖÜäöü";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]   = "#:";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_LOCAL] = ".";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_LOCAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_CHAR] = "'";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_CHAR]   = "'";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_STRING] = "\"";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_STRING]   = "\"";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_NUMBER] = "0123456789abcdefABCDEF$%";
                AllowedTokenChars[Types.TokenInfo.TokenType.LITERAL_NUMBER]      = "0123456789abcdefABCDEFx";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.COMMENT] = ";";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.MACRO] = "!";
                AllowedTokenChars[Types.TokenInfo.TokenType.MACRO]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.CALL_MACRO] = ":";
                AllowedTokenChars[Types.TokenInfo.TokenType.CALL_MACRO]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";

                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_INTERNAL] = "+-";

                AllowedSingleTokens = ",#(){}*";

                AddMacro("DC.B", Types.MacroInfo.MacroType.TEXT);
                AddMacro("DC.W", Types.MacroInfo.MacroType.WORD);
                AddMacro("MAC", Types.MacroInfo.MacroType.MACRO);
                AddMacro("ENDM", Types.MacroInfo.MacroType.END);
                AddMacro("!TEXT", Types.MacroInfo.MacroType.TEXT);
                AddMacro("!TX", Types.MacroInfo.MacroType.TEXT);
                AddMacro("!SCR", Types.MacroInfo.MacroType.TEXT_SCREEN);
                AddMacro("RORG", Types.MacroInfo.MacroType.PSEUDO_PC);
                AddMacro("REND", Types.MacroInfo.MacroType.REAL_PC);
                AddMacro("!BANK", Types.MacroInfo.MacroType.BANK);
                AddMacro("!CONVTAB", Types.MacroInfo.MacroType.CONVERSION_TAB);
                AddMacro("!CT", Types.MacroInfo.MacroType.CONVERSION_TAB);
                AddMacro("INCBIN", Types.MacroInfo.MacroType.INCLUDE_BINARY);
                AddMacro("INCLUDE", Types.MacroInfo.MacroType.INCLUDE_SOURCE);
                AddMacro("!TO", Types.MacroInfo.MacroType.COMPILE_TARGET);
                AddMacro("SUBROUTINE", Types.MacroInfo.MacroType.ZONE);
                AddMacro("!ERROR", Types.MacroInfo.MacroType.ERROR);
                AddMacro("!IFDEF", Types.MacroInfo.MacroType.IFDEF);
                AddMacro("!IFNDEF", Types.MacroInfo.MacroType.IFNDEF);
                AddMacro("IF", Types.MacroInfo.MacroType.IF);
                AddMacro("ELSE", Types.MacroInfo.MacroType.ELSE);
                AddMacro("ENDIF", Types.MacroInfo.MacroType.END_IF);
                AddMacro("DS.Z", Types.MacroInfo.MacroType.FILL);
                AddMacro("DS", Types.MacroInfo.MacroType.FILL);
                AddMacro("DS.B", Types.MacroInfo.MacroType.FILL);
                AddMacro("ALIGN", Types.MacroInfo.MacroType.ALIGN_DASM);
                AddMacro("!ENDOFFILE", Types.MacroInfo.MacroType.END_OF_FILE);

                AddMacro("REPEAT", Types.MacroInfo.MacroType.LOOP_START);
                AddMacro("REPEND", Types.MacroInfo.MacroType.LOOP_END);

                AddMacro("PROCESSOR", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("ORG", Types.MacroInfo.MacroType.ORG);
                AddMacro("SEG", Types.MacroInfo.MacroType.SEG);
                AddMacro("SEG.U", Types.MacroInfo.MacroType.SEG);

                LabelPostfix            = ":";
                MacroFunctionCallPrefix = ":";
                GlobalLabelsAutoZone    = false;
                DefineSeparatorKeywords.Add("SET");
                DefineSeparatorKeywords.Add("=");
                MacroIsZone = true;
                MacrosHaveVariableNumberOfArguments = true;
                IncludeExpectsStringLiteral         = false;
                break;

            case Types.AssemblerType.PDS:
                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_GLOBAL] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzÄÖÜäöü";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]   = "#";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_LOCAL] = ".!";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_LOCAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_CHAR] = "'";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_CHAR]   = "'";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_STRING] = "\"";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_STRING]   = "\"";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_NUMBER] = "0123456789abcdefABCDEF$%";
                AllowedTokenChars[Types.TokenInfo.TokenType.LITERAL_NUMBER]      = "0123456789abcdefABCDEFx";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.COMMENT] = ";";
                AllowedTokenStartChars[Types.TokenInfo.TokenType.COMMENT_IF_FIRST_CHAR] = "*";

                /*
                 * AllowedTokenStartChars[Types.TokenInfo.TokenType.MACRO] = "!";
                 * AllowedTokenChars[Types.TokenInfo.TokenType.MACRO] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
                 */

                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_INTERNAL] = "+-";

                AllowedSingleTokens = ",#(){}*";

                AddMacro("DC.B", Types.MacroInfo.MacroType.TEXT);
                AddMacro("DC.V", Types.MacroInfo.MacroType.TEXT);
                AddMacro("DB", Types.MacroInfo.MacroType.TEXT);
                AddMacro("DH", Types.MacroInfo.MacroType.HIGH_BYTE);
                AddMacro("DL", Types.MacroInfo.MacroType.LOW_BYTE);
                AddMacro("DW", Types.MacroInfo.MacroType.WORD);
                AddMacro("HEX", Types.MacroInfo.MacroType.HEX);
                AddMacro("!WORD", Types.MacroInfo.MacroType.WORD);
                AddMacro("!WO", Types.MacroInfo.MacroType.WORD);
                AddMacro("!16", Types.MacroInfo.MacroType.WORD);
                AddMacro("!TEXT", Types.MacroInfo.MacroType.TEXT);
                AddMacro("!TX", Types.MacroInfo.MacroType.TEXT);
                AddMacro("!SCR", Types.MacroInfo.MacroType.TEXT_SCREEN);
                AddMacro("CBM", Types.MacroInfo.MacroType.TEXT_SCREEN);
                AddMacro("!PSEUDOPC", Types.MacroInfo.MacroType.PSEUDO_PC);
                AddMacro("!REALPC", Types.MacroInfo.MacroType.REAL_PC);
                AddMacro("!BANK", Types.MacroInfo.MacroType.BANK);
                AddMacro("!CONVTAB", Types.MacroInfo.MacroType.CONVERSION_TAB);
                AddMacro("!CT", Types.MacroInfo.MacroType.CONVERSION_TAB);
                AddMacro("!BINARY", Types.MacroInfo.MacroType.INCLUDE_BINARY);
                AddMacro("!BIN", Types.MacroInfo.MacroType.INCLUDE_BINARY);
                AddMacro("!BI", Types.MacroInfo.MacroType.INCLUDE_BINARY);
                AddMacro("!SOURCE", Types.MacroInfo.MacroType.INCLUDE_SOURCE);
                AddMacro("!SRC", Types.MacroInfo.MacroType.INCLUDE_SOURCE);
                AddMacro("!TO", Types.MacroInfo.MacroType.COMPILE_TARGET);
                AddMacro("!ZONE", Types.MacroInfo.MacroType.ZONE);
                AddMacro("!ZN", Types.MacroInfo.MacroType.ZONE);
                AddMacro("!ERROR", Types.MacroInfo.MacroType.ERROR);
                AddMacro("!IFDEF", Types.MacroInfo.MacroType.IFDEF);
                AddMacro("!IFNDEF", Types.MacroInfo.MacroType.IFNDEF);
                AddMacro("!IF", Types.MacroInfo.MacroType.IF);
                AddMacro("!FILL", Types.MacroInfo.MacroType.FILL);
                AddMacro("DS", Types.MacroInfo.MacroType.FILL);
                AddMacro("!FI", Types.MacroInfo.MacroType.FILL);
                AddMacro("!ALIGN", Types.MacroInfo.MacroType.ALIGN);
                AddMacro("!ENDOFFILE", Types.MacroInfo.MacroType.END_OF_FILE);
                AddMacro("DO", Types.MacroInfo.MacroType.LOOP_START);
                AddMacro("LOOP", Types.MacroInfo.MacroType.LOOP_END);

                AddMacro("PROCESSOR", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("ORG", Types.MacroInfo.MacroType.ORG);
                AddMacro("FREE", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("SEND", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("SKIP", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("END", Types.MacroInfo.MacroType.END_OF_FILE);

                LabelPostfix         = ":";
                GlobalLabelsAutoZone = true;
                DefineSeparatorKeywords.Add("EQU");
                DefineSeparatorKeywords.Add("=");
                CaseSensitive = false;
                IncludeExpectsStringLiteral = true;
                StatementSeparatorChars.Add(':');
                break;

            case Types.AssemblerType.C64ASM:
                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_GLOBAL] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzÄÖÜäöü";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]   = "#";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_LOCAL] = "_";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_LOCAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_CHAR] = "'";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_CHAR]   = "'";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_STRING] = "\"";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_STRING]   = "\"";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_NUMBER] = "0123456789abcdefABCDEF$%";
                AllowedTokenChars[Types.TokenInfo.TokenType.LITERAL_NUMBER]      = "0123456789abcdefABCDEFx";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.COMMENT] = ";";
                //AllowedTokenStartChars[Types.TokenInfo.TokenType.COMMENT_IF_FIRST_CHAR] = "*";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.MACRO] = ".";
                AllowedTokenChars[Types.TokenInfo.TokenType.MACRO]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_INTERNAL] = "+-";

                AllowedSingleTokens = ",#(){}*";

                MacroPrefix = ".";

                AddMacro(".BYTE", Types.MacroInfo.MacroType.BYTE);
                AddMacro(".WORD", Types.MacroInfo.MacroType.WORD);

                GlobalLabelsAutoZone = true;
                DefineSeparatorKeywords.Add("=");
                CaseSensitive = false;
                IncludeExpectsStringLiteral = true;
                break;

            case Types.AssemblerType.CBMPRGSTUDIO:
                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_GLOBAL] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyzÄÖÜäöü";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LABEL_GLOBAL]   = "#:";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LABEL_LOCAL] = ".";
                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_LOCAL]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_CHAR] = "'";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_CHAR]   = "'";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_STRING] = "\"";
                AllowedTokenEndChars[Types.TokenInfo.TokenType.LITERAL_STRING]   = "\"";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.LITERAL_NUMBER] = "0123456789abcdefABCDEF$%";
                AllowedTokenChars[Types.TokenInfo.TokenType.LITERAL_NUMBER]      = "0123456789abcdefABCDEFx";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.COMMENT] = ";";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.MACRO] = "!";
                AllowedTokenChars[Types.TokenInfo.TokenType.MACRO]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";

                AllowedTokenStartChars[Types.TokenInfo.TokenType.CALL_MACRO] = ":";
                AllowedTokenChars[Types.TokenInfo.TokenType.CALL_MACRO]      = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_äöüÄÖÜß.";

                AllowedTokenChars[Types.TokenInfo.TokenType.LABEL_INTERNAL] = "+-";

                AllowedSingleTokens = ",#(){}*";

                AddMacro("DC.B", Types.MacroInfo.MacroType.TEXT);
                AddMacro("DC.W", Types.MacroInfo.MacroType.WORD);
                AddMacro("MAC", Types.MacroInfo.MacroType.MACRO);
                AddMacro("ENDM", Types.MacroInfo.MacroType.END);
                AddMacro("!TEXT", Types.MacroInfo.MacroType.TEXT);
                AddMacro("!TX", Types.MacroInfo.MacroType.TEXT);
                AddMacro("!SCR", Types.MacroInfo.MacroType.TEXT_SCREEN);
                AddMacro("RORG", Types.MacroInfo.MacroType.PSEUDO_PC);
                AddMacro("REND", Types.MacroInfo.MacroType.REAL_PC);
                AddMacro("!BANK", Types.MacroInfo.MacroType.BANK);
                AddMacro("!CONVTAB", Types.MacroInfo.MacroType.CONVERSION_TAB);
                AddMacro("!CT", Types.MacroInfo.MacroType.CONVERSION_TAB);
                AddMacro("INCBIN", Types.MacroInfo.MacroType.INCLUDE_BINARY);
                AddMacro("INCLUDE", Types.MacroInfo.MacroType.INCLUDE_SOURCE);
                AddMacro("!TO", Types.MacroInfo.MacroType.COMPILE_TARGET);
                AddMacro("SUBROUTINE", Types.MacroInfo.MacroType.ZONE);
                AddMacro("!ERROR", Types.MacroInfo.MacroType.ERROR);
                AddMacro("!IFDEF", Types.MacroInfo.MacroType.IFDEF);
                AddMacro("!IFNDEF", Types.MacroInfo.MacroType.IFNDEF);
                AddMacro("IF", Types.MacroInfo.MacroType.IF);
                AddMacro("ELSE", Types.MacroInfo.MacroType.ELSE);
                AddMacro("ENDIF", Types.MacroInfo.MacroType.END_IF);
                AddMacro("DS.Z", Types.MacroInfo.MacroType.FILL);
                AddMacro("DS", Types.MacroInfo.MacroType.FILL);
                AddMacro("DS.B", Types.MacroInfo.MacroType.FILL);
                AddMacro("ALIGN", Types.MacroInfo.MacroType.ALIGN_DASM);
                AddMacro("!ENDOFFILE", Types.MacroInfo.MacroType.END_OF_FILE);

                AddMacro("REPEAT", Types.MacroInfo.MacroType.LOOP_START);
                AddMacro("REPEND", Types.MacroInfo.MacroType.LOOP_END);

                AddMacro("PROCESSOR", Types.MacroInfo.MacroType.IGNORE);
                AddMacro("ORG", Types.MacroInfo.MacroType.ORG);
                AddMacro("SEG", Types.MacroInfo.MacroType.SEG);
                AddMacro("SEG.U", Types.MacroInfo.MacroType.SEG);
                AddMacro("BYTE", Types.MacroInfo.MacroType.BYTE);

                LabelPostfix            = ":";
                MacroFunctionCallPrefix = ":";
                GlobalLabelsAutoZone    = false;
                DefineSeparatorKeywords.Add("SET");
                DefineSeparatorKeywords.Add("=");
                MacroIsZone = true;
                MacrosHaveVariableNumberOfArguments = true;
                IncludeExpectsStringLiteral         = false;
                break;
            }
        }