Exemple #1
0
        private bool TryReadFrac(
            out FloatLiteral frac,
            int fracBase,
            Func <BigInteger, char, BigInteger?> tryAccumulateFracDigit)
        {
            (BigInteger, int)pair;
            bool parsed = TryReadNum(out pair, (BigInteger.Zero, 0), (acc, c) =>
            {
                var(i, n)    = acc;
                var maybeAcc = tryAccumulateFracDigit(i, c);
                if (maybeAcc.HasValue)
                {
                    return(maybeAcc.Value, n + 1);
                }
                else
                {
                    return(null);
                }
            });

            if (parsed)
            {
                var(i, n) = pair;
                frac      = FloatLiteral.Number(i, fracBase, -n);
                return(true);
            }
            else
            {
                frac = FloatLiteral.Zero(fracBase);
                return(false);
            }
        }
Exemple #2
0
        private bool TryAppendExponent(
            FloatLiteral floatNum,
            out FloatLiteral result)
        {
            bool negateExp = false;

            if (Expect('-'))
            {
                negateExp = true;
            }
            else
            {
                Expect('+');
            }
            BigInteger exp;

            if (!TryReadNum(out exp))
            {
                result = floatNum;
                return(false);
            }
            else
            {
                result = floatNum.AddToExponent(MaybeNegate(exp, negateExp));
                return(true);
            }
        }
Exemple #3
0
        /// <summary>
        /// Losslessly changes a float literal's base. Base changes only work if old base
        /// is a power of the new base.
        /// </summary>
        /// <param name="newBase">The new base.</param>
        /// <returns>An equivalent float literal with base <paramref name="newBase"/>.</returns>
        public FloatLiteral ChangeBase(int newBase)
        {
            if (Kind != FloatLiteralKind.Number || Base == newBase)
            {
                return(this);
            }
            else if (Exponent == 0)
            {
                return(FloatLiteral.Number(IsNegative, Significand, newBase, 0));
            }

            // Note: `x * (n ^ m) ^ k` equals `x * n ^ (m * k)`.
            var power      = 1;
            var resultBase = Base;

            while (resultBase != newBase)
            {
                if (resultBase < newBase || resultBase % newBase != 0)
                {
                    throw new InvalidOperationException(
                              $"Float literal '{this}' with base '{Base}' cannot be transformed losslessly to float with base '{newBase}'.");
                }

                resultBase /= newBase;
                power++;
            }

            return(FloatLiteral.Number(IsNegative, Significand, newBase, power * Exponent));
        }
Exemple #4
0
        private Token ReadKeywordToken()
        {
            var  spanStart = offset;
            char c;

            if (!TryPeekChar(out c) || c < 'a' || c > 'z')
            {
                return(ReadReservedToken(spanStart));
            }

            var builder = new StringBuilder();

            while (TryReadIdentifierChar(out c))
            {
                builder.Append(c);
            }

            var span   = new SourceSpan(document, spanStart, offset - spanStart);
            var result = builder.ToString();

            // Some floating point tokens look like keywords, so we'll handle
            // them here as well as in the FP parsing routine.
            if (result == "nan")
            {
                return(new Token(TokenKind.Float, span, FloatLiteral.NaN(false)));
            }
            else if (result.StartsWith("nan:0x", StringComparison.Ordinal))
            {
                var  payload = result.Substring("nan:0x".Length);
                long newBits = 0;
                for (int i = 0; i < payload.Length; i++)
                {
                    int digit;
                    if (payload[i] == '_')
                    {
                        continue;
                    }
                    else if (TryParseHexDigit(payload[i], out digit))
                    {
                        newBits = newBits * 16 + digit;
                    }
                    else
                    {
                        return(new Token(TokenKind.Keyword, span, result));
                    }
                }
                return(new Token(TokenKind.Float, span, FloatLiteral.NaN(false, newBits)));
            }
            else if (result == "inf")
            {
                return(new Token(TokenKind.Float, span, FloatLiteral.PositiveInfinity));
            }
            else
            {
                return(new Token(TokenKind.Keyword, span, result));
            }
        }
Exemple #5
0
        private bool TryReadUnsignedNumber(
            bool negate,
            out object result,
            IntegerReader tryReadNum,
            FloatReader tryReadFrac,
            char exponentChar,
            int exponent)
        {
            BigInteger num;

            if (tryReadNum(out num))
            {
                if (Expect('.'))
                {
                    FloatLiteral frac;
                    if (!tryReadFrac(out frac))
                    {
                        frac = FloatLiteral.Zero(exponent);
                    }
                    var floatNum = num + frac;

                    if (Expect(exponentChar) || Expect(char.ToUpperInvariant(exponentChar)))
                    {
                        floatNum = floatNum.ChangeBase(exponent);
                        if (!TryAppendExponent(floatNum, out floatNum))
                        {
                            result = null;
                            return(false);
                        }
                    }

                    result = MaybeNegate(floatNum, negate);
                }
                else if (Expect(exponentChar) || Expect(char.ToUpperInvariant(exponentChar)))
                {
                    FloatLiteral floatNum;
                    if (!TryAppendExponent(FloatLiteral.Number(num, exponent), out floatNum))
                    {
                        result = null;
                        return(false);
                    }

                    result = MaybeNegate(floatNum, negate);
                }
                else
                {
                    result = MaybeNegate(num, negate);
                }
                return(true);
            }
            else
            {
                result = null;
                return(false);
            }
        }
Exemple #6
0
 private bool TryReadFrac(out FloatLiteral frac)
 {
     return(TryReadFrac(out frac, 10, (i, c) =>
     {
         if (c >= '0' && c <= '9')
         {
             return i * 10 + (c - '0');
         }
         else
         {
             return null;
         }
     }));
 }
Exemple #7
0
 private bool TryReadHexFrac(out FloatLiteral frac)
 {
     return(TryReadFrac(out frac, 16, (i, c) =>
     {
         int digit;
         if (TryParseHexDigit(c, out digit))
         {
             return i * 16 + digit;
         }
         else
         {
             return null;
         }
     }));
 }
Exemple #8
0
 private bool TryReadUnsignedNumber(bool negate, out object result)
 {
     if (Expect("nan:0x"))
     {
         BigInteger hexNum;
         if (TryReadHexNum(out hexNum))
         {
             result = FloatLiteral.NaN(negate, (long)hexNum);
             return(true);
         }
         else
         {
             result = FloatLiteral.NaN(negate);
             return(false);
         }
     }
     else if (Expect("nan"))
     {
         result = FloatLiteral.NaN(negate);
         return(true);
     }
     else if (Expect("inf"))
     {
         result = MaybeNegate(FloatLiteral.PositiveInfinity, negate);
         return(true);
     }
     else if (Expect("0x"))
     {
         return(TryReadUnsignedNumber(
                    negate,
                    out result,
                    TryReadHexNum,
                    TryReadHexFrac,
                    'p',
                    2));
     }
     else
     {
         return(TryReadUnsignedNumber(
                    negate,
                    out result,
                    TryReadNum,
                    TryReadFrac,
                    'e',
                    10));
     }
 }
Exemple #9
0
 private FloatLiteral MaybeNegate(FloatLiteral v, bool negate)
 {
     return(negate ? -v : v);
 }
Exemple #10
0
        /// <summary>
        /// Runs a single expression in the script.
        /// </summary>
        /// <param name="expression">The expression to run.</param>
        public TestStatistics Run(SExpression expression)
        {
            if (expression.IsCallTo("module"))
            {
                var module   = Assembler.AssembleModule(expression, out string moduleId);
                var instance = Wasm.Interpret.ModuleInstance.Instantiate(
                    module,
                    importer,
                    policy: ExecutionPolicy.Create(maxMemorySize: 0x1000),
                    compiler: Compiler);

                moduleInstances.Add(instance);
                if (moduleId != null)
                {
                    moduleInstancesByName[moduleId] = instance;
                }
                if (module.StartFunctionIndex.HasValue)
                {
                    instance.Functions[(int)module.StartFunctionIndex.Value].Invoke(Array.Empty <object>());
                }
                return(TestStatistics.Empty);
            }
            else if (expression.IsCallTo("register"))
            {
                var tail = expression.Tail;
                var name = Assembler.AssembleString(tail[0], Log);
                tail = tail.Skip(1).ToArray();
                var moduleId = Assembler.AssembleLabelOrNull(ref tail);
                if (moduleId == null)
                {
                    importer.RegisterImporter(name, new ModuleExportsImporter(moduleInstances[moduleInstances.Count - 1]));
                }
                else
                {
                    importer.RegisterImporter(name, new ModuleExportsImporter(moduleInstancesByName[moduleId]));
                }
                return(TestStatistics.Empty);
            }
            else if (expression.IsCallTo("invoke") || expression.IsCallTo("get"))
            {
                RunAction(expression);
                return(TestStatistics.SingleSuccess);
            }
            else if (expression.IsCallTo("assert_return"))
            {
                var results  = RunAction(expression.Tail[0]);
                var expected = expression.Tail
                               .Skip(1)
                               .Zip(results, (expr, val) => EvaluateConstExpr(expr, val.GetType()))
                               .ToArray();

                if (expected.Length != results.Count)
                {
                    Log.Log(
                        new LogEntry(
                            Severity.Error,
                            "assertion failed",
                            "action produced result ",
                            string.Join(", ", results),
                            "; expected ",
                            string.Join(", ", expected),
                            ".",
                            Assembler.Highlight(expression)));
                    return(TestStatistics.SingleFailure);
                }

                bool failures = false;
                for (int i = 0; i < expected.Length; i++)
                {
                    if (!object.Equals(results[i], expected[i]))
                    {
                        if (AlmostEquals(results[i], expected[i]))
                        {
                            Log.Log(
                                new LogEntry(
                                    Severity.Warning,
                                    "rounding error",
                                    "action produced result ",
                                    results[i].ToString(),
                                    "; expected ",
                                    expected[i].ToString(),
                                    ".",
                                    Assembler.Highlight(expression)));
                        }
                        else
                        {
                            Log.Log(
                                new LogEntry(
                                    Severity.Error,
                                    "assertion failed",
                                    "action produced result ",
                                    results[i].ToString(),
                                    "; expected ",
                                    expected[i].ToString(),
                                    ".",
                                    Assembler.Highlight(expression)));
                            failures = true;
                        }
                    }
                }
                return(failures ? TestStatistics.SingleFailure : TestStatistics.SingleSuccess);
            }
            else if (expression.IsCallTo("assert_trap") || expression.IsCallTo("assert_exhaustion"))
            {
                var       expected  = Assembler.AssembleString(expression.Tail[1], Log);
                bool      caught    = false;
                Exception exception = null;
                try
                {
                    if (expression.Tail[0].IsCallTo("module"))
                    {
                        Run(expression.Tail[0]);
                    }
                    else
                    {
                        RunAction(expression.Tail[0], false);
                    }
                }
                catch (TrapException ex)
                {
                    caught    = ex.SpecMessage == expected;
                    exception = ex;
                }
                catch (PixieException)
                {
                    throw;
                }
                catch (Exception ex)
                {
                    caught    = false;
                    exception = ex;
                }

                if (caught)
                {
                    return(TestStatistics.SingleSuccess);
                }
                else
                {
                    if (exception == null)
                    {
                        Log.Log(
                            new LogEntry(
                                Severity.Error,
                                "assertion failed",
                                "action should have trapped, but didn't.",
                                Assembler.Highlight(expression)));
                    }
                    else
                    {
                        Log.Log(
                            new LogEntry(
                                Severity.Error,
                                "assertion failed",
                                "action trapped as expected, but with an unexpected exception. ",
                                exception.ToString(),
                                Assembler.Highlight(expression)));
                    }
                    return(TestStatistics.SingleFailure);
                }
            }
            else if (expression.IsCallTo("assert_return_canonical_nan"))
            {
                var  results = RunAction(expression.Tail[0]);
                bool isCanonicalNaN;
                if (results.Count != 1)
                {
                    Log.Log(
                        new LogEntry(
                            Severity.Error,
                            "assertion failed",
                            "action produced ",
                            results.Count.ToString(),
                            " results (",
                            string.Join(", ", results),
                            "); expected a single canonical NaN.",
                            Assembler.Highlight(expression)));
                    return(TestStatistics.SingleFailure);
                }
                else if (results[0] is double)
                {
                    var val = Interpret.ValueHelpers.ReinterpretAsInt64((double)results[0]);
                    isCanonicalNaN = val == Interpret.ValueHelpers.ReinterpretAsInt64((double)FloatLiteral.NaN(false)) ||
                                     val == Interpret.ValueHelpers.ReinterpretAsInt64((double)FloatLiteral.NaN(true));
                }
                else if (results[0] is float)
                {
                    var val = Interpret.ValueHelpers.ReinterpretAsInt32((float)results[0]);
                    isCanonicalNaN = val == Interpret.ValueHelpers.ReinterpretAsInt32((float)FloatLiteral.NaN(false)) ||
                                     val == Interpret.ValueHelpers.ReinterpretAsInt32((float)FloatLiteral.NaN(true));
                }
                else
                {
                    isCanonicalNaN = false;
                }
                if (isCanonicalNaN)
                {
                    return(TestStatistics.SingleSuccess);
                }
                else
                {
                    Log.Log(
                        new LogEntry(
                            Severity.Error,
                            "assertion failed",
                            "action produced ",
                            results[0].ToString(),
                            "; expected a single canonical NaN.",
                            Assembler.Highlight(expression)));
                    return(TestStatistics.SingleFailure);
                }
            }
            else if (expression.IsCallTo("assert_return_arithmetic_nan"))
            {
                var  results = RunAction(expression.Tail[0]);
                bool isNaN;
                if (results.Count != 1)
                {
                    Log.Log(
                        new LogEntry(
                            Severity.Error,
                            "assertion failed",
                            "action produced ",
                            results.Count.ToString(),
                            " results (",
                            string.Join(", ", results),
                            "); expected a single NaN.",
                            Assembler.Highlight(expression)));
                    return(TestStatistics.SingleFailure);
                }
                else if (results[0] is double)
                {
                    isNaN = double.IsNaN((double)results[0]);
                }
                else if (results[0] is float)
                {
                    isNaN = float.IsNaN((float)results[0]);
                }
                else
                {
                    isNaN = false;
                }
                if (isNaN)
                {
                    return(TestStatistics.SingleSuccess);
                }
                else
                {
                    Log.Log(
                        new LogEntry(
                            Severity.Error,
                            "assertion failed",
                            "action produced ",
                            results[0].ToString(),
                            "; expected a single NaN.",
                            Assembler.Highlight(expression)));
                    return(TestStatistics.SingleFailure);
                }
            }
            else
            {
                Log.Log(
                    new LogEntry(
                        Severity.Warning,
                        "unknown script command",
                        Quotation.QuoteEvenInBold(
                            "expression ",
                            expression.Head.Span.Text,
                            " was not recognized as a known script command."),
                        Assembler.Highlight(expression)));
                return(TestStatistics.SingleUnknown);
            }
        }