コード例 #1
0
        /// <summary>
        /// Visit a parse tree produced by <see cref="Z80TestParser.memPattern"/>.
        /// <para>
        /// The default implementation returns the result of calling <see cref="AbstractParseTreeVisitor{Result}.VisitChildren(IRuleNode)"/>
        /// on <paramref name="context"/>.
        /// </para>
        /// </summary>
        /// <param name="context">The parse tree.</param>
        /// <return>The visitor result.</return>
        public override object VisitMemPattern(Z80TestParser.MemPatternContext context)
        {
            if (IsInvalidContext(context))
            {
                return(null);
            }
            var node = new MemoryPatternMemberNode(context);

            foreach (var body in context.memPatternBody())
            {
                node.Patterns.Add((MemoryPatternNode)VisitMemPatternBody(body));
            }
            return(node);
        }
コード例 #2
0
        /// <summary>
        /// Visits a memory pattern member
        /// </summary>
        /// <param name="plan">Test file plan</param>
        /// <param name="testSetPlan">TestSetPlan to visit</param>
        /// <param name="mempatMember">Memory pattern member syntax node</param>
        private void VisitMemoryPatternMember(TestFilePlan plan, TestSetPlan testSetPlan, MemoryPatternMemberNode mempatMember)
        {
            // --- Check ID duplication
            var id = mempatMember.Id;

            if (testSetPlan.ContainsSymbol(id))
            {
                ReportError(Errors.T0006, plan, mempatMember.IdSpan, id);
                return;
            }

            // --- Evaluate byte array
            var bytes      = new List <byte>();
            var errorFound = false;

            foreach (var mempat in mempatMember.Patterns)
            {
                if (mempat is BytePatternNode bytePattern)
                {
                    foreach (var byteExpr in bytePattern.Bytes)
                    {
                        var value = Eval(plan, testSetPlan, byteExpr);
                        if (value != null)
                        {
                            bytes.Add((byte)value.AsNumber());
                        }
                        else
                        {
                            errorFound = true;
                        }
                    }
                }
                else if (mempat is WordPatternNode wordPattern)
                {
                    foreach (var byteExpr in wordPattern.Words)
                    {
                        var value = Eval(plan, testSetPlan, byteExpr);
                        if (value != null)
                        {
                            var word = value.AsWord();
                            bytes.Add((byte)word);
                            bytes.Add((byte)(word >> 8));
                        }
                        else
                        {
                            errorFound = true;
                        }
                    }
                }
                else if (mempat is TextPatternNode textPattern)
                {
                    foreach (var val in SyntaxHelper.SpectrumStringToBytes(textPattern.String))
                    {
                        bytes.Add(val);
                    }
                }
            }

            if (errorFound)
            {
                return;
            }
            testSetPlan.SetDataMember(id, new ExpressionValue(bytes.ToArray()));
        }