Struct PowerShellSession 

pub struct PowerShellSession { /* private fields */ }

Represents a PowerShell parsing and evaluation session.

This is the main entry point for parsing and evaluating PowerShell scripts. It maintains the session state including variables, tokens, and error information.

Examples

use ps_parser::PowerShellSession;

// Create a new session
let mut session = PowerShellSession::new();

// Evaluate a simple expression
let result = session.safe_eval("$a = 1 + 2; Write-Output $a").unwrap();
assert_eq!(result, "3");

// Parse and get detailed results
let script_result = session.parse_input("$b = 'Hello World'; $b").unwrap();
println!("Result: {:?}", script_result.result());

Represents a PowerShell value that can be stored and manipulated.

This enum covers all the basic PowerShell data types including primitives, collections, and complex objects like script blocks and hash tables.

Examples

use ps_parser::PsValue;

// Different value types  
let int_val = PsValue::Int(42);
let string_val = PsValue::String("Hello".into());
let bool_val = PsValue::Bool(true);

Contains the complete result of parsing and evaluating a PowerShell script.

This structure holds the final result value, any output generated, parsing errors encountered, and the tokenized representation of the script. It’s particularly useful for debugging and deobfuscation purposes.

Examples

use ps_parser::PowerShellSession;

let mut session = PowerShellSession::new();
let script_result = session.parse_input("$a = 42; $a").unwrap();

// Access different parts of the result
println!("Final value: {:?}", script_result.result());
println!("Output: {:?}", script_result.output());
println!("Errors: {:?}", script_result.errors());

Represents a parsed token from a PowerShell script.

Tokens are the building blocks of parsed PowerShell code and are used for syntax analysis, deobfuscation, and code transformation.

Examples

use ps_parser::PowerShellSession;

let mut session = PowerShellSession::new();
let script_result = session.parse_input("$var = 123").unwrap();

// Inspect the tokens
for token in script_result.tokens().all() {
    println!("Token: {:?}", token);
}

Manages PowerShell variables across different scopes.

This structure handles variable storage, retrieval, and scope management for PowerShell scripts. It supports loading variables from environment variables, INI files, and manual assignment.

Examples

use ps_parser::{Variables, PowerShellSession};
use std::path::Path;

// Load environment variables
let env_vars = Variables::env();
let mut session = PowerShellSession::new().with_variables(env_vars);

// Load from INI string
let ini_vars = Variables::from_ini_string("[global]\nname = John Doe\n[local]\nlocal_var = \"local_value\"").unwrap();
let mut session2 = PowerShellSession::new().with_variables(ini_vars);

// Create empty and add manually
let mut vars = Variables::new();
// ... add variables manually

Implementations

impl<'a> PowerShellSession

pub fn new() -> Self

Creates a new PowerShell parsing session with default settings.

The session is initialized with built-in variables like $true, $false, $null, and special variables like $? for error status tracking.

Returns

A new PowerShellSession instance ready for script evaluation.

Examples

use ps_parser::PowerShellSession;

let mut session = PowerShellSession::new();
let result = session.safe_eval("$true").unwrap();
assert_eq!(result, "True");

pub fn with_variables(self, variables: Variables) -> Self

Creates a new PowerShell session with the provided variables.

This constructor allows you to initialize the session with a custom set of variables, such as environment variables or variables loaded from configuration files.

Arguments

• variables - A Variables instance containing the initial variable set.

Returns

A new PowerShellSession instance with the provided variables.

Examples

use ps_parser::{PowerShellSession, Variables};

let env_vars = Variables::env();
let mut session = PowerShellSession::new().with_variables(env_vars);
let username = session.safe_eval("$env:USERNAME").unwrap();

pub fn safe_eval(&mut self, script: &str) -> Result<String, ParserError>

Safely evaluates a PowerShell script and returns the output as a string.

This method parses and evaluates the provided PowerShell script, handling errors gracefully and returning the result as a formatted string. It’s the recommended method for simple script evaluation.

Arguments

• script - A string slice containing the PowerShell script to evaluate.

Returns

• Result<String, ParserError> - The output of the script evaluation, or an error if parsing/evaluation fails.

Examples

use ps_parser::PowerShellSession;

let mut session = PowerShellSession::new();

// Simple arithmetic
let result = session.safe_eval("1 + 2 * 3").unwrap();
assert_eq!(result, "7");

// Variable assignment and retrieval
let result = session.safe_eval("$name = 'World'; \"Hello $name\"").unwrap();
assert_eq!(result, "Hello World");

pub fn parse_input(&mut self, input: &str) -> Result<ScriptResult, ParserError>

Parses and evaluates a PowerShell script, returning detailed results.

This method provides comprehensive information about the parsing and evaluation process, including the final result, generated output, any errors encountered, and the tokenized representation of the script. It’s particularly useful for debugging and deobfuscation.

Arguments

• input - A string slice containing the PowerShell script to parse and evaluate.

Returns

• Result<ScriptResult, ParserError> - A detailed result containing the evaluation outcome, output, errors, and tokens, or a parsing error if the script is malformed.

Examples

use ps_parser::PowerShellSession;

let mut session = PowerShellSession::new();
let script_result = session.parse_input("$a = 42; Write-Output $a").unwrap();

println!("Final result: {:?}", script_result.result());
println!("Generated output: {:?}", script_result.output());
println!("Parsing errors: {:?}", script_result.errors());
println!("Deobfuscated code: {:?}", script_result.deobfuscated());

Trait Implementations

impl Default for PowerShellSession

fn default() -> Self

Returns the “default value” for a type.