Struct Script 

pub struct Script { /* private fields */ }

Recovered AutoIt script view.

Implementations

impl Script

pub const fn record_index(&self) -> usize

Returns the source record index.

Returns

The index of the Record this script was recovered from.

Examples found in repository

examples/dump.rs (line 223)

fn print_scripts(scripts: &[Script]) {
    section(&format!("scripts ({})", scripts.len()));
    for script in scripts {
        println!(
            "  record #{} {}",
            script.record_index(),
            escape_inline(script.name())
        );
        subfield("kind", format!("{:?}", script.kind()));
        subfield("bytes", script.bytes().len().to_string());
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                script.creation_time(),
                script.last_write_time()
            ),
        );
        subfield(
            "text encoding",
            script.text().map_or_else(
                || "none".to_string(),
                |text| format!("{:?}", text.encoding()),
            ),
        );
        subfield("decode error", opt_debug(script.decode_error()));
        match script.token_stream() {
            None => subfield("token stream", "none".to_string()),
            Some(tokens) => subfield(
                "token stream",
                format!(
                    "line_count={} tokens={}",
                    tokens.line_count(),
                    tokens.tokens().len()
                ),
            ),
        }
        match script.source_text() {
            None => subfield("source", "<unavailable>".to_string()),
            Some(source) => {
                println!("    source ({} chars):", source.chars().count());
                print_block(source);
            }
        }
    }
}

pub fn name(&self) -> &str

Returns the stored script name/path.

Returns

The decoded name/path string of the source record.

Examples found in repository

examples/dump.rs (line 224)

fn print_scripts(scripts: &[Script]) {
    section(&format!("scripts ({})", scripts.len()));
    for script in scripts {
        println!(
            "  record #{} {}",
            script.record_index(),
            escape_inline(script.name())
        );
        subfield("kind", format!("{:?}", script.kind()));
        subfield("bytes", script.bytes().len().to_string());
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                script.creation_time(),
                script.last_write_time()
            ),
        );
        subfield(
            "text encoding",
            script.text().map_or_else(
                || "none".to_string(),
                |text| format!("{:?}", text.encoding()),
            ),
        );
        subfield("decode error", opt_debug(script.decode_error()));
        match script.token_stream() {
            None => subfield("token stream", "none".to_string()),
            Some(tokens) => subfield(
                "token stream",
                format!(
                    "line_count={} tokens={}",
                    tokens.line_count(),
                    tokens.tokens().len()
                ),
            ),
        }
        match script.source_text() {
            None => subfield("source", "<unavailable>".to_string()),
            Some(source) => {
                println!("    source ({} chars):", source.chars().count());
                print_block(source);
            }
        }
    }
}

pub const fn kind(&self) -> ScriptKind

Returns the recovered script kind.

Returns

The ScriptKind classifying how the script was recovered.

Examples found in repository

examples/dump.rs (line 226)

fn print_scripts(scripts: &[Script]) {
    section(&format!("scripts ({})", scripts.len()));
    for script in scripts {
        println!(
            "  record #{} {}",
            script.record_index(),
            escape_inline(script.name())
        );
        subfield("kind", format!("{:?}", script.kind()));
        subfield("bytes", script.bytes().len().to_string());
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                script.creation_time(),
                script.last_write_time()
            ),
        );
        subfield(
            "text encoding",
            script.text().map_or_else(
                || "none".to_string(),
                |text| format!("{:?}", text.encoding()),
            ),
        );
        subfield("decode error", opt_debug(script.decode_error()));
        match script.token_stream() {
            None => subfield("token stream", "none".to_string()),
            Some(tokens) => subfield(
                "token stream",
                format!(
                    "line_count={} tokens={}",
                    tokens.line_count(),
                    tokens.tokens().len()
                ),
            ),
        }
        match script.source_text() {
            None => subfield("source", "<unavailable>".to_string()),
            Some(source) => {
                println!("    source ({} chars):", source.chars().count());
                print_block(source);
            }
        }
    }
}

pub fn bytes(&self) -> &[u8]

Returns raw recovered script bytes.

Returns

The best available payload bytes for the source record, before any text decode.

Examples found in repository

examples/dump.rs (line 227)

fn print_scripts(scripts: &[Script]) {
    section(&format!("scripts ({})", scripts.len()));
    for script in scripts {
        println!(
            "  record #{} {}",
            script.record_index(),
            escape_inline(script.name())
        );
        subfield("kind", format!("{:?}", script.kind()));
        subfield("bytes", script.bytes().len().to_string());
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                script.creation_time(),
                script.last_write_time()
            ),
        );
        subfield(
            "text encoding",
            script.text().map_or_else(
                || "none".to_string(),
                |text| format!("{:?}", text.encoding()),
            ),
        );
        subfield("decode error", opt_debug(script.decode_error()));
        match script.token_stream() {
            None => subfield("token stream", "none".to_string()),
            Some(tokens) => subfield(
                "token stream",
                format!(
                    "line_count={} tokens={}",
                    tokens.line_count(),
                    tokens.tokens().len()
                ),
            ),
        }
        match script.source_text() {
            None => subfield("source", "<unavailable>".to_string()),
            Some(source) => {
                println!("    source ({} chars):", source.chars().count());
                print_block(source);
            }
        }
    }
}

pub const fn text(&self) -> Option<&ScriptText>

Returns decoded script text when available.

Returns

Some with the ScriptText when text was recovered, or None when decoding failed or was not attempted.

Examples found in repository

examples/dump.rs (line 238)

fn print_scripts(scripts: &[Script]) {
    section(&format!("scripts ({})", scripts.len()));
    for script in scripts {
        println!(
            "  record #{} {}",
            script.record_index(),
            escape_inline(script.name())
        );
        subfield("kind", format!("{:?}", script.kind()));
        subfield("bytes", script.bytes().len().to_string());
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                script.creation_time(),
                script.last_write_time()
            ),
        );
        subfield(
            "text encoding",
            script.text().map_or_else(
                || "none".to_string(),
                |text| format!("{:?}", text.encoding()),
            ),
        );
        subfield("decode error", opt_debug(script.decode_error()));
        match script.token_stream() {
            None => subfield("token stream", "none".to_string()),
            Some(tokens) => subfield(
                "token stream",
                format!(
                    "line_count={} tokens={}",
                    tokens.line_count(),
                    tokens.tokens().len()
                ),
            ),
        }
        match script.source_text() {
            None => subfield("source", "<unavailable>".to_string()),
            Some(source) => {
                println!("    source ({} chars):", source.chars().count());
                print_block(source);
            }
        }
    }
}

pub const fn decode_error(&self) -> Option<ScriptDecodeError>

Returns text decode error details when text recovery failed.

Returns

Some with the ScriptDecodeError when decoding failed, or None otherwise.

Examples found in repository

examples/dump.rs (line 243)

fn print_scripts(scripts: &[Script]) {
    section(&format!("scripts ({})", scripts.len()));
    for script in scripts {
        println!(
            "  record #{} {}",
            script.record_index(),
            escape_inline(script.name())
        );
        subfield("kind", format!("{:?}", script.kind()));
        subfield("bytes", script.bytes().len().to_string());
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                script.creation_time(),
                script.last_write_time()
            ),
        );
        subfield(
            "text encoding",
            script.text().map_or_else(
                || "none".to_string(),
                |text| format!("{:?}", text.encoding()),
            ),
        );
        subfield("decode error", opt_debug(script.decode_error()));
        match script.token_stream() {
            None => subfield("token stream", "none".to_string()),
            Some(tokens) => subfield(
                "token stream",
                format!(
                    "line_count={} tokens={}",
                    tokens.line_count(),
                    tokens.tokens().len()
                ),
            ),
        }
        match script.source_text() {
            None => subfield("source", "<unavailable>".to_string()),
            Some(source) => {
                println!("    source ({} chars):", source.chars().count());
                print_block(source);
            }
        }
    }
}

pub const fn token_stream(&self) -> Option<&TokenStream>

Returns parsed token stream for tokenized scripts when available.

Returns

Some with the token::TokenStream for a tokenized EA06 script, or None for other kinds or when token parsing failed.

Examples found in repository

examples/dump.rs (line 244)

fn print_scripts(scripts: &[Script]) {
    section(&format!("scripts ({})", scripts.len()));
    for script in scripts {
        println!(
            "  record #{} {}",
            script.record_index(),
            escape_inline(script.name())
        );
        subfield("kind", format!("{:?}", script.kind()));
        subfield("bytes", script.bytes().len().to_string());
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                script.creation_time(),
                script.last_write_time()
            ),
        );
        subfield(
            "text encoding",
            script.text().map_or_else(
                || "none".to_string(),
                |text| format!("{:?}", text.encoding()),
            ),
        );
        subfield("decode error", opt_debug(script.decode_error()));
        match script.token_stream() {
            None => subfield("token stream", "none".to_string()),
            Some(tokens) => subfield(
                "token stream",
                format!(
                    "line_count={} tokens={}",
                    tokens.line_count(),
                    tokens.tokens().len()
                ),
            ),
        }
        match script.source_text() {
            None => subfield("source", "<unavailable>".to_string()),
            Some(source) => {
                println!("    source ({} chars):", source.chars().count());
                print_block(source);
            }
        }
    }
}

pub fn source_text(&self) -> Option<&str>

Returns decoded source text when available.

Returns

Some with the decoded text string when Self::text is present, or None otherwise.

Examples found in repository

examples/dump.rs (line 255)

fn print_scripts(scripts: &[Script]) {
    section(&format!("scripts ({})", scripts.len()));
    for script in scripts {
        println!(
            "  record #{} {}",
            script.record_index(),
            escape_inline(script.name())
        );
        subfield("kind", format!("{:?}", script.kind()));
        subfield("bytes", script.bytes().len().to_string());
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                script.creation_time(),
                script.last_write_time()
            ),
        );
        subfield(
            "text encoding",
            script.text().map_or_else(
                || "none".to_string(),
                |text| format!("{:?}", text.encoding()),
            ),
        );
        subfield("decode error", opt_debug(script.decode_error()));
        match script.token_stream() {
            None => subfield("token stream", "none".to_string()),
            Some(tokens) => subfield(
                "token stream",
                format!(
                    "line_count={} tokens={}",
                    tokens.line_count(),
                    tokens.tokens().len()
                ),
            ),
        }
        match script.source_text() {
            None => subfield("source", "<unavailable>".to_string()),
            Some(source) => {
                println!("    source ({} chars):", source.chars().count());
                print_block(source);
            }
        }
    }
}

pub const fn creation_time(&self) -> u64

Returns the source record creation timestamp as raw Windows FILETIME.

Returns

The raw 64-bit Windows FILETIME creation timestamp from the source record.

Examples found in repository

examples/dump.rs (line 232)

fn print_scripts(scripts: &[Script]) {
    section(&format!("scripts ({})", scripts.len()));
    for script in scripts {
        println!(
            "  record #{} {}",
            script.record_index(),
            escape_inline(script.name())
        );
        subfield("kind", format!("{:?}", script.kind()));
        subfield("bytes", script.bytes().len().to_string());
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                script.creation_time(),
                script.last_write_time()
            ),
        );
        subfield(
            "text encoding",
            script.text().map_or_else(
                || "none".to_string(),
                |text| format!("{:?}", text.encoding()),
            ),
        );
        subfield("decode error", opt_debug(script.decode_error()));
        match script.token_stream() {
            None => subfield("token stream", "none".to_string()),
            Some(tokens) => subfield(
                "token stream",
                format!(
                    "line_count={} tokens={}",
                    tokens.line_count(),
                    tokens.tokens().len()
                ),
            ),
        }
        match script.source_text() {
            None => subfield("source", "<unavailable>".to_string()),
            Some(source) => {
                println!("    source ({} chars):", source.chars().count());
                print_block(source);
            }
        }
    }
}

pub const fn last_write_time(&self) -> u64

Returns the source record last-write timestamp as raw Windows FILETIME.

Returns

The raw 64-bit Windows FILETIME last-write timestamp from the source record.

Examples found in repository

examples/dump.rs (line 233)

fn print_scripts(scripts: &[Script]) {
    section(&format!("scripts ({})", scripts.len()));
    for script in scripts {
        println!(
            "  record #{} {}",
            script.record_index(),
            escape_inline(script.name())
        );
        subfield("kind", format!("{:?}", script.kind()));
        subfield("bytes", script.bytes().len().to_string());
        subfield(
            "timestamps",
            format!(
                "created={} last_write={}",
                script.creation_time(),
                script.last_write_time()
            ),
        );
        subfield(
            "text encoding",
            script.text().map_or_else(
                || "none".to_string(),
                |text| format!("{:?}", text.encoding()),
            ),
        );
        subfield("decode error", opt_debug(script.decode_error()));
        match script.token_stream() {
            None => subfield("token stream", "none".to_string()),
            Some(tokens) => subfield(
                "token stream",
                format!(
                    "line_count={} tokens={}",
                    tokens.line_count(),
                    tokens.tokens().len()
                ),
            ),
        }
        match script.source_text() {
            None => subfield("source", "<unavailable>".to_string()),
            Some(source) => {
                println!("    source ({} chars):", source.chars().count());
                print_block(source);
            }
        }
    }
}

Trait Implementations

impl Clone for Script

fn clone(&self) -> Script

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Script

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

Formats the value using the given formatter.

impl PartialEq for Script

fn eq(&self, other: &Script) -> bool

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Script