public bool TryGetNext([MaybeNullWhen(false)] out ITraceDebugRecord record)
            {
                if (disposedValue)
                {
                    throw new ObjectDisposedException(nameof(TraceFile));
                }

                if (nextRecords.TryPop(out record))
                {
                    previousRecords.Push(record);
                    return(true);
                }

                while (traceFileStream.Position < traceFileStream.Length)
                {
                    record = MessagePackSerializer.Deserialize <ITraceDebugRecord>(traceFileStream, options);
                    if (record is ScriptRecord script)
                    {
                        contracts.TryAdd(script.ScriptHash, script.Script);
                    }
                    else if (record is ProtocolSettingsRecord protocolSettings)
                    {
                        Network        = protocolSettings.Network;
                        AddressVersion = protocolSettings.AddressVersion;
                    }
                    else
                    {
                        previousRecords.Push(record);
                        return(true);
                    }
                }

                return(false);
            }
            public bool TryGetPrev([MaybeNullWhen(false)] out ITraceDebugRecord record)
            {
                if (disposedValue)
                {
                    throw new ObjectDisposedException(nameof(TraceFile));
                }

                if (previousRecords.TryPop(out record))
                {
                    nextRecords.Push(record);
                    return(true);
                }

                return(false);
            }
Exemple #3
0
        private void ProcessRecord(ITraceDebugRecord record, bool stepBack = false)
        {
            switch (record)
            {
            case TraceRecord trace:
                State           = trace.State;
                GasConsumed     = trace.GasConsumed;
                stackFrames     = trace.StackFrames;
                InvocationStack = trace.StackFrames
                                  .Select(sf => new ExecutionContextAdapter(sf, contracts))
                                  .ToList();
                break;

            case StorageRecord _:
                break;

            case NotifyRecord notify:
                if (!stepBack)
                {
                    DebugNotify?.Invoke(this, (notify.ScriptHash, notify.ScriptName, notify.EventName, new NeoArray(notify.State)));
                }
                break;

            case LogRecord log:
                if (!stepBack)
                {
                    DebugLog?.Invoke(this, (log.ScriptHash, log.ScriptName, log.Message));
                }
                break;

            case ResultsRecord results:
                ResultStack = stepBack ? new List <StackItem>() : results.ResultStack;
                break;

            case FaultRecord fault:
                FaultException = stepBack ? null : new Exception(fault.Exception);
                break;

            default:
                throw new InvalidDataException($"TraceDebugRecord {record.GetType().Name}");
            }
        }