// // Establish the compiler hook (if we haven't already). // private void HookScriptCompiler() { if (m_Compiler != null) { return; } if (m_CompilerField == null) { MessageBox.Show(NWN2ToolsetMainForm.App, "Failed to hook script compiler (compiler field not found). The standard compiler will be used."); return; } IScriptCompiler Compiler = (IScriptCompiler)m_CompilerField.GetValue(null); if (Compiler == null) { MessageBox.Show(NWN2ToolsetMainForm.App, "Failed to hook script compiler (compiler not initialized). The standard compiler will be used."); return; } m_Compiler = new ScriptCompilerHook(Compiler, m_ResourceAccessor, m_SettingsManager); m_CompilerField.SetValue(null, m_Compiler); }
/// <summary> /// creates a new <see cref="ScriptExecutor"/> /// </summary> /// <param name="logger">used for logging in script</param> /// <param name="compiler">compiler used to parse script</param> /// <param name="name">name of script to execute</param> /// <param name="revision">revision of script to execute</param> public ScriptExecutor(WorkableLogger logger, IScriptCompiler compiler, string name, int?revision) { this.logger = logger; this.compiler = compiler; this.name = name; this.revision = revision; }
public IScriptGenerator ExecuteCompiler(IScriptCompiler compiler) { _generator = compiler.Compile(this); _compiled = true; return(_generator); }
/// <summary> /// creates a new <see cref="WorkflowCompiler"/> /// </summary> /// <param name="logger">access to logging</param> /// <param name="cacheservice">access to object cache</param> /// <param name="workflowservice">access to workflow data</param> /// <param name="compiler">compiles scripts for conditions and internal workflow code</param> public WorkflowCompiler(ILogger <WorkflowCompiler> logger, ICacheService cacheservice, IWorkflowService workflowservice, IScriptCompiler compiler) { this.logger = logger; this.cacheservice = cacheservice; this.workflowservice = workflowservice; this.compiler = compiler; }
public IScriptGenerator ExecuteCompiler( IScriptCompiler compiler ) { _generator = compiler.Compile( this ); _compiled = true; return _generator; }
private bool registerMacro(String macro, String name, IScriptCompiler scriptCompiler, IMacroService macroService, XmlScriptExecutor executor) { ScriptedMacro scriptedMacro = new ScriptedMacro(executor); scriptedMacro.Name = name; scriptedMacro.Script = scriptCompiler.Compile(macro, name); return macroService.registerMacro(new XnaScrapId(name), scriptedMacro); }
/// <summary> /// creates a new <see cref="ScriptNode"/> /// </summary> /// <param name="nodeid">id of workflow node</param> /// <param name="name">name of node</param> /// <param name="parameters">parameters for script</param> /// <param name="compiler">compiler used to retrieve script instance</param> /// <param name="language">language used to translate parameters</param> public ScriptNode(Guid nodeid, string name, CallWorkableParameters parameters, IScriptCompiler compiler, ScriptLanguage?language) : base(nodeid, name) { this.compiler = compiler; Name = parameters.Name; Arguments = parameters.Arguments.BuildArguments(compiler, language); }
/// <summary> /// Adds the script compiler. /// </summary> /// <param name="type">The type.</param> /// <param name="compiler">The compiler.</param> public static void AddScriptCompiler([NotNull] IScriptCompiler compiler) { if (type2compiler.ContainsKey(compiler.ScriptCodeType)) { throw new ArgumentException("The type " + compiler.ScriptCodeType + " already registered."); } type2compiler[compiler.ScriptCodeType] = compiler; }
public ScriptCache(IScriptCompiler scriptCompiler) { if (scriptCompiler == null) { throw new ArgumentNullException("scriptCompiler"); } _scriptCompiler = scriptCompiler; }
// // Construct a new instance with the given stock compiler that is to be // attached. // public ScriptCompilerHook(IScriptCompiler StandardCompiler, ResourceAccessor ResourceAccessor, SettingsManager SettingsMgr) { m_Disposed = false; m_StandardCompiler = StandardCompiler; m_ResourceAccessor = ResourceAccessor; m_SettingsManager = SettingsMgr; m_NscCompiler = new NscCompiler(ResourceAccessor, SettingsMgr); }
// // Construct a new instance with the given stock compiler that is to be // attached. // public ScriptCompilerHook(IScriptCompiler StandardCompiler, ResourceAccessor ResourceAccessor, SettingsManager SettingsMgr) { m_Disposed = false; m_StandardCompiler = StandardCompiler; m_ResourceAccessor = ResourceAccessor; m_SettingsManager = SettingsMgr; m_NscCompiler = new NscCompiler(ResourceAccessor, SettingsMgr); }
public YggParser(YggParserConfig config, IScriptCompiler compiler) { _config = config ?? new YggParserConfig(); _compiler = compiler; BaseNodeMap = AppDomain.CurrentDomain.GetAssemblies() .Where(a => _config.NodeTypeAssemblies.Contains(a.GetName().Name)) .SelectMany(a => a.GetTypes()) .Where(t => typeof(Node).IsAssignableFrom(t) && !t.IsAbstract && t != typeof(Node)) .GroupBy(t => t.Name) .Select(g => g.First()) .ToDictionary(t => t.Name, t => t); }
private void registerScript(String script, String name, IScriptCompiler scriptCompiler, IResourceService resourceService) { IScript compiled = scriptCompiler.Compile(script, name); if (!resourceService.Scripts.Keys.Contains(name)) { resourceService.Scripts.Add(name, compiled); } else { resourceService.Scripts[name] = compiled; // TODO report an error back! } }
/// <summary> /// creates a new <see cref="IteratorNode"/> /// </summary> /// <param name="nodeid">id of workflow node</param> /// <param name="nodeName">name of node</param> /// <param name="parameters">parameters to use</param> /// <param name="compiler">compiler used to compile expressions</param> public IteratorNode(Guid nodeid, string nodeName, IteratorParameters parameters, IScriptCompiler compiler) : base(nodeid, nodeName) { this.compiler = compiler; Parameters = parameters; }
public ScriptCompilerService(IScriptCompiler scriptCompiler) { _scriptCompiler = scriptCompiler; }
protected virtual void Dispose(bool Disposing) { if (m_Disposed) return; if (m_StandardCompiler != null) { m_StandardCompiler.Dispose(); m_StandardCompiler = null; } if (m_NscCompiler != null) { m_NscCompiler.Dispose(); m_NscCompiler = null; } }
/// <summary> /// builds argument scripts for workflow nodes /// </summary> /// <param name="arguments">arguments to use as code source</param> /// <param name="compiler">compiler used to compile scripts</param> /// <returns></returns> public static IDictionary <string, IScript> BuildArguments(this IDictionary <string, object> arguments, IScriptCompiler compiler, ScriptLanguage?language) { if (arguments == null) { return(null); } Dictionary <string, IScript> result = new Dictionary <string, IScript>(); foreach ((string key, object value) in arguments) { if (value is string code) { result[key] = compiler.CompileCode(code, language ?? ScriptLanguage.NCScript) ?? new ConstantValueScript(null); } else { result[key] = new ConstantValueScript(value); } } return(result); }
/// <summary> /// creates a new <see cref="ScriptExecutionService"/> /// </summary> /// <param name="logger">access to logging</param> /// <param name="scriptinstances">access to script instances</param> /// <param name="scriptcompiler">compiles code to executable scripts</param> public ScriptExecutionService(ILogger <ScriptExecutionService> logger, ITaskService scriptinstances, IScriptCompiler scriptcompiler) { this.logger = logger; this.scriptinstances = scriptinstances; this.scriptcompiler = scriptcompiler; }
/// <summary> /// creates a new <see cref="ValueNode"/> /// </summary> /// <param name="nodeid">id of workflow node</param> /// <param name="name">name of node</param> /// <param name="value">value to provide to workflow</param> /// <param name="compiler">compiler used to compile generated code</param> public ValueNode(Guid nodeid, string name, object value, IScriptCompiler compiler) : base(nodeid, name, compiler) { Value = value; }
/// <summary> /// creates a new <see cref="CallNode"/> /// </summary> /// <param name="nodeid">id of workflow node</param> /// <param name="nodeName">name of node</param> /// <param name="parameters">parameters for method call</param> /// <param name="compiler">parser for script code</param> public CallNode(Guid nodeid, string nodeName, CallParameters parameters, IScriptCompiler compiler) : base(nodeid, nodeName, compiler) { Parameters = parameters; }
/// <summary> /// Removes the script compiler. /// </summary> /// <param name="type">The type.</param> /// <returns></returns> public static bool RemoveScriptCompiler([NotNull] IScriptCompiler compiler) { return(type2compiler.Remove(compiler.ScriptCodeType)); }
/// <summary> /// creates a new <see cref="ScriptIdMethod"/> /// </summary> /// <param name="scriptid">id of script</param> /// <param name="compiler">compiler used to retrieve script instance</param> public ScriptIdMethod(long scriptid, IScriptCompiler compiler) { this.scriptid = scriptid; this.compiler = compiler; }
//public void _StartScript(uint localID, UUID itemID, string Script, int startParam, bool postOnRez) private void _StartScript(LoadUnloadStructure ScriptObject) { m_log.DebugFormat( "[{0}]: ScriptManager StartScript: localID: {1}, itemID: {2}", Name, ScriptObject.Script.LocalID, ScriptObject.Script.ItemID); // We will initialize and start the script. // It will be up to the script itself to hook up the correct events. SceneObjectPart m_host = ScriptObject.Script.RegionInfo.Scene.GetSceneObjectPart(ScriptObject.Script.LocalID); if (null == m_host) { m_log.ErrorFormat( "[{0}]: Could not find scene object part corresponding " + "to localID {1} to start script", Name, ScriptObject.Script.LocalID); return; } //UUID assetID = UUID.Zero; TaskInventoryItem taskInventoryItem = new TaskInventoryItem(); //if (m_host.TaskInventory.TryGetValue(ScriptObject.Script.ItemID, out taskInventoryItem)) // assetID = taskInventoryItem.AssetID; ScenePresence presence = ScriptObject.Script.RegionInfo.Scene.GetScenePresence(taskInventoryItem.OwnerID); CultureInfo USCulture = new CultureInfo("en-US"); Thread.CurrentThread.CurrentCulture = USCulture; try { // // Compile script to an assembly // //TODO: DEBUG BaseClassFactory.MakeBaseClass(ScriptObject.Script); m_log.DebugFormat("[{0}] Compiling script {1}", Name, ScriptObject.Script.Name); string fileName = ""; try { IScriptCompiler compiler = ScriptObject.Script.RegionInfo.FindCompiler(ScriptObject.Script.ScriptMetaData); //RegionInfoStructure currentRegionInfo = ScriptObject.Script.RegionInfo; fileName = compiler.Compile(ScriptObject.Script.ScriptMetaData, ref ScriptObject.Script.Source); ScriptObject.Script.AssemblyFileName = fileName; } catch (Exception e) { m_log.ErrorFormat("[{0}] Internal error while compiling \"{1}\": {2}", Name, ScriptObject.Script.Name, e.ToString()); } m_log.DebugFormat("[{0}] Compiled \"{1}\" to assembly: \"{2}\".", Name, ScriptObject.Script.Name, fileName); // Add it to our script memstruct MemAddScript(ScriptObject.Script); ScriptAssemblies.IScript CompiledScript; CompiledScript = CurrentRegion.ScriptLoader.LoadScript(ScriptObject.Script); ScriptObject.Script.State = "default"; ScriptObject.Script.ScriptObject = CompiledScript; ScriptObject.Script.Disabled = false; ScriptObject.Script.Running = true; //id.LineMap = LSLCompiler.LineMap(); //id.Script = CompiledScript; //id.Source = item.Script.Script; //item.StartParam = startParam; // TODO: Fire the first start-event //int eventFlags = // m_scriptEngine.m_ScriptManager.GetStateEventFlags( // localID, itemID); //m_host.SetScriptEvents(itemID, eventFlags); ScriptObject.Script.RegionInfo.Executors_Execute(ScriptObject.Script, new EventParams(ScriptObject.Script.LocalID, ScriptObject.Script.ItemID, "state_entry", new object[] { }, new Region.ScriptEngine.Shared.DetectParams[0]) ); if (ScriptObject.PostOnRez) { ScriptObject.Script.RegionInfo.Executors_Execute(ScriptObject.Script, new EventParams(ScriptObject.Script.LocalID, "on_rez", new object[] { new Region.ScriptEngine.Shared.LSL_Types.LSLInteger(ScriptObject.StartParam) }, new Region.ScriptEngine.Shared.DetectParams[0])); } } catch (Exception e) // LEGIT: User Scripting { if (presence != null && (!ScriptObject.PostOnRez)) { presence.ControllingClient.SendAgentAlertMessage( "Script saved with errors, check debug window!", false); } try { // DISPLAY ERROR INWORLD string text = "Error compiling script:\n" + e.Message.ToString(); if (text.Length > 1100) { text = text.Substring(0, 1099); } ScriptObject.Script.RegionInfo.Scene.SimChat(Utils.StringToBytes(text), ChatTypeEnum.DebugChannel, 2147483647, m_host.AbsolutePosition, m_host.Name, m_host.UUID, false); } catch (Exception e2) // LEGIT: User Scripting { m_log.Error("[" + Name + "]: Error displaying error in-world: " + e2.ToString()); m_log.Error("[" + Name + "]: " + "Errormessage: Error compiling script:\r\n" + e2.Message.ToString()); } } }
/// <summary> /// creates a new <see cref="StartNode"/> /// </summary> /// <param name="nodeid">id of workflow node</param> /// <param name="nodeName">name of node</param> /// <param name="parameters">parameters for workflow start</param> /// <param name="compiler">parser used to convert parameter data</param> public StartNode(Guid nodeid, string nodeName, StartParameters parameters, IScriptCompiler compiler) : base(nodeid, nodeName) { this.compiler = compiler; Parameters = parameters; }
/// <summary> /// creates a new <see cref="CompiledExpressionNode"/> /// </summary> /// <param name="nodeid">id of workflow node</param> /// <param name="nodeName">name of node</param> /// <param name="compiler">compiler used to compile scripts</param> protected CompiledExpressionNode(Guid nodeid, string nodeName, IScriptCompiler compiler) : base(nodeid, nodeName) { this.compiler = compiler; }
/// <summary> /// translates workable variables to parameter values /// </summary> /// <param name="variables">variables to translate</param> /// <param name="compiler">compiler to use to parse variable scripts</param> /// <returns>workable parameter variables</returns> public static async Task <IDictionary <string, object> > TranslateVariables(this IDictionary <string, object> variables, IScriptCompiler compiler, ScriptLanguage?language) { if (variables == null) { return(null); } Dictionary <string, object> translated = new Dictionary <string, object>(); foreach (KeyValuePair <string, object> kvp in variables) { if (kvp.Value is string code) { translated[kvp.Key] = await(await compiler.CompileCodeAsync(code, language ?? ScriptLanguage.NCScript)).ExecuteAsync(); } else { translated[kvp.Key] = kvp.Value; } } return(translated); }
public ScriptsBuilder() { _scriptCompiler = new ScriptCompilerCSharp(); }
/// <summary> /// creates a new <see cref="WorkflowInstanceNode"/> /// </summary> /// <param name="nodeid">id of workflow node</param> /// <param name="name">name of node</param> /// <param name="parameters">parameters for workflow call</param> /// <param name="scriptcompiler">compiler used to build workflow arguments</param> /// <param name="language">language used to translate arguments</param> public WorkflowInstanceNode(Guid nodeid, string name, CallWorkableParameters parameters, IScriptCompiler scriptcompiler, ScriptLanguage?language) : base(nodeid, name) { this.parameters = parameters; Arguments = parameters.Arguments.BuildArguments(scriptcompiler, language ?? ScriptLanguage.NCScript); }
/// <summary> /// creates a new <see cref="AssignStateNode"/> /// </summary> /// <param name="node">node of which to assign result</param> /// <param name="variableName">name of variable to assign result to</param> /// <param name="variableoperation">operation to use when assigning variable</param> /// <param name="compiler">compiler to use to compile variable operation</param> public AssignStateNode(IInstanceNode node, string variableName, VariableOperation variableoperation, IScriptCompiler compiler) { this.node = node; VariableName = variableName; if (variableoperation != VariableOperation.Assign) { operation = compiler.CompileCode($"$lhs{variableoperation.ToOperatorString()}$rhs", ScriptLanguage.NCScript); } }
/// <summary> /// creates a new <see cref="BinaryNode"/> /// </summary> /// <param name="nodeid">id of workflow node</param> /// <param name="name">name of node</param> /// <param name="parameters">parameters for operation</param> /// <param name="compiler">access to code compiler</param> public BinaryNode(Guid nodeid, string name, BinaryOpParameters parameters, IScriptCompiler compiler) : base(nodeid, name, compiler) { Parameters = parameters; }
/// <summary> /// creates a new <see cref="LogNode"/> /// </summary> /// <param name="nodeid">id of workflow node</param> /// <param name="nodeName">name of node</param> /// <param name="compiler">compiler for script code</param> /// <param name="parameters">parameters for log action</param> public LogNode(Guid nodeid, string nodeName, IScriptCompiler compiler, LogParameters parameters) : base(nodeid, nodeName) { this.compiler = compiler; Parameters = parameters; }
/// <summary> /// creates a new <see cref="ScriptIdMethod"/> /// </summary> /// <param name="scriptname">name of script</param> /// <param name="compiler">compiler used to retrieve script instances</param> public ScriptNameMethod(string scriptname, IScriptCompiler compiler) { this.scriptname = scriptname; this.compiler = compiler; }