Esempio n. 1
0
        /////////////////////////////////////////////////////////////

        CompileResult CompileMnemonicType3(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 <= 9)
                {
                    OutCodeLength = 2;
                    OutCode[0]    = (byte)(OpCode.Function & 0xff);
                    OutCode[1]    = (byte)(Token.IntValue & 0xff);
                }
                else
                {
                    Error    = CompileResult.CompileError;
                    ErrorMsg = String.Format("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);
        }
Esempio n. 2
0
        /////////////////////////////////////////////////////////////

        public bool Compile(String Line, ref int OutCodeLength, ref byte [] OutCode, out String ErrorMsg)
        {
            bool Error = false;

            ErrorMsg = "";
            Token Token = new Token();

            Lex.GetFirstToken(Line, ref Token);

            if (EndProcessed)
            {
                switch (Token.TokenType)
                {
                case Token.TokType.Eol:
                case Token.TokType.Comment:
                    return(false);

                default:
                    ErrorMsg = "Statement after .END. detected";
                    return(true);
                }
            }

            switch (Token.TokenType)
            {
            case Token.TokType.Id:
                if (CompileId(Token, ref OutCodeLength, ref OutCode, out ErrorMsg) != CompileResult.Ok)
                {
                    Error = true;
                }

                break;

            case Token.TokType.Append:
                if (CompileTextAppend(Token, ref OutCodeLength, ref OutCode, out ErrorMsg) != CompileResult.Ok)
                {
                    Error = true;
                }

                break;

            case Token.TokType.Text:
                if (CompileText(Token, ref OutCodeLength, ref OutCode, out ErrorMsg) != CompileResult.Ok)
                {
                    Error = true;
                }

                break;

            case Token.TokType.Int:
            case Token.TokType.Number:
                if (CompileNumber(Token, ref OutCodeLength, ref OutCode, out ErrorMsg) != CompileResult.Ok)
                {
                    Error = true;
                }

                break;

            case Token.TokType.Eol:
            case Token.TokType.Comment:
                break;

            default:
                Error    = true;
                ErrorMsg = String.Format("Unknown statement \"{0}\"", Token.StringValue);
                break;
            }

            if (!Error)
            {
                Lex.GetToken(ref Token);

                if (Token.TokenType != Token.TokType.Eol && Token.TokenType != Token.TokType.Comment)
                {
                    Error    = true;
                    ErrorMsg = String.Format("Unexpected parameter \"{0}\"", Token.StringValue);
                }
            }

            return(Error);
        }