Enum ModuleKind 

#[repr(u8)]
pub enum ModuleKind {
    Library = 0,
    Executable = 1,
    Kernel = 2,
}

Represents the kind of a Module.

The three different kinds have slightly different rules on what syntax is allowed, as well as what operations can be performed in the body of procedures defined in the module. See the documentation for each variant for a summary of these differences.

Variants

Library = 0

A library is a simple container of code that must be included into an executable module to form a complete program.

Library modules cannot use the begin..end syntax, which is used to define the entrypoint procedure for an executable. Aside from this, they are free to use all other MASM syntax.

Executable = 1

An executable is the root module of a program, and provides the entrypoint for executing that program.

As the executable module is the root module, it may not export procedures for other modules to depend on, it may only import and call externally-defined procedures, or private locally-defined procedures.

An executable module must contain a begin..end block.

Kernel = 2

A kernel is like a library module, but is special in a few ways:

• Its code always executes in the root context, so it is stateful in a way that normal libraries cannot replicate. This can be used to provide core services that would otherwise not be possible to implement.

• The procedures exported from the kernel may be the target of the syscall instruction, and in fact must be called that way.

Implementations

impl ModuleKind

pub fn is_executable(&self) -> bool

pub fn is_kernel(&self) -> bool

pub fn is_library(&self) -> bool

Trait Implementations

impl Clone for ModuleKind

fn clone(&self) -> ModuleKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ModuleKind

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

Formats the value using the given formatter.

impl Default for ModuleKind

fn default() -> ModuleKind

Returns the “default value” for a type.

impl Deserializable for ModuleKind

fn read_from<R>(source: &mut R) -> Result<ModuleKind, DeserializationError>

where R: ByteReader,

Reads a sequence of bytes from the provided source, attempts to deserialize these bytes into Self, and returns the result.

fn min_serialized_size() -> usize

Returns the minimum serialized size for one instance of this type.

fn read_from_bytes(bytes: &[u8]) -> Result<Self, DeserializationError>

Attempts to deserialize the provided bytes into Self and returns the result.

fn read_from_bytes_with_budget( bytes: &[u8], budget: usize, ) -> Result<Self, DeserializationError>

Deserializes Self from bytes with a byte budget limit.

impl Display for ModuleKind

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

Formats the value using the given formatter.

impl PartialEq for ModuleKind

fn eq(&self, other: &ModuleKind) -> 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 Serializable for ModuleKind

fn write_into<W>(&self, target: &mut W)

where W: ByteWriter,

Serializes self into bytes and writes these bytes into the target.

fn to_bytes(&self) -> Vec<u8>

Serializes self into a vector of bytes.

fn get_size_hint(&self) -> usize

Returns an estimate of how many bytes are needed to represent self.

impl Copy for ModuleKind

impl Eq for ModuleKind

impl StructuralPartialEq for ModuleKind