Esempio n. 1
0
        public void Emit(CompilationContext context)
        {
            context.EmitComment(";Multiplicative expression");

            ((ICodeEmitter)Tokens[0]).Emit(context);

            var t1ExpressionType = ((IHasType)Tokens[0]).GetExpressionType(context);

            if (Tokens.Count > 1)
            {
                TypeChecking.CheckExpressionTypeIsNumeric(t1ExpressionType);
            }

            for (int i = 1; i < Tokens.Count; i += 2)
            {
                ((ICodeEmitter)Tokens[i + 1]).Emit(context);

                var t2ExpressionType = ((IHasType)Tokens[i + 1]).GetExpressionType(context);

                TypeChecking.CheckExpressionTypeIsNumeric(t2ExpressionType);
                TypeChecking.CheckExpressionTypesMatch(t1ExpressionType, t2ExpressionType);

                t1ExpressionType = t2ExpressionType;

                string op = ((DefaultLanguageTerminalToken)Tokens[i]).Value;

                context.EmitInstruction(new IRPop()
                {
                    To = "ebx"
                });
                context.EmitInstruction(new IRPop()
                {
                    To = "eax"
                });

                switch (op)
                {
                case "*":
                    context.EmitInstruction(new IRMult()
                    {
                        Left = "eax", Right = "ebx", To = "ecx"
                    });
                    break;

                case "/":
                    context.EmitInstruction(new IRDiv()
                    {
                        Left = "eax", Right = "ebx", To = "ecx"
                    });
                    break;
                }

                context.EmitInstruction(new IRPushRegister()
                {
                    From = "ecx"
                });
            }
        }
Esempio n. 2
0
        public void Emit(CompilationContext context)
        {
            context.EmitComment(";Bitwise expression");

            ((ICodeEmitter)Tokens[0]).Emit(context);

            var expressionType = ((IHasType)Tokens[0]).GetExpressionType(context);

            if (Tokens.Count > 1)
            {
                TypeChecking.CheckExpressionTypeIsNumeric(expressionType);
            }

            for (int i = 1; i < Tokens.Count; i += 2)
            {
                string op = ((DefaultLanguageTerminalToken)Tokens[i]).Value;

                ((ICodeEmitter)Tokens[i + 1]).Emit(context);

                expressionType = ((IHasType)Tokens[i + 1]).GetExpressionType(context);

                TypeChecking.CheckExpressionTypeIsNumeric(expressionType);

                context.EmitInstruction(new IRPop()
                {
                    To = "ebx"
                });
                context.EmitInstruction(new IRPop()
                {
                    To = "eax"
                });

                switch (op)
                {
                case "&":
                    context.EmitInstruction(new IRAnd()
                    {
                        Left = "eax", Right = "ebx", To = "ecx"
                    });
                    break;

                case "|":
                    context.EmitInstruction(new IROr()
                    {
                        Left = "eax", Right = "ebx", To = "ecx"
                    });
                    break;

                case "^":
                    context.EmitInstruction(new IRXOr()
                    {
                        Left = "eax", Right = "ebx", To = "ecx"
                    });
                    break;
                }

                context.EmitInstruction(new IRPushRegister()
                {
                    From = "ecx"
                });
            }
        }