Parcel.NExT.Interpreter

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer

A code analyzer that studies the flow of a C# program and generates corresponding Zora Node descriptions. Useful for converting C# script into Zora nodes both in production settings and for quickly generating Zora program examples. This handles simple codes, and uses intermediate data structures to hold analysis results, for more comprehensive analysis, we should provide another analyzer that performs code analysis directly and converts to ZoraGraph directly.

Remarks

TODO: Probably need to formalize such translations in DiOS for Pure/C#/Zora conversion.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Expression

Represents a C# expression. Expressions on their own cannot be statements.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Expression.InstanceName

Name of the variable/object/class if this expression is a function call.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Expression.ExpressionValue

All expressions are either literal values or must call some functions - be it constructors, or local functions. Basic operators like +-*/ are considered functions with two arguments. Assignment (=) is "Assign" function. In case of attributes or properties getters, it's the name of the attribute or property setter function.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Expression.Arguments

Literal values of arguments in case of function call.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Expression.Type

Type of the expression or its return type in case of a function.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Expression.IsLiteral

The expression is a literal (including variable name references).

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Expression.IsFunctionCall

The expression is calling a function.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Expression.IsComplex

The expression is more complex than simple cases above.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Statement

Represents a valid C# statement, including basic assignments, function calls, and flow controls (like loops).

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Statement.InstanceName

This is the variable name if the statement is a variable declaration or assignment statement. Or it can be the name of the instance if the statement is calling a function on that instance.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Statement.FunctionName

All statements must call some functions - be it constructors, or local functions. Basic operators like +-*/ are considered functions with two arguments. Assignment (=) is "Assign" function. In case of setting class attributes or properties, it's the name of the attribute or property setter function. The "return" keyword is also considered a function name.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Statement.Arguments

Literal values of arguments. In case of assignment, this is just one single element.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Statement.LineComment

Any line comment.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Statement.DeclaredType

Type of the variable in case of declaration (e.g., int, string, SKPaint, etc.).

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Statement.Body

Body of a loop

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Statement.IsPropertySetter

True if the statement is setting a class attribute or property.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Statement.IsAssignment

Indicates this statement is an assignment.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Statement.IsDeclaration

Indicates this statement is a new variable declaration. When this is true, IsAssignment is also true.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Statement.IsFunctionReturn

Whether this statement is a function return.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Statement.IsControlFlow

Indicates whether this statement represents control flow (e.g., if, for, while).

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Statement.IsUsingBlock

Indicates whether this statement is part of a using block.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.StatementBlock

Represents a function or body (including instance functions, static functions, or property getter or setters (as obtained from PropertyInfo `GetGetMethod()` and `GetSetMethod()`)) of loops or lambdas.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.StatementBlock.Namespace

The namespace containing this function or block.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.StatementBlock.ClassName

The class containing this function or block.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.StatementBlock.FunctionName

The function name or block name (could be anonymous in case of lambdas).

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.StatementBlock.Statements

The statements contained within this block.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.StatementBlock.Visibility

Visibility of the function (e.g., public, private).

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.StatementBlock.IsStatic

Whether the function or block is static.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.StatementBlock.IsAsync

Whether the function or block is async.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.StatementBlock.LocalVariables

Any local variables declared within the block.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Variable

Represents a local variable within a statement block or function.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Variable.Name

Name of the variable.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Variable.Type

Type of the variable (e.g., int, string, SKPaint).

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.Variable.InitialValue

Initial value or expression assigned to the variable.

Parcel.NExT.Interpreter.Analyzer.CSharpToZoraNodeAnalyzer.ToRuth()

Converts a single block to YAML DSL.

Parcel.NExT.Interpreter.Analyzer.InvalidScriptException

Not a grammar error but doesn't conform to expectation

Parcel.NExT.Interpreter.Analyzer.NodeGenCodeAnalyzer

A code analyzer for the purpose of creating nodes/functions from snippets.

Parcel.NExT.Interpreter.Analyzer.NodeGenCodeAnalyzer.AnalyzeFunctionalNode()

Analyze code without generating Roslyn contexts

Parcel.NExT.Interpreter.Analyzer.NodeGenCodeAnalyzer.CompileFunctionalNode()

Generate Roslyn context from code (Single entrance)

Parcel.NExT.Interpreter.Analyzer.NodeGenCodeAnalyzer.CompileNodeFunctions()

Generate Roslyn context from code (multiple functions)

Parcel.NExT.Interpreter.Analyzer.SingleEntranceCodeSnippetComponents

Holder and analyzer for global statements only (Roslyn scripting/Pure style)

Parcel.NExT.Interpreter.Helpers.FunctionCaller.CallWithDefaults()

Calls a method or constructor, automatically supplying default or best-effort values for all parameters, including ref/out.

Parameters

Name	Description	Default
`method`	A MethodInfo or ConstructorInfo.

Returns

The return value of the invoked method, or the constructed object in case of a constructor. If the method has ref/out parameters, you can retrieve their final values from the 'arguments' array this method uses internally (see comments below).

Parcel.NExT.Interpreter.Helpers.FunctionCaller.CallWithArguments()

Calls a method or constructor, using the provided arguments where present, and filling the remaining parameters with default or best-effort values.

Parameters

Name	Description	Default
`method`	A MethodInfo or ConstructorInfo.
`providedArguments`	Arguments you want to explicitly pass. If fewer than the required parameters, the rest are automatically filled with default or best-effort values.

Returns

Same return convention as Parcel.NExT.Interpreter.Helpers.FunctionCaller.CallWithDefaults().

Parcel.NExT.Interpreter.Helpers.FunctionCaller.CreateArgument()

Creates a best-effort argument for a given parameter: - If there's a default value, use it. - If it's an out parameter, supply a dummy value of the underlying type. - If it's a ref parameter, supply a dummy value of the underlying type. - If it's a delegate, pass null (or provide an empty stub if needed). - Otherwise, try to create an instance of the parameter's type (value types via Activator, reference types with default constructor, etc.). Otherwise, fallback to null.

Parcel.NExT.Interpreter.Helpers.FunctionCaller.CreateNoOpDelegate()

Creates a "no-op" delegate of the specified delegateType. That means for void-returning delegates, it does nothing, and for delegates that return a value, it returns the default value of the return type.

Parcel.NExT.Interpreter.Helpers.FunctionCaller.CreateNoOpDelegate()

Creates an empty delegate with given sinatures.

Parameters

Name	Description	Default
`returnType`	Return types.
`argumentTypes`	Type of parameters

Returns

Result delegate.

Parcel.NExT.Interpreter.Helpers.FunctionCaller.CreateInstance()

Attempts to create an instance of the specified type by: - Checking for a parameterless constructor - If none is found or creation fails, returns null. You can enhance this to recursively resolve constructors with default/best-effort arguments, or integrate with an IoC container, etc., if needed.

Parcel.NExT.Interpreter.Helpers.DelegateSearcher.SearchAvailableDelegate()

Searches the specified handlerType (e.g., StaticDelegateHandlers) for a public static method that exactly matches the signature of the given delegateType. If found, returns a delegate; otherwise null.

Parcel.NExT.Interpreter.Helpers.DelegateSearcher.ReturnTypesMatch()

Simple check to match method's return type vs. the delegate's return type. Here we do a strict check, but you could do further checks if you allow covariance or other type relationships.

Parcel.NExT.Interpreter.Helpers.DecoratedDelegateInvoker.TryInvokeAvailableDelegate()

Invokes a delegate with a custom decorator.

Parcel.NExT.Interpreter.Helpers.DecoratedDelegateInvoker.TryInvokeAvailableDelegate()

Similar to TryInvokeAvailableDelegate, but the decorator has access to the argument values.

Parameters

Name	Description	Default
`delegateType`	The type of the delegate to build and return.
`searchClass`	A type containing public static methods to search for a signature match.
`decorator`	A callback that receives the matched delegate and the arguments used for the call. This is invoked before the actual method call.

Returns

A decorated delegate of delegateType if found, otherwise null.

Parcel.NExT.Interpreter.Helpers.TypeExtensions.GetFormattedName()

Returns the type name. If this is a generic type, appends the list of generic type arguments between angle brackets. (Does not account for embedded / inner generic arguments)

Remarks

Handles nested type.

Parameters

Name	Description	Default
`type`	The type.

Returns

System.String.

Parcel.NExT.Interpreter.Helpers.MethodInfoHelper

Those functions are only for display purpose

Parcel.NExT.Interpreter.Helpers.PureEvaluator

A divooka usable Pure API.

Parcel.NExT.Interpreter.Helpers.PureEvaluator.Evaluate()

Evaluate a C# script with optional result.

Remarks

Standard output from the script is printed to standard output of the process only and will not be redirected. This does not involve any Pure infrastructure.

Parameters

Name	Description	Default
`script`	Can be either a single expression or complete C# script.

Parcel.NExT.Interpreter.Helpers.PureEvaluator.Execute()

Execute a one shot Pure script. Equivalent to Pure -m "script".

Remarks

Standard output from the script is printed to standard output of the process only and will not be redirected.

Parameters

Name	Description	Default
`script`

Parcel.NExT.Interpreter.Helpers.PureMiniParcel

A MiniParcel implementation in C#/Pure, with slightly different syntax but overall same flow. Node() and code-gen ZoraNode, similar to MiniParcel, declarative.

Parcel.NExT.Interpreter.Helpers.PureMiniParcel.Parse()

Parcel.NExT.Interpreter.PluginLoadContext

Remarks

Remark-cz-20250430: This trick was not possible without the knowledge of ChatGPT 03.

Parcel.NExT.Interpreter.Interpreter

Main provider for external frontends, this is the interface into Parcel.NExT.Interpreter.Scripting.PureInterpreterRoslynContext.

Parcel.NExT.Interpreter.Interpreter.DistributionVersion

The overall distribution version for Pure in general; This should match the version of the Core assembly

Parcel.NExT.Interpreter.Interpreter.ScriptPath

Path of script, used for resolving relative paths

Parcel.NExT.Interpreter.Interpreter.NugetRepoIdentifier

Configures the identification for current running instance for the purpose of caching and compiling nuget package references

Parcel.NExT.Interpreter.Interpreter.Initialize()

Parameters

Name	Description	Default
`contextObject`	Either a raw object whose members will be mapped, or a Dictionary<string, object> whose key-values will be mapped

Parcel.NExT.Interpreter.Interpreter.SplitScripts()

Split a large script into executable units for Roslyn

Remarks

Notice due to state issues we can ONLY use this function (when combined with Construct.Parse()) inside hosting contexts that spawns the Interpreter and should NOT use it inside anything that's already being parsed

Parcel.NExT.Interpreter.Scripting.Construct

Provides some global-level functions that's exposed at the root of Roslyn context; Refer to PureInterpreterRoslynContext()

Parcel.NExT.Interpreter.Scripting.ContextFreeRoslyn

Provides standalone use context-free Roslyn

Parcel.NExT.Interpreter.Scripting.ContextFreeRoslyn.LowLevelRunLocalNoReturn()

Runs code in a local function so user code cannot import namespaces or define custom types etc.

Remarks

Do not use this if you do you need ScriptState; Use higher level functions instead.

Parcel.NExT.Interpreter.Scripting.ContextFreeRoslyn.LowLeveRunLocalWithReturn()

Runs code in a local function so user code cannot import namespaces or define custom types etc.; Return value is provided inside a "result" variable.

Remarks

Do not use this if you do you need ScriptState; Use higher level functions instead.

Parcel.NExT.Interpreter.Scripting.ContextFreeRoslyn.LowLeveRunGlobal()

Runs code at Roslyn top-level

Remarks

Do not use this if you do you need ScriptState; Use higher level functions instead.

Parcel.NExT.Interpreter.Scripting.ContextFreeRoslyn.EvaluateLocalReturn``1()

Runs a code fragment as a local function with optionally provided global variables. Expects a return of target type from code snippet.

Remarks

This function is similar to but serves different purpose. This is not efficient for things that runs often - in which case we should compile and extract MethodInfo using CodeAnalyzer instead rely on Roslyn.

Parcel.NExT.Interpreter.Scripting.ContextFreeRoslyn.EvaluateLocalSnippet()

Run code fragment on initial set of provided objects and return final values on such objects; Specific names from the original dictionary will be available as global variables.

Remarks

Automatically exposes namespace of referenced objects from initial values.

Parcel.NExT.Interpreter.Scripting.ContextFreeRoslyn.Map``1()

Enumerate code fragment on collection

Parcel.NExT.Interpreter.Scripting.ContextFreeRoslyn.TryFindAutomaticImports()

Figure out all the types used in the code and try to generate automatic import statements for them.

Remarks

Current implementation of this is slow, so we should use it with care.

Parcel.NExT.Interpreter.Scripting.ContextFreeRoslyn.InitializeStateWithGlobalVariables()

Initialize a state with global variables with proper namespace imports.

Parcel.NExT.Interpreter.Scripting.PureInterpreterRoslynContext

Remarks

Provides contexted Roslyn. ~~(Pure) This is implementation detail and should be protected from external users~~ (In ParcelNExT, we don't exclude the possibility people would use it directly) Pending makeing it thread safe and properly instanced with proper context protection.

Parcel.NExT.Interpreter.Scripting.PureInterpreterRoslynContext.OutputHandler

Configures the output handler to use

Parcel.NExT.Interpreter.Scripting.PureInterpreterRoslynContext.Shutdown

Remarks

We recommend host environment either explicitly calls this, or bind to process exit event like so: AppDomain.CurrentDomain.ProcessExit += new EventHandler((sender, e) => { RoslynContext.Shutdown(); });

Parcel.NExT.Interpreter.Scripting.PureInterpreterRoslynContext.#ctor()

Parameters

Name	Description	Default
`contextObject`	Either a raw object whose members will be mapped, or a Dictionary<string, object> whose key-values will be mapped

Parcel.NExT.Interpreter.Scripting.PureInterpreterRoslynContext.ParseSingle()

Remarks

Remark-cz: Things like "using" statement cannot be put in the middle of code block like other statements and require special treatment

Parcel.NExT.Interpreter.Scripting.PureInterpreterRoslynContext.ParseSingleUnsafe()

Parse without enforcing context lock; Also will not log code

Parcel.NExT.Interpreter.Scripting.PureInterpreterRoslynContext.CreateReference()

Remarks

NEW: Deals with in-memory assemblies! Reference: https://stackoverflow.com/a/78652390/2856597

Parcel.NExT.Interpreter.Scripting.PureInterpreterRoslynContext.ImportModuleRegex

Remarks

Pattern:

^Import\\((.*?)(, ?(.*?))?\\);?$

Explanation:


            ○ Match if at the beginning of the string.
            ○ Match the string "Import(".
            ○ 1st capture group.
                ○ Match a character other than '\n' lazily any number of times.
            ○ Optional (greedy).
                ○ 2nd capture group.
                    ○ Match ','.
                    ○ Match ' ' greedily, optionally.
                    ○ 3rd capture group.
                        ○ Match a character other than '\n' lazily any number of times.
            ○ Match ')'.
            ○ Match ';' atomically, optionally.
            ○ Match if at the end of the string or if before an ending newline.

Parcel.NExT.Interpreter.Scripting.PureInterpreterRoslynContext.IncludeScriptRegex

Remarks

Pattern:

^Include\\((.*?)(, ?(.*?))?\\);?$

Explanation:


            ○ Match if at the beginning of the string.
            ○ Match the string "Include(".
            ○ 1st capture group.
                ○ Match a character other than '\n' lazily any number of times.
            ○ Optional (greedy).
                ○ 2nd capture group.
                    ○ Match ','.
                    ○ Match ' ' greedily, optionally.
                    ○ 3rd capture group.
                        ○ Match a character other than '\n' lazily any number of times.
            ○ Match ')'.
            ○ Match ';' atomically, optionally.
            ○ Match if at the end of the string or if before an ending newline.

Parcel.NExT.Interpreter.Scripting.PureInterpreterRoslynContext.IsolatedScriptLineForSpecialFunctionsRegex

Remarks

Pattern:

^(Parse\\((.*?)(, ?(.*?))?\\);?)|(Pull\\((.*?)(, ?(.*?))?\\);?)$

Explanation:


            ○ Match with 2 alternative expressions, atomically.
                ○ Match a sequence of expressions.
                    ○ Match if at the beginning of the string.
                    ○ 1st capture group.
                        ○ Match the string "Parse(".
                        ○ 2nd capture group.
                            ○ Match a character other than '\n' lazily any number of times.
                        ○ Optional (greedy).
                            ○ 3rd capture group.
                                ○ Match ','.
                                ○ Match ' ' greedily, optionally.
                                ○ 4th capture group.
                                    ○ Match a character other than '\n' lazily any number of times.
                        ○ Match ')'.
                        ○ Match ';' atomically, optionally.
                ○ Match a sequence of expressions.
                    ○ 5th capture group.
                        ○ Match the string "Pull(".
                        ○ 6th capture group.
                            ○ Match a character other than '\n' lazily any number of times.
                        ○ Optional (greedy).
                            ○ 7th capture group.
                                ○ Match ','.
                                ○ Match ' ' greedily, optionally.
                                ○ 8th capture group.
                                    ○ Match a character other than '\n' lazily any number of times.
                        ○ Match ')'.
                        ○ Match ';' atomically, optionally.
                    ○ Match if at the end of the string or if before an ending newline.

Parcel.NExT.Interpreter.Scripting.PureInterpreterRoslynContext.HelpItemRegex

Remarks

Pattern:

^Help\\((.*?)\\)$

Explanation:


            ○ Match if at the beginning of the string.
            ○ Match the string "Help(".
            ○ 1st capture group.
                ○ Match a character other than '\n' lazily any number of times.
            ○ Match ')'.
            ○ Match if at the end of the string or if before an ending newline.

Parcel.NExT.Interpreter.Scripting.PureInterpreterRoslynContext.LineAssignmentRegex

Remarks

Pattern:

^(\\S*)?\\s*[a-zA-Z0-9_]+\\s*=.*[^;]$

Explanation:


            ○ Match if at the beginning of the string.
            ○ Optional (greedy).
                ○ 1st capture group.
                    ○ Match any character other than a whitespace character greedily any number of times.
            ○ Match a whitespace character atomically any number of times.
            ○ Match a character in the set [0-9A-Z_a-z] atomically at least once.
            ○ Match a whitespace character atomically any number of times.
            ○ Match '='.
            ○ Match a character other than '\n' greedily any number of times.
            ○ Match any character other than ';'.
            ○ Match if at the end of the string or if before an ending newline.

Parcel.NExT.Interpreter.Types.Callable

Represents a method/constructor/delegate that can be called. In general, this is equivalent to MethodInfo but it enables containing constructors. TODO: Merge the "this is equivalent to MethodInfo but it enables containing constructors" aspect with MethodBase

Parcel.NExT.Interpreter.Types.Callable.CallableType.Event

Not to be called directly, but serves semantical purpose.

Parcel.NExT.Interpreter.Types.Callable.CallableType.ConstructOnly

A constructed callable that doesn't do anything and should never be directly executed.

Parcel.NExT.Interpreter.Types.Callable.CallableType.Delegate

A non-reflection based callable; Usually constructed from other means.

Parcel.NExT.Interpreter.Types.Callable.Member

Used by reflected methods and snippets. For snippets, they will be converted to MethodInfo.

Remarks

TODO: Cleanup/optimization - Downstream shouldn't depend on ParameterInfo, or otherwise we should attempt to abstract only the parameters we need TODO: Combine Method and Constructor into `MethodBase`

Parcel.NExT.Interpreter.Types.Callable.Snippet

Snippet source code

Parcel.NExT.Interpreter.Types.Callable.IsConst

Indicates for non-static (instance) methods, this function doesn't modify any internal states. It's useful both from runtime (though we should not trust function authors) and GUI perspective (avoid using too many static classes and extension methods).

Remarks

This could be true depiste Parcel.NExT.Interpreter.Types.Callable.MemberDoc's IsConst is absent or false, when the callable is created with const set to true.

Parcel.NExT.Interpreter.Types.Callable.Arguments

Remarks

It's possible the documentation provides less than Parcel.NExT.Interpreter.Types.Callable.Parameters if doc is incomplete. Actually this can happen frequently. However at this step we ensure we create null in such slots.

Parcel.NExT.Interpreter.Types.Callable.ReturnName

Name of return value

Parcel.NExT.Interpreter.Types.Callable.ReflectedType

Remarks

Comparing to DeclaringType, ReflectedType takes inheritance into consideration. (So for a child member the reflected type would be the child type or the parent type?)

Parcel.NExT.Interpreter.Types.Callable.DeclaringType

Remarks

Will not be null even if it's from snippet

Parcel.NExT.Interpreter.Types.Callable.#ctor()

Create a callable from a single-entrace snippet

Parcel.NExT.Interpreter.Types.Callable.#ctor()

Remarks

Experimental while we still work out the details of how Desktop Assistant works and the relation between ActionReference and Callable

Parcel.NExT.Interpreter.Types.Callable.CanFit()

Tests whether a set of arguments can fit and be executed using current callable. Arguments are represented using strings.

Parcel.NExT.Interpreter.Types.Callable.CanFit()

Tests whether a set of arguments can fit and be executed using current callable. Arguments are fully typed. May miss optional arguments.

Parcel.NExT.Interpreter.Types.Callable.GetNodeTypeDisplayName()

Get a display label that's localized and used to identity "node type".

Remarks

TODO: Clarify when to use node type name and when to use node title. TODO: At the moment this cause problem for instance when dediting Two Body Slide title and delete everything - we will get "PresentationMaker" instead of (expected) "Two Body Slide".

Parcel.NExT.Interpreter.Types.Callable.GetRuntimeNodeTypeIdentifier

At the moment also called as "Function Resource Identifier". Assembly/Package related identifying name, including all information that is needed to load this particular node from any given assembly.

Remarks

Pending better internal name/jargon for this; Pending consolidating with DiOS.

Parcel.NExT.Interpreter.Types.Callable.GetMethodSignature

Get short signature for utility purpose. This is like the shorter version of Parcel.NExT.Interpreter.Types.Callable.GetRuntimeNodeTypeIdentifier

Parcel.NExT.Interpreter.Types.Callable.GetMethodSignatureNoTypeName

Get short signature for utility purpose. This is like the shorter version of Parcel.NExT.Interpreter.Types.Callable.GetRuntimeNodeTypeIdentifier

Parcel.NExT.Interpreter.Types.Callable.GetMemberDocSignature

Get's the member ID even if a member doc is not absent.

Parcel.NExT.Interpreter.Types.Callable.GetCallableSourceFriendlyDisplay

Get a friendly indicator of the source of this caller.

Parcel.NExT.Interpreter.Types.Callable.GetSpecialName

Get special name for regular member info.

Parcel.CoreEngine.Service.Interpretation.FunctionalNodeDescription

Provides metadata about functions/nodes based on native/C# implementations;

Remarks

This is a key concept in Divooka: By having this abstraction (along with the ), it enables us to quickly define a large library of fully functional Divooka nodes without explicitly defining classes for them (and use a single ) by directly expoing functions defined in C# (compared to previously, aka. the first prototype where all nodes are C# classes in themselves, which is the most flexible/performant way to define nodes but not efficient from development persepective).

Parcel.CoreEngine.Service.Interpretation.FunctionalNodeDescription.SourceType

Type of the declaring source class.

System.Text.RegularExpressions.Generated.ImportModuleRegex_0

Custom System.Text.RegularExpressions.Regex-derived type for the ImportModuleRegex method.

System.Text.RegularExpressions.Generated.ImportModuleRegex_0.Instance

Cached, thread-safe singleton instance.

System.Text.RegularExpressions.Generated.ImportModuleRegex_0.#ctor

Initializes the instance.

System.Text.RegularExpressions.Generated.ImportModuleRegex_0.RunnerFactory

Provides a factory for creating System.Text.RegularExpressions.RegexRunner instances to be used by methods on System.Text.RegularExpressions.Regex.

System.Text.RegularExpressions.Generated.ImportModuleRegex_0.RunnerFactory.CreateInstance

Creates an instance of a System.Text.RegularExpressions.RegexRunner used by methods on System.Text.RegularExpressions.Regex.

System.Text.RegularExpressions.Generated.ImportModuleRegex_0.RunnerFactory.Runner

Provides the runner that contains the custom logic implementing the specified regular expression.

System.Text.RegularExpressions.Generated.ImportModuleRegex_0.RunnerFactory.Runner.Scan()

Scan the inputSpan starting from base.runtextstart for the next match.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

System.Text.RegularExpressions.Generated.ImportModuleRegex_0.RunnerFactory.Runner.TryFindNextPossibleStartingPosition()

Search inputSpan starting from base.runtextpos for the next location a match could possibly start.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

Returns

true if a possible match was found; false if no more matches are possible.

System.Text.RegularExpressions.Generated.ImportModuleRegex_0.RunnerFactory.Runner.TryMatchAtCurrentPosition()

Determine whether inputSpan at base.runtextpos is a match for the regular expression.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

Returns

true if the regular expression matches at the current position; otherwise, false.

System.Text.RegularExpressions.Generated.IncludeScriptRegex_1

Custom System.Text.RegularExpressions.Regex-derived type for the IncludeScriptRegex method.

System.Text.RegularExpressions.Generated.IncludeScriptRegex_1.Instance

Cached, thread-safe singleton instance.

System.Text.RegularExpressions.Generated.IncludeScriptRegex_1.#ctor

Initializes the instance.

System.Text.RegularExpressions.Generated.IncludeScriptRegex_1.RunnerFactory

Provides a factory for creating System.Text.RegularExpressions.RegexRunner instances to be used by methods on System.Text.RegularExpressions.Regex.

System.Text.RegularExpressions.Generated.IncludeScriptRegex_1.RunnerFactory.CreateInstance

Creates an instance of a System.Text.RegularExpressions.RegexRunner used by methods on System.Text.RegularExpressions.Regex.

System.Text.RegularExpressions.Generated.IncludeScriptRegex_1.RunnerFactory.Runner

Provides the runner that contains the custom logic implementing the specified regular expression.

System.Text.RegularExpressions.Generated.IncludeScriptRegex_1.RunnerFactory.Runner.Scan()

Scan the inputSpan starting from base.runtextstart for the next match.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

System.Text.RegularExpressions.Generated.IncludeScriptRegex_1.RunnerFactory.Runner.TryFindNextPossibleStartingPosition()

Search inputSpan starting from base.runtextpos for the next location a match could possibly start.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

Returns

true if a possible match was found; false if no more matches are possible.

System.Text.RegularExpressions.Generated.IncludeScriptRegex_1.RunnerFactory.Runner.TryMatchAtCurrentPosition()

Determine whether inputSpan at base.runtextpos is a match for the regular expression.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

Returns

true if the regular expression matches at the current position; otherwise, false.

System.Text.RegularExpressions.Generated.IsolatedScriptLineForSpecialFunctionsRegex_2

Custom System.Text.RegularExpressions.Regex-derived type for the IsolatedScriptLineForSpecialFunctionsRegex method.

System.Text.RegularExpressions.Generated.IsolatedScriptLineForSpecialFunctionsRegex_2.Instance

Cached, thread-safe singleton instance.

System.Text.RegularExpressions.Generated.IsolatedScriptLineForSpecialFunctionsRegex_2.#ctor

Initializes the instance.

System.Text.RegularExpressions.Generated.IsolatedScriptLineForSpecialFunctionsRegex_2.RunnerFactory

Provides a factory for creating System.Text.RegularExpressions.RegexRunner instances to be used by methods on System.Text.RegularExpressions.Regex.

System.Text.RegularExpressions.Generated.IsolatedScriptLineForSpecialFunctionsRegex_2.RunnerFactory.CreateInstance

Creates an instance of a System.Text.RegularExpressions.RegexRunner used by methods on System.Text.RegularExpressions.Regex.

System.Text.RegularExpressions.Generated.IsolatedScriptLineForSpecialFunctionsRegex_2.RunnerFactory.Runner

Provides the runner that contains the custom logic implementing the specified regular expression.

System.Text.RegularExpressions.Generated.IsolatedScriptLineForSpecialFunctionsRegex_2.RunnerFactory.Runner.Scan()

Scan the inputSpan starting from base.runtextstart for the next match.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

System.Text.RegularExpressions.Generated.IsolatedScriptLineForSpecialFunctionsRegex_2.RunnerFactory.Runner.TryFindNextPossibleStartingPosition()

Search inputSpan starting from base.runtextpos for the next location a match could possibly start.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

Returns

true if a possible match was found; false if no more matches are possible.

System.Text.RegularExpressions.Generated.IsolatedScriptLineForSpecialFunctionsRegex_2.RunnerFactory.Runner.TryMatchAtCurrentPosition()

Determine whether inputSpan at base.runtextpos is a match for the regular expression.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

Returns

true if the regular expression matches at the current position; otherwise, false.

System.Text.RegularExpressions.Generated.HelpItemRegex_3

Custom System.Text.RegularExpressions.Regex-derived type for the HelpItemRegex method.

System.Text.RegularExpressions.Generated.HelpItemRegex_3.Instance

Cached, thread-safe singleton instance.

System.Text.RegularExpressions.Generated.HelpItemRegex_3.#ctor

Initializes the instance.

System.Text.RegularExpressions.Generated.HelpItemRegex_3.RunnerFactory

Provides a factory for creating System.Text.RegularExpressions.RegexRunner instances to be used by methods on System.Text.RegularExpressions.Regex.

System.Text.RegularExpressions.Generated.HelpItemRegex_3.RunnerFactory.CreateInstance

Creates an instance of a System.Text.RegularExpressions.RegexRunner used by methods on System.Text.RegularExpressions.Regex.

System.Text.RegularExpressions.Generated.HelpItemRegex_3.RunnerFactory.Runner

Provides the runner that contains the custom logic implementing the specified regular expression.

System.Text.RegularExpressions.Generated.HelpItemRegex_3.RunnerFactory.Runner.Scan()

Scan the inputSpan starting from base.runtextstart for the next match.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

System.Text.RegularExpressions.Generated.HelpItemRegex_3.RunnerFactory.Runner.TryFindNextPossibleStartingPosition()

Search inputSpan starting from base.runtextpos for the next location a match could possibly start.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

Returns

true if a possible match was found; false if no more matches are possible.

System.Text.RegularExpressions.Generated.HelpItemRegex_3.RunnerFactory.Runner.TryMatchAtCurrentPosition()

Determine whether inputSpan at base.runtextpos is a match for the regular expression.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

Returns

true if the regular expression matches at the current position; otherwise, false.

System.Text.RegularExpressions.Generated.LineAssignmentRegex_4

Custom System.Text.RegularExpressions.Regex-derived type for the LineAssignmentRegex method.

System.Text.RegularExpressions.Generated.LineAssignmentRegex_4.Instance

Cached, thread-safe singleton instance.

System.Text.RegularExpressions.Generated.LineAssignmentRegex_4.#ctor

Initializes the instance.

System.Text.RegularExpressions.Generated.LineAssignmentRegex_4.RunnerFactory

Provides a factory for creating System.Text.RegularExpressions.RegexRunner instances to be used by methods on System.Text.RegularExpressions.Regex.

System.Text.RegularExpressions.Generated.LineAssignmentRegex_4.RunnerFactory.CreateInstance

Creates an instance of a System.Text.RegularExpressions.RegexRunner used by methods on System.Text.RegularExpressions.Regex.

System.Text.RegularExpressions.Generated.LineAssignmentRegex_4.RunnerFactory.Runner

Provides the runner that contains the custom logic implementing the specified regular expression.

System.Text.RegularExpressions.Generated.LineAssignmentRegex_4.RunnerFactory.Runner.Scan()

Scan the inputSpan starting from base.runtextstart for the next match.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

System.Text.RegularExpressions.Generated.LineAssignmentRegex_4.RunnerFactory.Runner.TryFindNextPossibleStartingPosition()

Search inputSpan starting from base.runtextpos for the next location a match could possibly start.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

Returns

true if a possible match was found; false if no more matches are possible.

System.Text.RegularExpressions.Generated.LineAssignmentRegex_4.RunnerFactory.Runner.TryMatchAtCurrentPosition()

Determine whether inputSpan at base.runtextpos is a match for the regular expression.

Parameters

Name	Description	Default
`inputSpan`	The text being scanned by the regular expression.

Returns

true if the regular expression matches at the current position; otherwise, false.

System.Text.RegularExpressions.Generated.Utilities

Helper methods used by generated System.Text.RegularExpressions.Regex-derived implementations.

System.Text.RegularExpressions.Generated.Utilities.s_defaultTimeout

Default timeout value set in System.AppContext, or System.Text.RegularExpressions.Regex.InfiniteMatchTimeout if none was set.

System.Text.RegularExpressions.Generated.Utilities.s_hasTimeout

Whether System.Text.RegularExpressions.Generated.Utilities.s_defaultTimeout is non-infinite.

System.Text.RegularExpressions.Generated.Utilities.StackPop()

Pops 2 values from the backtracking stack.

System.Text.RegularExpressions.Generated.Utilities.StackPush()

Pushes 1 value onto the backtracking stack.

System.Text.RegularExpressions.Generated.Utilities.StackPush()

Pushes 2 values onto the backtracking stack.

System.Text.RegularExpressions.Generated.Utilities.StackPush()

Pushes 3 values onto the backtracking stack.

System.Text.RegularExpressions.Generated.Utilities.s_asciiWordChars

Supports searching for characters in or not in "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz".