Exemplo n.º 1
0
        /////////////////////////////////////////////////////////////

        CompileResult CompileMnemonicType6(OpCode OpCode, ref int OutCodeLength, ref byte[] OutCode, out String ErrorMsg)
        {
            CompileResult Error = CompileResult.Ok;

            ErrorMsg = String.Empty;
            Token Token = new Token();

            Lex.GetToken(ref Token);

            switch (Token.TokenType)
            {
            case Token.TokType.Int:
                if (OpCode.ShortParamRange == FctType.R_0_14 && 0 <= Token.IntValue && Token.IntValue <= 14)
                {
                    OutCodeLength = 2;
                    OutCode[0]    = (byte)(((byte)OpCode.ShortFunction + (byte)Token.IntValue) & 0xff);
                    OutCode[1]    = 0x00;
                }
                else
                if (0 <= Token.IntValue && Token.IntValue <= 101)
                {
                    OutCodeLength = 3;
                    OutCode[0]    = (byte)(OpCode.Function & 0xff);
                    OutCode[1]    = (byte)0x00;
                    OutCode[2]    = (byte)(Token.IntValue & 0xff);
                }
                else
                {
                    Error    = CompileResult.CompileError;
                    ErrorMsg = String.Format("Parameter out of range \"{0}\"", Token.StringValue);
                }
                break;

            case Token.TokType.Letter:
            {
                short Value;

                if (Parameter.GetShortLabelParamter(Token.StringValue, out Value))
                {
                    OutCodeLength = 3;
                    OutCode[0]    = (byte)(OpCode.Function & 0xff);
                    OutCode[1]    = (byte)0x00;
                    OutCode[2]    = (byte)Value;
                }
                else
                {
                    Error    = CompileResult.CompileError;
                    ErrorMsg = String.Format("Parameter out of range \"{0}\"", Token.StringValue);
                }
                break;
            }

            case Token.TokType.Text:
                if (Token.StringValue.Length <= 14)
                {
                    OutCode[0] = (byte)OpCode.AlphaFunction;
                    OutCode[1] = (byte)(0xF0 + Token.StringValue.Length);

                    OutCodeLength = 2;

                    foreach (char c in Token.StringValue)
                    {
                        OutCode[OutCodeLength++] = (byte)c;
                    }
                }
                else
                {
                    Error    = CompileResult.CompileError;
                    ErrorMsg = String.Format("String too long \"{0}\"", Token.StringValue);
                }
                break;

            case Token.TokType.Indirect:
                Lex.GetToken(ref Token);

                switch (Token.TokenType)
                {
                case Token.TokType.Int:
                    if (0 <= Token.IntValue && Token.IntValue <= 101)
                    {
                        OutCodeLength = 2;
                        OutCode[0]    = (byte)(OpCode.IndirectFunction & 0xff);
                        OutCode[1]    = (byte)(Token.IntValue);

                        if (OpCode.IndirectOr)
                        {
                            OutCode[1] |= (byte)0x80;
                        }
                    }
                    else
                    {
                        Error    = CompileResult.CompileError;
                        ErrorMsg = String.Format("Parameter out of range \"{0}\"", Token.StringValue);
                    }
                    break;

                case Token.TokType.Letter:
                {
                    short Value;

                    if (Parameter.GetStackParamter(Token.StringValue, out Value))
                    {
                        OutCodeLength = 2;
                        OutCode[0]    = (byte)(OpCode.IndirectFunction & 0xff);
                        OutCode[1]    = (byte)(Value);

                        if (OpCode.IndirectOr)
                        {
                            OutCode[1] |= (byte)0x80;
                        }
                    }
                    else
                    {
                        Error    = CompileResult.CompileError;
                        ErrorMsg = String.Format("Parameter out of range \"{0}\"", Token.StringValue);
                    }
                    break;
                }

                default:
                    Error    = CompileResult.CompileError;
                    ErrorMsg = String.Format("Wrong parameter type or parameter expected");
                    break;
                }
                break;

            default:
                Error    = CompileResult.CompileError;
                ErrorMsg = String.Format("Wrong parameter type or parameter expected");
                break;
            }

            return(Error);
        }
Exemplo n.º 2
0
        /////////////////////////////////////////////////////////////

        CompileResult CompileMnemonicType4(OpCode OpCode, ref int OutCodeLength, ref byte[] OutCode, out String ErrorMsg)
        {
            CompileResult Error = CompileResult.Ok;

            ErrorMsg = String.Empty;
            Token Token = new Token();

            Lex.GetToken(ref Token);

            switch (Token.TokenType)
            {
            case Token.TokType.Int:
                if (0 <= Token.IntValue && Token.IntValue <= 55)
                {
                    OutCodeLength = 2;
                    OutCode[0]    = (byte)(OpCode.Function & 0xff);
                    OutCode[1]    = (byte)(Token.IntValue & 0xff);
                }
                else
                {
                    Error    = CompileResult.CompileError;
                    ErrorMsg = String.Format("Wronge parameter type or parameter out of range \"{0}\"", Token.StringValue);
                }
                break;

            case Token.TokType.Indirect:
                Lex.GetToken(ref Token);

                switch (Token.TokenType)
                {
                case Token.TokType.Int:
                    if (0 <= Token.IntValue && Token.IntValue <= 101)
                    {
                        OutCodeLength = 2;
                        OutCode[0]    = (byte)(OpCode.IndirectFunction & 0xff);
                        OutCode[1]    = (byte)(Token.IntValue | (byte)0x80);
                    }
                    else
                    {
                        Error    = CompileResult.CompileError;
                        ErrorMsg = String.Format("Parameter out of range \"{0}\"", Token.StringValue);
                    }
                    break;

                case Token.TokType.Letter:
                {
                    short Value;

                    if (Parameter.GetStackParamter(Token.StringValue, out Value))
                    {
                        OutCodeLength = 2;
                        OutCode[0]    = (byte)(OpCode.IndirectFunction & 0xff);
                        OutCode[1]    = (byte)(Value | (byte)0x80);
                    }
                    else
                    {
                        Error    = CompileResult.CompileError;
                        ErrorMsg = String.Format("Parameter out of range \"{0}\"", Token.StringValue);
                    }
                    break;
                }

                default:
                    Error    = CompileResult.CompileError;
                    ErrorMsg = String.Format("Wrong parameter type or parameter expected");
                    break;
                }
                break;

            default:
                Error    = CompileResult.CompileError;
                ErrorMsg = String.Format("Wronge parameter type or parameter out of range \"{0}\"", Token.StringValue);
                break;
            }

            return(Error);
        }