Struct EngineState

pub struct EngineState {

    pub spans: Vec<Span>,
    pub scope: ScopeFrame,
    pub signal_handlers: Option<Handlers>,
    pub env_vars: Arc<EnvVars>,
    pub previous_env_vars: Arc<HashMap<String, Value>>,
    pub config: Arc<Config>,
    pub pipeline_externals_state: Arc<(AtomicU32, AtomicU32)>,
    pub repl_state: Arc<Mutex<ReplState>>,
    pub table_decl_id: Option<DeclId>,
    pub plugin_path: Option<PathBuf>,
    pub history_enabled: bool,
    pub history_session_id: i64,
    pub file: Option<PathBuf>,
    pub regex_cache: Arc<Mutex<LruCache<String, Regex>>>,
    pub is_interactive: bool,
    pub is_login: bool,
    pub debugger: Arc<Mutex<Box<dyn Debugger>>>,
    /* private fields */
}

The core global engine state. This includes all global definitions as well as any global state that will persist for the whole session.

Declarations, variables, blocks, and other forms of data are held in the global state and referenced elsewhere using their IDs. These IDs are simply their index into the global state. This allows us to more easily handle creating blocks, binding variables and callsites, and more, because each of these will refer to the corresponding IDs rather than their definitions directly. At runtime, this means less copying and smaller structures.

Many of the larger objects in this structure are stored within Arc to decrease the cost of cloning EngineState. While Arcs are generally immutable, they can be modified using Arc::make_mut, which automatically clones to a new allocation if there are other copies of the Arc already in use, but will let us modify the Arc directly if we have the only reference to it.

Note that the runtime stack is not part of this global state. Runtime stacks are handled differently, but they also rely on using IDs rather than full definitions.

Fields

spans: Vec<Span>

scope: ScopeFrame

signal_handlers: Option<Handlers>

env_vars: Arc<EnvVars>

previous_env_vars: Arc<HashMap<String, Value>>

config: Arc<Config>

pipeline_externals_state: Arc<(AtomicU32, AtomicU32)>

repl_state: Arc<Mutex<ReplState>>

table_decl_id: Option<DeclId>

plugin_path: Option<PathBuf>

history_enabled: bool

history_session_id: i64

file: Option<PathBuf>

regex_cache: Arc<Mutex<LruCache<String, Regex>>>

is_interactive: bool

is_login: bool

debugger: Arc<Mutex<Box<dyn Debugger>>>

Implementations

impl EngineState

pub fn new() -> Self

pub fn signals(&self) -> &Signals

pub fn reset_signals(&mut self)

pub fn set_signals(&mut self, signals: Signals)

pub fn merge_delta(&mut self, delta: StateDelta) -> Result<(), ShellError>

Merges a StateDelta onto the current state. These deltas come from a system, like the parser, that creates a new set of definitions and visible symbols in the current scope. We make this transactional as there are times when we want to run the parser and immediately throw away the results (namely: syntax highlighting and completions).

When we want to preserve what the parser has created, we can take its output (the StateDelta) and use this function to merge it into the global state.

pub fn merge_env(&mut self, stack: &mut Stack) -> Result<(), ShellError>

Merge the environment from the runtime Stack into the engine state

pub fn has_overlay(&self, name: &[u8]) -> bool

pub fn active_overlay_ids<'a, 'b>( &'b self, removed_overlays: &'a [Vec<u8>], ) -> impl DoubleEndedIterator<Item = &OverlayId> + 'a

where 'b: 'a,

pub fn active_overlays<'a, 'b>( &'b self, removed_overlays: &'a [Vec<u8>], ) -> impl DoubleEndedIterator<Item = &OverlayFrame> + 'a

where 'b: 'a,

pub fn active_overlay_names<'a, 'b>( &'b self, removed_overlays: &'a [Vec<u8>], ) -> impl DoubleEndedIterator<Item = &[u8]> + 'a

where 'b: 'a,

pub fn translate_overlay_ids(&self, other: &ScopeFrame) -> Vec<OverlayId>

Translate overlay IDs from other to IDs in self

pub fn last_overlay_name(&self, removed_overlays: &[Vec<u8>]) -> &[u8]

pub fn last_overlay(&self, removed_overlays: &[Vec<u8>]) -> &OverlayFrame

pub fn get_overlay_name(&self, overlay_id: OverlayId) -> &[u8]

pub fn get_overlay(&self, overlay_id: OverlayId) -> &OverlayFrame

pub fn render_env_vars(&self) -> HashMap<&str, &Value>

pub fn add_env_var(&mut self, name: String, val: Value)

pub fn get_env_var(&self, name: &str) -> Option<&Value>

pub fn get_path_env_var(&self) -> Option<&Value>

pub fn plugins(&self) -> &[Arc<dyn RegisteredPlugin>]

pub fn update_plugin_file( &self, updated_items: Vec<PluginRegistryItem>, ) -> Result<(), ShellError>

pub fn num_files(&self) -> usize

pub fn num_virtual_paths(&self) -> usize

pub fn num_vars(&self) -> usize

pub fn num_decls(&self) -> usize

pub fn num_blocks(&self) -> usize

pub fn num_modules(&self) -> usize

pub fn num_spans(&self) -> usize

pub fn print_vars(&self)

pub fn print_decls(&self)

pub fn print_blocks(&self)

pub fn print_contents(&self)

pub fn find_decl( &self, name: &[u8], removed_overlays: &[Vec<u8>], ) -> Option<DeclId>

pub fn find_decl_name( &self, decl_id: DeclId, removed_overlays: &[Vec<u8>], ) -> Option<&[u8]>

pub fn get_module_comments(&self, module_id: ModuleId) -> Option<&[Span]>

pub fn plugin_decls(&self) -> impl Iterator<Item = &Box<dyn Command + 'static>>

pub fn find_module( &self, name: &[u8], removed_overlays: &[Vec<u8>], ) -> Option<ModuleId>

pub fn which_module_has_decl( &self, decl_name: &[u8], removed_overlays: &[Vec<u8>], ) -> Option<&[u8]>

pub fn find_overlay(&self, name: &[u8]) -> Option<OverlayId>

pub fn find_active_overlay(&self, name: &[u8]) -> Option<OverlayId>

pub fn find_commands_by_predicate( &self, predicate: impl Fn(&[u8]) -> bool, ignore_deprecated: bool, ) -> Vec<(Vec<u8>, Option<String>, CommandType)>

pub fn get_span_contents(&self, span: Span) -> &[u8]

pub fn get_config(&self) -> &Arc<Config>

Get the global config from the engine state.

Use Stack::get_config() instead whenever the Stack is available, as it takes into account local changes to $env.config.

pub fn set_config(&mut self, conf: impl Into<Arc<Config>>)

pub fn get_plugin_config(&self, plugin: &str) -> Option<&Value>

Fetch the configuration for a plugin

The plugin must match the registered name of a plugin. For plugin add nu_plugin_example the plugin name to use will be "example"

pub fn history_config(&self) -> Option<HistoryConfig>

Returns the configuration settings for command history or None if history is disabled

pub fn get_var(&self, var_id: VarId) -> &Variable

pub fn get_constant(&self, var_id: VarId) -> Option<&Value>

pub fn generate_nu_constant(&mut self)

pub fn get_decl(&self, decl_id: DeclId) -> &dyn Command

pub fn get_decls_sorted(&self, include_hidden: bool) -> Vec<(Vec<u8>, DeclId)>

Get all commands within scope, sorted by the commands’ names

pub fn get_signature(&self, decl: &dyn Command) -> Signature

pub fn get_signatures_and_declids( &self, include_hidden: bool, ) -> Vec<(Signature, DeclId)>

Get signatures of all commands within scope with their decl ids.

pub fn get_block(&self, block_id: BlockId) -> &Arc<Block>

pub fn try_get_block(&self, block_id: BlockId) -> Option<&Arc<Block>>

Optionally get a block by id, if it exists

Prefer to use .get_block() in most cases - BlockIds that don’t exist are normally a compiler error. This only exists to stop plugins from crashing the engine if they send us something invalid.

pub fn get_module(&self, module_id: ModuleId) -> &Module

pub fn get_virtual_path( &self, virtual_path_id: VirtualPathId, ) -> &(String, VirtualPath)

pub fn next_span_start(&self) -> usize

pub fn files(&self) -> impl Iterator<Item = &CachedFile>

pub fn add_file(&mut self, filename: Arc<str>, content: Arc<[u8]>) -> FileId

pub fn set_config_path(&mut self, key: &str, val: PathBuf)

pub fn get_config_path(&self, key: &str) -> Option<&PathBuf>

pub fn build_desc(&self, spans: &[Span]) -> (String, String)

pub fn build_module_desc(&self, module_id: ModuleId) -> Option<(String, String)>

pub fn current_work_dir(&self) -> String

👎Deprecated since 0.92.3: please use EngineState::cwd() instead

Returns the current working directory, which is guaranteed to be canonicalized.

Returns an empty String if $env.PWD doesn’t exist.

pub fn cwd(&self, stack: Option<&Stack>) -> Result<AbsolutePathBuf, ShellError>

Returns the current working directory, which is guaranteed to be an absolute path without trailing slashes (unless it’s the root path), but might contain symlink components.

If stack is supplied, also considers modifications to the working directory on the stack that have yet to be merged into the engine state.

pub fn cwd_as_string(&self, stack: Option<&Stack>) -> Result<String, ShellError>

Like EngineState::cwd(), but returns a String instead of a PathBuf for convenience.

pub fn get_file_contents(&self) -> &[CachedFile]

pub fn get_startup_time(&self) -> i64

pub fn set_startup_time(&mut self, startup_time: i64)

pub fn activate_debugger( &self, debugger: Box<dyn Debugger>, ) -> Result<(), PoisonError<MutexGuard<'_, Box<dyn Debugger>>>>

pub fn deactivate_debugger( &self, ) -> Result<Box<dyn Debugger>, PoisonError<MutexGuard<'_, Box<dyn Debugger>>>>

pub fn is_debugging(&self) -> bool

pub fn recover_from_panic(&mut self)

pub fn add_span(&mut self, span: Span) -> SpanId

Add new span and return its ID

pub fn find_span_id(&self, span: Span) -> Option<SpanId>

Find ID of a span (should be avoided if possible)

Trait Implementations

impl Clone for EngineState

fn clone(&self) -> EngineState

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for EngineState

fn default() -> Self

Returns the “default value” for a type.

impl<'a> GetSpan for &'a EngineState

fn get_span(&self, span_id: SpanId) -> Span

Get existing span