All Classes and Interfaces
Class
Description
Compiler recovery expression inserted after semantic analysis has already reported an error.
Bound field increment/decrement expression with prefix or postfix result semantics.
Represents an LPC from-end index bound such as
<1.A named callable reference, parsed from source forms such as
#'moveHook.AST node for LPC inline callable syntax,
(: expression :) or (: { ... } :).AST node for an LPC floating-point literal.
Bound local increment/decrement expression with prefix or postfix result semantics.
Binary operator expression, including semantic refinements for context-sensitive LPC operators.
JVMud-neutral protected evaluation expression.
A quoted LPC symbol/name literal, parsed from source forms such as
'item.AST node for the LPC compatibility form
function type (params) { return expr; }.Unresolved local-or-field increment/decrement expression before semantic binding.
Represents a bare semicolon statement.
AST node for an LPC
switch statement.One
case or default label and the statements owned by that label.Unified visitor entry point for walking AST nodes.
Emits JVM bytecode from the typed IR.
Engine-level capabilities described by JVMud's principles.
Stateless text + stateful index; safe peeking; maintains line/column via
LineMap.
Receives coarse-grained compiler progress events for tools such as the admin CLI.
Coordinates the LPC compiler stages for one source unit.
Per-file compilation metadata and analysis artifacts.
Defines and registers JVMud's built-in LPC-facing engine functions.
Runtime implementation of one LPC-facing engine function.
Instance-scoped registry for LPC-facing engine functions.
Describes the LPC-facing signature of an engine function.
Something that exists within a JVMud world and may itself contain entities.
Result of resolving an include directive.
Parses postfix increment/decrement expressions after a mutable target.
Numeric field increment/decrement expression with prefix or postfix result semantics.
Runtime marker expression for an LPC from-end index bound such as
<1.IR value for an LPC named function reference such as
#'helper.IR value for an LPC inline callable literal, such as
(: $1 > 0 :).Numeric local increment/decrement expression with prefix or postfix result semantics.
Lowers typed AST nodes into the JVM-oriented IR model.
Human-oriented formatter for typed IR inspection.
IR value for an LPC typed function literal that can be passed as a callable value.
Fast line lookup by maintaining offsets of line starts.
A navigable relationship from one place to another place.
A location that can immediately contain entities in a JVMud world.
Result wrapper for loading LPC objects, allowing callers to handle failures gracefully.
Handle to a compiled LPC object instance managed by an
LPCRuntime.Snapshot of host-visible state for a loaded LPC object.
Observes host-side LPC object load and compile attempts for diagnostics.
Host-facing LPC execution runtime that owns classloading, object identity, and runtime context.
Configuration options for the host-facing LPC execution runtime.
Signals failures while compiling or instantiating LPC objects for a runtime instance.
JVMud-native registry of mudlib-side boundary objects and lifecycle interests.
Reads JVMud-native mudlib boundary declarations from a simple manifest file.
Native JVMud lifecycle moments that a mudlib may map to LPC methods.
Opaque mudlib-side projection attached to JVMud-native Player or Persona records.
Engine-visible role played by an opaque mudlib-side compatibility projection.
Applies engine-owned presentation formatting to text leaving the runtime.
Stable engine identifier for a Player's in-World manifestation.
Engine-owned record for the Player's in-World manifestation.
A discrete occupiable location in a JVMud world.
Stable engine identifier for the human or account-like controller.
Engine-owned record for the human or account-like controller.
Parses prefix unary operators, including mutating increment and decrement targets.
Result of preprocessing: expanded source text with a mapping back to originals.
Minimal LPC preprocessor for includes, macro definitions, conditional directives, comment
stripping, and line splicing with backslash-newline.
Runtime arithmetic helpers for dynamically typed LPC expressions.
Runtime helpers for LPC array operations that need dynamic equality semantics.
Runtime contract for LPC callable values.
Runtime coercion helpers for LPC compatibility values.
Runtime helpers for LPC collection callbacks.
Runtime comparison helpers for LPC mixed/string/numeric relational operators.
Encapsulates runtime state required by compiled LPC code.
Thread-local binding point for the active
RuntimeContext.Runtime equality helpers for LPC compatibility semantics.
Runtime iteration helpers for LPC foreach lowering.
Runtime representation for an LPC function literal.
Runtime indexing helpers for dynamically typed LPC values.
Runtime marker for an LPC from-end index bound such as
<1.Runtime helpers for LPC mapping operations that accept legacy false sentinels.
Runtime representation for an LDMud mapping entry with multiple semicolon-separated values.
Shared validation helpers for engine model records.
Runtime support for LPC sscanf-style output captures.
Runtime helpers for LPC string operations that differ from Java operators.
Captures how a runtime value should be interpreted in conditional contexts.
Represents the runtime type carried through IR and code generation.
Centralizes canonical runtime types and conversions from LPC surface types.
Serializes and deserializes LPC data values using a JVMud-owned tagged JSON format.
Describes the runtime shape for LPC values after semantic typing.
A cancellable handle for work registered with a
WorldScheduler.Include resolver that searches a configurable list of system include roots.
Mapping implementation that tracks contiguous segments of generated text back to original
LineMaps.Result of running semantic analysis over an AST.
Performs semantic analysis on a parsed AST and produces a typed model.
Captures semantic artifacts produced by
SemanticAnalyzer.Represents a lexical scope containing symbol declarations.
Semantic type checker that validates expressions, arguments, and returns while refining symbol
types when they remain unspecified or
mixed.Stable engine identifier for one active or resumable connection context.
Engine-owned record for a connection and transport context.
Maps offsets in generated/processed text back to the original source.
1-based line/column position within a logical source file with absolute offset.
Inclusive start, exclusive end span within a single logical source file.
Immutable storage for a scanned token sequence, plus a stateful Cursor that
provides parser-friendly operations (peek/consume/mark).
Lightweight unchecked error a parser can catch at statement/decl boundaries.
Re-classifies identifier tokens into language keywords.
Utility helpers for LPC truthiness semantics.
Resolves LPC type keyword strings to
LPCType values.The complete virtual domain hosted by one JVMud engine instance.
Advances deterministic world time from wall-clock time for a hosted world.
Owns the core world ontology, place links, and containment rules for one JVMud world.
Owns deterministic world time and scheduled work for one JVMud world.