Example #1
0
        void ProcessGoodFactor_return_type_whenever_inner_type_is_double_or_long()
        {
            foreach (var type in new List <DataType> {
                DataType.Long, DataType.Double
            })
            {
                foreach (var isNegative in new List <bool> {
                    true, false
                })
                {
                    var negativeOperators = new List <OperatorToken>();
                    if (isNegative)
                    {
                        negativeOperators.Add(new OperatorToken(Operator.Minus, default));
                    }

                    var ast = new GoodFactorAst(negativeOperators, new Mock <StrongFactorAst>().Object);

                    var generator = MockStrongFactor(type);

                    var returningType = generator.ProcessGoodFactor(ast);
                    Assert.Equal(type, returningType);
                }
            }
        }
Example #2
0
        public virtual DataType ProcessGoodFactor(GoodFactorAst goodFactor)
        {
            Guard.Against.Null(goodFactor, nameof(goodFactor));
            // { - } strong_factor
            // 检查能否取符号

            var strongFactorType = ProcessStrongFactor(goodFactor.StrongFactor);

            if (goodFactor.IsNegative && !DataTypeHelper.IsLongOrDouble(strongFactorType))
            {
                throw new SemanticException($"{strongFactorType} cannot be negative");
            }

            if (CodeGenerationEnabled)
            {
                if (goodFactor.IsNegative)
                {
                    Debug.Assert(DataTypeHelper.IsLongOrDouble(strongFactorType));
                    var negativeOperation = "neg." + DataTypeHelper.Suffix(strongFactorType);
                    ExpressionBucket.AddSingle(negativeOperation);
                }
            }

            return(strongFactorType);
        }
Example #3
0
        void ProcessGoodFactor_return_type_whenever_not_negative()
        {
            foreach (var type in Utils.GetEnumList <DataType>())
            {
                var negatives = Enumerable.Empty <OperatorToken>();// not negative
                var ast       = new GoodFactorAst(negatives, new Mock <StrongFactorAst>().Object);

                var generator = MockStrongFactor(type);

                var returningType = generator.ProcessGoodFactor(ast);
                Assert.Equal(type, returningType);
            }
        }
Example #4
0
        void ProcessGoodFactor_throws_when_negative_and_inner_not_int_double()
        {
            foreach (var type in Utils.GetEnumList <DataType>())
            {
                if (DataTypeHelper.IsLongOrDouble(type))
                {
                    continue;
                }

                var negatives = new OperatorToken[] { new OperatorToken(Operator.Minus, default) };
                var ast       = new GoodFactorAst(negatives, new Mock <StrongFactorAst>().Object);

                var generator = MockStrongFactor(type);

                Assert.Throws <SemanticException>(() => generator.ProcessGoodFactor(ast));
            }
        }