Esempio n. 1
0
        public static string ToPrettyString(this FOpCode type)
        {
            if (type == FOpCode.PushCst)
            {
                return("push.cst");
            }
            if (type == FOpCode.PushGlb)
            {
                return("push.glb");
            }
            if (type == FOpCode.PushI16)
            {
                return("push.i16");
            }
            if (type == FOpCode.PushVar)
            {
                return("push.var");
            }

            return(type.ToString().ToLowerInvariant());
        }
Esempio n. 2
0
        public static string ToPrettyString(this FOpCode type)
        {
            switch (type)
            {
            case FOpCode.PushCst:
                return("push.cst");

            case FOpCode.PushLoc:
                return("push.loc");

            case FOpCode.PushGlb:
                return("push.glb");

            case FOpCode.PushI16:
                return("push.i16");

            case FOpCode.PushVar:
                return("push.var");
            }

            return(type.ToString().ToLowerInvariant());
        }
Esempio n. 3
0
        static OpCodePair     TokenToOpCodes(Token t, ComparisonType comp = 0, DataType data = 0, InstanceType inst = (InstanceType)1)
        {
            if (t is NormalToken && ((NormalToken)t).Kind == TokenKind.OpCode)
            {
                switch (((NormalToken)t).Type)
                {
                case TokenType.Conv:
                    return(new OpCodePair {
                        VersionE = EOpCode.Conv, VersionF = FOpCode.Conv
                    });

                case TokenType.Mul:
                    return(new OpCodePair {
                        VersionE = EOpCode.Mul, VersionF = FOpCode.Mul
                    });

                case TokenType.Div:
                    return(new OpCodePair {
                        VersionE = EOpCode.Div, VersionF = FOpCode.Div
                    });

                case TokenType.Rem:
                    return(new OpCodePair {
                        VersionE = EOpCode.Rem, VersionF = FOpCode.Rem
                    });

                case TokenType.Mod:
                    return(new OpCodePair {
                        VersionE = EOpCode.Mod, VersionF = FOpCode.Mod
                    });

                case TokenType.Add:
                    return(new OpCodePair {
                        VersionE = EOpCode.Add, VersionF = FOpCode.Add
                    });

                case TokenType.Sub:
                    return(new OpCodePair {
                        VersionE = EOpCode.Sub, VersionF = FOpCode.Sub
                    });

                case TokenType.And:
                    return(new OpCodePair {
                        VersionE = EOpCode.And, VersionF = FOpCode.And
                    });

                case TokenType.Or:
                    return(new OpCodePair {
                        VersionE = EOpCode.Or, VersionF = FOpCode.Or
                    });

                case TokenType.Xor:
                    return(new OpCodePair {
                        VersionE = EOpCode.Xor, VersionF = FOpCode.Xor
                    });

                case TokenType.Neg:
                    return(new OpCodePair {
                        VersionE = EOpCode.Neg, VersionF = FOpCode.Neg
                    });

                case TokenType.Not:
                    return(new OpCodePair {
                        VersionE = EOpCode.Not, VersionF = FOpCode.Not
                    });

                case TokenType.Shl:
                    return(new OpCodePair {
                        VersionE = EOpCode.Shl, VersionF = FOpCode.Shl
                    });

                case TokenType.Shr:
                    return(new OpCodePair {
                        VersionE = EOpCode.Shr, VersionF = FOpCode.Shr
                    });

                case TokenType.Clt:
                    return(new OpCodePair {
                        VersionE = EOpCode.Clt, VersionF = FOpCode.Cmp
                    });

                case TokenType.Cle:
                    return(new OpCodePair {
                        VersionE = EOpCode.Cle, VersionF = FOpCode.Cmp
                    });

                case TokenType.Ceq:
                    return(new OpCodePair {
                        VersionE = EOpCode.Ceq, VersionF = FOpCode.Cmp
                    });

                case TokenType.Cne:
                    return(new OpCodePair {
                        VersionE = EOpCode.Cne, VersionF = FOpCode.Cmp
                    });

                case TokenType.Cge:
                    return(new OpCodePair {
                        VersionE = EOpCode.Cge, VersionF = FOpCode.Cmp
                    });

                case TokenType.Cgt:
                    return(new OpCodePair {
                        VersionE = EOpCode.Cgt, VersionF = FOpCode.Cmp
                    });

                case TokenType.Set:
                    return(new OpCodePair {
                        VersionE = EOpCode.Set, VersionF = FOpCode.Set
                    });

                case TokenType.Dup:
                    return(new OpCodePair {
                        VersionE = EOpCode.Dup, VersionF = FOpCode.Dup
                    });

                case TokenType.Ret:
                    return(new OpCodePair {
                        VersionE = EOpCode.Ret, VersionF = FOpCode.Ret
                    });

                case TokenType.Exit:
                    return(new OpCodePair {
                        VersionE = EOpCode.Exit, VersionF = FOpCode.Exit
                    });

                case TokenType.Pop:
                    return(new OpCodePair {
                        VersionE = EOpCode.Pop, VersionF = FOpCode.Pop
                    });

                case TokenType.Br:
                    return(new OpCodePair {
                        VersionE = EOpCode.Br, VersionF = FOpCode.Br
                    });

                case TokenType.Brt:
                    return(new OpCodePair {
                        VersionE = EOpCode.Brt, VersionF = FOpCode.Brt
                    });

                case TokenType.Brf:
                    return(new OpCodePair {
                        VersionE = EOpCode.Brf, VersionF = FOpCode.Brf
                    });

                case TokenType.PushEnv:
                    return(new OpCodePair {
                        VersionE = EOpCode.PushEnv, VersionF = FOpCode.PushEnv
                    });

                case TokenType.PopEnv:
                    return(new OpCodePair {
                        VersionE = EOpCode.PopEnv, VersionF = FOpCode.PopEnv
                    });

                case TokenType.Push:
                    FOpCode pt = FOpCode.PushCst;
                    switch (data)
                    {
                    case DataType.Variable:
                        if (inst <= InstanceType.Other)
                        {
                            pt = FOpCode.PushVar;
                        }
                        break;

                    case DataType.Int16:
                        pt = FOpCode.PushI16;
                        break;
                    }
                    if (inst == InstanceType.Global)
                    {
                        pt = FOpCode.PushGlb;
                    }

                    return(new OpCodePair {
                        VersionE = EOpCode.Push, VersionF = pt
                    });

                case TokenType.Call:
                    return(new OpCodePair {
                        VersionE = EOpCode.Call, VersionF = FOpCode.Call
                    });

                case TokenType.Break:
                    return(new OpCodePair {
                        VersionE = EOpCode.Break, VersionF = FOpCode.Break
                    });

                case TokenType.Cmp:
                    EOpCode ct;
                    switch (comp)
                    {
                    case ComparisonType.LowerThan:
                        ct = EOpCode.Clt;
                        break;

                    case ComparisonType.LTOrEqual:
                        ct = EOpCode.Cle;
                        break;

                    case ComparisonType.Equality:
                        ct = EOpCode.Ceq;
                        break;

                    case ComparisonType.Inequality:
                        ct = EOpCode.Cne;
                        break;

                    case ComparisonType.GTOrEqual:
                        ct = EOpCode.Cge;
                        break;

                    case ComparisonType.GreaterThan:
                        ct = EOpCode.Cgt;
                        break;

                    default:
                        throw new ArgumentOutOfRangeException(nameof(comp));
                    }

                    return(new OpCodePair {
                        VersionE = ct, VersionF = FOpCode.Cmp
                    });

                case TokenType.PushCst:
                    return(new OpCodePair {
                        VersionE = EOpCode.Push, VersionF = FOpCode.PushCst
                    });

                case TokenType.PushLoc:
                    return(new OpCodePair {
                        VersionE = EOpCode.Push, VersionF = FOpCode.PushLoc
                    });

                case TokenType.PushGlb:
                    return(new OpCodePair {
                        VersionE = EOpCode.Push, VersionF = FOpCode.PushGlb
                    });

                case TokenType.PushVar:
                    return(new OpCodePair {
                        VersionE = EOpCode.Push, VersionF = FOpCode.PushVar
                    });

                case TokenType.PushI16:
                    return(new OpCodePair {
                        VersionE = EOpCode.Push, VersionF = FOpCode.PushI16
                    });
                }
            }

            throw new ArgumentException($"Expected opcode token, got '{t}' {Pos(t)}.");
        }