     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88

    // Copyright 2015-2017 Parity Technologies (UK) Ltd.
    // This file is part of Parity.

    // Parity is free software: you can redistribute it and/or modify
    // it under the terms of the GNU General Public License as published by
    // the Free Software Foundation, either version 3 of the License, or
    // (at your option) any later version.

    // Parity is distributed in the hope that it will be useful,
    // but WITHOUT ANY WARRANTY; without even the implied warranty of
    // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    // GNU General Public License for more details.

    // You should have received a copy of the GNU General Public License
    // along with Parity.  If not, see <http://www.gnu.org/licenses/>.

    //! Nonoperative tracer.

    use util::{Bytes, Address, U256};
    use action_params::ActionParams;
    use trace::{Tracer, VMTracer, FlatTrace, TraceError};
    use trace::trace::{Call, Create, VMTrace};

    /// Nonoperative tracer. Does not trace anything.
    pub struct NoopTracer;

    impl Tracer for NoopTracer {
    	fn prepare_trace_call(&self, _: &ActionParams) -> Option<Call> {
    		None
    	}

    	fn prepare_trace_create(&self, _: &ActionParams) -> Option<Create> {
    		None
    	}

    	fn prepare_trace_output(&self) -> Option<Bytes> {
    		None
    	}

    	fn trace_call(&mut self, call: Option<Call>, _: U256, output: Option<Bytes>, _: Vec<FlatTrace>) {
    		assert!(call.is_none(), "self.prepare_trace_call().is_none(): so we can't be tracing: qed");
    		assert!(output.is_none(), "self.prepare_trace_output().is_none(): so we can't be tracing: qed");
    	}

    	fn trace_create(&mut self, create: Option<Create>, _: U256, code: Option<Bytes>, _: Address, _: Vec<FlatTrace>) {
    		assert!(create.is_none(), "self.prepare_trace_create().is_none(): so we can't be tracing: qed");
    		assert!(code.is_none(), "self.prepare_trace_output().is_none(): so we can't be tracing: qed");
    	}

    	fn trace_failed_call(&mut self, call: Option<Call>, _: Vec<FlatTrace>, _: TraceError) {
    		assert!(call.is_none(), "self.prepare_trace_call().is_none(): so we can't be tracing: qed");
    	}

    	fn trace_failed_create(&mut self, create: Option<Create>, _: Vec<FlatTrace>, _: TraceError) {
    		assert!(create.is_none(), "self.prepare_trace_create().is_none(): so we can't be tracing: qed");
    	}

    	fn trace_suicide(&mut self, _address: Address, _balance: U256, _refund_address: Address) {
    	}

    	fn subtracer(&self) -> Self {
    		NoopTracer
    	}

    	fn traces(self) -> Vec<FlatTrace> {
    		vec![]
    	}
    }

    /// Nonoperative VM tracer. Does not trace anything.
    pub struct NoopVMTracer;

    impl VMTracer for NoopVMTracer {
    	/// Trace the preparation to execute a single instruction.
    	fn trace_prepare_execute(&mut self, _pc: usize, _instruction: u8, _gas_cost: &U256) -> bool { false }

    	/// Trace the finalised execution of a single instruction.
    	fn trace_executed(&mut self, _gas_used: U256, _stack_push: &[U256], _mem_diff: Option<(usize, &[u8])>, _store_diff: Option<(U256, U256)>) {}

    	/// Spawn subtracer which will be used to trace deeper levels of execution.
    	fn prepare_subtrace(&self, _code: &[u8]) -> Self { NoopVMTracer }

    	/// Spawn subtracer which will be used to trace deeper levels of execution.
    	fn done_subtrace(&mut self, _sub: Self) {}

    	/// Consumes self and returns all VM traces.
    	fn drain(self) -> Option<VMTrace> { None }
    }

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)