Exemplo n.º 1
0
        private static int EvaluateIntUnaryExpression(DaedalusParser.ExpressionContext expression,
                                                      AssemblyBuilder assemblyBuilder)
        {
            var oper  = expression.GetChild(0).GetText();
            var param = EvaluateConstIntExpression((DaedalusParser.ExpressionContext)expression.GetChild(1),
                                                   assemblyBuilder);

            switch (oper)
            {
            case "-":
                return(-param);

            case "+":
                return(+param);

            case "!":
                return(param == 0 ? 1 : 0);

            case "~":
                return(~param);

            default:
                throw new Exception($"Invalid unary operator: {oper}");
            }
        }
Exemplo n.º 2
0
        private static string EvaluateConstStringExpression(DaedalusParser.ExpressionContext expression)
        {
            if (expression is DaedalusParser.ValExpressionContext context)
            {
                return(context.value().GetChild(0).GetText().Replace("\"", ""));
            }

            throw new Exception(
                      $"Unable to evaluate constant. Expression '{expression.GetText()}' contains unsupported operations.");
        }
Exemplo n.º 3
0
        private static int EvaluateConstIntExpression(DaedalusParser.ExpressionContext expression,
                                                      AssemblyBuilder assemblyBuilder)
        {
            if (expression is DaedalusParser.BracketExpressionContext expressionContext)
            {
                return(EvaluateConstIntExpression(expressionContext.expression(), assemblyBuilder));
            }

            if (expression is DaedalusParser.ValExpressionContext context)
            {
                return(EvaluateIntValueExpression(context.value(), assemblyBuilder));
            }

            if (expression is DaedalusParser.OneArgExpressionContext)
            {
                return(EvaluateIntUnaryExpression(expression, assemblyBuilder));
            }

            if (expression is DaedalusParser.MultExpressionContext)
            {
                return(EvaluateIntBinaryExpression(expression, assemblyBuilder));
            }

            if (expression is DaedalusParser.AddExpressionContext)
            {
                return(EvaluateIntBinaryExpression(expression, assemblyBuilder));
            }

            if (expression is DaedalusParser.BitMoveExpressionContext)
            {
                return(EvaluateIntBinaryExpression(expression, assemblyBuilder));
            }

            if (expression is DaedalusParser.CompExpressionContext)
            {
                return(EvaluateIntBinaryExpression(expression, assemblyBuilder));
            }

            if (expression is DaedalusParser.EqExpressionContext)
            {
                return(EvaluateIntBinaryExpression(expression, assemblyBuilder));
            }

            if (expression is DaedalusParser.BinOrExpressionContext)
            {
                return(EvaluateIntBinaryExpression(expression, assemblyBuilder));
            }

            throw new Exception(
                      $"Unable to evaluate constant. Expression '{expression.GetText()}' contains unsupported operations.");
        }
Exemplo n.º 4
0
        public static object EvaluateConst(DaedalusParser.ExpressionContext expression, AssemblyBuilder assemblyBuilder,
                                           DatSymbolType type)
        {
            switch (type)
            {
            case DatSymbolType.String:
                return(EvaluateConstStringExpression(expression));

            case DatSymbolType.Float:
                return(EvaluateConstFloatExpression(expression.GetText()));

            case DatSymbolType.Int:
                return(EvaluateConstIntExpression(expression, assemblyBuilder));

            default:
                throw new Exception($"Unable to evaluate constant. Invalid symbol type '{type}'.");
            }
        }
Exemplo n.º 5
0
        private static int EvaluateIntBinaryExpression(DaedalusParser.ExpressionContext expression,
                                                       AssemblyBuilder assemblyBuilder)
        {
            var leftParam = EvaluateConstIntExpression((DaedalusParser.ExpressionContext)expression.GetChild(0),
                                                       assemblyBuilder);
            var oper       = expression.GetChild(1).GetText();
            var rightParam = EvaluateConstIntExpression((DaedalusParser.ExpressionContext)expression.GetChild(2),
                                                        assemblyBuilder);

            switch (oper)
            {
            case "*":
                return(leftParam * rightParam);

            case "/":
                return(leftParam / rightParam);

            case "%":
                return(leftParam % rightParam);

            case "+":
                return(leftParam + rightParam);

            case "-":
                return(leftParam - rightParam);

            case ">>":
                return(leftParam >> rightParam);

            case "<<":
                return(leftParam << rightParam);

            case ">":
                return(leftParam > rightParam ? 1 : 0);

            case "<":
                return(leftParam < rightParam ? 1 : 0);

            case ">=":
                return(leftParam >= rightParam ? 1 : 0);

            case "<=":
                return(leftParam <= rightParam ? 1 : 0);

            case "==":
                return(leftParam == rightParam ? 1 : 0);

            case "!=":
                return(leftParam != rightParam ? 1 : 0);

            case "|":
                return(leftParam | rightParam);

            case "&":
                return(leftParam & rightParam);

            case "||":
                return(((leftParam != 0) || (rightParam != 0)) ? 1 : 0);

            case "&&":
                return(((leftParam != 0) && (rightParam != 0)) ? 1 : 0);

            default:
                throw new Exception($"Invalid binary operator: {oper}");
            }
        }