Enum StatementOpcode

pub enum StatementOpcode<'a> {
    Break,
    BreakPoint,
    Continue,
    Fatal {
        fatal_type: u8,
        code: u32,
        arg: TermArg<'a>,
    },
    If {
        predicate: TermArg<'a>,
        if_true: Vec<TermObject<'a>>,
        if_false: Vec<TermObject<'a>>,
    },
    Load {
        name: NameString,
        definition_block_handle: SuperName<'a>,
    },
    NoOp,
    Notify {
        device_or_zone: SuperName<'a>,
        value: TermArg<'a>,
    },
    Release {
        mutex: SuperName<'a>,
    },
    Reset {
        event: SuperName<'a>,
    },
    Return(TermArg<'a>),
    Signal {
        event: SuperName<'a>,
    },
    Sleep {
        milliseconds: TermArg<'a>,
    },
    Stall {
        microseconds: TermArg<'a>,
    },
    While {
        predicate: TermArg<'a>,
        body: Vec<TermObject<'a>>,
    },
}

Terminal operation that does not evaluate to a value, a.k.a. “Type 1 Opcode.”

Variants

Break

Break from a loop

BreakPoint

Trigger a debugger breakpoint

Continue

Continue to the next loop iteration

Fatal

Signal an error that requires a system shutdown

Fields

fatal_type: u8

code: u32

arg: TermArg<'a>

If

Branch on a predicate

Fields

predicate: TermArg<'a>

if_true: Vec<TermObject<'a>>

if_false: Vec<TermObject<'a>>

Load

Load a dynamically-generated SSDT from a field, region, or buffer

Fields

name: NameString

definition_block_handle: SuperName<'a>

NoOp

Do nothing

Notify

Send a signal value to a device/processor/zone

Fields

device_or_zone: SuperName<'a>

value: TermArg<'a>

Release

Release a held mutex

Fields

mutex: SuperName<'a>

Reset

Clear the signalled state of an event object

Fields

event: SuperName<'a>

Return(TermArg<'a>)

Exit the current method and yield the given value to the caller

Signal

Signal to one thread waiting on the event

Fields

event: SuperName<'a>

Sleep

Delay for at least the given milliseconds, releasing the processor

Fields

milliseconds: TermArg<'a>

Stall

Delay for at least the given microseconds, but do not release the processor

Fields

microseconds: TermArg<'a>

While

Execute a series of statements as long as the predicate is true

Fields

predicate: TermArg<'a>

body: Vec<TermObject<'a>>

Trait Implementations

impl<'a> Clone for StatementOpcode<'a>

fn clone(&self) -> StatementOpcode<'a>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a> Debug for StatementOpcode<'a>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a> From<StatementOpcode<'a>> for TermObject<'a>

fn from(s: StatementOpcode<'a>) -> TermObject<'a>

Converts to this type from the input type.

impl<'a> Parse<'a> for StatementOpcode<'a>

Grammar:

Type1Opcode := DefBreak | DefBreakPoint | DefContinue | DefFatal | DefIfElse |
               DefLoad | DefNoop | DefNotify | DefRelease | DefReset | DefReturn |
               DefSignal | DefSleep | DefStall | DefWhile

fn parse<E: AMLParseError<'a>>( i: ParserState<'a>, ) -> AMLParseResult<'a, Self, E>

Try to parse an object of this type from the given input and state.

impl<'a> PartialEq for StatementOpcode<'a>

fn eq(&self, other: &StatementOpcode<'a>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Eq for StatementOpcode<'a>

impl<'a> StructuralPartialEq for StatementOpcode<'a>